Pileus Git - ~andy/gtk/blob - gtk/gtkpaned.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include <config.h>
  28 #include "gtkintl.h"
  29 #include "gtkpaned.h"
  30 #include "gtkbindings.h"
  31 #include "gtksignal.h"
  32 #include "gdk/gdkkeysyms.h"
  33 #include "gtkwindow.h"
  34 #include "gtkmain.h"
  35 #include "gtkmarshalers.h"
  36 #include "gtkprivate.h"
  37 #include "gtkalias.h"
  38
  39 enum {
  40   PROP_0,
  41   PROP_POSITION,
  42   PROP_POSITION_SET,
  43   PROP_MIN_POSITION,
  44   PROP_MAX_POSITION
  45 };
  46
  47 enum {
  48   CHILD_PROP_0,
  49   CHILD_PROP_RESIZE,
  50   CHILD_PROP_SHRINK
  51 };
  52
  53 enum {
  54   CYCLE_CHILD_FOCUS,
  55   TOGGLE_HANDLE_FOCUS,
  56   MOVE_HANDLE,
  57   CYCLE_HANDLE_FOCUS,
  58   ACCEPT_POSITION,
  59   CANCEL_POSITION,
  60   LAST_SIGNAL
  61 };
  62
  63 static void     gtk_paned_set_property          (GObject          *object,
  64                                                  guint             prop_id,
  65                                                  const GValue     *value,
  66                                                  GParamSpec       *pspec);
  67 static void     gtk_paned_get_property          (GObject          *object,
  68                                                  guint             prop_id,
  69                                                  GValue           *value,
  70                                                  GParamSpec       *pspec);
  71 static void gtk_paned_set_child_property        (GtkContainer      *container,
  72                                                  GtkWidget         *child,
  73                                                  guint              property_id,
  74                                                  const GValue      *value,
  75                                                  GParamSpec        *pspec);
  76 static void gtk_paned_get_child_property        (GtkContainer      *container,
  77                                                  GtkWidget         *child,
  78                                                  guint              property_id,
  79                                                  GValue            *value,
  80                                                  GParamSpec        *pspec);
  81 static void     gtk_paned_finalize              (GObject          *object);
  82 static void     gtk_paned_realize               (GtkWidget        *widget);
  83 static void     gtk_paned_unrealize             (GtkWidget        *widget);
  84 static void     gtk_paned_map                   (GtkWidget        *widget);
  85 static void     gtk_paned_unmap                 (GtkWidget        *widget);
  86 static void     gtk_paned_state_changed         (GtkWidget        *widget,
  87                                                  GtkStateType      previous_state);
  88 static gboolean gtk_paned_expose                (GtkWidget        *widget,
  89                                                  GdkEventExpose   *event);
  90 static gboolean gtk_paned_enter                 (GtkWidget        *widget,
  91                                                  GdkEventCrossing *event);
  92 static gboolean gtk_paned_leave                 (GtkWidget        *widget,
  93                                                  GdkEventCrossing *event);
  94 static gboolean gtk_paned_button_press          (GtkWidget        *widget,
  95                                                  GdkEventButton   *event);
  96 static gboolean gtk_paned_button_release        (GtkWidget        *widget,
  97                                                  GdkEventButton   *event);
  98 static gboolean gtk_paned_motion                (GtkWidget        *widget,
  99                                                  GdkEventMotion   *event);
 100 static gboolean gtk_paned_focus                 (GtkWidget        *widget,
 101                                                  GtkDirectionType  direction);
 102 static gboolean gtk_paned_grab_broken           (GtkWidget          *widget,
 103                                                  GdkEventGrabBroken *event);
 104 static void     gtk_paned_add                   (GtkContainer     *container,
 105                                                  GtkWidget        *widget);
 106 static void     gtk_paned_remove                (GtkContainer     *container,
 107                                                  GtkWidget        *widget);
 108 static void     gtk_paned_forall                (GtkContainer     *container,
 109                                                  gboolean          include_internals,
 110                                                  GtkCallback       callback,
 111                                                  gpointer          callback_data);
 112 static void     gtk_paned_set_focus_child       (GtkContainer     *container,
 113                                                  GtkWidget        *child);
 114 static void     gtk_paned_set_saved_focus       (GtkPaned         *paned,
 115                                                  GtkWidget        *widget);
 116 static void     gtk_paned_set_first_paned       (GtkPaned         *paned,
 117                                                  GtkPaned         *first_paned);
 118 static void     gtk_paned_set_last_child1_focus (GtkPaned         *paned,
 119                                                  GtkWidget        *widget);
 120 static void     gtk_paned_set_last_child2_focus (GtkPaned         *paned,
 121                                                  GtkWidget        *widget);
 122 static gboolean gtk_paned_cycle_child_focus     (GtkPaned         *paned,
 123                                                  gboolean          reverse);
 124 static gboolean gtk_paned_cycle_handle_focus    (GtkPaned         *paned,
 125                                                  gboolean          reverse);
 126 static gboolean gtk_paned_move_handle           (GtkPaned         *paned,
 127                                                  GtkScrollType     scroll);
 128 static gboolean gtk_paned_accept_position       (GtkPaned         *paned);
 129 static gboolean gtk_paned_cancel_position       (GtkPaned         *paned);
 130 static gboolean gtk_paned_toggle_handle_focus   (GtkPaned         *paned);
 131
 132 static GType    gtk_paned_child_type            (GtkContainer     *container);
 133 static void     gtk_paned_grab_notify           (GtkWidget        *widget,
 134                                                  gboolean          was_grabbed);
 135
 136 struct _GtkPanedPrivate
 137 {
 138   GtkWidget *saved_focus;
 139   GtkPaned  *first_paned;
 140   guint32    grab_time;
 141 };
 142
 143 G_DEFINE_ABSTRACT_TYPE (GtkPaned, gtk_paned, GTK_TYPE_CONTAINER)
 144
 145 static guint signals[LAST_SIGNAL] = { 0 };
 146
 147 static void
 148 add_tab_bindings (GtkBindingSet    *binding_set,
 149                   GdkModifierType   modifiers)
 150 {
 151   gtk_binding_entry_add_signal (binding_set, GDK_Tab, modifiers,
 152                                 "toggle_handle_focus", 0);
 153   gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, modifiers,
 154                                 "toggle_handle_focus", 0);
 155 }
 156
 157 static void
 158 add_move_binding (GtkBindingSet   *binding_set,
 159                   guint            keyval,
 160                   GdkModifierType  mask,
 161                   GtkScrollType    scroll)
 162 {
 163   gtk_binding_entry_add_signal (binding_set, keyval, mask,
 164                                 "move_handle", 1,
 165                                 GTK_TYPE_SCROLL_TYPE, scroll);
 166 }
 167
 168 static void
 169 gtk_paned_class_init (GtkPanedClass *class)
 170 {
 171   GObjectClass *object_class;
 172   GtkWidgetClass *widget_class;
 173   GtkContainerClass *container_class;
 174   GtkPanedClass *paned_class;
 175   GtkBindingSet *binding_set;
 176
 177   object_class = (GObjectClass *) class;
 178   widget_class = (GtkWidgetClass *) class;
 179   container_class = (GtkContainerClass *) class;
 180   paned_class = (GtkPanedClass *) class;
 181
 182   object_class->set_property = gtk_paned_set_property;
 183   object_class->get_property = gtk_paned_get_property;
 184   object_class->finalize = gtk_paned_finalize;
 185
 186   widget_class->realize = gtk_paned_realize;
 187   widget_class->unrealize = gtk_paned_unrealize;
 188   widget_class->map = gtk_paned_map;
 189   widget_class->unmap = gtk_paned_unmap;
 190   widget_class->expose_event = gtk_paned_expose;
 191   widget_class->focus = gtk_paned_focus;
 192   widget_class->enter_notify_event = gtk_paned_enter;
 193   widget_class->leave_notify_event = gtk_paned_leave;
 194   widget_class->button_press_event = gtk_paned_button_press;
 195   widget_class->button_release_event = gtk_paned_button_release;
 196   widget_class->motion_notify_event = gtk_paned_motion;
 197   widget_class->grab_broken_event = gtk_paned_grab_broken;
 198   widget_class->grab_notify = gtk_paned_grab_notify;
 199   widget_class->state_changed = gtk_paned_state_changed;
 200
 201   container_class->add = gtk_paned_add;
 202   container_class->remove = gtk_paned_remove;
 203   container_class->forall = gtk_paned_forall;
 204   container_class->child_type = gtk_paned_child_type;
 205   container_class->set_focus_child = gtk_paned_set_focus_child;
 206   container_class->set_child_property = gtk_paned_set_child_property;
 207   container_class->get_child_property = gtk_paned_get_child_property;
 208
 209   paned_class->cycle_child_focus = gtk_paned_cycle_child_focus;
 210   paned_class->toggle_handle_focus = gtk_paned_toggle_handle_focus;
 211   paned_class->move_handle = gtk_paned_move_handle;
 212   paned_class->cycle_handle_focus = gtk_paned_cycle_handle_focus;
 213   paned_class->accept_position = gtk_paned_accept_position;
 214   paned_class->cancel_position = gtk_paned_cancel_position;
 215
 216   g_object_class_install_property (object_class,
 217                                    PROP_POSITION,
 218                                    g_param_spec_int ("position",
 219                                                      P_("Position"),
 220                                                      P_("Position of paned separator in pixels (0 means all the way to the left/top)"),
 221                                                      0,
 222                                                      G_MAXINT,
 223                                                      0,
 224                                                      GTK_PARAM_READWRITE));
 225   g_object_class_install_property (object_class,
 226                                    PROP_POSITION_SET,
 227                                    g_param_spec_boolean ("position-set",
 228                                                          P_("Position Set"),
 229                                                          P_("TRUE if the Position property should be used"),
 230                                                          FALSE,
 231                                                          GTK_PARAM_READWRITE));
 232
 233   gtk_widget_class_install_style_property (widget_class,
 234                                            g_param_spec_int ("handle-size",
 235                                                              P_("Handle Size"),
 236                                                              P_("Width of handle"),
 237                                                              0,
 238                                                              G_MAXINT,
 239                                                              5,
 240                                                              GTK_PARAM_READABLE));
 241   /**
 242    * GtkPaned:min-position:
 243    *
 244    * The smallest possible value for the position property. This property is derived from the
 245    * size and shrinkability of the widget's children.
 246    *
 247    * Since: 2.4
 248    */
 249   g_object_class_install_property (object_class,
 250                                    PROP_MIN_POSITION,
 251                                    g_param_spec_int ("min-position",
 252                                                      P_("Minimal Position"),
 253                                                      P_("Smallest possible value for the \"position\" property"),
 254                                                      0,
 255                                                      G_MAXINT,
 256                                                      0,
 257                                                      GTK_PARAM_READABLE));
 258
 259   /**
 260    * GtkPaned:max-position:
 261    *
 262    * The largest possible value for the position property. This property is derived from the
 263    * size and shrinkability of the widget's children.
 264    *
 265    * Since: 2.4
 266    */
 267   g_object_class_install_property (object_class,
 268                                    PROP_MAX_POSITION,
 269                                    g_param_spec_int ("max-position",
 270                                                      P_("Maximal Position"),
 271                                                      P_("Largest possible value for the \"position\" property"),
 272                                                      0,
 273                                                      G_MAXINT,
 274                                                      G_MAXINT,
 275                                                      GTK_PARAM_READABLE));
 276
 277 /**
 278  * GtkPaned:resize:
 279  *
 280  * The "resize" child property determines whether the child expands and
 281  * shrinks along with the paned widget.
 282  *
 283  * Since: 2.4
 284  */
 285   gtk_container_class_install_child_property (container_class,
 286                                               CHILD_PROP_RESIZE,
 287                                               g_param_spec_boolean ("resize",
 288                                                                     P_("Resize"),
 289                                                                     P_("If TRUE, the child expands and shrinks along with the paned widget"),
 290                                                                     TRUE,
 291                                                                     GTK_PARAM_READWRITE));
 292
 293 /**
 294  * GtkPaned:shrink:
 295  *
 296  * The "shrink" child property determines whether the child can be made
 297  * smaller than its requisition.
 298  *
 299  * Since: 2.4
 300  */
 301   gtk_container_class_install_child_property (container_class,
 302                                               CHILD_PROP_SHRINK,
 303                                               g_param_spec_boolean ("shrink",
 304                                                                     P_("Shrink"),
 305                                                                     P_("If TRUE, the child can be made smaller than its requisition"),
 306                                                                     TRUE,
 307                                                                     GTK_PARAM_READWRITE));
 308
 309   /**
 310    * GtkPaned::cycle-child-focus:
 311    * @widget: the object that received the signal
 312    * @reversed: whether cycling backward or forward
 313    *
 314    * The ::cycle-child-focus signal is a
 315    * <link linkend="keybinding-signals">keybinding signal</link>
 316    * which gets emitted to cycle the focus between the children of the paned.
 317    *
 318    * The default binding is f6.
 319    *
 320    * Since: 2.0
 321    */
 322   signals [CYCLE_CHILD_FOCUS] =
 323     g_signal_new (I_("cycle_child_focus"),
 324                   G_TYPE_FROM_CLASS (object_class),
 325                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 326                   G_STRUCT_OFFSET (GtkPanedClass, cycle_child_focus),
 327                   NULL, NULL,
 328                   _gtk_marshal_BOOLEAN__BOOLEAN,
 329                   G_TYPE_BOOLEAN, 1,
 330                   G_TYPE_BOOLEAN);
 331
 332   /**
 333    * GtkPaned::toggle-handle-focus:
 334    * @widget: the object that received the signal
 335    *
 336    * The ::toggle-handle-focus is a
 337    * <link linkend="keybinding-signals">keybinding signal</link>
 338    * which gets emitted to accept the current position of the handle and then
 339    * move focus to the next widget in the focus chain.
 340    *
 341    * The default binding is Tab.
 342    *
 343    * Since: 2.0
 344    */
 345   signals [TOGGLE_HANDLE_FOCUS] =
 346     g_signal_new (I_("toggle_handle_focus"),
 347                   G_TYPE_FROM_CLASS (object_class),
 348                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 349                   G_STRUCT_OFFSET (GtkPanedClass, toggle_handle_focus),
 350                   NULL, NULL,
 351                   _gtk_marshal_BOOLEAN__VOID,
 352                   G_TYPE_BOOLEAN, 0);
 353
 354   /**
 355    * GtkPaned::move-handle:
 356    * @widget: the object that received the signal
 357    * @scroll_type: a #GtkScrollType
 358    *
 359    * The ::move-handle signal is a
 360    * <link linkend="keybinding-signals">keybinding signal</link>
 361    * which gets emitted to move the handle when the user is using key bindings
 362    * to move it.
 363    *
 364    * Since: 2.0
 365    */
 366   signals[MOVE_HANDLE] =
 367     g_signal_new (I_("move_handle"),
 368                   G_TYPE_FROM_CLASS (object_class),
 369                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 370                   G_STRUCT_OFFSET (GtkPanedClass, move_handle),
 371                   NULL, NULL,
 372                   _gtk_marshal_BOOLEAN__ENUM,
 373                   G_TYPE_BOOLEAN, 1,
 374                   GTK_TYPE_SCROLL_TYPE);
 375
 376   /**
 377    * GtkPaned::cycle-handle-focus:
 378    * @widget: the object that received the signal
 379    * @reversed: whether cycling backward or forward
 380    *
 381    * The ::cycle-handle-focus signal is a
 382    * <link linkend="keybinding-signals">keybinding signal</link>
 383    * which gets emitted to cycle whether the paned should grab focus to allow
 384    * the user to change position of the handle by using key bindings.
 385    *
 386    * The default binding for this signal is f8.
 387    *
 388    * Since: 2.0
 389    */
 390   signals [CYCLE_HANDLE_FOCUS] =
 391     g_signal_new (I_("cycle_handle_focus"),
 392                   G_TYPE_FROM_CLASS (object_class),
 393                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 394                   G_STRUCT_OFFSET (GtkPanedClass, cycle_handle_focus),
 395                   NULL, NULL,
 396                   _gtk_marshal_BOOLEAN__BOOLEAN,
 397                   G_TYPE_BOOLEAN, 1,
 398                   G_TYPE_BOOLEAN);
 399
 400   /**
 401    * GtkPaned::accept-position:
 402    * @widget: the object that received the signal
 403    *
 404    * The ::accept-position signal is a
 405    * <link linkend="keybinding-signals">keybinding signal</link>
 406    * which gets emitted to accept the current position of the handle when
 407    * moving it using key bindings.
 408    *
 409    * The default binding for this signal is Return or Space.
 410    *
 411    * Since: 2.0
 412    */
 413   signals [ACCEPT_POSITION] =
 414     g_signal_new (I_("accept_position"),
 415                   G_TYPE_FROM_CLASS (object_class),
 416                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 417                   G_STRUCT_OFFSET (GtkPanedClass, accept_position),
 418                   NULL, NULL,
 419                   _gtk_marshal_BOOLEAN__VOID,
 420                   G_TYPE_BOOLEAN, 0);
 421
 422   /**
 423    * GtkPaned::cancel-position:
 424    * @widget: the object that received the signal
 425    *
 426    * The ::cancel-position signal is a
 427    * <link linkend="keybinding-signals">keybinding signal</link>
 428    * which gets emitted to cancel moving the position of the handle using key
 429    * bindings. The position of the handle will be reset to the value prior to
 430    * moving it.
 431    *
 432    * The default binding for this signal is Escape.
 433    *
 434    * Since: 2.0
 435    */
 436   signals [CANCEL_POSITION] =
 437     g_signal_new (I_("cancel_position"),
 438                   G_TYPE_FROM_CLASS (object_class),
 439                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 440                   G_STRUCT_OFFSET (GtkPanedClass, cancel_position),
 441                   NULL, NULL,
 442                   _gtk_marshal_BOOLEAN__VOID,
 443                   G_TYPE_BOOLEAN, 0);
 444
 445   binding_set = gtk_binding_set_by_class (class);
 446
 447   /* F6 and friends */
 448   gtk_binding_entry_add_signal (binding_set,
 449                                 GDK_F6, 0,
 450                                 "cycle_child_focus", 1,
 451                                 G_TYPE_BOOLEAN, FALSE);
 452   gtk_binding_entry_add_signal (binding_set,
 453                                 GDK_F6, GDK_SHIFT_MASK,
 454                                 "cycle_child_focus", 1,
 455                                 G_TYPE_BOOLEAN, TRUE);
 456
 457   /* F8 and friends */
 458   gtk_binding_entry_add_signal (binding_set,
 459                                 GDK_F8, 0,
 460                                 "cycle_handle_focus", 1,
 461                                 G_TYPE_BOOLEAN, FALSE);
 462
 463   gtk_binding_entry_add_signal (binding_set,
 464                                 GDK_F8, GDK_SHIFT_MASK,
 465                                 "cycle_handle_focus", 1,
 466                                 G_TYPE_BOOLEAN, TRUE);
 467
 468   add_tab_bindings (binding_set, 0);
 469   add_tab_bindings (binding_set, GDK_CONTROL_MASK);
 470   add_tab_bindings (binding_set, GDK_SHIFT_MASK);
 471   add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK);
 472
 473   /* accept and cancel positions */
 474   gtk_binding_entry_add_signal (binding_set,
 475                                 GDK_Escape, 0,
 476                                 "cancel_position", 0);
 477
 478   gtk_binding_entry_add_signal (binding_set,
 479                                 GDK_Return, 0,
 480                                 "accept_position", 0);
 481   gtk_binding_entry_add_signal (binding_set,
 482                                 GDK_KP_Enter, 0,
 483                                 "accept_position", 0);
 484   gtk_binding_entry_add_signal (binding_set,
 485                                 GDK_space, 0,
 486                                 "accept_position", 0);
 487   gtk_binding_entry_add_signal (binding_set,
 488                                 GDK_KP_Space, 0,
 489                                 "accept_position", 0);
 490
 491   /* move handle */
 492   add_move_binding (binding_set, GDK_Left, 0, GTK_SCROLL_STEP_LEFT);
 493   add_move_binding (binding_set, GDK_KP_Left, 0, GTK_SCROLL_STEP_LEFT);
 494   add_move_binding (binding_set, GDK_Left, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_LEFT);
 495   add_move_binding (binding_set, GDK_KP_Left, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_LEFT);
 496
 497   add_move_binding (binding_set, GDK_Right, 0, GTK_SCROLL_STEP_RIGHT);
 498   add_move_binding (binding_set, GDK_Right, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_RIGHT);
 499   add_move_binding (binding_set, GDK_KP_Right, 0, GTK_SCROLL_STEP_RIGHT);
 500   add_move_binding (binding_set, GDK_KP_Right, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_RIGHT);
 501
 502   add_move_binding (binding_set, GDK_Up, 0, GTK_SCROLL_STEP_UP);
 503   add_move_binding (binding_set, GDK_Up, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_UP);
 504   add_move_binding (binding_set, GDK_KP_Up, 0, GTK_SCROLL_STEP_UP);
 505   add_move_binding (binding_set, GDK_KP_Up, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_UP);
 506   add_move_binding (binding_set, GDK_Page_Up, 0, GTK_SCROLL_PAGE_UP);
 507   add_move_binding (binding_set, GDK_KP_Page_Up, 0, GTK_SCROLL_PAGE_UP);
 508
 509   add_move_binding (binding_set, GDK_Down, 0, GTK_SCROLL_STEP_DOWN);
 510   add_move_binding (binding_set, GDK_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_DOWN);
 511   add_move_binding (binding_set, GDK_KP_Down, 0, GTK_SCROLL_STEP_DOWN);
 512   add_move_binding (binding_set, GDK_KP_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_DOWN);
 513   add_move_binding (binding_set, GDK_Page_Down, 0, GTK_SCROLL_PAGE_RIGHT);
 514   add_move_binding (binding_set, GDK_KP_Page_Down, 0, GTK_SCROLL_PAGE_RIGHT);
 515
 516   add_move_binding (binding_set, GDK_Home, 0, GTK_SCROLL_START);
 517   add_move_binding (binding_set, GDK_KP_Home, 0, GTK_SCROLL_START);
 518   add_move_binding (binding_set, GDK_End, 0, GTK_SCROLL_END);
 519   add_move_binding (binding_set, GDK_KP_End, 0, GTK_SCROLL_END);
 520
 521   g_type_class_add_private (object_class, sizeof (GtkPanedPrivate));
 522 }
 523
 524 static GType
 525 gtk_paned_child_type (GtkContainer *container)
 526 {
 527   if (!GTK_PANED (container)->child1 || !GTK_PANED (container)->child2)
 528     return GTK_TYPE_WIDGET;
 529   else
 530     return G_TYPE_NONE;
 531 }
 532
 533 static void
 534 gtk_paned_init (GtkPaned *paned)
 535 {
 536   GTK_WIDGET_SET_FLAGS (paned, GTK_NO_WINDOW | GTK_CAN_FOCUS);
 537
 538   paned->child1 = NULL;
 539   paned->child2 = NULL;
 540   paned->handle = NULL;
 541   paned->xor_gc = NULL;
 542   paned->cursor_type = GDK_CROSS;
 543
 544   paned->handle_pos.width = 5;
 545   paned->handle_pos.height = 5;
 546   paned->position_set = FALSE;
 547   paned->last_allocation = -1;
 548   paned->in_drag = FALSE;
 549
 550   paned->priv = G_TYPE_INSTANCE_GET_PRIVATE (paned, GTK_TYPE_PANED, GtkPanedPrivate);
 551   paned->last_child1_focus = NULL;
 552   paned->last_child2_focus = NULL;
 553   paned->in_recursion = FALSE;
 554   paned->handle_prelit = FALSE;
 555   paned->original_position = -1;
 556
 557   paned->handle_pos.x = -1;
 558   paned->handle_pos.y = -1;
 559
 560   paned->drag_pos = -1;
 561 }
 562
 563 static void
 564 gtk_paned_set_property (GObject        *object,
 565                         guint           prop_id,
 566                         const GValue   *value,
 567                         GParamSpec     *pspec)
 568 {
 569   GtkPaned *paned = GTK_PANED (object);
 570
 571   switch (prop_id)
 572     {
 573     case PROP_POSITION:
 574       gtk_paned_set_position (paned, g_value_get_int (value));
 575       break;
 576     case PROP_POSITION_SET:
 577       paned->position_set = g_value_get_boolean (value);
 578       gtk_widget_queue_resize (GTK_WIDGET (paned));
 579       break;
 580     default:
 581       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 582       break;
 583     }
 584 }
 585
 586 static void
 587 gtk_paned_get_property (GObject        *object,
 588                         guint           prop_id,
 589                         GValue         *value,
 590                         GParamSpec     *pspec)
 591 {
 592   GtkPaned *paned = GTK_PANED (object);
 593
 594   switch (prop_id)
 595     {
 596     case PROP_POSITION:
 597       g_value_set_int (value, paned->child1_size);
 598       break;
 599     case PROP_POSITION_SET:
 600       g_value_set_boolean (value, paned->position_set);
 601       break;
 602     case PROP_MIN_POSITION:
 603       g_value_set_int (value, paned->min_position);
 604       break;
 605     case PROP_MAX_POSITION:
 606       g_value_set_int (value, paned->max_position);
 607       break;
 608     default:
 609       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 610       break;
 611     }
 612 }
 613
 614 static void
 615 gtk_paned_set_child_property (GtkContainer    *container,
 616                               GtkWidget       *child,
 617                               guint            property_id,
 618                               const GValue    *value,
 619                               GParamSpec      *pspec)
 620 {
 621   GtkPaned *paned = GTK_PANED (container);
 622   gboolean old_value, new_value;
 623
 624   g_assert (child == paned->child1 || child == paned->child2);
 625
 626   new_value = g_value_get_boolean (value);
 627   switch (property_id)
 628     {
 629     case CHILD_PROP_RESIZE:
 630       if (child == paned->child1)
 631         {
 632           old_value = paned->child1_resize;
 633           paned->child1_resize = new_value;
 634         }
 635       else
 636         {
 637           old_value = paned->child2_resize;
 638           paned->child2_resize = new_value;
 639         }
 640       break;
 641     case CHILD_PROP_SHRINK:
 642       if (child == paned->child1)
 643         {
 644           old_value = paned->child1_shrink;
 645           paned->child1_shrink = new_value;
 646         }
 647       else
 648         {
 649           old_value = paned->child2_shrink;
 650           paned->child2_shrink = new_value;
 651         }
 652       break;
 653     default:
 654       GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
 655       old_value = -1; /* quiet gcc */
 656       break;
 657     }
 658   if (old_value != new_value)
 659     gtk_widget_queue_resize (GTK_WIDGET (container));
 660 }
 661
 662 static void
 663 gtk_paned_get_child_property (GtkContainer *container,
 664                               GtkWidget    *child,
 665                               guint         property_id,
 666                               GValue       *value,
 667                               GParamSpec   *pspec)
 668 {
 669   GtkPaned *paned = GTK_PANED (container);
 670
 671   g_assert (child == paned->child1 || child == paned->child2);
 672
 673   switch (property_id)
 674     {
 675     case CHILD_PROP_RESIZE:
 676       if (child == paned->child1)
 677         g_value_set_boolean (value, paned->child1_resize);
 678       else
 679         g_value_set_boolean (value, paned->child2_resize);
 680       break;
 681     case CHILD_PROP_SHRINK:
 682       if (child == paned->child1)
 683         g_value_set_boolean (value, paned->child1_shrink);
 684       else
 685         g_value_set_boolean (value, paned->child2_shrink);
 686       break;
 687     default:
 688       GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
 689       break;
 690     }
 691 }
 692
 693 static void
 694 gtk_paned_finalize (GObject *object)
 695 {
 696   GtkPaned *paned = GTK_PANED (object);
 697
 698   gtk_paned_set_saved_focus (paned, NULL);
 699   gtk_paned_set_first_paned (paned, NULL);
 700
 701   G_OBJECT_CLASS (gtk_paned_parent_class)->finalize (object);
 702 }
 703
 704 static void
 705 gtk_paned_realize (GtkWidget *widget)
 706 {
 707   GtkPaned *paned;
 708   GdkWindowAttr attributes;
 709   gint attributes_mask;
 710
 711   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 712   paned = GTK_PANED (widget);
 713
 714   widget->window = gtk_widget_get_parent_window (widget);
 715   g_object_ref (widget->window);
 716
 717   attributes.window_type = GDK_WINDOW_CHILD;
 718   attributes.wclass = GDK_INPUT_ONLY;
 719   attributes.x = paned->handle_pos.x;
 720   attributes.y = paned->handle_pos.y;
 721   attributes.width = paned->handle_pos.width;
 722   attributes.height = paned->handle_pos.height;
 723   attributes.event_mask = gtk_widget_get_events (widget);
 724   attributes.event_mask |= (GDK_BUTTON_PRESS_MASK |
 725                             GDK_BUTTON_RELEASE_MASK |
 726                             GDK_ENTER_NOTIFY_MASK |
 727                             GDK_LEAVE_NOTIFY_MASK |
 728                             GDK_POINTER_MOTION_MASK |
 729                             GDK_POINTER_MOTION_HINT_MASK);
 730   attributes_mask = GDK_WA_X | GDK_WA_Y;
 731   if (GTK_WIDGET_IS_SENSITIVE (widget))
 732     {
 733       attributes.cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
 734                                                       paned->cursor_type);
 735       attributes_mask |= GDK_WA_CURSOR;
 736     }
 737
 738   paned->handle = gdk_window_new (widget->window,
 739                                   &attributes, attributes_mask);
 740   gdk_window_set_user_data (paned->handle, paned);
 741   if (attributes_mask & GDK_WA_CURSOR)
 742     gdk_cursor_unref (attributes.cursor);
 743
 744   widget->style = gtk_style_attach (widget->style, widget->window);
 745
 746   if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1) &&
 747       paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
 748     gdk_window_show (paned->handle);
 749 }
 750
 751 static void
 752 gtk_paned_unrealize (GtkWidget *widget)
 753 {
 754   GtkPaned *paned = GTK_PANED (widget);
 755
 756   if (paned->xor_gc)
 757     {
 758       g_object_unref (paned->xor_gc);
 759       paned->xor_gc = NULL;
 760     }
 761
 762   if (paned->handle)
 763     {
 764       gdk_window_set_user_data (paned->handle, NULL);
 765       gdk_window_destroy (paned->handle);
 766       paned->handle = NULL;
 767     }
 768
 769   gtk_paned_set_last_child1_focus (paned, NULL);
 770   gtk_paned_set_last_child2_focus (paned, NULL);
 771   gtk_paned_set_saved_focus (paned, NULL);
 772   gtk_paned_set_first_paned (paned, NULL);
 773
 774   if (GTK_WIDGET_CLASS (gtk_paned_parent_class)->unrealize)
 775     (* GTK_WIDGET_CLASS (gtk_paned_parent_class)->unrealize) (widget);
 776 }
 777
 778 static void
 779 gtk_paned_map (GtkWidget *widget)
 780 {
 781   GtkPaned *paned = GTK_PANED (widget);
 782
 783   gdk_window_show (paned->handle);
 784
 785   GTK_WIDGET_CLASS (gtk_paned_parent_class)->map (widget);
 786 }
 787
 788 static void
 789 gtk_paned_unmap (GtkWidget *widget)
 790 {
 791   GtkPaned *paned = GTK_PANED (widget);
 792
 793   gdk_window_hide (paned->handle);
 794
 795   GTK_WIDGET_CLASS (gtk_paned_parent_class)->unmap (widget);
 796 }
 797
 798 static gboolean
 799 gtk_paned_expose (GtkWidget      *widget,
 800                   GdkEventExpose *event)
 801 {
 802   GtkPaned *paned = GTK_PANED (widget);
 803
 804   if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget) &&
 805       paned->child1 && GTK_WIDGET_VISIBLE (paned->child1) &&
 806       paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
 807     {
 808       GtkStateType state;
 809
 810       if (gtk_widget_is_focus (widget))
 811         state = GTK_STATE_SELECTED;
 812       else if (paned->handle_prelit)
 813         state = GTK_STATE_PRELIGHT;
 814       else
 815         state = GTK_WIDGET_STATE (widget);
 816
 817       gtk_paint_handle (widget->style, widget->window,
 818                         state, GTK_SHADOW_NONE,
 819                         &paned->handle_pos, widget, "paned",
 820                         paned->handle_pos.x, paned->handle_pos.y,
 821                         paned->handle_pos.width, paned->handle_pos.height,
 822                         paned->orientation);
 823     }
 824
 825   /* Chain up to draw children */
 826   GTK_WIDGET_CLASS (gtk_paned_parent_class)->expose_event (widget, event);
 827
 828   return FALSE;
 829 }
 830
 831 static gboolean
 832 is_rtl (GtkPaned *paned)
 833 {
 834   if (paned->orientation == GTK_ORIENTATION_VERTICAL &&
 835       gtk_widget_get_direction (GTK_WIDGET (paned)) == GTK_TEXT_DIR_RTL)
 836     {
 837       return TRUE;
 838     }
 839
 840   return FALSE;
 841 }
 842
 843 static void
 844 update_drag (GtkPaned *paned)
 845 {
 846   gint pos;
 847   gint handle_size;
 848   gint size;
 849
 850   if (paned->orientation == GTK_ORIENTATION_HORIZONTAL)
 851     gtk_widget_get_pointer (GTK_WIDGET (paned), NULL, &pos);
 852   else
 853     gtk_widget_get_pointer (GTK_WIDGET (paned), &pos, NULL);
 854
 855   pos -= paned->drag_pos;
 856
 857   if (is_rtl (paned))
 858     {
 859       gtk_widget_style_get (GTK_WIDGET (paned),
 860                             "handle-size", &handle_size,
 861                             NULL);
 862
 863       size = GTK_WIDGET (paned)->allocation.width - pos - handle_size;
 864     }
 865   else
 866     {
 867       size = pos;
 868     }
 869
 870   size -= GTK_CONTAINER (paned)->border_width;
 871
 872   size = CLAMP (size, paned->min_position, paned->max_position);
 873
 874   if (size != paned->child1_size)
 875     gtk_paned_set_position (paned, size);
 876 }
 877
 878 static gboolean
 879 gtk_paned_enter (GtkWidget        *widget,
 880                  GdkEventCrossing *event)
 881 {
 882   GtkPaned *paned = GTK_PANED (widget);
 883
 884   if (paned->in_drag)
 885     update_drag (paned);
 886   else
 887     {
 888       paned->handle_prelit = TRUE;
 889       gtk_widget_queue_draw_area (widget,
 890                                   paned->handle_pos.x,
 891                                   paned->handle_pos.y,
 892                                   paned->handle_pos.width,
 893                                   paned->handle_pos.height);
 894     }
 895
 896   return TRUE;
 897 }
 898
 899 static gboolean
 900 gtk_paned_leave (GtkWidget        *widget,
 901                  GdkEventCrossing *event)
 902 {
 903   GtkPaned *paned = GTK_PANED (widget);
 904
 905   if (paned->in_drag)
 906     update_drag (paned);
 907   else
 908     {
 909       paned->handle_prelit = FALSE;
 910       gtk_widget_queue_draw_area (widget,
 911                                   paned->handle_pos.x,
 912                                   paned->handle_pos.y,
 913                                   paned->handle_pos.width,
 914                                   paned->handle_pos.height);
 915     }
 916
 917   return TRUE;
 918 }
 919
 920 static gboolean
 921 gtk_paned_focus (GtkWidget        *widget,
 922                  GtkDirectionType  direction)
 923
 924 {
 925   gboolean retval;
 926
 927   /* This is a hack, but how can this be done without
 928    * excessive cut-and-paste from gtkcontainer.c?
 929    */
 930
 931   GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS);
 932   retval = (* GTK_WIDGET_CLASS (gtk_paned_parent_class)->focus) (widget, direction);
 933   GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
 934
 935   return retval;
 936 }
 937
 938 static gboolean
 939 gtk_paned_button_press (GtkWidget      *widget,
 940                         GdkEventButton *event)
 941 {
 942   GtkPaned *paned = GTK_PANED (widget);
 943
 944   if (!paned->in_drag &&
 945       (event->window == paned->handle) && (event->button == 1))
 946     {
 947       /* We need a server grab here, not gtk_grab_add(), since
 948        * we don't want to pass events on to the widget's children */
 949       if (gdk_pointer_grab (paned->handle, FALSE,
 950                             GDK_POINTER_MOTION_HINT_MASK
 951                             | GDK_BUTTON1_MOTION_MASK
 952                             | GDK_BUTTON_RELEASE_MASK
 953                             | GDK_ENTER_NOTIFY_MASK
 954                             | GDK_LEAVE_NOTIFY_MASK,
 955                             NULL, NULL,
 956                             event->time) != GDK_GRAB_SUCCESS)
 957         return FALSE;
 958
 959       paned->in_drag = TRUE;
 960       paned->priv->grab_time = event->time;
 961
 962       if (paned->orientation == GTK_ORIENTATION_HORIZONTAL)
 963         paned->drag_pos = event->y;
 964       else
 965         paned->drag_pos = event->x;
 966
 967       return TRUE;
 968     }
 969
 970   return FALSE;
 971 }
 972
 973 static gboolean
 974 gtk_paned_grab_broken (GtkWidget          *widget,
 975                        GdkEventGrabBroken *event)
 976 {
 977   GtkPaned *paned = GTK_PANED (widget);
 978
 979   paned->in_drag = FALSE;
 980   paned->drag_pos = -1;
 981   paned->position_set = TRUE;
 982
 983   return TRUE;
 984 }
 985
 986 static void
 987 stop_drag (GtkPaned *paned)
 988 {
 989   paned->in_drag = FALSE;
 990   paned->drag_pos = -1;
 991   paned->position_set = TRUE;
 992   gdk_display_pointer_ungrab (gtk_widget_get_display (GTK_WIDGET (paned)),
 993                               paned->priv->grab_time);
 994 }
 995
 996 static void
 997 gtk_paned_grab_notify (GtkWidget *widget,
 998                        gboolean   was_grabbed)
 999 {
1000   GtkPaned *paned = GTK_PANED (widget);
1001
1002   if (!was_grabbed && paned->in_drag)
1003     stop_drag (paned);
1004 }
1005
1006 static void
1007 gtk_paned_state_changed (GtkWidget    *widget,
1008                          GtkStateType  previous_state)
1009 {
1010   GtkPaned *paned = GTK_PANED (widget);
1011   GdkCursor *cursor;
1012
1013   if (GTK_WIDGET_REALIZED (paned))
1014     {
1015       if (GTK_WIDGET_IS_SENSITIVE (widget))
1016         cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
1017                                              paned->cursor_type);
1018       else
1019         cursor = NULL;
1020
1021       gdk_window_set_cursor (paned->handle, cursor);
1022
1023       if (cursor)
1024         gdk_cursor_unref (cursor);
1025     }
1026 }
1027
1028 static gboolean
1029 gtk_paned_button_release (GtkWidget      *widget,
1030                           GdkEventButton *event)
1031 {
1032   GtkPaned *paned = GTK_PANED (widget);
1033
1034   if (paned->in_drag && (event->button == 1))
1035     {
1036       stop_drag (paned);
1037
1038       return TRUE;
1039     }
1040
1041   return FALSE;
1042 }
1043
1044 static gboolean
1045 gtk_paned_motion (GtkWidget      *widget,
1046                   GdkEventMotion *event)
1047 {
1048   GtkPaned *paned = GTK_PANED (widget);
1049
1050   if (paned->in_drag)
1051     {
1052       update_drag (paned);
1053       return TRUE;
1054     }
1055
1056   return FALSE;
1057 }
1058
1059 void
1060 gtk_paned_add1 (GtkPaned  *paned,
1061                 GtkWidget *widget)
1062 {
1063   gtk_paned_pack1 (paned, widget, FALSE, TRUE);
1064 }
1065
1066 void
1067 gtk_paned_add2 (GtkPaned  *paned,
1068                 GtkWidget *widget)
1069 {
1070   gtk_paned_pack2 (paned, widget, TRUE, TRUE);
1071 }
1072
1073 void
1074 gtk_paned_pack1 (GtkPaned  *paned,
1075                  GtkWidget *child,
1076                  gboolean   resize,
1077                  gboolean   shrink)
1078 {
1079   g_return_if_fail (GTK_IS_PANED (paned));
1080   g_return_if_fail (GTK_IS_WIDGET (child));
1081
1082   if (!paned->child1)
1083     {
1084       paned->child1 = child;
1085       paned->child1_resize = resize;
1086       paned->child1_shrink = shrink;
1087
1088       gtk_widget_set_parent (child, GTK_WIDGET (paned));
1089     }
1090 }
1091
1092 void
1093 gtk_paned_pack2 (GtkPaned  *paned,
1094                  GtkWidget *child,
1095                  gboolean   resize,
1096                  gboolean   shrink)
1097 {
1098   g_return_if_fail (GTK_IS_PANED (paned));
1099   g_return_if_fail (GTK_IS_WIDGET (child));
1100
1101   if (!paned->child2)
1102     {
1103       paned->child2 = child;
1104       paned->child2_resize = resize;
1105       paned->child2_shrink = shrink;
1106
1107       gtk_widget_set_parent (child, GTK_WIDGET (paned));
1108     }
1109 }
1110
1111
1112 static void
1113 gtk_paned_add (GtkContainer *container,
1114                GtkWidget    *widget)
1115 {
1116   GtkPaned *paned;
1117
1118   g_return_if_fail (GTK_IS_PANED (container));
1119
1120   paned = GTK_PANED (container);
1121
1122   if (!paned->child1)
1123     gtk_paned_add1 (paned, widget);
1124   else if (!paned->child2)
1125     gtk_paned_add2 (paned, widget);
1126   else
1127     g_warning ("GtkPaned cannot have more than 2 children\n");
1128 }
1129
1130 static void
1131 gtk_paned_remove (GtkContainer *container,
1132                   GtkWidget    *widget)
1133 {
1134   GtkPaned *paned;
1135   gboolean was_visible;
1136
1137   paned = GTK_PANED (container);
1138   was_visible = GTK_WIDGET_VISIBLE (widget);
1139
1140   if (paned->child1 == widget)
1141     {
1142       gtk_widget_unparent (widget);
1143
1144       paned->child1 = NULL;
1145
1146       if (was_visible && GTK_WIDGET_VISIBLE (container))
1147         gtk_widget_queue_resize (GTK_WIDGET (container));
1148     }
1149   else if (paned->child2 == widget)
1150     {
1151       gtk_widget_unparent (widget);
1152
1153       paned->child2 = NULL;
1154
1155       if (was_visible && GTK_WIDGET_VISIBLE (container))
1156         gtk_widget_queue_resize (GTK_WIDGET (container));
1157     }
1158 }
1159
1160 static void
1161 gtk_paned_forall (GtkContainer *container,
1162                   gboolean      include_internals,
1163                   GtkCallback   callback,
1164                   gpointer      callback_data)
1165 {
1166   GtkPaned *paned;
1167
1168   g_return_if_fail (callback != NULL);
1169
1170   paned = GTK_PANED (container);
1171
1172   if (paned->child1)
1173     (*callback) (paned->child1, callback_data);
1174   if (paned->child2)
1175     (*callback) (paned->child2, callback_data);
1176 }
1177
1178 /**
1179  * gtk_paned_get_position:
1180  * @paned: a #GtkPaned widget
1181  *
1182  * Obtains the position of the divider between the two panes.
1183  *
1184  * Return value: position of the divider
1185  **/
1186 gint
1187 gtk_paned_get_position (GtkPaned  *paned)
1188 {
1189   g_return_val_if_fail (GTK_IS_PANED (paned), 0);
1190
1191   return paned->child1_size;
1192 }
1193
1194 /**
1195  * gtk_paned_set_position:
1196  * @paned: a #GtkPaned widget
1197  * @position: pixel position of divider, a negative value means that the position
1198  *            is unset.
1199  *
1200  * Sets the position of the divider between the two panes.
1201  **/
1202 void
1203 gtk_paned_set_position (GtkPaned *paned,
1204                         gint      position)
1205 {
1206   GObject *object;
1207
1208   g_return_if_fail (GTK_IS_PANED (paned));
1209
1210   object = G_OBJECT (paned);
1211
1212   if (position >= 0)
1213     {
1214       /* We don't clamp here - the assumption is that
1215        * if the total allocation changes at the same time
1216        * as the position, the position set is with reference
1217        * to the new total size. If only the position changes,
1218        * then clamping will occur in gtk_paned_compute_position()
1219        */
1220
1221       paned->child1_size = position;
1222       paned->position_set = TRUE;
1223     }
1224   else
1225     {
1226       paned->position_set = FALSE;
1227     }
1228
1229   g_object_freeze_notify (object);
1230   g_object_notify (object, "position");
1231   g_object_notify (object, "position-set");
1232   g_object_thaw_notify (object);
1233
1234   gtk_widget_queue_resize (GTK_WIDGET (paned));
1235
1236 #ifdef G_OS_WIN32
1237   /* Hacky work-around for bug #144269 */
1238   if (paned->child2 != NULL)
1239     {
1240       gtk_widget_queue_draw (paned->child2);
1241     }
1242 #endif
1243 }
1244
1245 /**
1246  * gtk_paned_get_child1:
1247  * @paned: a #GtkPaned widget
1248  *
1249  * Obtains the first child of the paned widget.
1250  *
1251  * Return value: first child, or %NULL if it is not set.
1252  *
1253  * Since: 2.4
1254  **/
1255 GtkWidget *
1256 gtk_paned_get_child1 (GtkPaned *paned)
1257 {
1258   g_return_val_if_fail (GTK_IS_PANED (paned), NULL);
1259
1260   return paned->child1;
1261 }
1262
1263 /**
1264  * gtk_paned_get_child2:
1265  * @paned: a #GtkPaned widget
1266  *
1267  * Obtains the second child of the paned widget.
1268  *
1269  * Return value: second child, or %NULL if it is not set.
1270  *
1271  * Since: 2.4
1272  **/
1273 GtkWidget *
1274 gtk_paned_get_child2 (GtkPaned *paned)
1275 {
1276   g_return_val_if_fail (GTK_IS_PANED (paned), NULL);
1277
1278   return paned->child2;
1279 }
1280
1281 void
1282 gtk_paned_compute_position (GtkPaned *paned,
1283                             gint      allocation,
1284                             gint      child1_req,
1285                             gint      child2_req)
1286 {
1287   gint old_position;
1288   gint old_min_position;
1289   gint old_max_position;
1290
1291   g_return_if_fail (GTK_IS_PANED (paned));
1292
1293   old_position = paned->child1_size;
1294   old_min_position = paned->min_position;
1295   old_max_position = paned->max_position;
1296
1297   paned->min_position = paned->child1_shrink ? 0 : child1_req;
1298
1299   paned->max_position = allocation;
1300   if (!paned->child2_shrink)
1301     paned->max_position = MAX (1, paned->max_position - child2_req);
1302   paned->max_position = MAX (paned->min_position, paned->max_position);
1303
1304   if (!paned->position_set)
1305     {
1306       if (paned->child1_resize && !paned->child2_resize)
1307         paned->child1_size = MAX (0, allocation - child2_req);
1308       else if (!paned->child1_resize && paned->child2_resize)
1309         paned->child1_size = child1_req;
1310       else if (child1_req + child2_req != 0)
1311         paned->child1_size = allocation * ((gdouble)child1_req / (child1_req + child2_req)) + 0.5;
1312       else
1313         paned->child1_size = allocation * 0.5 + 0.5;
1314     }
1315   else
1316     {
1317       /* If the position was set before the initial allocation.
1318        * (paned->last_allocation <= 0) just clamp it and leave it.
1319        */
1320       if (paned->last_allocation > 0)
1321         {
1322           if (paned->child1_resize && !paned->child2_resize)
1323             paned->child1_size += allocation - paned->last_allocation;
1324           else if (!(!paned->child1_resize && paned->child2_resize))
1325             paned->child1_size = allocation * ((gdouble) paned->child1_size / (paned->last_allocation)) + 0.5;
1326         }
1327     }
1328
1329   paned->child1_size = CLAMP (paned->child1_size,
1330                               paned->min_position,
1331                               paned->max_position);
1332
1333   if (paned->child1)
1334     gtk_widget_set_child_visible (paned->child1, paned->child1_size != 0);
1335
1336   if (paned->child2)
1337     gtk_widget_set_child_visible (paned->child2, paned->child1_size != allocation);
1338
1339   g_object_freeze_notify (G_OBJECT (paned));
1340   if (paned->child1_size != old_position)
1341     g_object_notify (G_OBJECT (paned), "position");
1342   if (paned->min_position != old_min_position)
1343     g_object_notify (G_OBJECT (paned), "min-position");
1344   if (paned->max_position != old_max_position)
1345     g_object_notify (G_OBJECT (paned), "max-position");
1346   g_object_thaw_notify (G_OBJECT (paned));
1347
1348   paned->last_allocation = allocation;
1349 }
1350
1351 static void
1352 gtk_paned_set_saved_focus (GtkPaned *paned, GtkWidget *widget)
1353 {
1354   if (paned->priv->saved_focus)
1355     g_object_remove_weak_pointer (G_OBJECT (paned->priv->saved_focus),
1356                                   (gpointer *)&(paned->priv->saved_focus));
1357
1358   paned->priv->saved_focus = widget;
1359
1360   if (paned->priv->saved_focus)
1361     g_object_add_weak_pointer (G_OBJECT (paned->priv->saved_focus),
1362                                (gpointer *)&(paned->priv->saved_focus));
1363 }
1364
1365 static void
1366 gtk_paned_set_first_paned (GtkPaned *paned, GtkPaned *first_paned)
1367 {
1368   if (paned->priv->first_paned)
1369     g_object_remove_weak_pointer (G_OBJECT (paned->priv->first_paned),
1370                                   (gpointer *)&(paned->priv->first_paned));
1371
1372   paned->priv->first_paned = first_paned;
1373
1374   if (paned->priv->first_paned)
1375     g_object_add_weak_pointer (G_OBJECT (paned->priv->first_paned),
1376                                (gpointer *)&(paned->priv->first_paned));
1377 }
1378
1379 static void
1380 gtk_paned_set_last_child1_focus (GtkPaned *paned, GtkWidget *widget)
1381 {
1382   if (paned->last_child1_focus)
1383     g_object_remove_weak_pointer (G_OBJECT (paned->last_child1_focus),
1384                                   (gpointer *)&(paned->last_child1_focus));
1385
1386   paned->last_child1_focus = widget;
1387
1388   if (paned->last_child1_focus)
1389     g_object_add_weak_pointer (G_OBJECT (paned->last_child1_focus),
1390                                (gpointer *)&(paned->last_child1_focus));
1391 }
1392
1393 static void
1394 gtk_paned_set_last_child2_focus (GtkPaned *paned, GtkWidget *widget)
1395 {
1396   if (paned->last_child2_focus)
1397     g_object_remove_weak_pointer (G_OBJECT (paned->last_child2_focus),
1398                                   (gpointer *)&(paned->last_child2_focus));
1399
1400   paned->last_child2_focus = widget;
1401
1402   if (paned->last_child2_focus)
1403     g_object_add_weak_pointer (G_OBJECT (paned->last_child2_focus),
1404                                (gpointer *)&(paned->last_child2_focus));
1405 }
1406
1407 static GtkWidget *
1408 paned_get_focus_widget (GtkPaned *paned)
1409 {
1410   GtkWidget *toplevel;
1411
1412   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (paned));
1413   if (GTK_WIDGET_TOPLEVEL (toplevel))
1414     return GTK_WINDOW (toplevel)->focus_widget;
1415
1416   return NULL;
1417 }
1418
1419 static void
1420 gtk_paned_set_focus_child (GtkContainer *container,
1421                            GtkWidget    *focus_child)
1422 {
1423   GtkPaned *paned;
1424
1425   g_return_if_fail (GTK_IS_PANED (container));
1426
1427   paned = GTK_PANED (container);
1428
1429   if (focus_child == NULL)
1430     {
1431       GtkWidget *last_focus;
1432       GtkWidget *w;
1433
1434       last_focus = paned_get_focus_widget (paned);
1435
1436       if (last_focus)
1437         {
1438           /* If there is one or more paned widgets between us and the
1439            * focus widget, we want the topmost of those as last_focus
1440            */
1441           for (w = last_focus; w != GTK_WIDGET (paned); w = w->parent)
1442             if (GTK_IS_PANED (w))
1443               last_focus = w;
1444
1445           if (container->focus_child == paned->child1)
1446             gtk_paned_set_last_child1_focus (paned, last_focus);
1447           else if (container->focus_child == paned->child2)
1448             gtk_paned_set_last_child2_focus (paned, last_focus);
1449         }
1450     }
1451
1452   if (GTK_CONTAINER_CLASS (gtk_paned_parent_class)->set_focus_child)
1453     (* GTK_CONTAINER_CLASS (gtk_paned_parent_class)->set_focus_child) (container, focus_child);
1454 }
1455
1456 static void
1457 gtk_paned_get_cycle_chain (GtkPaned          *paned,
1458                            GtkDirectionType   direction,
1459                            GList            **widgets)
1460 {
1461   GtkContainer *container = GTK_CONTAINER (paned);
1462   GtkWidget *ancestor = NULL;
1463   GList *temp_list = NULL;
1464   GList *list;
1465
1466   if (paned->in_recursion)
1467     return;
1468
1469   g_assert (widgets != NULL);
1470
1471   if (paned->last_child1_focus &&
1472       !gtk_widget_is_ancestor (paned->last_child1_focus, GTK_WIDGET (paned)))
1473     {
1474       gtk_paned_set_last_child1_focus (paned, NULL);
1475     }
1476
1477   if (paned->last_child2_focus &&
1478       !gtk_widget_is_ancestor (paned->last_child2_focus, GTK_WIDGET (paned)))
1479     {
1480       gtk_paned_set_last_child2_focus (paned, NULL);
1481     }
1482
1483   if (GTK_WIDGET (paned)->parent)
1484     ancestor = gtk_widget_get_ancestor (GTK_WIDGET (paned)->parent, GTK_TYPE_PANED);
1485
1486   /* The idea here is that temp_list is a list of widgets we want to cycle
1487    * to. The list is prioritized so that the first element is our first
1488    * choice, the next our second, and so on.
1489    *
1490    * We can't just use g_list_reverse(), because we want to try
1491    * paned->last_child?_focus before paned->child?, both when we
1492    * are going forward and backward.
1493    */
1494   if (direction == GTK_DIR_TAB_FORWARD)
1495     {
1496       if (container->focus_child == paned->child1)
1497         {
1498           temp_list = g_list_append (temp_list, paned->last_child2_focus);
1499           temp_list = g_list_append (temp_list, paned->child2);
1500           temp_list = g_list_append (temp_list, ancestor);
1501         }
1502       else if (container->focus_child == paned->child2)
1503         {
1504           temp_list = g_list_append (temp_list, ancestor);
1505           temp_list = g_list_append (temp_list, paned->last_child1_focus);
1506           temp_list = g_list_append (temp_list, paned->child1);
1507         }
1508       else
1509         {
1510           temp_list = g_list_append (temp_list, paned->last_child1_focus);
1511           temp_list = g_list_append (temp_list, paned->child1);
1512           temp_list = g_list_append (temp_list, paned->last_child2_focus);
1513           temp_list = g_list_append (temp_list, paned->child2);
1514           temp_list = g_list_append (temp_list, ancestor);
1515         }
1516     }
1517   else
1518     {
1519       if (container->focus_child == paned->child1)
1520         {
1521           temp_list = g_list_append (temp_list, ancestor);
1522           temp_list = g_list_append (temp_list, paned->last_child2_focus);
1523           temp_list = g_list_append (temp_list, paned->child2);
1524         }
1525       else if (container->focus_child == paned->child2)
1526         {
1527           temp_list = g_list_append (temp_list, paned->last_child1_focus);
1528           temp_list = g_list_append (temp_list, paned->child1);
1529           temp_list = g_list_append (temp_list, ancestor);
1530         }
1531       else
1532         {
1533           temp_list = g_list_append (temp_list, paned->last_child2_focus);
1534           temp_list = g_list_append (temp_list, paned->child2);
1535           temp_list = g_list_append (temp_list, paned->last_child1_focus);
1536           temp_list = g_list_append (temp_list, paned->child1);
1537           temp_list = g_list_append (temp_list, ancestor);
1538         }
1539     }
1540
1541   /* Walk the list and expand all the paned widgets. */
1542   for (list = temp_list; list != NULL; list = list->next)
1543     {
1544       GtkWidget *widget = list->data;
1545
1546       if (widget)
1547         {
1548           if (GTK_IS_PANED (widget))
1549             {
1550               paned->in_recursion = TRUE;
1551               gtk_paned_get_cycle_chain (GTK_PANED (widget), direction, widgets);
1552               paned->in_recursion = FALSE;
1553             }
1554           else
1555             {
1556               *widgets = g_list_append (*widgets, widget);
1557             }
1558         }
1559     }
1560
1561   g_list_free (temp_list);
1562 }
1563
1564 static gboolean
1565 gtk_paned_cycle_child_focus (GtkPaned *paned,
1566                              gboolean  reversed)
1567 {
1568   GList *cycle_chain = NULL;
1569   GList *list;
1570
1571   GtkDirectionType direction = reversed? GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD;
1572
1573   /* ignore f6 if the handle is focused */
1574   if (gtk_widget_is_focus (GTK_WIDGET (paned)))
1575     return TRUE;
1576
1577   /* we can't just let the event propagate up the hierarchy,
1578    * because the paned will want to cycle focus _unless_ an
1579    * ancestor paned handles the event
1580    */
1581   gtk_paned_get_cycle_chain (paned, direction, &cycle_chain);
1582
1583   for (list = cycle_chain; list != NULL; list = list->next)
1584     if (gtk_widget_child_focus (GTK_WIDGET (list->data), direction))
1585       break;
1586
1587   g_list_free (cycle_chain);
1588
1589   return TRUE;
1590 }
1591
1592 static void
1593 get_child_panes (GtkWidget  *widget,
1594                  GList     **panes)
1595 {
1596   if (GTK_IS_PANED (widget))
1597     {
1598       GtkPaned *paned = GTK_PANED (widget);
1599
1600       get_child_panes (paned->child1, panes);
1601       *panes = g_list_prepend (*panes, widget);
1602       get_child_panes (paned->child2, panes);
1603     }
1604   else if (GTK_IS_CONTAINER (widget))
1605     {
1606       gtk_container_forall (GTK_CONTAINER (widget),
1607                              (GtkCallback)get_child_panes, panes);
1608     }
1609 }
1610
1611 static GList *
1612 get_all_panes (GtkPaned *paned)
1613 {
1614   GtkPaned *topmost = NULL;
1615   GList *result = NULL;
1616   GtkWidget *w;
1617
1618   for (w = GTK_WIDGET (paned); w != NULL; w = w->parent)
1619     {
1620       if (GTK_IS_PANED (w))
1621         topmost = GTK_PANED (w);
1622     }
1623
1624   g_assert (topmost);
1625
1626   get_child_panes (GTK_WIDGET (topmost), &result);
1627
1628   return g_list_reverse (result);
1629 }
1630
1631 static void
1632 gtk_paned_find_neighbours (GtkPaned  *paned,
1633                            GtkPaned **next,
1634                            GtkPaned **prev)
1635 {
1636   GList *all_panes;
1637   GList *this_link;
1638
1639   all_panes = get_all_panes (paned);
1640   g_assert (all_panes);
1641
1642   this_link = g_list_find (all_panes, paned);
1643
1644   g_assert (this_link);
1645
1646   if (this_link->next)
1647     *next = this_link->next->data;
1648   else
1649     *next = all_panes->data;
1650
1651   if (this_link->prev)
1652     *prev = this_link->prev->data;
1653   else
1654     *prev = g_list_last (all_panes)->data;
1655
1656   g_list_free (all_panes);
1657 }
1658
1659 static gboolean
1660 gtk_paned_move_handle (GtkPaned      *paned,
1661                        GtkScrollType  scroll)
1662 {
1663   if (gtk_widget_is_focus (GTK_WIDGET (paned)))
1664     {
1665       gint old_position;
1666       gint new_position;
1667       gint increment;
1668
1669       enum {
1670         SINGLE_STEP_SIZE = 1,
1671         PAGE_STEP_SIZE   = 75
1672       };
1673
1674       new_position = old_position = gtk_paned_get_position (paned);
1675       increment = 0;
1676
1677       switch (scroll)
1678         {
1679         case GTK_SCROLL_STEP_LEFT:
1680         case GTK_SCROLL_STEP_UP:
1681         case GTK_SCROLL_STEP_BACKWARD:
1682           increment = - SINGLE_STEP_SIZE;
1683           break;
1684
1685         case GTK_SCROLL_STEP_RIGHT:
1686         case GTK_SCROLL_STEP_DOWN:
1687         case GTK_SCROLL_STEP_FORWARD:
1688           increment = SINGLE_STEP_SIZE;
1689           break;
1690
1691         case GTK_SCROLL_PAGE_LEFT:
1692         case GTK_SCROLL_PAGE_UP:
1693         case GTK_SCROLL_PAGE_BACKWARD:
1694           increment = - PAGE_STEP_SIZE;
1695           break;
1696
1697         case GTK_SCROLL_PAGE_RIGHT:
1698         case GTK_SCROLL_PAGE_DOWN:
1699         case GTK_SCROLL_PAGE_FORWARD:
1700           increment = PAGE_STEP_SIZE;
1701           break;
1702
1703         case GTK_SCROLL_START:
1704           new_position = paned->min_position;
1705           break;
1706
1707         case GTK_SCROLL_END:
1708           new_position = paned->max_position;
1709           break;
1710
1711         default:
1712           break;
1713         }
1714
1715       if (increment)
1716         {
1717           if (is_rtl (paned))
1718             increment = -increment;
1719
1720           new_position = old_position + increment;
1721         }
1722
1723       new_position = CLAMP (new_position, paned->min_position, paned->max_position);
1724
1725       if (old_position != new_position)
1726         gtk_paned_set_position (paned, new_position);
1727
1728       return TRUE;
1729     }
1730
1731   return FALSE;
1732 }
1733
1734 static void
1735 gtk_paned_restore_focus (GtkPaned *paned)
1736 {
1737   if (gtk_widget_is_focus (GTK_WIDGET (paned)))
1738     {
1739       if (paned->priv->saved_focus &&
1740           GTK_WIDGET_SENSITIVE (paned->priv->saved_focus))
1741         {
1742           gtk_widget_grab_focus (paned->priv->saved_focus);
1743         }
1744       else
1745         {
1746           /* the saved focus is somehow not available for focusing,
1747            * try
1748            *   1) tabbing into the paned widget
1749            * if that didn't work,
1750            *   2) unset focus for the window if there is one
1751            */
1752
1753           if (!gtk_widget_child_focus (GTK_WIDGET (paned), GTK_DIR_TAB_FORWARD))
1754             {
1755               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (paned));
1756
1757               if (GTK_IS_WINDOW (toplevel))
1758                 gtk_window_set_focus (GTK_WINDOW (toplevel), NULL);
1759             }
1760         }
1761
1762       gtk_paned_set_saved_focus (paned, NULL);
1763       gtk_paned_set_first_paned (paned, NULL);
1764     }
1765 }
1766
1767 static gboolean
1768 gtk_paned_accept_position (GtkPaned *paned)
1769 {
1770   if (gtk_widget_is_focus (GTK_WIDGET (paned)))
1771     {
1772       paned->original_position = -1;
1773       gtk_paned_restore_focus (paned);
1774
1775       return TRUE;
1776     }
1777
1778   return FALSE;
1779 }
1780
1781
1782 static gboolean
1783 gtk_paned_cancel_position (GtkPaned *paned)
1784 {
1785   if (gtk_widget_is_focus (GTK_WIDGET (paned)))
1786     {
1787       if (paned->original_position != -1)
1788         {
1789           gtk_paned_set_position (paned, paned->original_position);
1790           paned->original_position = -1;
1791         }
1792
1793       gtk_paned_restore_focus (paned);
1794       return TRUE;
1795     }
1796
1797   return FALSE;
1798 }
1799
1800 static gboolean
1801 gtk_paned_cycle_handle_focus (GtkPaned *paned,
1802                               gboolean  reversed)
1803 {
1804   GtkPaned *next, *prev;
1805
1806   if (gtk_widget_is_focus (GTK_WIDGET (paned)))
1807     {
1808       GtkPaned *focus = NULL;
1809
1810       if (!paned->priv->first_paned)
1811         {
1812           /* The first_pane has disappeared. As an ad-hoc solution,
1813            * we make the currently focused paned the first_paned. To the
1814            * user this will seem like the paned cycling has been reset.
1815            */
1816
1817           gtk_paned_set_first_paned (paned, paned);
1818         }
1819
1820       gtk_paned_find_neighbours (paned, &next, &prev);
1821
1822       if (reversed && prev &&
1823           prev != paned && paned != paned->priv->first_paned)
1824         {
1825           focus = prev;
1826         }
1827       else if (!reversed && next &&
1828                next != paned && next != paned->priv->first_paned)
1829         {
1830           focus = next;
1831         }
1832       else
1833         {
1834           gtk_paned_accept_position (paned);
1835           return TRUE;
1836         }
1837
1838       g_assert (focus);
1839
1840       gtk_paned_set_saved_focus (focus, paned->priv->saved_focus);
1841       gtk_paned_set_first_paned (focus, paned->priv->first_paned);
1842
1843       gtk_paned_set_saved_focus (paned, NULL);
1844       gtk_paned_set_first_paned (paned, NULL);
1845
1846       gtk_widget_grab_focus (GTK_WIDGET (focus));
1847
1848       if (!gtk_widget_is_focus (GTK_WIDGET (paned)))
1849         {
1850           paned->original_position = -1;
1851           focus->original_position = gtk_paned_get_position (focus);
1852         }
1853     }
1854   else
1855     {
1856       GtkContainer *container = GTK_CONTAINER (paned);
1857       GtkPaned *focus;
1858       GtkPaned *first;
1859       GtkPaned *prev, *next;
1860       GtkWidget *toplevel;
1861
1862       gtk_paned_find_neighbours (paned, &next, &prev);
1863
1864       if (container->focus_child == paned->child1)
1865         {
1866           if (reversed)
1867             {
1868               focus = prev;
1869               first = paned;
1870             }
1871           else
1872             {
1873               focus = paned;
1874               first = paned;
1875             }
1876         }
1877       else if (container->focus_child == paned->child2)
1878         {
1879           if (reversed)
1880             {
1881               focus = paned;
1882               first = next;
1883             }
1884           else
1885             {
1886               focus = next;
1887               first = next;
1888             }
1889         }
1890       else
1891         {
1892           /* Focus is not inside this paned, and we don't have focus.
1893            * Presumably this happened because the application wants us
1894            * to start keyboard navigating.
1895            */
1896           focus = paned;
1897
1898           if (reversed)
1899             first = paned;
1900           else
1901             first = next;
1902         }
1903
1904       toplevel = gtk_widget_get_toplevel (GTK_WIDGET (paned));
1905
1906       if (GTK_IS_WINDOW (toplevel))
1907         gtk_paned_set_saved_focus (focus, GTK_WINDOW (toplevel)->focus_widget);
1908       gtk_paned_set_first_paned (focus, first);
1909       focus->original_position = gtk_paned_get_position (focus);
1910
1911       gtk_widget_grab_focus (GTK_WIDGET (focus));
1912    }
1913
1914   return TRUE;
1915 }
1916
1917 static gboolean
1918 gtk_paned_toggle_handle_focus (GtkPaned *paned)
1919 {
1920   /* This function/signal has the wrong name. It is called when you
1921    * press Tab or Shift-Tab and what we do is act as if
1922    * the user pressed Return and then Tab or Shift-Tab
1923    */
1924   if (gtk_widget_is_focus (GTK_WIDGET (paned)))
1925     gtk_paned_accept_position (paned);
1926
1927   return FALSE;
1928 }
1929
1930 #define __GTK_PANED_C__
1931 #include "gtkaliasdef.c"