Fix bug encodig missing value keys in gui
[pspp-builds.git] / lib / gtk-contrib / gtkxpaned.c
1 /*******************************************************************************
2 **3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 
3 **      10        20        30        40        50        60        70        80
4 **
5 **  library for GtkXPaned-widget, a 2x2 grid-like variation of GtkPaned of gtk+
6 **  Copyright (C) 2005-2006 Mirco "MacSlow" Müller <macslow@bangang.de>
7 **
8 **  This library is free software; you can redistribute it and/or
9 **  modify it under the terms of the GNU Lesser General Public
10 **  License as published by the Free Software Foundation; either
11 **  version 2.1 of the License, or (at your option) any later version.
12 **
13 **  This library is distributed in the hope that it will be useful,
14 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
15 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 **  Lesser General Public License for more details.
17 **
18 **  You should have received a copy of the GNU Lesser General Public
19 **  License along with this library; if not, write to the Free Software
20 **  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 **
22 **  GtkXPaned is based on GtkPaned which was done by...
23 **
24 **  "Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald"
25 **
26 **  and later modified by...
27 **
28 **  "the GTK+ Team and others 1997-2000"
29 **
30 *******************************************************************************/
31
32 #include <config.h>
33 #include "gtkxpaned.h"
34 #include <ui/gui/psppire-marshal.h>
35 #include <gtk/gtkbindings.h>
36 #include <gtk/gtksignal.h>
37 #include <gdk/gdkkeysyms.h>
38 #include <gtk/gtkwindow.h>
39 #include <gtk/gtkmain.h>
40
41 enum WidgetProperties
42 {
43         PROP_0,
44         PROP_X_POSITION,
45         PROP_Y_POSITION,
46         PROP_POSITION_SET,
47         PROP_MIN_X_POSITION,
48         PROP_MIN_Y_POSITION,
49         PROP_MAX_X_POSITION,
50         PROP_MAX_Y_POSITION
51 };
52
53 enum ChildProperties
54 {
55         CHILD_PROP_0,
56         CHILD_PROP_RESIZE,
57         CHILD_PROP_SHRINK
58 };
59
60 enum WidgetSignals
61 {
62         CYCLE_CHILD_FOCUS,
63         TOGGLE_HANDLE_FOCUS,
64         MOVE_HANDLE,
65         CYCLE_HANDLE_FOCUS,
66         ACCEPT_POSITION,
67         CANCEL_POSITION,
68         LAST_SIGNAL
69 };
70
71 static void gtk_xpaned_class_init (GtkXPanedClass* klass);
72
73 static void gtk_xpaned_init (GtkXPaned* xpaned);
74
75 static void gtk_xpaned_size_request (GtkWidget* widget,
76                                                                          GtkRequisition* requisition);
77
78 static void gtk_xpaned_size_allocate (GtkWidget* widget,
79                                                                           GtkAllocation* allocation);
80
81 static void gtk_xpaned_set_property (GObject* object,
82                                                                          guint prop_id,
83                                                                          const GValue* value,
84                                                                          GParamSpec* pspec);
85
86 static void gtk_xpaned_get_property (GObject* object,
87                                                                          guint prop_id,
88                                                                          GValue* value,
89                                                                          GParamSpec* pspec);
90
91 static void gtk_xpaned_set_child_property (GtkContainer* container,
92                                                                                    GtkWidget* child,
93                                                                                    guint property_id,
94                                                                                    const GValue* value,
95                                                                                    GParamSpec* pspec);
96
97 static void gtk_xpaned_get_child_property (GtkContainer* container,
98                                                                                    GtkWidget* child,
99                                                                                    guint property_id,
100                                                                                    GValue* value,
101                                                                                    GParamSpec* pspec);
102
103 static void gtk_xpaned_finalize (GObject* object);
104
105 static void gtk_xpaned_realize (GtkWidget* widget);
106
107 static void gtk_xpaned_unrealize (GtkWidget* widget);
108
109 static void gtk_xpaned_map (GtkWidget* widget);
110
111 static void gtk_xpaned_unmap (GtkWidget* widget);
112
113 static gboolean gtk_xpaned_expose (GtkWidget* widget, GdkEventExpose* event);
114
115 static gboolean gtk_xpaned_enter (GtkWidget* widget, GdkEventCrossing* event);
116
117 static gboolean gtk_xpaned_leave (GtkWidget* widget, GdkEventCrossing* event);
118
119 static gboolean gtk_xpaned_button_press (GtkWidget* widget,
120                                                                                  GdkEventButton* event);
121
122 static gboolean gtk_xpaned_button_release (GtkWidget* widget,
123                                                                                    GdkEventButton* event);
124
125 static gboolean gtk_xpaned_motion (GtkWidget* widget, GdkEventMotion* event);
126
127 static gboolean gtk_xpaned_focus (GtkWidget* widget,
128                                                                   GtkDirectionType direction);
129
130 static void gtk_xpaned_add (GtkContainer* container, GtkWidget* widget);
131
132 static void gtk_xpaned_remove (GtkContainer* container, GtkWidget* widget);
133
134 static void gtk_xpaned_forall (GtkContainer* container,
135                                                            gboolean include_internals,
136                                                            GtkCallback callback,
137                                                            gpointer callback_data);
138
139 static void gtk_xpaned_set_focus_child (GtkContainer* container,
140                                                                             GtkWidget* child);
141
142 static void gtk_xpaned_set_saved_focus (GtkXPaned* xpaned, GtkWidget* widget);
143
144 static void gtk_xpaned_set_first_xpaned (GtkXPaned* xpaned,
145                                                                                  GtkXPaned* first_xpaned);
146
147 static void gtk_xpaned_set_last_top_left_child_focus (GtkXPaned* xpaned,
148                                                                                                           GtkWidget* widget);
149
150 static void gtk_xpaned_set_last_top_right_child_focus (GtkXPaned* xpaned,
151                                                                                                            GtkWidget* widget);
152
153 static void gtk_xpaned_set_last_bottom_left_child_focus (GtkXPaned* xpaned,
154                                                                                                                  GtkWidget* widget);
155
156 static void gtk_xpaned_set_last_bottom_right_child_focus (GtkXPaned* xpaned,
157                                                                                                                   GtkWidget* widget);
158
159 static gboolean gtk_xpaned_cycle_child_focus (GtkXPaned* xpaned,
160                                                                                           gboolean reverse);
161
162 static gboolean gtk_xpaned_cycle_handle_focus (GtkXPaned* xpaned,
163                                                                                            gboolean reverse);
164
165 static gboolean gtk_xpaned_move_handle (GtkXPaned* xpaned,
166                                                                             GtkScrollType scroll);
167
168 static gboolean gtk_xpaned_accept_position (GtkXPaned* xpaned);
169
170 static gboolean gtk_xpaned_cancel_position (GtkXPaned* xpaned);
171
172 static gboolean gtk_xpaned_toggle_handle_focus (GtkXPaned* xpaned);
173
174 static GType gtk_xpaned_child_type (GtkContainer* container);
175
176 static GtkContainerClass* parent_class = NULL;
177
178 struct _GtkXPanedPrivate
179 {
180         GtkWidget *saved_focus;
181         GtkXPaned *first_xpaned;
182 };
183
184 GType gtk_xpaned_get_type (void)
185 {
186         static GType xpaned_type = 0;
187   
188         if (!xpaned_type)
189         {
190                 static const GTypeInfo xpaned_info =
191                 {
192                         sizeof (GtkXPanedClass),
193                         NULL,           /* base_init */
194                         NULL,           /* base_finalize */
195                         (GClassInitFunc) gtk_xpaned_class_init,
196                         NULL,           /* class_finalize */
197                         NULL,           /* class_data */
198                         sizeof (GtkXPaned),
199                         0,              /* n_preallocs */
200                         (GInstanceInitFunc) gtk_xpaned_init
201                 };
202
203                 xpaned_type = g_type_register_static (GTK_TYPE_CONTAINER,
204                                                                                           "GtkXPaned",
205                                                                                           &xpaned_info,
206                                                                                           0);
207         }
208
209         return xpaned_type;
210 }
211
212 GtkWidget* gtk_xpaned_new (void)
213 {
214         GtkXPaned* xpaned;
215
216         xpaned = g_object_new (GTK_TYPE_XPANED, NULL);
217
218         return GTK_WIDGET (xpaned);
219 }
220
221 static guint signals[LAST_SIGNAL] = { 0 };
222
223 static void add_tab_bindings (GtkBindingSet* binding_set,
224                                                           GdkModifierType modifiers)
225 {
226         gtk_binding_entry_add_signal (binding_set,
227                                                                   GDK_Tab,
228                                                                   modifiers,
229                                                                   "toggle_handle_focus",
230                                                                   0);
231
232         gtk_binding_entry_add_signal (binding_set,
233                                                                   GDK_KP_Tab,
234                                                                   modifiers,
235                                                                   "toggle_handle_focus",
236                                                                   0);
237 }
238
239 static void add_move_binding (GtkBindingSet* binding_set,
240                                                           guint keyval,
241                                                           GdkModifierType mask,
242                                                           GtkScrollType scroll)
243 {
244         gtk_binding_entry_add_signal (binding_set,
245                                                                   keyval,
246                                                                   mask,
247                                                                   "move_handle",
248                                                                   1,
249                                                                   GTK_TYPE_SCROLL_TYPE,
250                                                                   scroll);
251 }
252
253 static void gtk_xpaned_class_init (GtkXPanedClass* class)
254 {
255         GObjectClass* object_class;
256         GtkWidgetClass* widget_class;
257         GtkContainerClass* container_class;
258         GtkXPanedClass* xpaned_class;
259         GtkBindingSet* binding_set;
260
261         object_class = (GObjectClass *) class;
262         widget_class = (GtkWidgetClass *) class;
263         container_class = (GtkContainerClass *) class;
264         xpaned_class = (GtkXPanedClass *) class;
265
266         parent_class = g_type_class_peek_parent (class);
267
268         object_class->set_property = gtk_xpaned_set_property;
269         object_class->get_property = gtk_xpaned_get_property;
270         object_class->finalize = gtk_xpaned_finalize;
271
272         widget_class->realize = gtk_xpaned_realize;
273         widget_class->unrealize = gtk_xpaned_unrealize;
274         widget_class->map = gtk_xpaned_map;
275         widget_class->unmap = gtk_xpaned_unmap;
276         widget_class->expose_event = gtk_xpaned_expose;
277         widget_class->focus = gtk_xpaned_focus;
278         widget_class->enter_notify_event = gtk_xpaned_enter;
279         widget_class->leave_notify_event = gtk_xpaned_leave;
280         widget_class->button_press_event = gtk_xpaned_button_press;
281         widget_class->button_release_event = gtk_xpaned_button_release;
282         widget_class->motion_notify_event = gtk_xpaned_motion;
283         widget_class->size_request = gtk_xpaned_size_request;
284         widget_class->size_allocate = gtk_xpaned_size_allocate;
285
286         container_class->add = gtk_xpaned_add;
287         container_class->remove = gtk_xpaned_remove;
288         container_class->forall = gtk_xpaned_forall;
289         container_class->child_type = gtk_xpaned_child_type;
290         container_class->set_focus_child = gtk_xpaned_set_focus_child;
291         container_class->set_child_property = gtk_xpaned_set_child_property;
292         container_class->get_child_property = gtk_xpaned_get_child_property;
293
294         xpaned_class->cycle_child_focus = gtk_xpaned_cycle_child_focus;
295         xpaned_class->toggle_handle_focus = gtk_xpaned_toggle_handle_focus;
296         xpaned_class->move_handle = gtk_xpaned_move_handle;
297         xpaned_class->cycle_handle_focus = gtk_xpaned_cycle_handle_focus;
298         xpaned_class->accept_position = gtk_xpaned_accept_position;
299         xpaned_class->cancel_position = gtk_xpaned_cancel_position;
300
301         g_object_class_install_property (object_class,
302                                                                          PROP_X_POSITION,
303                                                                          g_param_spec_int ("x-position",
304                                                                                                            ("x-Position"),
305                                                                                                            ("x-Position of paned separator in pixels (0 means all the way to the left)"),
306                                                                                                            0,
307                                                                                                            G_MAXINT,
308                                                                                                            0,
309                                                                                                            G_PARAM_READABLE | G_PARAM_WRITABLE));
310
311         g_object_class_install_property (object_class,
312                                                                          PROP_Y_POSITION,
313                                                                          g_param_spec_int ("y-position",
314                                                                                                            "y-Position",
315                                                                                                            "y-Position of paned separator in pixels (0 means all the way to the top)",
316                                                                                                            0,
317                                                                                                            G_MAXINT,
318                                                                                                            0,
319                                                                                                            G_PARAM_READABLE | G_PARAM_WRITABLE));
320
321         g_object_class_install_property (object_class,
322                                                                          PROP_POSITION_SET,
323                                                                          g_param_spec_boolean ("position-set",
324                                                                                                                    "Position Set",
325                                                                                                                    "TRUE if the Position property should be used",
326                                                                                                                    FALSE,
327                                                                                                                    G_PARAM_READABLE | G_PARAM_WRITABLE));
328                                    
329         gtk_widget_class_install_style_property (widget_class,
330                                                                                          g_param_spec_int ("handle-size",
331                                                                                                                            "Handle Size",
332                                                                                                                            "Width of handle",
333                                                                                                                            0,
334                                                                                                                            G_MAXINT,
335                                                                                                                            3,
336                                                                                                                            G_PARAM_READABLE));
337         /**
338         * GtkXPaned:min-x-position:
339         *
340         * The smallest possible value for the x-position property. This property is derived from the
341         * size and shrinkability of the widget's children.
342         *
343         * Since: 2.4
344         */
345         g_object_class_install_property (object_class,
346                                                                          PROP_MIN_X_POSITION,
347                                                                          g_param_spec_int ("min-x-position",
348                                                                                                            "Minimal x-Position",
349                                                                                                            "Smallest possible value for the \"x-position\" property",
350                                                                                                            0,
351                                                                                                            G_MAXINT,
352                                                                                                            0,
353                                                                                                            G_PARAM_READABLE));
354
355         /**
356         * GtkXPaned:min-y-position:
357         *
358         * The smallest possible value for the y-position property. This property is derived from the
359         * size and shrinkability of the widget's children.
360         *
361         * Since: 2.4
362         */
363         g_object_class_install_property (object_class,
364                                                                          PROP_MIN_Y_POSITION,
365                                                                          g_param_spec_int ("min-y-position",
366                                                                                                            "Minimal y-Position",
367                                                                                                            "Smallest possible value for the \"y-position\" property",
368                                                                                                            0,
369                                                                                                            G_MAXINT,
370                                                                                                            0,
371                                                                                                            G_PARAM_READABLE));
372
373         /**
374         * GtkPaned:max-x-position:
375         *
376         * The largest possible value for the x-position property. This property is derived from the
377         * size and shrinkability of the widget's children.
378         *
379         * Since: 2.4
380         */
381         g_object_class_install_property (object_class,
382                                                                          PROP_MAX_X_POSITION,
383                                                                          g_param_spec_int ("max-x-position",
384                                                                                                            "Maximal x-Position",
385                                                                                                            "Largest possible value for the \"x-position\" property",
386                                                                                                            0,
387                                                                                                            G_MAXINT,
388                                                                                                            G_MAXINT,
389                                                                                                            G_PARAM_READABLE));
390
391         /**
392         * GtkPaned:max-y-position:
393         *
394         * The largest possible value for the y-position property. This property is derived from the
395         * size and shrinkability of the widget's children.
396         *
397         * Since: 2.4
398         */
399         g_object_class_install_property (object_class,
400                                                                          PROP_MAX_Y_POSITION,
401                                                                          g_param_spec_int ("max-y-position",
402                                                                                                            "Maximal y-Position",
403                                                                                                            "Largest possible value for the \"y-position\" property",
404                                                                                                            0,
405                                                                                                            G_MAXINT,
406                                                                                                            G_MAXINT,
407                                                                                                            G_PARAM_READABLE));
408
409         /**
410         * GtkPaned:resize:
411         *
412         * The "resize" child property determines whether the child expands and 
413         * shrinks along with the paned widget.
414         * 
415         * Since: 2.4 
416         */
417         gtk_container_class_install_child_property (container_class,
418                                                                                                 CHILD_PROP_RESIZE,
419                                                                                                 g_param_spec_boolean ("resize",
420                                                                                                                                           "Resize",
421                                                                                                                                           "If TRUE, the child expands and shrinks along with the paned widget",
422                                                                                                                                           TRUE,
423                                                                                                                                           G_PARAM_READWRITE));
424
425         /**
426         * GtkPaned:shrink:
427         *
428         * The "shrink" child property determines whether the child can be made 
429         * smaller than its requisition.
430         * 
431         * Since: 2.4 
432         */
433         gtk_container_class_install_child_property (container_class,
434                                                                                                 CHILD_PROP_SHRINK,
435                                                                                                 g_param_spec_boolean ("shrink", 
436                                                                                                                                           "Shrink",
437                                                                                                                                           "If TRUE, the child can be made smaller than its requisition",
438                                                                                                                                           TRUE,
439                                                                                                                                           G_PARAM_READWRITE));
440
441         signals [CYCLE_CHILD_FOCUS] = g_signal_new ("cycle-child-focus",
442                                                                                                 G_TYPE_FROM_CLASS (object_class),
443                                                                                                 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
444                                                                                                 G_STRUCT_OFFSET (GtkXPanedClass, cycle_child_focus),
445                                                                                                 NULL, NULL,
446                                                                                                 psppire_marshal_BOOLEAN__BOOLEAN,
447                                                                                                 G_TYPE_BOOLEAN, 1,
448                                                                                                 G_TYPE_BOOLEAN);
449
450         signals [TOGGLE_HANDLE_FOCUS] = g_signal_new ("toggle-handle-focus",
451                                                                                                   G_TYPE_FROM_CLASS (object_class),
452                                                                                                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
453                                                                                                   G_STRUCT_OFFSET (GtkXPanedClass, toggle_handle_focus),
454                                                                                                   NULL, NULL,
455                                                                                                   psppire_marshal_BOOLEAN__VOID,
456                                                                                                   G_TYPE_BOOLEAN, 0);
457
458         signals[MOVE_HANDLE] = g_signal_new ("move-handle",
459                                                                                  G_TYPE_FROM_CLASS (object_class),
460                                                                                  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
461                                                                                  G_STRUCT_OFFSET (GtkXPanedClass, move_handle),
462                                                                                  NULL, NULL,
463                                                                                  psppire_marshal_BOOLEAN__ENUM,
464                                                                                  G_TYPE_BOOLEAN, 1,
465                                                                                  GTK_TYPE_SCROLL_TYPE);
466
467         signals [CYCLE_HANDLE_FOCUS] = g_signal_new ("cycle-handle-focus",
468                                                                                                  G_TYPE_FROM_CLASS (object_class),
469                                                                                                  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
470                                                                                                  G_STRUCT_OFFSET (GtkXPanedClass, cycle_handle_focus),
471                                                                                                  NULL, NULL,
472                                                                                                  psppire_marshal_BOOLEAN__BOOLEAN,
473                                                                                                  G_TYPE_BOOLEAN, 1,
474                                                                                                  G_TYPE_BOOLEAN);
475
476         signals [ACCEPT_POSITION] = g_signal_new ("accept-position",
477                                                                                           G_TYPE_FROM_CLASS (object_class),
478                                                                                           G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
479                                                                                           G_STRUCT_OFFSET (GtkXPanedClass, accept_position),
480                                                                                           NULL, NULL,
481                                                                                           psppire_marshal_BOOLEAN__VOID,
482                                                                                           G_TYPE_BOOLEAN, 0);
483
484         signals [CANCEL_POSITION] = g_signal_new ("cancel-position",
485                                                                                           G_TYPE_FROM_CLASS (object_class),
486                                                                                           G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
487                                                                                           G_STRUCT_OFFSET (GtkXPanedClass, cancel_position),
488                                                                                           NULL, NULL,
489                                                                                           psppire_marshal_BOOLEAN__VOID,
490                                                                                           G_TYPE_BOOLEAN, 0);
491
492         binding_set = gtk_binding_set_by_class (class);
493
494         /* F6 and friends */
495         gtk_binding_entry_add_signal (binding_set,
496                                                                   GDK_F6, 0,
497                                                                   "cycle-child-focus", 1, 
498                                                                   G_TYPE_BOOLEAN, FALSE);
499
500         gtk_binding_entry_add_signal (binding_set,
501                                                                   GDK_F6, GDK_SHIFT_MASK,
502                                                                   "cycle-child-focus", 1,
503                                                                   G_TYPE_BOOLEAN, TRUE);
504
505         /* F8 and friends */
506         gtk_binding_entry_add_signal (binding_set,
507                                                                   GDK_F8, 0,
508                                                                   "cycle-handle-focus", 1,
509                                                                   G_TYPE_BOOLEAN, FALSE);
510  
511         gtk_binding_entry_add_signal (binding_set,
512                                                                   GDK_F8, GDK_SHIFT_MASK,
513                                                                   "cycle-handle-focus", 1,
514                                                                   G_TYPE_BOOLEAN, TRUE);
515  
516         add_tab_bindings (binding_set, 0);
517         add_tab_bindings (binding_set, GDK_CONTROL_MASK);
518         add_tab_bindings (binding_set, GDK_SHIFT_MASK);
519         add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK);
520
521         /* accept and cancel positions */
522         gtk_binding_entry_add_signal (binding_set,
523                                                                   GDK_Escape, 0,
524                                                                   "cancel-position", 0);
525
526         gtk_binding_entry_add_signal (binding_set,
527                                                                   GDK_Return, 0,
528                                                                   "accept-position", 0);
529
530         gtk_binding_entry_add_signal (binding_set,
531                                                                   GDK_KP_Enter, 0,
532                                                                   "accept-position", 0);
533
534         gtk_binding_entry_add_signal (binding_set,
535                                                                   GDK_space, 0,
536                                                                   "accept-position", 0);
537                                                                   
538         gtk_binding_entry_add_signal (binding_set,
539                                                                   GDK_KP_Space, 0,
540                                                                   "accept-position", 0);
541
542         /* move handle */
543         add_move_binding (binding_set, GDK_Left, 0, GTK_SCROLL_STEP_LEFT);
544         add_move_binding (binding_set, GDK_KP_Left, 0, GTK_SCROLL_STEP_LEFT);
545         add_move_binding (binding_set, GDK_Left, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_LEFT);
546         add_move_binding (binding_set, GDK_KP_Left, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_LEFT);
547
548         add_move_binding (binding_set, GDK_Right, 0, GTK_SCROLL_STEP_RIGHT);
549         add_move_binding (binding_set, GDK_Right, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_RIGHT);
550         add_move_binding (binding_set, GDK_KP_Right, 0, GTK_SCROLL_STEP_RIGHT);
551         add_move_binding (binding_set, GDK_KP_Right, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_RIGHT);
552
553         add_move_binding (binding_set, GDK_Up, 0, GTK_SCROLL_STEP_UP);
554         add_move_binding (binding_set, GDK_Up, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_UP);
555         add_move_binding (binding_set, GDK_KP_Up, 0, GTK_SCROLL_STEP_UP);
556         add_move_binding (binding_set, GDK_KP_Up, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_UP);
557         add_move_binding (binding_set, GDK_Page_Up, 0, GTK_SCROLL_PAGE_UP);
558         add_move_binding (binding_set, GDK_KP_Page_Up, 0, GTK_SCROLL_PAGE_UP);
559
560         add_move_binding (binding_set, GDK_Down, 0, GTK_SCROLL_STEP_DOWN);
561         add_move_binding (binding_set, GDK_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_DOWN);
562         add_move_binding (binding_set, GDK_KP_Down, 0, GTK_SCROLL_STEP_DOWN);
563         add_move_binding (binding_set, GDK_KP_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_DOWN);
564         add_move_binding (binding_set, GDK_Page_Down, 0, GTK_SCROLL_PAGE_RIGHT);
565         add_move_binding (binding_set, GDK_KP_Page_Down, 0, GTK_SCROLL_PAGE_RIGHT);
566
567         add_move_binding (binding_set, GDK_Home, 0, GTK_SCROLL_START);
568         add_move_binding (binding_set, GDK_KP_Home, 0, GTK_SCROLL_START);
569         add_move_binding (binding_set, GDK_End, 0, GTK_SCROLL_END);
570         add_move_binding (binding_set, GDK_KP_End, 0, GTK_SCROLL_END);
571 }
572
573 static GType gtk_xpaned_child_type (GtkContainer* container)
574 {
575         if (!GTK_XPANED (container)->top_left_child || 
576                 !GTK_XPANED (container)->top_right_child ||
577                 !GTK_XPANED (container)->bottom_left_child || 
578                 !GTK_XPANED (container)->bottom_right_child)
579                 return GTK_TYPE_WIDGET;
580           else
581                 return G_TYPE_NONE;
582 }
583
584 static void gtk_xpaned_init (GtkXPaned* xpaned)
585 {
586         GTK_WIDGET_SET_FLAGS (xpaned, GTK_NO_WINDOW | GTK_CAN_FOCUS);
587   
588         xpaned->top_left_child = NULL;
589         xpaned->top_right_child = NULL;
590         xpaned->bottom_left_child = NULL;
591         xpaned->bottom_right_child = NULL;
592         xpaned->handle_east = NULL;
593         xpaned->handle_west = NULL;
594         xpaned->handle_north = NULL;
595         xpaned->handle_south = NULL;
596         xpaned->handle_middle = NULL;
597         xpaned->xor_gc = NULL;
598         xpaned->cursor_type_east = GDK_SB_V_DOUBLE_ARROW;
599         xpaned->cursor_type_west = GDK_SB_V_DOUBLE_ARROW;
600         xpaned->cursor_type_north = GDK_SB_H_DOUBLE_ARROW;
601         xpaned->cursor_type_south = GDK_SB_H_DOUBLE_ARROW;
602         xpaned->cursor_type_middle = GDK_FLEUR;
603
604         xpaned->handle_pos_east.width = 5;
605         xpaned->handle_pos_east.height = 5;
606         xpaned->handle_pos_west.width = 5;
607         xpaned->handle_pos_west.height = 5;
608         xpaned->handle_pos_north.width = 5;
609         xpaned->handle_pos_north.height = 5;
610         xpaned->handle_pos_south.width = 5;
611         xpaned->handle_pos_south.height = 5;
612         xpaned->handle_pos_middle.width = 5;
613         xpaned->handle_pos_middle.height = 5;
614
615         xpaned->position_set = FALSE;
616         xpaned->last_allocation.width = -1;
617         xpaned->last_allocation.height = -1;
618         xpaned->in_drag_vert = FALSE;
619         xpaned->in_drag_horiz = FALSE;
620         xpaned->in_drag_vert_and_horiz = FALSE;
621
622         xpaned->maximized[GTK_XPANED_TOP_LEFT] = FALSE;
623         xpaned->maximized[GTK_XPANED_TOP_RIGHT] = FALSE;
624         xpaned->maximized[GTK_XPANED_BOTTOM_LEFT] = FALSE;
625         xpaned->maximized[GTK_XPANED_BOTTOM_RIGHT] = FALSE;
626
627         xpaned->priv = g_new0 (GtkXPanedPrivate, 1);
628         xpaned->last_top_left_child_focus = NULL;
629         xpaned->last_top_right_child_focus = NULL;
630         xpaned->last_bottom_left_child_focus = NULL;
631         xpaned->last_bottom_right_child_focus = NULL;
632         xpaned->in_recursion = FALSE;
633         xpaned->handle_prelit = FALSE;
634         xpaned->original_position.x = -1;
635         xpaned->original_position.y = -1;
636         xpaned->unmaximized_position.x = -1;
637         xpaned->unmaximized_position.y = -1;
638
639         xpaned->handle_pos_east.x = -1;
640         xpaned->handle_pos_east.y = -1;
641         xpaned->handle_pos_west.x = -1;
642         xpaned->handle_pos_west.y = -1;
643         xpaned->handle_pos_north.x = -1;
644         xpaned->handle_pos_north.y = -1;
645         xpaned->handle_pos_south.x = -1;
646         xpaned->handle_pos_south.y = -1;
647         xpaned->handle_pos_middle.x = -1;
648         xpaned->handle_pos_middle.y = -1;
649
650         xpaned->drag_pos.x = -1;
651         xpaned->drag_pos.y = -1;
652 }
653
654 static void gtk_xpaned_size_request (GtkWidget* widget,
655                                                                          GtkRequisition* requisition)
656 {
657         GtkXPaned* xpaned = GTK_XPANED (widget);
658         GtkRequisition child_requisition;
659
660         requisition->width = 0;
661         requisition->height = 0;
662
663         if (xpaned->top_left_child && GTK_WIDGET_VISIBLE (xpaned->top_left_child))
664         {
665                 gtk_widget_size_request (xpaned->top_left_child, &child_requisition);
666
667                 requisition->width = child_requisition.width;
668                 requisition->height = child_requisition.height;
669         }
670
671         if (xpaned->top_right_child && GTK_WIDGET_VISIBLE (xpaned->top_right_child))
672         {
673                 gtk_widget_size_request (xpaned->top_right_child, &child_requisition);
674
675                 requisition->width += child_requisition.width;
676                 requisition->height = MAX (requisition->height, child_requisition.height);
677         }
678
679         if (xpaned->bottom_left_child && GTK_WIDGET_VISIBLE (xpaned->bottom_left_child))
680         {
681                 gtk_widget_size_request (xpaned->bottom_left_child, &child_requisition);
682
683                 requisition->width = MAX (requisition->width, child_requisition.width);
684                 requisition->height += child_requisition.height;
685         }
686
687         if (xpaned->bottom_right_child && GTK_WIDGET_VISIBLE (xpaned->bottom_right_child))
688         {
689                 gtk_widget_size_request (xpaned->bottom_right_child, &child_requisition);
690
691                 requisition->width = MAX (requisition->width, child_requisition.width);
692                 requisition->height = MAX (requisition->height, child_requisition.height);
693         }
694
695         /* add 2 times the set border-width to the GtkXPaneds requisition */
696         requisition->width += GTK_CONTAINER (xpaned)->border_width * 2;
697         requisition->height += GTK_CONTAINER (xpaned)->border_width * 2;
698
699         /* also add the handle "thickness" to GtkXPaneds width- and height-requisitions */
700         if (xpaned->top_left_child && GTK_WIDGET_VISIBLE (xpaned->top_left_child) &&
701                 xpaned->top_right_child && GTK_WIDGET_VISIBLE (xpaned->top_right_child) &&
702                 xpaned->bottom_left_child && GTK_WIDGET_VISIBLE (xpaned->bottom_left_child) &&
703                 xpaned->bottom_right_child && GTK_WIDGET_VISIBLE (xpaned->bottom_right_child))
704         {
705                 gint handle_size;
706
707                 gtk_widget_style_get (widget, "handle-size", &handle_size, NULL);
708                 requisition->width += handle_size;
709                 requisition->height += handle_size;
710         }
711 }
712
713 void
714 gtk_xpaned_compute_position (GtkXPaned* xpaned,
715                              const GtkAllocation* allocation,
716                              GtkRequisition* top_left_child_req,
717                              GtkRequisition* top_right_child_req,
718                              GtkRequisition* bottom_left_child_req,
719                              GtkRequisition* bottom_right_child_req);
720
721
722 static void gtk_xpaned_size_allocate (GtkWidget* widget,
723                                                                           GtkAllocation* allocation)
724 {
725         GtkXPaned* xpaned = GTK_XPANED (widget);
726         gint border_width = GTK_CONTAINER (xpaned)->border_width;
727         GtkAllocation top_left_child_allocation;
728         GtkAllocation top_right_child_allocation;
729         GtkAllocation bottom_left_child_allocation;
730         GtkAllocation bottom_right_child_allocation;
731         GtkRequisition top_left_child_requisition;
732         GtkRequisition top_right_child_requisition;
733         GtkRequisition bottom_left_child_requisition;
734         GtkRequisition bottom_right_child_requisition;
735         gint handle_size;
736
737         /* determine size of handle(s) */
738         gtk_widget_style_get (widget, "handle-size", &handle_size, NULL);
739
740         widget->allocation = *allocation;
741
742         if (xpaned->top_left_child && GTK_WIDGET_VISIBLE (xpaned->top_left_child) &&
743                 xpaned->top_right_child && GTK_WIDGET_VISIBLE (xpaned->top_right_child) &&
744                 xpaned->bottom_left_child && GTK_WIDGET_VISIBLE (xpaned->bottom_left_child) &&
745                 xpaned->bottom_right_child && GTK_WIDGET_VISIBLE (xpaned->bottom_right_child))
746     {
747                 /* what sizes do the children want to be at least at */
748                 gtk_widget_get_child_requisition (xpaned->top_left_child,
749                                                                                   &top_left_child_requisition);
750                 gtk_widget_get_child_requisition (xpaned->top_right_child,
751                                                                                   &top_right_child_requisition);
752                 gtk_widget_get_child_requisition (xpaned->bottom_left_child,
753                                                                                   &bottom_left_child_requisition);
754                 gtk_widget_get_child_requisition (xpaned->bottom_right_child,
755                                                                                   &bottom_right_child_requisition);
756
757                 /* determine the total requisition-sum of all requisitions of borders,
758                  * handles, children etc. */
759                 gtk_xpaned_compute_position (xpaned,
760                                                                          allocation,
761                                                                          &top_left_child_requisition,
762                                                                          &top_right_child_requisition,
763                                                                          &bottom_left_child_requisition,
764                                                                          &bottom_right_child_requisition);
765
766                 /* calculate the current positions and sizes of the handles */
767                 xpaned->handle_pos_east.x = widget->allocation.x + border_width + xpaned->top_left_child_size.width + handle_size;
768                 xpaned->handle_pos_east.y = widget->allocation.y + border_width + xpaned->top_left_child_size.height;
769                 xpaned->handle_pos_east.width = widget->allocation.width - xpaned->top_left_child_size.width - 2 * border_width - handle_size;
770                 xpaned->handle_pos_east.height = handle_size;
771
772                 xpaned->handle_pos_west.x = widget->allocation.x + border_width;
773                 xpaned->handle_pos_west.y = xpaned->handle_pos_east.y;
774                 xpaned->handle_pos_west.width = widget->allocation.width - xpaned->handle_pos_east.width - 2 * border_width - handle_size;
775                 xpaned->handle_pos_west.height = handle_size;
776
777                 xpaned->handle_pos_north.x = xpaned->handle_pos_east.x - handle_size;
778                 xpaned->handle_pos_north.y = widget->allocation.y + border_width;
779                 xpaned->handle_pos_north.width = handle_size;
780                 xpaned->handle_pos_north.height = xpaned->handle_pos_east.y - widget->allocation.y - border_width;
781
782                 xpaned->handle_pos_south.x = xpaned->handle_pos_north.x;
783                 xpaned->handle_pos_south.y = xpaned->handle_pos_east.y + handle_size;
784                 xpaned->handle_pos_south.width = handle_size;
785                 xpaned->handle_pos_south.height = widget->allocation.height - xpaned->handle_pos_north.height - 2 * border_width - handle_size;
786
787
788 #define CENTRUM 20
789                 xpaned->handle_pos_middle.x = xpaned->handle_pos_north.x ;
790                 xpaned->handle_pos_middle.y = xpaned->handle_pos_east.y ;
791                 xpaned->handle_pos_middle.width = handle_size + CENTRUM ;
792                 xpaned->handle_pos_middle.height = handle_size + CENTRUM;
793
794                 /* set allocation for top-left child */
795                 top_left_child_allocation.x = widget->allocation.x + border_width;
796                 top_left_child_allocation.y = widget->allocation.y + border_width;
797                 top_left_child_allocation.width = xpaned->handle_pos_west.width;
798                 top_left_child_allocation.height = xpaned->handle_pos_north.height;
799
800                 /* set allocation for top-right child */
801                 top_right_child_allocation.x = widget->allocation.x + border_width + handle_size + top_left_child_allocation.width;
802                 top_right_child_allocation.y = widget->allocation.y + border_width;
803                 top_right_child_allocation.width = xpaned->handle_pos_east.width;
804                 top_right_child_allocation.height = xpaned->handle_pos_north.height;
805
806                 /* set allocation for bottom-left child */
807                 bottom_left_child_allocation.x = xpaned->handle_pos_west.x;
808                 bottom_left_child_allocation.y = xpaned->handle_pos_south.y;
809                 bottom_left_child_allocation.width = xpaned->handle_pos_west.width;
810                 bottom_left_child_allocation.height = xpaned->handle_pos_south.height;
811
812                 /* set allocation for bottom-right child */
813                 bottom_right_child_allocation.x = top_right_child_allocation.x;
814                 bottom_right_child_allocation.y = bottom_left_child_allocation.y;
815                 bottom_right_child_allocation.width = xpaned->handle_pos_east.width;
816                 bottom_right_child_allocation.height = xpaned->handle_pos_south.height;
817
818                 if (GTK_WIDGET_REALIZED (widget))
819                 {
820                         if (GTK_WIDGET_MAPPED (widget))
821                         {
822                                 gdk_window_show (xpaned->handle_east);
823                                 gdk_window_show (xpaned->handle_west);
824                                 gdk_window_show (xpaned->handle_north);
825                                 gdk_window_show (xpaned->handle_south);
826                                 gdk_window_show (xpaned->handle_middle);
827                         }
828
829                         gdk_window_move_resize (xpaned->handle_east,
830                                                                         xpaned->handle_pos_east.x,
831                                                                         xpaned->handle_pos_east.y,
832                                                                         xpaned->handle_pos_east.width,
833                                                                         xpaned->handle_pos_east.height);
834
835                         gdk_window_move_resize (xpaned->handle_west,
836                                                                         xpaned->handle_pos_west.x,
837                                                                         xpaned->handle_pos_west.y,
838                                                                         xpaned->handle_pos_west.width,
839                                                                         xpaned->handle_pos_west.height);
840
841                         gdk_window_move_resize (xpaned->handle_north,
842                                                                         xpaned->handle_pos_north.x,
843                                                                         xpaned->handle_pos_north.y,
844                                                                         xpaned->handle_pos_north.width,
845                                                                         xpaned->handle_pos_north.height);
846
847                         gdk_window_move_resize (xpaned->handle_south,
848                                                                         xpaned->handle_pos_south.x,
849                                                                         xpaned->handle_pos_south.y,
850                                                                         xpaned->handle_pos_south.width,
851                                                                         xpaned->handle_pos_south.height);
852
853                         gdk_window_move_resize (xpaned->handle_middle,
854                                                 xpaned->handle_pos_middle.x,
855                                                 xpaned->handle_pos_middle.y,
856                                                 xpaned->handle_pos_middle.width,
857                                                 xpaned->handle_pos_middle.height);
858                 }
859
860                 /* Now allocate the childen, making sure, when resizing not to
861                 * overlap the windows
862                 */
863                 if (GTK_WIDGET_MAPPED (widget))
864                 {
865                         gtk_widget_size_allocate (xpaned->top_right_child, &top_right_child_allocation);
866                         gtk_widget_size_allocate (xpaned->top_left_child, &top_left_child_allocation);
867                         gtk_widget_size_allocate (xpaned->bottom_left_child, &bottom_left_child_allocation);
868                         gtk_widget_size_allocate (xpaned->bottom_right_child, &bottom_right_child_allocation);
869                 }
870         }
871 }
872
873 static void gtk_xpaned_set_property (GObject* object,
874                                                                          guint prop_id,
875                                                                          const GValue* value,
876                                                                          GParamSpec* pspec)
877 {
878         GtkXPaned* xpaned = GTK_XPANED (object);
879   
880         switch (prop_id)
881         {
882                 case PROP_X_POSITION:
883                         gtk_xpaned_set_position_x (xpaned, g_value_get_int (value));
884                 break;
885
886                 case PROP_Y_POSITION:
887                         gtk_xpaned_set_position_y (xpaned, g_value_get_int (value));
888                 break;
889
890                 case PROP_POSITION_SET:
891                         xpaned->position_set = g_value_get_boolean (value);
892                         gtk_widget_queue_resize (GTK_WIDGET (xpaned));
893                 break;
894
895                 default:
896                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
897                 break;
898         }
899 }
900
901 static void gtk_xpaned_get_property (GObject* object,
902                                                                          guint prop_id,
903                                                                          GValue* value,
904                                                                          GParamSpec* pspec)
905 {
906         GtkXPaned* xpaned = GTK_XPANED (object);
907   
908         switch (prop_id)
909         {
910                 case PROP_X_POSITION:
911                         g_value_set_int (value, xpaned->top_left_child_size.width);
912                 break;
913
914                 case PROP_Y_POSITION:
915                         g_value_set_int (value, xpaned->top_left_child_size.height);
916                 break;
917
918                 case PROP_POSITION_SET:
919                         g_value_set_boolean (value, xpaned->position_set);
920                 break;
921
922                 case PROP_MIN_X_POSITION:
923                         g_value_set_int (value, xpaned->min_position.x);
924                 break;
925
926                 case PROP_MIN_Y_POSITION:
927                         g_value_set_int (value, xpaned->min_position.y);
928                 break;
929
930                 case PROP_MAX_X_POSITION:
931                         g_value_set_int (value, xpaned->max_position.x);
932                 break;
933
934                 case PROP_MAX_Y_POSITION:
935                         g_value_set_int (value, xpaned->max_position.y);
936                 break;
937
938                 default:
939                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
940                 break;
941         }
942 }
943
944 static void gtk_xpaned_set_child_property (GtkContainer* container,
945                                                                                    GtkWidget* child,
946                                                                                    guint property_id,
947                                                                                    const GValue* value,
948                                                                                    GParamSpec* pspec)
949 {
950         GtkXPaned* xpaned = GTK_XPANED (container);
951         gboolean old_value = FALSE;
952         gboolean new_value = FALSE;
953
954         g_assert (child == xpaned->top_left_child ||
955                           child == xpaned->top_right_child ||
956                           child == xpaned->bottom_left_child ||
957                           child == xpaned->bottom_right_child);
958
959         new_value = g_value_get_boolean (value);
960
961         switch (property_id)
962         {
963                 case CHILD_PROP_RESIZE:
964                         if (child == xpaned->top_left_child)
965                         {
966                                 old_value = xpaned->top_left_child_resize;
967                                 xpaned->top_left_child_resize = new_value;
968                         }
969                         else if (child == xpaned->top_right_child)
970                         {
971                                 old_value = xpaned->top_right_child_resize;
972                                 xpaned->top_right_child_resize = new_value;
973                         }
974                         else if (child == xpaned->bottom_left_child)
975                         {
976                                 old_value = xpaned->bottom_left_child_resize;
977                                 xpaned->bottom_left_child_resize = new_value;
978                         }
979                         else if (child == xpaned->bottom_right_child)
980                         {
981                                 old_value = xpaned->bottom_right_child_resize;
982                                 xpaned->bottom_right_child_resize = new_value;
983                         }
984                 break;
985
986                 case CHILD_PROP_SHRINK :
987                         if (child == xpaned->top_left_child)
988                         {
989                                 old_value = xpaned->top_left_child_shrink;
990                                 xpaned->top_left_child_shrink = new_value;
991                         }
992                         else if (child == xpaned->top_right_child)
993                         {
994                                 old_value = xpaned->top_right_child_shrink;
995                                 xpaned->top_right_child_shrink = new_value;
996                         }
997                         else if (child == xpaned->bottom_left_child)
998                         {
999                                 old_value = xpaned->bottom_left_child_shrink;
1000                                 xpaned->bottom_left_child_shrink = new_value;
1001                         }
1002                         else if (child == xpaned->bottom_right_child)
1003                         {
1004                                 old_value = xpaned->bottom_right_child_shrink;
1005                                 xpaned->bottom_right_child_shrink = new_value;
1006                         }
1007                 break;
1008
1009                 default:
1010                         GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container,
1011                                                                                                                   property_id,
1012                                                                                                                   pspec);
1013                         old_value = -1; /* quiet gcc */
1014                 break;
1015         }
1016
1017         if (old_value != new_value)
1018                 gtk_widget_queue_resize (GTK_WIDGET (container));
1019 }
1020
1021 static void gtk_xpaned_get_child_property (GtkContainer* container,
1022                                                                                    GtkWidget* child,
1023                                                                                    guint property_id,
1024                                                                                    GValue* value,
1025                                                                                    GParamSpec* pspec)
1026 {
1027         GtkXPaned* xpaned = GTK_XPANED (container);
1028
1029         g_assert (child == xpaned->top_left_child ||
1030                           child == xpaned->top_right_child ||
1031                           child == xpaned->bottom_left_child ||
1032                           child == xpaned->bottom_right_child);
1033
1034         switch (property_id)
1035         {
1036                 case CHILD_PROP_RESIZE :
1037                         if (child == xpaned->top_left_child)
1038                                 g_value_set_boolean (value, xpaned->top_left_child_resize);
1039                         else if (child == xpaned->top_right_child)
1040                                 g_value_set_boolean (value, xpaned->top_right_child_resize);
1041                         else if (child == xpaned->bottom_left_child)
1042                                 g_value_set_boolean (value, xpaned->bottom_left_child_resize);
1043                         else if (child == xpaned->bottom_right_child)
1044                                 g_value_set_boolean (value, xpaned->bottom_right_child_resize);                 
1045                 break;
1046
1047                 case CHILD_PROP_SHRINK :
1048                         if (child == xpaned->top_left_child)
1049                                 g_value_set_boolean (value, xpaned->top_left_child_shrink);
1050                         else if (child == xpaned->top_right_child)
1051                                 g_value_set_boolean (value, xpaned->top_right_child_shrink);
1052                         else if (child == xpaned->bottom_left_child)
1053                                 g_value_set_boolean (value, xpaned->bottom_left_child_shrink);
1054                         else if (child == xpaned->bottom_right_child)
1055                                 g_value_set_boolean (value, xpaned->bottom_right_child_shrink);
1056                 break;
1057
1058                 default:
1059                         GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container,
1060                                                                                                                   property_id,
1061                                                                                                                   pspec);
1062                 break;
1063         }
1064 }
1065
1066 static void gtk_xpaned_finalize (GObject* object)
1067 {
1068         GtkXPaned* xpaned = GTK_XPANED (object);
1069   
1070         gtk_xpaned_set_saved_focus (xpaned, NULL);
1071         gtk_xpaned_set_first_xpaned (xpaned, NULL);
1072
1073         g_free (xpaned->priv);
1074
1075         G_OBJECT_CLASS (parent_class)->finalize (object);
1076 }
1077
1078 static void gtk_xpaned_realize (GtkWidget* widget)
1079 {
1080         GtkXPaned* xpaned;
1081         GdkWindowAttr attributes_east;
1082         GdkWindowAttr attributes_west;
1083         GdkWindowAttr attributes_north;
1084         GdkWindowAttr attributes_south;
1085         GdkWindowAttr attributes_middle;
1086         gint attributes_mask_east;
1087         gint attributes_mask_west;
1088         gint attributes_mask_north;
1089         gint attributes_mask_south;
1090         gint attributes_mask_middle;
1091
1092         GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1093         xpaned = GTK_XPANED (widget);
1094
1095         widget->window = gtk_widget_get_parent_window (widget);
1096         g_object_ref (widget->window);
1097   
1098         attributes_east.window_type = GDK_WINDOW_CHILD;
1099         attributes_west.window_type = GDK_WINDOW_CHILD;
1100         attributes_north.window_type = GDK_WINDOW_CHILD;
1101         attributes_south.window_type = GDK_WINDOW_CHILD;
1102         attributes_middle.window_type = GDK_WINDOW_CHILD;
1103
1104         attributes_east.wclass = GDK_INPUT_ONLY;
1105         attributes_west.wclass = GDK_INPUT_ONLY;
1106         attributes_north.wclass = GDK_INPUT_ONLY;
1107         attributes_south.wclass = GDK_INPUT_ONLY;
1108         attributes_middle.wclass = GDK_INPUT_ONLY;
1109
1110         attributes_east.x = xpaned->handle_pos_east.x;
1111         attributes_east.y = xpaned->handle_pos_east.y;
1112         attributes_east.width = xpaned->handle_pos_east.width;
1113         attributes_east.height = xpaned->handle_pos_east.height;
1114
1115         attributes_west.x = xpaned->handle_pos_west.x;
1116         attributes_west.y = xpaned->handle_pos_west.y;
1117         attributes_west.width = xpaned->handle_pos_west.width;
1118         attributes_west.height = xpaned->handle_pos_west.height;
1119
1120         attributes_north.x = xpaned->handle_pos_north.x;
1121         attributes_north.y = xpaned->handle_pos_north.y;
1122         attributes_north.width = xpaned->handle_pos_north.width;
1123         attributes_north.height = xpaned->handle_pos_north.height;
1124
1125         attributes_south.x = xpaned->handle_pos_south.x;
1126         attributes_south.y = xpaned->handle_pos_south.y;
1127         attributes_south.width = xpaned->handle_pos_south.width;
1128         attributes_south.height = xpaned->handle_pos_south.height;
1129
1130         attributes_middle.x = xpaned->handle_pos_middle.x;
1131         attributes_middle.y = xpaned->handle_pos_middle.y;
1132         attributes_middle.width = xpaned->handle_pos_middle.width;
1133         attributes_middle.height = xpaned->handle_pos_middle.height;
1134
1135         attributes_east.cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
1136                                                                                                         xpaned->cursor_type_east);
1137         attributes_west.cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
1138                                                                                                         xpaned->cursor_type_west);
1139         attributes_north.cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
1140                                                                                                         xpaned->cursor_type_north);
1141         attributes_south.cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
1142                                                                                                         xpaned->cursor_type_south);
1143         attributes_middle.cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
1144                                                                                                         xpaned->cursor_type_middle);
1145
1146         attributes_east.event_mask = gtk_widget_get_events (widget);
1147         attributes_west.event_mask = gtk_widget_get_events (widget);
1148         attributes_north.event_mask = gtk_widget_get_events (widget);
1149         attributes_south.event_mask = gtk_widget_get_events (widget);
1150         attributes_middle.event_mask = gtk_widget_get_events (widget);
1151
1152         attributes_east.event_mask |= (GDK_BUTTON_PRESS_MASK |
1153                                                           GDK_BUTTON_RELEASE_MASK |
1154                                                           GDK_ENTER_NOTIFY_MASK |
1155                                                           GDK_LEAVE_NOTIFY_MASK |
1156                                                           GDK_POINTER_MOTION_MASK |
1157                                                           GDK_POINTER_MOTION_HINT_MASK);
1158         attributes_west.event_mask |= (GDK_BUTTON_PRESS_MASK |
1159                                                           GDK_BUTTON_RELEASE_MASK |
1160                                                           GDK_ENTER_NOTIFY_MASK |
1161                                                           GDK_LEAVE_NOTIFY_MASK |
1162                                                           GDK_POINTER_MOTION_MASK |
1163                                                           GDK_POINTER_MOTION_HINT_MASK);
1164         attributes_north.event_mask |= (GDK_BUTTON_PRESS_MASK |
1165                                                           GDK_BUTTON_RELEASE_MASK |
1166                                                           GDK_ENTER_NOTIFY_MASK |
1167                                                           GDK_LEAVE_NOTIFY_MASK |
1168                                                           GDK_POINTER_MOTION_MASK |
1169                                                           GDK_POINTER_MOTION_HINT_MASK);
1170         attributes_south.event_mask |= (GDK_BUTTON_PRESS_MASK |
1171                                                           GDK_BUTTON_RELEASE_MASK |
1172                                                           GDK_ENTER_NOTIFY_MASK |
1173                                                           GDK_LEAVE_NOTIFY_MASK |
1174                                                           GDK_POINTER_MOTION_MASK |
1175                                                           GDK_POINTER_MOTION_HINT_MASK);
1176         attributes_middle.event_mask |= (GDK_BUTTON_PRESS_MASK |
1177                                                           GDK_BUTTON_RELEASE_MASK |
1178                                                           GDK_ENTER_NOTIFY_MASK |
1179                                                           GDK_LEAVE_NOTIFY_MASK |
1180                                                           GDK_POINTER_MOTION_MASK |
1181                                                           GDK_POINTER_MOTION_HINT_MASK);
1182
1183         attributes_mask_east = GDK_WA_X | GDK_WA_Y | GDK_WA_CURSOR;
1184         attributes_mask_west = GDK_WA_X | GDK_WA_Y | GDK_WA_CURSOR;
1185         attributes_mask_north = GDK_WA_X | GDK_WA_Y | GDK_WA_CURSOR;
1186         attributes_mask_south = GDK_WA_X | GDK_WA_Y | GDK_WA_CURSOR;
1187         attributes_mask_middle = GDK_WA_X | GDK_WA_Y | GDK_WA_CURSOR;
1188
1189         xpaned->handle_east = gdk_window_new (widget->window,
1190                                                                                   &attributes_east,
1191                                                                                   attributes_mask_east);
1192         xpaned->handle_west = gdk_window_new (widget->window,
1193                                                                                   &attributes_west,
1194                                                                                   attributes_mask_west);
1195         xpaned->handle_north = gdk_window_new (widget->window,
1196                                                                                   &attributes_north,
1197                                                                                   attributes_mask_north);
1198         xpaned->handle_south = gdk_window_new (widget->window,
1199                                                                                   &attributes_south,
1200                                                                                   attributes_mask_south);
1201         xpaned->handle_middle = gdk_window_new (widget->window,
1202                                                                                   &attributes_middle,
1203                                                                                   attributes_mask_middle);
1204
1205         gdk_window_set_user_data (xpaned->handle_east, xpaned);
1206         gdk_window_set_user_data (xpaned->handle_west, xpaned);
1207         gdk_window_set_user_data (xpaned->handle_north, xpaned);
1208         gdk_window_set_user_data (xpaned->handle_south, xpaned);
1209         gdk_window_set_user_data (xpaned->handle_middle, xpaned);
1210
1211         gdk_cursor_unref (attributes_east.cursor);
1212         gdk_cursor_unref (attributes_west.cursor);
1213         gdk_cursor_unref (attributes_north.cursor);
1214         gdk_cursor_unref (attributes_south.cursor);
1215         gdk_cursor_unref (attributes_middle.cursor);
1216
1217         widget->style = gtk_style_attach (widget->style, widget->window);
1218
1219         if (xpaned->top_left_child && GTK_WIDGET_VISIBLE (xpaned->top_left_child) &&
1220                 xpaned->top_right_child && GTK_WIDGET_VISIBLE (xpaned->top_right_child) &&
1221                 xpaned->bottom_left_child && GTK_WIDGET_VISIBLE (xpaned->bottom_left_child) &&
1222                 xpaned->bottom_right_child && GTK_WIDGET_VISIBLE (xpaned->bottom_right_child))
1223         {
1224                 gdk_window_show (xpaned->handle_east);
1225                 gdk_window_show (xpaned->handle_west);
1226                 gdk_window_show (xpaned->handle_north);
1227                 gdk_window_show (xpaned->handle_south);
1228                 gdk_window_show (xpaned->handle_middle);
1229         }
1230 }
1231
1232 static void gtk_xpaned_unrealize (GtkWidget *widget)
1233 {
1234         GtkXPaned* xpaned = GTK_XPANED (widget);
1235
1236         if (xpaned->xor_gc)
1237         {
1238                 g_object_unref (xpaned->xor_gc);
1239                 xpaned->xor_gc = NULL;
1240         }
1241
1242         if (xpaned->handle_east)
1243         {
1244                 gdk_window_set_user_data (xpaned->handle_east, NULL);
1245                 gdk_window_destroy (xpaned->handle_east);
1246                 xpaned->handle_east = NULL;
1247         }
1248
1249         if (xpaned->handle_west)
1250         {
1251                 gdk_window_set_user_data (xpaned->handle_west, NULL);
1252                 gdk_window_destroy (xpaned->handle_west);
1253                 xpaned->handle_west = NULL;
1254         }
1255
1256         if (xpaned->handle_north)
1257         {
1258                 gdk_window_set_user_data (xpaned->handle_north, NULL);
1259                 gdk_window_destroy (xpaned->handle_north);
1260                 xpaned->handle_north = NULL;
1261         }
1262
1263         if (xpaned->handle_south)
1264         {
1265                 gdk_window_set_user_data (xpaned->handle_south, NULL);
1266                 gdk_window_destroy (xpaned->handle_south);
1267                 xpaned->handle_south = NULL;
1268         }
1269
1270         if (xpaned->handle_middle)
1271         {
1272                 gdk_window_set_user_data (xpaned->handle_middle, NULL);
1273                 gdk_window_destroy (xpaned->handle_middle);
1274                 xpaned->handle_middle = NULL;
1275         }
1276
1277         gtk_xpaned_set_last_top_left_child_focus (xpaned, NULL);
1278         gtk_xpaned_set_last_top_right_child_focus (xpaned, NULL);
1279         gtk_xpaned_set_last_bottom_left_child_focus (xpaned, NULL);
1280         gtk_xpaned_set_last_bottom_right_child_focus (xpaned, NULL);
1281         gtk_xpaned_set_saved_focus (xpaned, NULL);
1282         gtk_xpaned_set_first_xpaned (xpaned, NULL);
1283   
1284         if (GTK_WIDGET_CLASS (parent_class)->unrealize)
1285                 (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
1286 }
1287
1288 static void gtk_xpaned_map (GtkWidget* widget)
1289 {
1290         GtkXPaned* xpaned = GTK_XPANED (widget);
1291
1292         gdk_window_show (xpaned->handle_east);
1293         gdk_window_show (xpaned->handle_west);
1294         gdk_window_show (xpaned->handle_north);
1295         gdk_window_show (xpaned->handle_south);
1296         gdk_window_show (xpaned->handle_middle);
1297
1298         GTK_WIDGET_CLASS (parent_class)->map (widget);
1299 }
1300
1301 static void gtk_xpaned_unmap (GtkWidget* widget)
1302 {
1303         GtkXPaned* xpaned = GTK_XPANED (widget);
1304
1305         gdk_window_hide (xpaned->handle_east);
1306         gdk_window_hide (xpaned->handle_west);
1307         gdk_window_hide (xpaned->handle_north);
1308         gdk_window_hide (xpaned->handle_south);
1309         gdk_window_hide (xpaned->handle_middle);
1310
1311         GTK_WIDGET_CLASS (parent_class)->unmap (widget);
1312 }
1313
1314 static gboolean gtk_xpaned_expose (GtkWidget* widget,
1315                                                                    GdkEventExpose* event)
1316 {
1317         GtkXPaned* xpaned = GTK_XPANED (widget);
1318         gint handle_size;
1319         GdkRectangle horizontalClipArea;
1320         GdkRectangle verticalClipArea;
1321
1322         /* determine size of handle(s) */
1323         gtk_widget_style_get (widget, "handle-size", &handle_size, NULL);
1324
1325         /* I want the handle-"thickness" to be at least 3 */
1326         g_assert (handle_size >= 3);
1327
1328         if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget) &&
1329                 xpaned->top_left_child && GTK_WIDGET_VISIBLE (xpaned->top_left_child) &&
1330                 xpaned->top_right_child && GTK_WIDGET_VISIBLE (xpaned->top_right_child) &&
1331                 xpaned->bottom_left_child && GTK_WIDGET_VISIBLE (xpaned->bottom_left_child) &&
1332                 xpaned->bottom_right_child && GTK_WIDGET_VISIBLE (xpaned->bottom_right_child))
1333     {
1334                 GtkStateType state;
1335
1336                 if (gtk_widget_is_focus (widget))
1337                         state = GTK_STATE_SELECTED;
1338                 else if (xpaned->handle_prelit)
1339                         state = GTK_STATE_PRELIGHT;
1340                 else
1341                         state = GTK_WIDGET_STATE (widget);
1342
1343                 horizontalClipArea.x = xpaned->handle_pos_west.x;
1344                 horizontalClipArea.y = xpaned->handle_pos_west.y;
1345                 horizontalClipArea.width = xpaned->handle_pos_west.width + handle_size + xpaned->handle_pos_east.width;
1346                 horizontalClipArea.height = handle_size;
1347
1348                 verticalClipArea.x = xpaned->handle_pos_north.x;
1349                 verticalClipArea.y = xpaned->handle_pos_north.y;
1350                 verticalClipArea.width = handle_size;
1351                 verticalClipArea.height = xpaned->handle_pos_north.height + handle_size + xpaned->handle_pos_south.height;
1352
1353                 gtk_paint_handle (widget->style,
1354                                                   widget->window,
1355                                                   state,
1356                                                   GTK_SHADOW_NONE,
1357                                                   &horizontalClipArea,
1358                                                   widget,
1359                                                   "paned",
1360                                                   xpaned->handle_pos_east.x - handle_size - 256 / 2,
1361                                                   xpaned->handle_pos_west.y + 1,
1362                                                   256 + handle_size,
1363                                                   handle_size - 2,
1364                                                   /*xpaned->handle_pos_west.x,
1365                                                   xpaned->handle_pos_west.y + 1,
1366                                                   xpaned->handle_pos_west.width + handle_size + xpaned->handle_pos_east.width,
1367                                                   handle_size - 2,*/
1368                                                   GTK_ORIENTATION_HORIZONTAL);
1369                 gtk_paint_handle (widget->style,
1370                                                   widget->window,
1371                                                   state,
1372                                                   GTK_SHADOW_NONE,
1373                                                   &verticalClipArea,
1374                                                   widget,
1375                                                   "paned",
1376                                                   xpaned->handle_pos_north.x + 1,
1377                                                   xpaned->handle_pos_south.y - handle_size - 256 / 2,
1378                                                   handle_size - 2,
1379                                                   256 + handle_size,
1380                                                   /*xpaned->handle_pos_north.x + 1,
1381                                                   xpaned->handle_pos_north.y,
1382                                                   handle_size - 2,
1383                                                   xpaned->handle_pos_north.height + handle_size + xpaned->handle_pos_south.height,*/
1384                                                   GTK_ORIENTATION_VERTICAL);
1385         }
1386
1387         /* Chain up to draw children */
1388         GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
1389   
1390         return FALSE;
1391 }
1392
1393 static gboolean is_rtl (GtkXPaned* xpaned)
1394 {
1395         if (gtk_widget_get_direction (GTK_WIDGET (xpaned)) == GTK_TEXT_DIR_RTL)
1396                 return TRUE;
1397
1398         return FALSE;
1399 }
1400
1401 static void update_drag (GtkXPaned* xpaned)
1402 {
1403         GdkPoint pos;
1404         gint handle_size;
1405         GtkRequisition size;
1406   
1407         gtk_widget_get_pointer (GTK_WIDGET (xpaned), &pos.x, &pos.y);
1408
1409         if (xpaned->in_drag_vert)
1410         {
1411                 pos.y -= xpaned->drag_pos.y;
1412
1413                 if (is_rtl (xpaned))
1414             {
1415                         gtk_widget_style_get (GTK_WIDGET (xpaned),
1416                                                                   "handle-size", &handle_size,
1417                                                                   NULL);
1418       
1419                         size.height = GTK_WIDGET (xpaned)->allocation.height - pos.y - handle_size;
1420                 }
1421                 else
1422                 {
1423                         size.height = pos.y;
1424                 }
1425
1426                 size.height -= GTK_CONTAINER (xpaned)->border_width;
1427
1428                 size.height = CLAMP (size.height, xpaned->min_position.y, xpaned->max_position.y);
1429
1430                 if (size.height != xpaned->top_left_child_size.height)
1431                         gtk_xpaned_set_position_y (xpaned, size.height);
1432         }
1433
1434         if (xpaned->in_drag_horiz)
1435         {
1436                 pos.x -= xpaned->drag_pos.x;
1437         
1438                 if (is_rtl (xpaned))
1439             {
1440                         gtk_widget_style_get (GTK_WIDGET (xpaned),
1441                                                                   "handle-size", &handle_size,
1442                                                                   NULL);
1443
1444                         size.width = GTK_WIDGET (xpaned)->allocation.width - pos.x - handle_size;
1445                 }
1446                 else
1447                 {
1448                         size.width = pos.x;
1449                 }
1450
1451                 size.width -= GTK_CONTAINER (xpaned)->border_width;
1452
1453                 size.width = CLAMP (size.width, xpaned->min_position.x, xpaned->max_position.x);
1454
1455                 if (size.width != xpaned->top_left_child_size.width)
1456                         gtk_xpaned_set_position_x (xpaned, size.width);
1457         }
1458
1459         if (xpaned->in_drag_vert_and_horiz)
1460         {
1461                 pos.x -= xpaned->drag_pos.x;
1462                 pos.y -= xpaned->drag_pos.y;
1463
1464                 if (is_rtl (xpaned))
1465             {
1466                         gtk_widget_style_get (GTK_WIDGET (xpaned),
1467                                                                   "handle-size", &handle_size,
1468                                                                   NULL);
1469       
1470                         size.width = GTK_WIDGET (xpaned)->allocation.width - pos.x - handle_size;
1471                         size.height = GTK_WIDGET (xpaned)->allocation.height - pos.y - handle_size;
1472                 }
1473                 else
1474                 {
1475                         size.width = pos.x;
1476                         size.height = pos.y;
1477                 }
1478
1479                 size.width -= GTK_CONTAINER (xpaned)->border_width;
1480                 size.height -= GTK_CONTAINER (xpaned)->border_width;
1481
1482                 size.width = CLAMP (size.width, xpaned->min_position.x, xpaned->max_position.x);
1483                 size.height = CLAMP (size.height, xpaned->min_position.y, xpaned->max_position.y);
1484
1485                 if (size.width != xpaned->top_left_child_size.width)
1486                         gtk_xpaned_set_position_x (xpaned, size.width);
1487
1488                 if (size.height != xpaned->top_left_child_size.height)
1489                         gtk_xpaned_set_position_y (xpaned, size.height);
1490         }
1491 }
1492
1493 static gboolean gtk_xpaned_enter (GtkWidget* widget, GdkEventCrossing* event)
1494 {
1495         GtkXPaned* xpaned = GTK_XPANED (widget);
1496
1497         if (xpaned->in_drag_vert ||
1498                 xpaned->in_drag_horiz ||
1499                 xpaned->in_drag_vert_and_horiz)
1500                 update_drag (xpaned);
1501         else
1502         {
1503                 xpaned->handle_prelit = TRUE;
1504
1505                 gtk_widget_queue_draw_area (widget,
1506                                                                         xpaned->handle_pos_east.x,
1507                                                                         xpaned->handle_pos_east.y,
1508                                                                         xpaned->handle_pos_east.width,
1509                                                                         xpaned->handle_pos_east.height);
1510
1511                 gtk_widget_queue_draw_area (widget,
1512                                                                         xpaned->handle_pos_west.x,
1513                                                                         xpaned->handle_pos_west.y,
1514                                                                         xpaned->handle_pos_west.width,
1515                                                                         xpaned->handle_pos_west.height);
1516
1517                 gtk_widget_queue_draw_area (widget,
1518                                                                         xpaned->handle_pos_north.x,
1519                                                                         xpaned->handle_pos_north.y,
1520                                                                         xpaned->handle_pos_north.width,
1521                                                                         xpaned->handle_pos_north.height);
1522
1523                 gtk_widget_queue_draw_area (widget,
1524                                                                         xpaned->handle_pos_south.x,
1525                                                                         xpaned->handle_pos_south.y,
1526                                                                         xpaned->handle_pos_south.width,
1527                                                                         xpaned->handle_pos_south.height);
1528
1529                 gtk_widget_queue_draw_area (widget,
1530                                                                         xpaned->handle_pos_middle.x,
1531                                                                         xpaned->handle_pos_middle.y,
1532                                                                         xpaned->handle_pos_middle.width,
1533                                                                         xpaned->handle_pos_middle.height);
1534         }
1535
1536         return TRUE;
1537 }
1538
1539 static gboolean gtk_xpaned_leave (GtkWidget* widget, GdkEventCrossing* event)
1540 {
1541         GtkXPaned* xpaned = GTK_XPANED (widget);
1542
1543         if (xpaned->in_drag_vert ||
1544                 xpaned->in_drag_horiz ||
1545                 xpaned->in_drag_vert_and_horiz)
1546                 update_drag (xpaned);
1547         else
1548         {
1549                 xpaned->handle_prelit = FALSE;
1550
1551                 gtk_widget_queue_draw_area (widget,
1552                                                                         xpaned->handle_pos_east.x,
1553                                                                         xpaned->handle_pos_east.y,
1554                                                                         xpaned->handle_pos_east.width,
1555                                                                         xpaned->handle_pos_east.height);
1556
1557                 gtk_widget_queue_draw_area (widget,
1558                                                                         xpaned->handle_pos_west.x,
1559                                                                         xpaned->handle_pos_west.y,
1560                                                                         xpaned->handle_pos_west.width,
1561                                                                         xpaned->handle_pos_west.height);
1562
1563                 gtk_widget_queue_draw_area (widget,
1564                                                                         xpaned->handle_pos_north.x,
1565                                                                         xpaned->handle_pos_north.y,
1566                                                                         xpaned->handle_pos_north.width,
1567                                                                         xpaned->handle_pos_north.height);
1568
1569                 gtk_widget_queue_draw_area (widget,
1570                                                                         xpaned->handle_pos_south.x,
1571                                                                         xpaned->handle_pos_south.y,
1572                                                                         xpaned->handle_pos_south.width,
1573                                                                         xpaned->handle_pos_south.height);
1574
1575                 gtk_widget_queue_draw_area (widget,
1576                                                                         xpaned->handle_pos_middle.x,
1577                                                                         xpaned->handle_pos_middle.y,
1578                                                                         xpaned->handle_pos_middle.width,
1579                                                                         xpaned->handle_pos_middle.height);
1580         }
1581
1582         return TRUE;
1583 }
1584
1585 static gboolean gtk_xpaned_focus (GtkWidget* widget, GtkDirectionType direction)
1586 {
1587         gboolean retval;
1588
1589         /* This is a hack, but how can this be done without
1590         * excessive cut-and-paste from gtkcontainer.c?
1591         */
1592
1593         GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS);
1594         retval = (* GTK_WIDGET_CLASS (parent_class)->focus) (widget, direction);
1595         GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
1596
1597   return retval;
1598 }
1599
1600 static gboolean gtk_xpaned_button_press (GtkWidget* widget,
1601                                                                                  GdkEventButton* event)
1602 {
1603         GtkXPaned* xpaned = GTK_XPANED (widget);
1604
1605         /* if any child is currently maximized, jump right back */
1606         if (xpaned->maximized[GTK_XPANED_TOP_LEFT]    ||
1607                 xpaned->maximized[GTK_XPANED_TOP_RIGHT]   ||
1608                 xpaned->maximized[GTK_XPANED_BOTTOM_LEFT] ||
1609                 xpaned->maximized[GTK_XPANED_BOTTOM_RIGHT])
1610                 return FALSE;
1611
1612         /* if user is dragging the handles around */
1613         if (!xpaned->in_drag_vert_and_horiz &&
1614                          event->window != xpaned->handle_east &&
1615                          event->window != xpaned->handle_west &&
1616                          event->window != xpaned->handle_north &&
1617                          event->window != xpaned->handle_south &&
1618                          event->window == xpaned->handle_middle &&
1619                          event->button == 1)
1620         {
1621                 xpaned->in_drag_vert_and_horiz = TRUE;
1622
1623                 /* We need a server grab here, not gtk_grab_add(), since
1624                 * we don't want to pass events on to the widget's children */
1625                 if (gdk_pointer_grab (xpaned->handle_middle,
1626                                                           FALSE,
1627                                                           GDK_POINTER_MOTION_HINT_MASK
1628                                                           | GDK_BUTTON1_MOTION_MASK
1629                                                           | GDK_BUTTON_RELEASE_MASK
1630                                                           | GDK_ENTER_NOTIFY_MASK
1631                                                           | GDK_LEAVE_NOTIFY_MASK,
1632                                                           NULL,
1633                                                           NULL,
1634                                                           event->time) == GDK_GRAB_SUCCESS)
1635                 {
1636                 }
1637
1638                 xpaned->drag_pos.x = event->x;
1639                 xpaned->drag_pos.y = event->y;
1640
1641                 return TRUE;
1642         }
1643         else if (!xpaned->in_drag_vert &&
1644                 event->window == xpaned->handle_east &&
1645                 event->window != xpaned->handle_west &&
1646                 event->window != xpaned->handle_north &&
1647                 event->window != xpaned->handle_south &&
1648                 event->window != xpaned->handle_middle &&
1649                 event->button == 1)
1650         {
1651                 xpaned->in_drag_vert = TRUE;
1652
1653                 /* We need a server grab here, not gtk_grab_add(), since
1654                 * we don't want to pass events on to the widget's children */
1655                 if (gdk_pointer_grab (xpaned->handle_east,
1656                                                           FALSE,
1657                                                           GDK_POINTER_MOTION_HINT_MASK
1658                                                           | GDK_BUTTON1_MOTION_MASK
1659                                                           | GDK_BUTTON_RELEASE_MASK
1660                                                           | GDK_ENTER_NOTIFY_MASK
1661                                                           | GDK_LEAVE_NOTIFY_MASK,
1662                                                           NULL,
1663                                                           NULL,
1664                                                           event->time) == GDK_GRAB_SUCCESS)
1665                 {
1666                 }
1667
1668                 xpaned->drag_pos.y = event->y;
1669
1670                 return TRUE;
1671         }
1672         else if (!xpaned->in_drag_vert &&
1673                          event->window != xpaned->handle_east &&
1674                          event->window == xpaned->handle_west &&
1675                          event->window != xpaned->handle_north &&
1676                          event->window != xpaned->handle_south &&
1677                          event->window != xpaned->handle_middle &&
1678                          event->button == 1)
1679         {
1680                 xpaned->in_drag_vert = TRUE;
1681
1682                 /* We need a server grab here, not gtk_grab_add(), since
1683                 * we don't want to pass events on to the widget's children */
1684                 if (gdk_pointer_grab (xpaned->handle_west,
1685                                                           FALSE,
1686                                                           GDK_POINTER_MOTION_HINT_MASK
1687                                                           | GDK_BUTTON1_MOTION_MASK
1688                                                           | GDK_BUTTON_RELEASE_MASK
1689                                                           | GDK_ENTER_NOTIFY_MASK
1690                                                           | GDK_LEAVE_NOTIFY_MASK,
1691                                                           NULL,
1692                                                           NULL,
1693                                                           event->time) == GDK_GRAB_SUCCESS)
1694                 {
1695                 }
1696
1697                 xpaned->drag_pos.y = event->y;
1698
1699                 return TRUE;
1700         }
1701         else if (!xpaned->in_drag_horiz &&
1702                          event->window != xpaned->handle_east &&
1703                          event->window != xpaned->handle_west &&
1704                          event->window == xpaned->handle_north &&
1705                          event->window != xpaned->handle_south &&
1706                          event->window != xpaned->handle_middle &&
1707                          event->button == 1)
1708         {
1709                 xpaned->in_drag_horiz = TRUE;
1710
1711                 /* We need a server grab here, not gtk_grab_add(), since
1712                 * we don't want to pass events on to the widget's children */
1713                 if (gdk_pointer_grab (xpaned->handle_north,
1714                                                           FALSE,
1715                                                           GDK_POINTER_MOTION_HINT_MASK
1716                                                           | GDK_BUTTON1_MOTION_MASK
1717                                                           | GDK_BUTTON_RELEASE_MASK
1718                                                           | GDK_ENTER_NOTIFY_MASK
1719                                                           | GDK_LEAVE_NOTIFY_MASK,
1720                                                           NULL,
1721                                                           NULL,
1722                                                           event->time) == GDK_GRAB_SUCCESS)
1723                 {
1724                 }
1725
1726                 xpaned->drag_pos.x = event->x;
1727
1728                 return TRUE;
1729         }
1730         else if (!xpaned->in_drag_horiz &&
1731                          event->window != xpaned->handle_east &&
1732                          event->window != xpaned->handle_west &&
1733                          event->window != xpaned->handle_north &&
1734                          event->window == xpaned->handle_south &&
1735                          event->window != xpaned->handle_middle &&
1736                          event->button == 1)
1737         {
1738                 xpaned->in_drag_horiz = TRUE;
1739
1740                 /* We need a server grab here, not gtk_grab_add(), since
1741                 * we don't want to pass events on to the widget's children */
1742                 if (gdk_pointer_grab (xpaned->handle_south,
1743                                                           FALSE,
1744                                                           GDK_POINTER_MOTION_HINT_MASK
1745                                                           | GDK_BUTTON1_MOTION_MASK
1746                                                           | GDK_BUTTON_RELEASE_MASK
1747                                                           | GDK_ENTER_NOTIFY_MASK
1748                                                           | GDK_LEAVE_NOTIFY_MASK,
1749                                                           NULL,
1750                                                           NULL,
1751                                                           event->time) == GDK_GRAB_SUCCESS)
1752                 {
1753                 }
1754
1755                 xpaned->drag_pos.x = event->x;
1756
1757                 return TRUE;
1758         }
1759         return FALSE;
1760 }
1761
1762 static gboolean gtk_xpaned_button_release (GtkWidget* widget,
1763                                                                                    GdkEventButton* event)
1764 {
1765         GtkXPaned* xpaned = GTK_XPANED (widget);
1766
1767         if (xpaned->in_drag_vert && (event->button == 1))
1768         {
1769                 xpaned->in_drag_vert = FALSE;
1770                 xpaned->drag_pos.y = -1;
1771                 xpaned->position_set = TRUE;
1772                 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
1773                                                                         event->time);
1774                 return TRUE;
1775     }
1776         else if (xpaned->in_drag_horiz && (event->button == 1))
1777         {
1778                 xpaned->in_drag_horiz = FALSE;
1779                 xpaned->drag_pos.x = -1;
1780                 xpaned->position_set = TRUE;
1781                 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
1782                                                                         event->time);
1783                 return TRUE;
1784     }
1785         else if (xpaned->in_drag_vert_and_horiz && (event->button == 1))
1786         {
1787                 xpaned->in_drag_vert_and_horiz = FALSE;
1788                 xpaned->drag_pos.x = -1;
1789                 xpaned->drag_pos.y = -1;
1790                 xpaned->position_set = TRUE;
1791                 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
1792                                                                         event->time);
1793                 return TRUE;
1794     }
1795
1796         return FALSE;
1797 }
1798
1799 static gboolean gtk_xpaned_motion (GtkWidget* widget, GdkEventMotion* event)
1800 {
1801         GtkXPaned* xpaned = GTK_XPANED (widget);
1802
1803         if (xpaned->in_drag_vert ||
1804                 xpaned->in_drag_horiz ||
1805                 xpaned->in_drag_vert_and_horiz)
1806
1807         {
1808                 update_drag (xpaned);
1809                 return TRUE;
1810         }
1811
1812         return FALSE;
1813 }
1814
1815 void gtk_xpaned_add_top_left (GtkXPaned* xpaned, GtkWidget *widget)
1816 {
1817         gtk_xpaned_pack_top_left (xpaned, widget, FALSE, TRUE);
1818 }
1819
1820 void gtk_xpaned_add_top_right (GtkXPaned* xpaned, GtkWidget *widget)
1821 {
1822         gtk_xpaned_pack_top_right (xpaned, widget, FALSE, TRUE);
1823 }
1824
1825 void gtk_xpaned_add_bottom_left (GtkXPaned* xpaned, GtkWidget *widget)
1826 {
1827         gtk_xpaned_pack_bottom_left (xpaned, widget, FALSE, TRUE);
1828 }
1829
1830 void gtk_xpaned_add_bottom_right (GtkXPaned* xpaned, GtkWidget *widget)
1831 {
1832         gtk_xpaned_pack_bottom_right (xpaned, widget, FALSE, TRUE);
1833 }
1834
1835 void gtk_xpaned_pack_top_left (GtkXPaned* xpaned,
1836                                                            GtkWidget* child,
1837                                                            gboolean   resize,
1838                                                            gboolean   shrink)
1839 {
1840         g_return_if_fail (GTK_IS_XPANED (xpaned));
1841         g_return_if_fail (GTK_IS_WIDGET (child));
1842
1843         if (!xpaned->top_left_child)
1844         {
1845                 xpaned->top_left_child = child;
1846                 xpaned->top_left_child_resize = resize;
1847                 xpaned->top_left_child_shrink = shrink;
1848
1849                 gtk_widget_set_parent (child, GTK_WIDGET (xpaned));
1850         }
1851 }
1852
1853 void gtk_xpaned_pack_top_right (GtkXPaned* xpaned,
1854                                                                 GtkWidget* child,
1855                                                                 gboolean   resize,
1856                                                                 gboolean   shrink)
1857 {
1858         g_return_if_fail (GTK_IS_XPANED (xpaned));
1859         g_return_if_fail (GTK_IS_WIDGET (child));
1860
1861         if (!xpaned->top_right_child)
1862         {
1863                 xpaned->top_right_child = child;
1864                 xpaned->top_right_child_resize = resize;
1865                 xpaned->top_right_child_shrink = shrink;
1866
1867                 gtk_widget_set_parent (child, GTK_WIDGET (xpaned));
1868         }
1869 }
1870
1871 void gtk_xpaned_pack_bottom_left (GtkXPaned* xpaned,
1872                                                                   GtkWidget* child,
1873                                                                   gboolean   resize,
1874                                                                   gboolean   shrink)
1875 {
1876         g_return_if_fail (GTK_IS_XPANED (xpaned));
1877         g_return_if_fail (GTK_IS_WIDGET (child));
1878
1879         if (!xpaned->bottom_left_child)
1880         {
1881                 xpaned->bottom_left_child = child;
1882                 xpaned->bottom_left_child_resize = resize;
1883                 xpaned->bottom_left_child_shrink = shrink;
1884
1885                 gtk_widget_set_parent (child, GTK_WIDGET (xpaned));
1886         }
1887 }
1888
1889 void gtk_xpaned_pack_bottom_right (GtkXPaned* xpaned,
1890                                                                    GtkWidget* child,
1891                                                                    gboolean   resize,
1892                                                                    gboolean   shrink)
1893 {
1894         g_return_if_fail (GTK_IS_XPANED (xpaned));
1895         g_return_if_fail (GTK_IS_WIDGET (child));
1896
1897         if (!xpaned->bottom_right_child)
1898         {
1899                 xpaned->bottom_right_child = child;
1900                 xpaned->bottom_right_child_resize = resize;
1901                 xpaned->bottom_right_child_shrink = shrink;
1902
1903                 gtk_widget_set_parent (child, GTK_WIDGET (xpaned));
1904         }
1905 }
1906
1907 static void gtk_xpaned_add (GtkContainer* container, GtkWidget* widget)
1908 {
1909         GtkXPaned* xpaned;
1910
1911         g_return_if_fail (GTK_IS_XPANED (container));
1912
1913         xpaned = GTK_XPANED (container);
1914
1915         if (!xpaned->top_left_child)
1916                 gtk_xpaned_add_top_left (xpaned, widget);
1917         else if (!xpaned->top_right_child)
1918                 gtk_xpaned_add_top_right (xpaned, widget);
1919         else if (!xpaned->bottom_left_child)
1920                 gtk_xpaned_add_bottom_left (xpaned, widget);
1921         else if (!xpaned->bottom_right_child)
1922                 gtk_xpaned_add_bottom_right (xpaned, widget);
1923         else
1924                 g_warning ("GtkXPaned cannot have more than 4 children\n");
1925 }
1926
1927 static void gtk_xpaned_remove (GtkContainer* container, GtkWidget* widget)
1928 {
1929         GtkXPaned* xpaned;
1930         gboolean was_visible;
1931
1932         xpaned = GTK_XPANED (container);
1933         was_visible = GTK_WIDGET_VISIBLE (widget);
1934
1935         if (xpaned->top_left_child == widget)
1936         {
1937                 gtk_widget_unparent (widget);
1938
1939                 xpaned->top_left_child = NULL;
1940
1941                 if (was_visible && GTK_WIDGET_VISIBLE (container))
1942                         gtk_widget_queue_resize (GTK_WIDGET (container));
1943         }
1944         else if (xpaned->top_right_child == widget)
1945         {
1946                 gtk_widget_unparent (widget);
1947
1948                 xpaned->top_right_child = NULL;
1949
1950                 if (was_visible && GTK_WIDGET_VISIBLE (container))
1951                         gtk_widget_queue_resize (GTK_WIDGET (container));
1952         }
1953         else if (xpaned->bottom_left_child == widget)
1954         {
1955                 gtk_widget_unparent (widget);
1956
1957                 xpaned->bottom_left_child = NULL;
1958
1959                 if (was_visible && GTK_WIDGET_VISIBLE (container))
1960                         gtk_widget_queue_resize (GTK_WIDGET (container));
1961         }
1962         else if (xpaned->bottom_right_child == widget)
1963         {
1964                 gtk_widget_unparent (widget);
1965
1966                 xpaned->bottom_right_child = NULL;
1967
1968                 if (was_visible && GTK_WIDGET_VISIBLE (container))
1969                         gtk_widget_queue_resize (GTK_WIDGET (container));
1970         }
1971         else
1972                 g_warning ("GtkXPaned has no more children attached\n");
1973
1974 }
1975
1976 static void gtk_xpaned_forall (GtkContainer* container,
1977                                                            gboolean      include_internals,
1978                                                            GtkCallback   callback,
1979                                                            gpointer      callback_data)
1980 {
1981         GtkXPaned* xpaned;
1982
1983         g_return_if_fail (callback != NULL);
1984
1985         xpaned = GTK_XPANED (container);
1986
1987         if (xpaned->top_left_child)
1988         (*callback) (xpaned->top_left_child, callback_data);
1989         if (xpaned->top_right_child)
1990                 (*callback) (xpaned->top_right_child, callback_data);
1991         if (xpaned->bottom_left_child)
1992         (*callback) (xpaned->bottom_left_child, callback_data);
1993         if (xpaned->bottom_right_child)
1994                 (*callback) (xpaned->bottom_right_child, callback_data);
1995 }
1996
1997 /**
1998  * gtk_xpaned_get_position_x:
1999  * @paned: a #GtkXPaned widget
2000  * 
2001  * Obtains the x-position of the divider.
2002  * 
2003  * Return value: x-position of the divider
2004  **/
2005 gint gtk_xpaned_get_position_x (GtkXPaned* xpaned)
2006 {
2007         g_return_val_if_fail (GTK_IS_XPANED (xpaned), 0);
2008
2009         return xpaned->top_left_child_size.width;
2010 }
2011
2012 /**
2013  * gtk_xpaned_get_position_y:
2014  * @paned: a #GtkXPaned widget
2015  * 
2016  * Obtains the y-position of the divider.
2017  * 
2018  * Return value: y-position of the divider
2019  **/
2020 gint gtk_xpaned_get_position_y (GtkXPaned* xpaned)
2021 {
2022         g_return_val_if_fail (GTK_IS_XPANED (xpaned), 0);
2023
2024         return xpaned->top_left_child_size.height;
2025 }
2026
2027 /**
2028  * gtk_xpaned_set_position_x:
2029  * @paned: a #GtkXPaned widget
2030  * @xposition: pixel x-position of divider, a negative values
2031  *                         of a component mean that the position is unset.
2032  * 
2033  * Sets the x-position of the divider between the four panes.
2034  **/
2035 void gtk_xpaned_set_position_x (GtkXPaned* xpaned, gint xposition)
2036 {
2037         GObject* object;
2038   
2039         g_return_if_fail (GTK_IS_XPANED (xpaned));
2040
2041         /* if any child is currently maximized, jump right back */
2042         if (xpaned->maximized[GTK_XPANED_TOP_LEFT]    ||
2043                 xpaned->maximized[GTK_XPANED_TOP_RIGHT]   ||
2044                 xpaned->maximized[GTK_XPANED_BOTTOM_LEFT] ||
2045                 xpaned->maximized[GTK_XPANED_BOTTOM_RIGHT])
2046                 return;
2047
2048         object = G_OBJECT (xpaned);
2049
2050         if (xposition >= 0)
2051         {
2052                 /* We don't clamp here - the assumption is that
2053                 * if the total allocation changes at the same time
2054                 * as the position, the position set is with reference
2055                 * to the new total size. If only the position changes,
2056                 * then clamping will occur in gtk_paned_compute_position()
2057                 */
2058
2059                 xpaned->top_left_child_size.width = xposition;
2060                 xpaned->position_set = TRUE;
2061         }
2062         else
2063         {
2064                 xpaned->position_set = FALSE;
2065         }
2066
2067         g_object_freeze_notify (object);
2068         g_object_notify (object, "x-position");
2069         g_object_notify (object, "position-set");
2070         g_object_thaw_notify (object);
2071
2072         gtk_widget_queue_resize (GTK_WIDGET (xpaned));
2073 }
2074
2075 /**
2076  * gtk_xpaned_set_position_y:
2077  * @paned: a #GtkXPaned widget
2078  * @yposition: pixel y-position of divider, a negative values
2079  *                         of a component mean that the position is unset.
2080  * 
2081  * Sets the y-position of the divider between the four panes.
2082  **/
2083 void gtk_xpaned_set_position_y (GtkXPaned* xpaned, gint yposition)
2084 {
2085         GObject* object;
2086   
2087         g_return_if_fail (GTK_IS_XPANED (xpaned));
2088
2089         /* if any child is currently maximized, jump right back */
2090         if (xpaned->maximized[GTK_XPANED_TOP_LEFT]    ||
2091                 xpaned->maximized[GTK_XPANED_TOP_RIGHT]   ||
2092                 xpaned->maximized[GTK_XPANED_BOTTOM_LEFT] ||
2093                 xpaned->maximized[GTK_XPANED_BOTTOM_RIGHT])
2094                 return;
2095
2096         object = G_OBJECT (xpaned);
2097
2098         if (yposition >= 0)
2099         {
2100                 /* We don't clamp here - the assumption is that
2101                 * if the total allocation changes at the same time
2102                 * as the position, the position set is with reference
2103                 * to the new total size. If only the position changes,
2104                 * then clamping will occur in gtk_paned_compute_position()
2105                 */
2106
2107                 xpaned->top_left_child_size.height = yposition;
2108                 xpaned->position_set = TRUE;
2109         }
2110         else
2111         {
2112                 xpaned->position_set = FALSE;
2113         }
2114
2115         g_object_freeze_notify (object);
2116         g_object_notify (object, "y-position");
2117         g_object_notify (object, "position-set");
2118         g_object_thaw_notify (object);
2119
2120         gtk_widget_queue_resize (GTK_WIDGET (xpaned));
2121 }
2122
2123 /* this call is private and only intended for internal use! */
2124 void gtk_xpaned_save_unmaximized_x (GtkXPaned* xpaned)
2125 {
2126         xpaned->unmaximized_position.x = gtk_xpaned_get_position_x (xpaned);
2127 }
2128
2129 /* this call is private and only intended for internal use! */
2130 void gtk_xpaned_save_unmaximized_y (GtkXPaned* xpaned)
2131 {
2132         xpaned->unmaximized_position.y = gtk_xpaned_get_position_y (xpaned);
2133 }
2134
2135 /* this call is private and only intended for internal use! */
2136 gint gtk_xpaned_fetch_unmaximized_x (GtkXPaned* xpaned)
2137 {
2138         return xpaned->unmaximized_position.x;
2139 }
2140
2141 /* this call is private and only intended for internal use! */
2142 gint gtk_xpaned_fetch_unmaximized_y (GtkXPaned* xpaned)
2143 {
2144         return xpaned->unmaximized_position.y;
2145 }
2146
2147 /**
2148  * gtk_xpaned_get_top_left_child:
2149  * @xpaned: a #GtkXPaned widget
2150  * 
2151  * Obtains the top-left child of the xpaned widget.
2152  * 
2153  * Return value: top-left child, or %NULL if it is not set.
2154  *
2155  * Since: 2.4
2156  **/
2157 GtkWidget* gtk_xpaned_get_top_left_child (GtkXPaned* xpaned)
2158 {
2159         g_return_val_if_fail (GTK_IS_XPANED (xpaned), NULL);
2160
2161         return xpaned->top_left_child;
2162 }
2163
2164 /**
2165  * gtk_xpaned_get_top_right_child:
2166  * @xpaned: a #GtkXPaned widget
2167  * 
2168  * Obtains the top-right child of the xpaned widget.
2169  * 
2170  * Return value: top-right child, or %NULL if it is not set.
2171  *
2172  * Since: 2.4
2173  **/
2174 GtkWidget* gtk_xpaned_get_top_right_child (GtkXPaned* xpaned)
2175 {
2176         g_return_val_if_fail (GTK_IS_XPANED (xpaned), NULL);
2177
2178         return xpaned->top_right_child;
2179 }
2180
2181 /**
2182  * gtk_xpaned_get_bottom_left_child:
2183  * @xpaned: a #GtkXPaned widget
2184  * 
2185  * Obtains the bottom-left child of the xpaned widget.
2186  * 
2187  * Return value: bottom-left child, or %NULL if it is not set.
2188  *
2189  * Since: 2.4
2190  **/
2191 GtkWidget* gtk_xpaned_get_bottom_left_child (GtkXPaned* xpaned)
2192 {
2193         g_return_val_if_fail (GTK_IS_XPANED (xpaned), NULL);
2194
2195         return xpaned->bottom_left_child;
2196 }
2197
2198 /**
2199  * gtk_xpaned_get_bottom_right_child:
2200  * @xpaned: a #GtkXPaned widget
2201  * 
2202  * Obtains the bottom-right child of the xpaned widget.
2203  * 
2204  * Return value: bottom-right child, or %NULL if it is not set.
2205  *
2206  * Since: 2.4
2207  **/
2208 GtkWidget* gtk_xpaned_get_bottom_right_child (GtkXPaned* xpaned)
2209 {
2210         g_return_val_if_fail (GTK_IS_XPANED (xpaned), NULL);
2211
2212         return xpaned->bottom_right_child;
2213 }
2214
2215 gboolean gtk_xpaned_maximize_top_left (GtkXPaned* xpaned, gboolean maximize)
2216 {
2217         if (maximize)
2218         {
2219                 /* see if any child is already maximized */
2220                 if (!xpaned->maximized[GTK_XPANED_TOP_LEFT] &&
2221                         !xpaned->maximized[GTK_XPANED_TOP_RIGHT] &&
2222                         !xpaned->maximized[GTK_XPANED_BOTTOM_LEFT] &&
2223                         !xpaned->maximized[GTK_XPANED_BOTTOM_RIGHT])
2224                 {
2225                         /* save current position */
2226                         gtk_xpaned_save_unmaximized_x (xpaned);
2227                         gtk_xpaned_save_unmaximized_y (xpaned);
2228
2229                         /* set new maximized position */
2230                         gtk_xpaned_set_position_x (xpaned, xpaned->max_position.x);
2231                         gtk_xpaned_set_position_y (xpaned, xpaned->max_position.y);
2232
2233                         /* mark maximized flag for top-left child */
2234                         xpaned->maximized[GTK_XPANED_TOP_LEFT] = TRUE;
2235
2236                         return TRUE;
2237                 }
2238                 /* already one child maximized, report error */
2239                 else
2240                         return FALSE;
2241         }
2242         else
2243         {
2244                 /* verify that top-left child is really currently maximized */
2245                 if (xpaned->maximized[GTK_XPANED_TOP_LEFT])
2246                 {
2247                         /* clear maximized flat for top-left child */
2248                         xpaned->maximized[GTK_XPANED_TOP_LEFT] = FALSE;
2249
2250                         /* restore unmaximized position */
2251                         gtk_xpaned_set_position_x (xpaned, gtk_xpaned_fetch_unmaximized_x (xpaned));
2252                         gtk_xpaned_set_position_y (xpaned, gtk_xpaned_fetch_unmaximized_y (xpaned));
2253
2254                         return TRUE;
2255                 }
2256                 /* top-left child is currently not maximized, report error */
2257                 else
2258                         return FALSE;
2259         }
2260 }
2261
2262 gboolean gtk_xpaned_maximize_top_right (GtkXPaned* xpaned, gboolean maximize)
2263 {
2264         if (maximize)
2265         {
2266                 /* see if any child is already maximized */
2267                 if (!xpaned->maximized[GTK_XPANED_TOP_LEFT] &&
2268                         !xpaned->maximized[GTK_XPANED_TOP_RIGHT] &&
2269                         !xpaned->maximized[GTK_XPANED_BOTTOM_LEFT] &&
2270                         !xpaned->maximized[GTK_XPANED_BOTTOM_RIGHT])
2271                 {
2272                         /* save current position */
2273                         gtk_xpaned_save_unmaximized_x (xpaned);
2274                         gtk_xpaned_save_unmaximized_y (xpaned);
2275
2276                         /* set new maximized position */
2277                         gtk_xpaned_set_position_x (xpaned, xpaned->min_position.x);
2278                         gtk_xpaned_set_position_y (xpaned, xpaned->max_position.y);
2279                 
2280                         /* mark maximized flag for top-right child */
2281                         xpaned->maximized[GTK_XPANED_TOP_RIGHT] = TRUE;
2282
2283                         return TRUE;
2284                 }
2285                 /* already one child maximized, report error */
2286                 else
2287                         return FALSE;
2288         }
2289         else
2290         {
2291                 /* verify that top-right child is really currently maximized */
2292                 if (xpaned->maximized[GTK_XPANED_TOP_RIGHT])
2293                 {
2294                         /* clear maximized flat for top-right child */
2295                         xpaned->maximized[GTK_XPANED_TOP_RIGHT] = FALSE;
2296
2297                         /* restore unmaximized position */
2298                         gtk_xpaned_set_position_x (xpaned, gtk_xpaned_fetch_unmaximized_x (xpaned));
2299                         gtk_xpaned_set_position_y (xpaned, gtk_xpaned_fetch_unmaximized_y (xpaned));
2300
2301                         return TRUE;
2302                 }
2303                 /* top-right child is currently not maximized, report error */
2304                 else
2305                         return FALSE;
2306         }
2307 }
2308
2309 gboolean gtk_xpaned_maximize_bottom_left (GtkXPaned* xpaned, gboolean maximize)
2310 {
2311         if (maximize)
2312         {
2313                 /* see if any child is already maximized */
2314                 if (!xpaned->maximized[GTK_XPANED_TOP_LEFT] &&
2315                         !xpaned->maximized[GTK_XPANED_TOP_RIGHT] &&
2316                         !xpaned->maximized[GTK_XPANED_BOTTOM_LEFT] &&
2317                         !xpaned->maximized[GTK_XPANED_BOTTOM_RIGHT])
2318                 {
2319                         /* save current position */
2320                         gtk_xpaned_save_unmaximized_x (xpaned);
2321                         gtk_xpaned_save_unmaximized_y (xpaned);
2322
2323                         /* set new maximized position */
2324                         gtk_xpaned_set_position_x (xpaned, xpaned->max_position.x);
2325                         gtk_xpaned_set_position_y (xpaned, xpaned->min_position.y);
2326
2327                         /* mark maximized flag for bottom-left child */
2328                         xpaned->maximized[GTK_XPANED_BOTTOM_LEFT] = TRUE;
2329
2330                         return TRUE;
2331                 }
2332                 /* already one child maximized, report error */
2333                 else
2334                         return FALSE;
2335         }
2336         else
2337         {
2338                 /* verify that bottom-left child is really currently maximized */
2339                 if (xpaned->maximized[GTK_XPANED_BOTTOM_LEFT])
2340                 {
2341                         /* clear maximized flat for bottom-left child */
2342                         xpaned->maximized[GTK_XPANED_BOTTOM_LEFT] = FALSE;
2343
2344                         /* restore unmaximized position */
2345                         gtk_xpaned_set_position_x (xpaned, gtk_xpaned_fetch_unmaximized_x (xpaned));
2346                         gtk_xpaned_set_position_y (xpaned, gtk_xpaned_fetch_unmaximized_y (xpaned));
2347
2348                         return TRUE;
2349                 }
2350                 /* bottom-left child is currently not maximized, report error */
2351                 else
2352                         return FALSE;
2353         }
2354 }
2355
2356 gboolean gtk_xpaned_maximize_bottom_right (GtkXPaned* xpaned, gboolean maximize)
2357 {
2358         if (maximize)
2359         {
2360                 /* see if any child is already maximized */
2361                 if (!xpaned->maximized[GTK_XPANED_TOP_LEFT] &&
2362                         !xpaned->maximized[GTK_XPANED_TOP_RIGHT] &&
2363                         !xpaned->maximized[GTK_XPANED_BOTTOM_LEFT] &&
2364                         !xpaned->maximized[GTK_XPANED_BOTTOM_RIGHT])
2365                 {
2366                         /* save current position */
2367                         gtk_xpaned_save_unmaximized_x (xpaned);
2368                         gtk_xpaned_save_unmaximized_y (xpaned);
2369
2370                         /* set new maximized position */
2371                         gtk_xpaned_set_position_x (xpaned, xpaned->min_position.x);
2372                         gtk_xpaned_set_position_y (xpaned, xpaned->min_position.y);
2373
2374                         /* mark maximized flag for bottom-right child */
2375                         xpaned->maximized[GTK_XPANED_BOTTOM_RIGHT] = TRUE;
2376
2377                         return TRUE;
2378                 }
2379                 /* already one child maximized, report error */
2380                 else
2381                         return FALSE;
2382         }
2383         else
2384         {
2385                 /* verify that bottom-right child is really currently maximized */
2386                 if (xpaned->maximized[GTK_XPANED_BOTTOM_RIGHT])
2387                 {
2388                         /* clear maximized flat for bottom-right child */
2389                         xpaned->maximized[GTK_XPANED_BOTTOM_RIGHT] = FALSE;
2390
2391                         /* restore unmaximized position */
2392                         gtk_xpaned_set_position_x (xpaned, gtk_xpaned_fetch_unmaximized_x (xpaned));
2393                         gtk_xpaned_set_position_y (xpaned, gtk_xpaned_fetch_unmaximized_y (xpaned));
2394
2395                         return TRUE;
2396                 }
2397                 /* bottom-right child is currently not maximized, report error */
2398                 else
2399                         return FALSE;
2400         }
2401 }
2402
2403 void
2404 gtk_xpaned_compute_position (GtkXPaned* xpaned,
2405                              const GtkAllocation* allocation,
2406                              GtkRequisition* top_left_child_req,
2407                              GtkRequisition* top_right_child_req,
2408                              GtkRequisition* bottom_left_child_req,
2409                              GtkRequisition* bottom_right_child_req)
2410 {
2411   GdkPoint old_position;
2412   GdkPoint old_min_position;
2413         GdkPoint old_max_position;
2414         gint handle_size;
2415         gint border_width = GTK_CONTAINER (xpaned)->border_width;
2416         float fX;
2417         float fY;
2418
2419         g_return_if_fail (GTK_IS_XPANED (xpaned));
2420
2421         old_position.x = xpaned->top_left_child_size.width;
2422         old_position.y = xpaned->top_left_child_size.height;
2423         old_min_position.x = xpaned->min_position.x;
2424         old_min_position.y = xpaned->min_position.y;
2425         old_max_position.x = xpaned->max_position.x;
2426         old_max_position.y = xpaned->max_position.y;
2427
2428         fX = 100.0f * (float) old_position.x / (float) allocation->width;
2429         fY = 100.0f * (float) old_position.y / (float) allocation->height;
2430
2431         xpaned->min_position.x = xpaned->top_left_child_shrink ? 0 : top_left_child_req->width;
2432         xpaned->min_position.y = xpaned->top_left_child_shrink ? 0 : top_left_child_req->height;
2433
2434         gtk_widget_style_get (GTK_WIDGET (xpaned), "handle-size", &handle_size, NULL);
2435
2436         xpaned->max_position.x = allocation->width - 2 * border_width - handle_size;
2437         xpaned->max_position.y = allocation->height - 2 * border_width - handle_size;
2438         if (!xpaned->top_left_child_shrink)
2439                 xpaned->max_position.x = MAX (1, xpaned->max_position.x - top_left_child_req->width);
2440         xpaned->max_position.x = MAX (xpaned->min_position.x, xpaned->max_position.x);
2441
2442         if (!xpaned->position_set)
2443         {
2444                 if (xpaned->top_left_child_resize && !xpaned->top_right_child_resize)
2445                 {
2446                         xpaned->top_left_child_size.width = MAX (0, allocation->width - top_right_child_req->width);
2447                         xpaned->top_left_child_size.height = MAX (0, allocation->height - top_right_child_req->height);
2448                 }
2449                 else if (!xpaned->top_left_child_resize && xpaned->top_right_child_resize)
2450                 {
2451                         xpaned->top_left_child_size.width = top_left_child_req->width;
2452                         xpaned->top_left_child_size.height = top_left_child_req->height;
2453                 }
2454                 else if (top_left_child_req->width + top_right_child_req->width != 0)
2455                 {
2456                         xpaned->top_left_child_size.width = allocation->width * ((gdouble)top_left_child_req->width / (top_left_child_req->width + top_right_child_req->width)) + 0.5;
2457                 }
2458                 else if (top_left_child_req->height + top_right_child_req->height != 0)
2459                 {
2460                         xpaned->top_left_child_size.height = allocation->height * ((gdouble)top_left_child_req->height / (top_left_child_req->height + top_right_child_req->height)) + 0.5;
2461                 }
2462                 else
2463                 {
2464                         xpaned->top_left_child_size.width = allocation->width * 0.5 + 0.5;
2465                         xpaned->top_left_child_size.height = allocation->height * 0.5 + 0.5;
2466                 }
2467         }
2468         else
2469         {
2470                 /* If the position was set before the initial allocation.
2471                 ** (paned->last_allocation <= 0) just clamp it and leave it. */
2472                 if (xpaned->last_allocation.width > 0)
2473                 {
2474                         if (xpaned->top_left_child_resize && !xpaned->top_right_child_resize)
2475                         {
2476                                 xpaned->top_left_child_size.width += allocation->width
2477                                                                                                          - xpaned->last_allocation.width;
2478
2479                                 xpaned->top_left_child_size.height += allocation->height
2480                                                                                                           - xpaned->last_allocation.height;
2481                         }
2482                         else if (!(!xpaned->top_left_child_resize && xpaned->top_right_child_resize))
2483                         {
2484                                 xpaned->top_left_child_size.width = allocation->width
2485                                                                                                         * ((gdouble) xpaned->top_left_child_size.width / (xpaned->last_allocation.width))
2486                                                                                                         + 0.5;
2487
2488                                 xpaned->top_left_child_size.height = allocation->height
2489                                                                                                          * ((gdouble) xpaned->top_left_child_size.height / (xpaned->last_allocation.height))
2490                                                                                                          + 0.5;
2491                         }
2492                 }
2493                 if (xpaned->last_allocation.height > 0)
2494                 {
2495                         if (xpaned->top_left_child_resize && !xpaned->top_right_child_resize)
2496                         {
2497                                 xpaned->top_left_child_size.width += allocation->width - xpaned->last_allocation.width;
2498                                 xpaned->top_left_child_size.height += allocation->height - xpaned->last_allocation.height;
2499                         }
2500                         else if (!(!xpaned->top_left_child_resize && xpaned->top_right_child_resize))
2501                         {
2502                                 xpaned->top_left_child_size.width = allocation->width * ((gdouble) xpaned->top_left_child_size.width / (xpaned->last_allocation.width)) + 0.5;
2503                                 xpaned->top_left_child_size.height = allocation->height * ((gdouble) xpaned->top_left_child_size.height / (xpaned->last_allocation.height)) + 0.5;
2504                         }
2505                 }
2506
2507     }
2508
2509         xpaned->top_left_child_size.width = CLAMP (xpaned->top_left_child_size.width,
2510                                                                                            xpaned->min_position.x,
2511                                                                                            xpaned->max_position.x);
2512         xpaned->top_left_child_size.height = CLAMP (xpaned->top_left_child_size.height,
2513                                                                                                 xpaned->min_position.y,
2514                                                                                                 xpaned->max_position.y);
2515
2516         xpaned->top_right_child_size.width = CLAMP (xpaned->top_right_child_size.width,
2517                                                                                                 xpaned->min_position.x,
2518                                                                                                 xpaned->max_position.x);
2519         xpaned->top_right_child_size.height = CLAMP (xpaned->top_right_child_size.height,
2520                                                                                                  xpaned->min_position.y,
2521                                                                                                  xpaned->max_position.y);
2522
2523         xpaned->bottom_left_child_size.width = CLAMP (xpaned->bottom_left_child_size.width,
2524                                                                                                   xpaned->min_position.x,
2525                                                                                                   xpaned->max_position.x);
2526         xpaned->bottom_left_child_size.height = CLAMP (xpaned->bottom_left_child_size.height,
2527                                                                                                    xpaned->min_position.y,
2528                                                                                                    xpaned->max_position.y);
2529
2530         xpaned->bottom_right_child_size.width = CLAMP (xpaned->bottom_right_child_size.width,
2531                                                                                                    xpaned->min_position.x,
2532                                                                                                    xpaned->max_position.x);
2533         xpaned->bottom_right_child_size.height = CLAMP (xpaned->bottom_right_child_size.height,
2534                                                                                                         xpaned->min_position.y,
2535                                                                                                         xpaned->max_position.y);
2536
2537         gtk_widget_set_child_visible (xpaned->top_left_child, TRUE);
2538         gtk_widget_set_child_visible (xpaned->top_right_child, TRUE);
2539         gtk_widget_set_child_visible (xpaned->bottom_left_child, TRUE);
2540         gtk_widget_set_child_visible (xpaned->bottom_right_child, TRUE);
2541
2542         g_object_freeze_notify (G_OBJECT (xpaned));
2543
2544         if (xpaned->top_left_child_size.width != old_position.x)
2545                 g_object_notify (G_OBJECT (xpaned), "x-position");
2546         if (xpaned->top_left_child_size.height != old_position.y)
2547                 g_object_notify (G_OBJECT (xpaned), "y-position");
2548
2549         if (xpaned->top_right_child_size.width != old_position.x)
2550                 g_object_notify (G_OBJECT (xpaned), "x-position");
2551         if (xpaned->top_right_child_size.height != old_position.y)
2552                 g_object_notify (G_OBJECT (xpaned), "y-position");
2553
2554         if (xpaned->bottom_left_child_size.width != old_position.x)
2555                 g_object_notify (G_OBJECT (xpaned), "x-position");
2556         if (xpaned->bottom_left_child_size.height != old_position.y)
2557                 g_object_notify (G_OBJECT (xpaned), "y-position");
2558
2559         if (xpaned->bottom_right_child_size.width != old_position.x)
2560                 g_object_notify (G_OBJECT (xpaned), "x-position");
2561         if (xpaned->bottom_right_child_size.height != old_position.y)
2562                 g_object_notify (G_OBJECT (xpaned), "y-position");
2563
2564         if (xpaned->min_position.x != old_min_position.x)
2565                 g_object_notify (G_OBJECT (xpaned), "min-x-position");
2566         if (xpaned->min_position.y != old_min_position.y)
2567                 g_object_notify (G_OBJECT (xpaned), "min-y-position");
2568
2569         if (xpaned->max_position.x != old_max_position.x)
2570         g_object_notify (G_OBJECT (xpaned), "max-y-position");
2571         if (xpaned->max_position.y != old_max_position.y)
2572         g_object_notify (G_OBJECT (xpaned), "max-y-position");
2573
2574         g_object_thaw_notify (G_OBJECT (xpaned));
2575
2576         xpaned->last_allocation.width = allocation->width;
2577         xpaned->last_allocation.height = allocation->height;
2578
2579         fX = 100.0f * (float) old_position.x / (float) allocation->width;
2580         fY = 100.0f * (float) old_position.y / (float) allocation->height;
2581 }
2582
2583 static void gtk_xpaned_set_saved_focus (GtkXPaned* xpaned, GtkWidget* widget)
2584 {
2585         if (xpaned->priv->saved_focus)
2586                 g_object_remove_weak_pointer (G_OBJECT (xpaned->priv->saved_focus),
2587                                                                           (gpointer *)&(xpaned->priv->saved_focus));
2588
2589         xpaned->priv->saved_focus = widget;
2590
2591         if (xpaned->priv->saved_focus)
2592                 g_object_add_weak_pointer (G_OBJECT (xpaned->priv->saved_focus),
2593                                                                    (gpointer *)&(xpaned->priv->saved_focus));
2594 }
2595
2596 static void gtk_xpaned_set_first_xpaned (GtkXPaned* xpaned,
2597                                                                                  GtkXPaned* first_xpaned)
2598 {
2599         if (xpaned->priv->first_xpaned)
2600                 g_object_remove_weak_pointer (G_OBJECT (xpaned->priv->first_xpaned),
2601                                                                           (gpointer *)&(xpaned->priv->first_xpaned));
2602
2603         xpaned->priv->first_xpaned = first_xpaned;
2604
2605         if (xpaned->priv->first_xpaned)
2606                 g_object_add_weak_pointer (G_OBJECT (xpaned->priv->first_xpaned),
2607                                                                    (gpointer *)&(xpaned->priv->first_xpaned));
2608 }
2609
2610 static void gtk_xpaned_set_last_top_left_child_focus (GtkXPaned* xpaned,
2611                                                                                                           GtkWidget* widget)
2612 {
2613         if (xpaned->last_top_left_child_focus)
2614                 g_object_remove_weak_pointer (G_OBJECT (xpaned->last_top_left_child_focus),
2615                                                                           (gpointer *)&(xpaned->last_top_left_child_focus));
2616
2617         xpaned->last_top_left_child_focus = widget;
2618
2619         if (xpaned->last_top_left_child_focus)
2620                 g_object_add_weak_pointer (G_OBJECT (xpaned->last_top_left_child_focus),
2621                                                                    (gpointer *)&(xpaned->last_top_left_child_focus));
2622 }
2623
2624 static void gtk_xpaned_set_last_top_right_child_focus (GtkXPaned* xpaned,
2625                                                                                                            GtkWidget *widget)
2626 {
2627         if (xpaned->last_top_right_child_focus)
2628                 g_object_remove_weak_pointer (G_OBJECT (xpaned->last_top_right_child_focus),
2629                                                                           (gpointer *)&(xpaned->last_top_right_child_focus));
2630
2631         xpaned->last_top_right_child_focus = widget;
2632
2633         if (xpaned->last_top_right_child_focus)
2634                 g_object_add_weak_pointer (G_OBJECT (xpaned->last_top_right_child_focus),
2635                                                                    (gpointer *)&(xpaned->last_top_right_child_focus));
2636 }
2637
2638 static void gtk_xpaned_set_last_bottom_left_child_focus (GtkXPaned* xpaned,
2639                                                                                                                  GtkWidget *widget)
2640 {
2641         if (xpaned->last_bottom_left_child_focus)
2642                 g_object_remove_weak_pointer (G_OBJECT (xpaned->last_bottom_left_child_focus),
2643                                                                           (gpointer *)&(xpaned->last_bottom_left_child_focus));
2644
2645         xpaned->last_bottom_left_child_focus = widget;
2646
2647         if (xpaned->last_bottom_left_child_focus)
2648                 g_object_add_weak_pointer (G_OBJECT (xpaned->last_bottom_left_child_focus),
2649                                                                    (gpointer *)&(xpaned->last_bottom_left_child_focus));
2650 }
2651
2652 static void gtk_xpaned_set_last_bottom_right_child_focus (GtkXPaned* xpaned,
2653                                                                                                                  GtkWidget *widget)
2654 {
2655         if (xpaned->last_bottom_right_child_focus)
2656                 g_object_remove_weak_pointer (G_OBJECT (xpaned->last_bottom_right_child_focus),
2657                                                                           (gpointer *)&(xpaned->last_bottom_right_child_focus));
2658
2659         xpaned->last_bottom_right_child_focus = widget;
2660
2661         if (xpaned->last_bottom_right_child_focus)
2662                 g_object_add_weak_pointer (G_OBJECT (xpaned->last_bottom_right_child_focus),
2663                                                                    (gpointer *)&(xpaned->last_bottom_right_child_focus));
2664 }
2665
2666 static GtkWidget* xpaned_get_focus_widget (GtkXPaned* xpaned)
2667 {
2668         GtkWidget* toplevel;
2669
2670         toplevel = gtk_widget_get_toplevel (GTK_WIDGET (xpaned));
2671         if (GTK_WIDGET_TOPLEVEL (toplevel))
2672                 return GTK_WINDOW (toplevel)->focus_widget;
2673
2674         return NULL;
2675 }
2676
2677 static void gtk_xpaned_set_focus_child (GtkContainer* container,
2678                                                                                 GtkWidget* focus_child)
2679 {
2680         GtkXPaned* xpaned;
2681
2682         g_return_if_fail (GTK_IS_XPANED (container));
2683
2684         xpaned = GTK_XPANED (container);
2685
2686         if (focus_child == NULL)
2687         {
2688                 GtkWidget* last_focus;
2689                 GtkWidget* w;
2690
2691                 last_focus = xpaned_get_focus_widget (xpaned);
2692
2693                 if (last_focus)
2694                 {
2695                         /* If there is one or more paned widgets between us and the
2696                         * focus widget, we want the topmost of those as last_focus
2697                         */
2698                         for (w = last_focus; w != GTK_WIDGET (xpaned); w = w->parent)
2699                                 if (GTK_IS_XPANED (w))
2700                                         last_focus = w;
2701
2702                         if (container->focus_child == xpaned->top_left_child)
2703                                 gtk_xpaned_set_last_top_left_child_focus (xpaned, last_focus);
2704                         else if (container->focus_child == xpaned->top_right_child)
2705                                 gtk_xpaned_set_last_top_right_child_focus (xpaned, last_focus);
2706                         else if (container->focus_child == xpaned->bottom_left_child)
2707                                 gtk_xpaned_set_last_bottom_left_child_focus (xpaned, last_focus);
2708                         else if (container->focus_child == xpaned->bottom_right_child)
2709                                 gtk_xpaned_set_last_bottom_right_child_focus (xpaned, last_focus);
2710                 }
2711         }
2712
2713         if (parent_class->set_focus_child)
2714                 (* parent_class->set_focus_child) (container, focus_child);
2715 }
2716
2717 static void gtk_xpaned_get_cycle_chain (GtkXPaned* xpaned,
2718                                                                                 GtkDirectionType direction,
2719                                                                                 GList** widgets)
2720 {
2721         GtkContainer* container = GTK_CONTAINER (xpaned);
2722         GtkWidget* ancestor = NULL;
2723         GList* temp_list = NULL;
2724         GList* list;
2725
2726         if (xpaned->in_recursion)
2727                 return;
2728
2729         g_assert (widgets != NULL);
2730
2731         if (xpaned->last_top_left_child_focus &&
2732                 !gtk_widget_is_ancestor (xpaned->last_top_left_child_focus,
2733                                                                  GTK_WIDGET (xpaned)))
2734         {
2735                 gtk_xpaned_set_last_top_left_child_focus (xpaned, NULL);
2736         }
2737
2738         if (xpaned->last_top_right_child_focus &&
2739                 !gtk_widget_is_ancestor (xpaned->last_top_right_child_focus,
2740                                                                  GTK_WIDGET (xpaned)))
2741         {
2742                 gtk_xpaned_set_last_top_right_child_focus (xpaned, NULL);
2743         }
2744
2745         if (xpaned->last_bottom_left_child_focus &&
2746                 !gtk_widget_is_ancestor (xpaned->last_bottom_left_child_focus,
2747                                                                  GTK_WIDGET (xpaned)))
2748         {
2749                 gtk_xpaned_set_last_bottom_left_child_focus (xpaned, NULL);
2750         }
2751
2752         if (xpaned->last_bottom_right_child_focus &&
2753                 !gtk_widget_is_ancestor (xpaned->last_bottom_right_child_focus,
2754                                                                  GTK_WIDGET (xpaned)))
2755         {
2756                 gtk_xpaned_set_last_bottom_right_child_focus (xpaned, NULL);
2757         }
2758
2759         if (GTK_WIDGET (xpaned)->parent)
2760                 ancestor = gtk_widget_get_ancestor (GTK_WIDGET (xpaned)->parent,
2761                                                                                         GTK_TYPE_XPANED);
2762
2763         /* The idea here is that temp_list is a list of widgets we want to cycle
2764         * to. The list is prioritized so that the first element is our first
2765         * choice, the next our second, and so on.
2766         *
2767         * We can't just use g_list_reverse(), because we want to try
2768         * paned->last_child?_focus before paned->child?, both when we
2769         * are going forward and backward.
2770         */
2771         if (direction == GTK_DIR_TAB_FORWARD)
2772         {
2773                 if (container->focus_child == xpaned->top_left_child)
2774                 {
2775                         temp_list = g_list_append (temp_list, xpaned->last_top_right_child_focus);
2776                         temp_list = g_list_append (temp_list, xpaned->top_right_child);
2777                         temp_list = g_list_append (temp_list, ancestor);
2778                 }
2779                 else if (container->focus_child == xpaned->top_right_child)
2780                 {
2781                         temp_list = g_list_append (temp_list, ancestor);
2782                         temp_list = g_list_append (temp_list, xpaned->last_bottom_left_child_focus);
2783                         temp_list = g_list_append (temp_list, xpaned->bottom_left_child);
2784                 }
2785                 else if (container->focus_child == xpaned->bottom_left_child)
2786                 {
2787                         temp_list = g_list_append (temp_list, ancestor);
2788                         temp_list = g_list_append (temp_list, xpaned->last_bottom_right_child_focus);
2789                         temp_list = g_list_append (temp_list, xpaned->bottom_right_child);
2790                 }
2791                 else if (container->focus_child == xpaned->bottom_right_child)
2792                 {
2793                         temp_list = g_list_append (temp_list, ancestor);
2794                         temp_list = g_list_append (temp_list, xpaned->last_top_left_child_focus);
2795                         temp_list = g_list_append (temp_list, xpaned->top_left_child);
2796                 }
2797                 else
2798                 {
2799                         temp_list = g_list_append (temp_list, xpaned->last_top_left_child_focus);
2800                         temp_list = g_list_append (temp_list, xpaned->top_left_child);
2801                         temp_list = g_list_append (temp_list, xpaned->last_top_right_child_focus);
2802                         temp_list = g_list_append (temp_list, xpaned->top_right_child);
2803                         temp_list = g_list_append (temp_list, xpaned->last_bottom_left_child_focus);
2804                         temp_list = g_list_append (temp_list, xpaned->bottom_left_child);
2805                         temp_list = g_list_append (temp_list, xpaned->last_bottom_right_child_focus);
2806                         temp_list = g_list_append (temp_list, xpaned->bottom_right_child);
2807                         temp_list = g_list_append (temp_list, ancestor);
2808                 }
2809         }
2810         else
2811         {
2812                 if (container->focus_child == xpaned->top_left_child)
2813                 {
2814                         temp_list = g_list_append (temp_list, ancestor);
2815                         temp_list = g_list_append (temp_list, xpaned->last_top_right_child_focus);
2816                         temp_list = g_list_append (temp_list, xpaned->top_right_child);
2817                 }
2818                 else if (container->focus_child == xpaned->top_right_child)
2819                 {
2820                         temp_list = g_list_append (temp_list, xpaned->last_bottom_left_child_focus);
2821                         temp_list = g_list_append (temp_list, xpaned->bottom_left_child);
2822                         temp_list = g_list_append (temp_list, ancestor);
2823                 }
2824                 else if (container->focus_child == xpaned->bottom_right_child)
2825                 {
2826                         temp_list = g_list_append (temp_list, xpaned->last_bottom_left_child_focus);
2827                         temp_list = g_list_append (temp_list, xpaned->bottom_left_child);
2828                         temp_list = g_list_append (temp_list, ancestor);
2829                 }
2830                 else if (container->focus_child == xpaned->top_right_child)
2831                 {
2832                         temp_list = g_list_append (temp_list, xpaned->last_bottom_left_child_focus);
2833                         temp_list = g_list_append (temp_list, xpaned->bottom_left_child);
2834                         temp_list = g_list_append (temp_list, ancestor);
2835                 }
2836                 else
2837                 {
2838                         temp_list = g_list_append (temp_list, xpaned->last_bottom_right_child_focus);
2839                         temp_list = g_list_append (temp_list, xpaned->bottom_right_child);
2840                         temp_list = g_list_append (temp_list, xpaned->last_bottom_left_child_focus);
2841                         temp_list = g_list_append (temp_list, xpaned->bottom_left_child);
2842                         temp_list = g_list_append (temp_list, xpaned->last_top_right_child_focus);
2843                         temp_list = g_list_append (temp_list, xpaned->top_right_child);
2844                         temp_list = g_list_append (temp_list, xpaned->last_top_left_child_focus);
2845                         temp_list = g_list_append (temp_list, xpaned->top_left_child);
2846                         temp_list = g_list_append (temp_list, ancestor);
2847                 }
2848         }
2849
2850         /* Walk the list and expand all the paned widgets. */
2851         for (list = temp_list; list != NULL; list = list->next)
2852         {
2853                 GtkWidget *widget = list->data;
2854
2855                 if (widget)
2856                 {
2857                         if (GTK_IS_XPANED (widget))
2858                         {
2859                                 xpaned->in_recursion = TRUE;
2860                                 gtk_xpaned_get_cycle_chain (GTK_XPANED (widget),
2861                                                                                         direction,
2862                                                                                         widgets);
2863                                 xpaned->in_recursion = FALSE;
2864                         }
2865                         else
2866                         {
2867                                 *widgets = g_list_append (*widgets, widget);
2868                         }
2869                 }
2870         }
2871
2872         g_list_free (temp_list);
2873 }
2874
2875 static gboolean gtk_xpaned_cycle_child_focus (GtkXPaned* xpaned,
2876                                                                                           gboolean reversed)
2877 {
2878         GList* cycle_chain = NULL;
2879         GList* list;
2880
2881         GtkDirectionType direction = reversed ? GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD;
2882
2883         /* ignore f6 if the handle is focused */
2884         if (gtk_widget_is_focus (GTK_WIDGET (xpaned)))
2885                 return TRUE;
2886
2887         /* we can't just let the event propagate up the hierarchy,
2888         * because the paned will want to cycle focus _unless_ an
2889         * ancestor paned handles the event
2890         */
2891         gtk_xpaned_get_cycle_chain (xpaned, direction, &cycle_chain);
2892
2893         for (list = cycle_chain; list != NULL; list = list->next)
2894                 if (gtk_widget_child_focus (GTK_WIDGET (list->data), direction))
2895                         break;
2896
2897         g_list_free (cycle_chain);
2898
2899         return TRUE;
2900 }
2901
2902 static void get_child_xpanes (GtkWidget* widget, GList** xpanes)
2903 {
2904         if (GTK_IS_XPANED (widget))
2905         {
2906                 GtkXPaned* xpaned = GTK_XPANED (widget);
2907
2908                 get_child_xpanes (xpaned->top_left_child, xpanes);
2909                 *xpanes = g_list_prepend (*xpanes, widget);
2910                 get_child_xpanes (xpaned->top_right_child, xpanes);
2911                 *xpanes = g_list_prepend (*xpanes, widget);
2912                 get_child_xpanes (xpaned->bottom_left_child, xpanes);
2913                 *xpanes = g_list_prepend (*xpanes, widget);
2914                 get_child_xpanes (xpaned->bottom_right_child, xpanes);
2915         }
2916         else if (GTK_IS_CONTAINER (widget))
2917         {
2918                 gtk_container_foreach (GTK_CONTAINER (widget),
2919                                                            (GtkCallback)get_child_xpanes,
2920                                                            xpanes);
2921         }
2922 }
2923
2924 static GList* get_all_xpanes (GtkXPaned* xpaned)
2925 {
2926         GtkXPaned* topmost = NULL;
2927         GList* result = NULL;
2928         GtkWidget* w;
2929   
2930         for (w = GTK_WIDGET (xpaned); w != NULL; w = w->parent)
2931         {
2932                 if (GTK_IS_XPANED (w))
2933                         topmost = GTK_XPANED (w);
2934         }
2935
2936         g_assert (topmost);
2937
2938         get_child_xpanes (GTK_WIDGET (topmost), &result);
2939
2940         return g_list_reverse (result);
2941 }
2942
2943 static void gtk_xpaned_find_neighbours (GtkXPaned* xpaned,
2944                                                                                 GtkXPaned** next,
2945                                                                                 GtkXPaned** prev)
2946 {
2947         GList* all_xpanes;
2948         GList* this_link;
2949
2950         all_xpanes = get_all_xpanes (xpaned);
2951         g_assert (all_xpanes);
2952
2953         this_link = g_list_find (all_xpanes, xpaned);
2954
2955         g_assert (this_link);
2956
2957         if (this_link->next)
2958                 *next = this_link->next->data;
2959         else
2960                 *next = all_xpanes->data;
2961
2962         if (this_link->prev)
2963                 *prev = this_link->prev->data;
2964         else
2965                 *prev = g_list_last (all_xpanes)->data;
2966
2967         g_list_free (all_xpanes);
2968 }
2969
2970 static gboolean gtk_xpaned_move_handle (GtkXPaned* xpaned, GtkScrollType scroll)
2971 {
2972         if (gtk_widget_is_focus (GTK_WIDGET (xpaned)))
2973         {
2974                 GdkPoint old_position;
2975                 GdkPoint new_position;
2976                 gint increment;
2977
2978                 enum
2979                 {
2980                         SINGLE_STEP_SIZE = 1,
2981                         PAGE_STEP_SIZE   = 75
2982                 };
2983
2984                 new_position.x = old_position.x = gtk_xpaned_get_position_x (xpaned);
2985                 new_position.y = old_position.y = gtk_xpaned_get_position_y (xpaned);
2986                 increment = 0;
2987
2988                 switch (scroll)
2989                 {
2990                         case GTK_SCROLL_STEP_LEFT:
2991                         case GTK_SCROLL_STEP_UP:
2992                         case GTK_SCROLL_STEP_BACKWARD:
2993                                 increment = - SINGLE_STEP_SIZE;
2994                         break;
2995
2996                         case GTK_SCROLL_STEP_RIGHT:
2997                         case GTK_SCROLL_STEP_DOWN:
2998                         case GTK_SCROLL_STEP_FORWARD:
2999                                 increment = SINGLE_STEP_SIZE;
3000                         break;
3001
3002                         case GTK_SCROLL_PAGE_LEFT:
3003                         case GTK_SCROLL_PAGE_UP:
3004                         case GTK_SCROLL_PAGE_BACKWARD:
3005                                 increment = - PAGE_STEP_SIZE;
3006                         break;
3007
3008                         case GTK_SCROLL_PAGE_RIGHT:
3009                         case GTK_SCROLL_PAGE_DOWN:
3010                         case GTK_SCROLL_PAGE_FORWARD:
3011                                 increment = PAGE_STEP_SIZE;
3012                         break;
3013
3014                         case GTK_SCROLL_START:
3015                                 new_position.x = xpaned->min_position.x;
3016                                 new_position.y = xpaned->min_position.y;
3017                         break;
3018
3019                         case GTK_SCROLL_END:
3020                                 new_position.x = xpaned->max_position.x;
3021                                 new_position.y = xpaned->max_position.y;
3022                         break;
3023
3024                         default:
3025                         break;
3026                 }
3027
3028                 if (increment)
3029                 {
3030                         if (is_rtl (xpaned))
3031                                 increment = -increment;
3032
3033                         new_position.x = old_position.x + increment;
3034                         new_position.y = old_position.y + increment;
3035                 }
3036
3037                 new_position.x = CLAMP (new_position.x,
3038                                                                 xpaned->min_position.x,
3039                                                                 xpaned->max_position.x);
3040
3041                 new_position.y = CLAMP (new_position.y,
3042                                                                 xpaned->min_position.y,
3043                                                                 xpaned->max_position.y);
3044
3045                 if (old_position.x != new_position.x)
3046                         gtk_xpaned_set_position_x (xpaned, new_position.x);
3047
3048                 if (old_position.y != new_position.y)
3049                         gtk_xpaned_set_position_y (xpaned, new_position.y);
3050
3051                 return TRUE;
3052         }
3053
3054         return FALSE;
3055 }
3056
3057 static void gtk_xpaned_restore_focus (GtkXPaned* xpaned)
3058 {
3059         if (gtk_widget_is_focus (GTK_WIDGET (xpaned)))
3060         {
3061                 if (xpaned->priv->saved_focus &&
3062                         GTK_WIDGET_SENSITIVE (xpaned->priv->saved_focus))
3063                 {
3064                         gtk_widget_grab_focus (xpaned->priv->saved_focus);
3065                 }
3066                 else
3067                 {
3068                         /* the saved focus is somehow not available for focusing,
3069                         * try
3070                         *   1) tabbing into the paned widget
3071                         * if that didn't work,
3072                         *   2) unset focus for the window if there is one
3073                         */
3074
3075                         if (!gtk_widget_child_focus (GTK_WIDGET (xpaned), GTK_DIR_TAB_FORWARD))
3076                         {
3077                                 GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (xpaned));
3078               
3079                                 if (GTK_IS_WINDOW (toplevel))
3080                                         gtk_window_set_focus (GTK_WINDOW (toplevel), NULL);
3081                         }
3082                 }
3083                 
3084                 gtk_xpaned_set_saved_focus (xpaned, NULL);
3085                 gtk_xpaned_set_first_xpaned (xpaned, NULL);
3086     }
3087 }
3088
3089 static gboolean gtk_xpaned_accept_position (GtkXPaned* xpaned)
3090 {
3091         if (gtk_widget_is_focus (GTK_WIDGET (xpaned)))
3092         {
3093                 xpaned->original_position.x = -1;
3094                 xpaned->original_position.y = -1;
3095                 gtk_xpaned_restore_focus (xpaned);
3096
3097                 return TRUE;
3098         }
3099
3100         return FALSE;
3101 }
3102
3103 static gboolean gtk_xpaned_cancel_position (GtkXPaned* xpaned)
3104 {
3105         if (gtk_widget_is_focus (GTK_WIDGET (xpaned)))
3106         {
3107                 if (xpaned->original_position.x != -1)
3108                 {
3109                         gtk_xpaned_set_position_x (xpaned, xpaned->original_position.x);
3110                         xpaned->original_position.x = -1;
3111                 }
3112
3113                 if (xpaned->original_position.y != -1)
3114                 {
3115                         gtk_xpaned_set_position_y (xpaned, xpaned->original_position.y);
3116                         xpaned->original_position.y = -1;
3117                 }
3118
3119                 gtk_xpaned_restore_focus (xpaned);
3120                 return TRUE;
3121         }
3122
3123         return FALSE;
3124 }
3125
3126 static gboolean gtk_xpaned_cycle_handle_focus (GtkXPaned* xpaned,
3127                                                                                            gboolean reversed)
3128 {
3129         GtkXPaned* next;
3130         GtkXPaned* prev;
3131
3132         if (gtk_widget_is_focus (GTK_WIDGET (xpaned)))
3133         {
3134                 GtkXPaned* focus = NULL;
3135
3136                 if (!xpaned->priv->first_xpaned)
3137                 {
3138                         /* The first_pane has disappeared. As an ad-hoc solution,
3139                         * we make the currently focused paned the first_paned. To the
3140                         * user this will seem like the paned cycling has been reset.
3141                         */
3142                         gtk_xpaned_set_first_xpaned (xpaned, xpaned);
3143                 }
3144
3145                 gtk_xpaned_find_neighbours (xpaned, &next, &prev);
3146
3147                 if (reversed && prev &&
3148                         prev != xpaned && xpaned != xpaned->priv->first_xpaned)
3149                 {
3150                         focus = prev;
3151                 }
3152                 else if (!reversed &&
3153                                  next &&
3154                                  next != xpaned &&
3155                                  next != xpaned->priv->first_xpaned)
3156                 {
3157                         focus = next;
3158                 }
3159                 else
3160                 {
3161                         gtk_xpaned_accept_position (xpaned);
3162                         return TRUE;
3163                 }
3164
3165                 g_assert (focus);
3166       
3167                 gtk_xpaned_set_saved_focus (focus, xpaned->priv->saved_focus);
3168                 gtk_xpaned_set_first_xpaned (focus, xpaned->priv->first_xpaned);
3169       
3170                 gtk_xpaned_set_saved_focus (xpaned, NULL);
3171                 gtk_xpaned_set_first_xpaned (xpaned, NULL);
3172       
3173                 gtk_widget_grab_focus (GTK_WIDGET (focus));
3174       
3175                 if (!gtk_widget_is_focus (GTK_WIDGET (xpaned)))
3176                 {
3177                         xpaned->original_position.x = -1;
3178                         xpaned->original_position.y = -1;
3179                         focus->original_position.x = gtk_xpaned_get_position_x (focus);
3180                         focus->original_position.y = gtk_xpaned_get_position_y (focus);
3181                 }
3182         }
3183         else
3184     {
3185                 GtkContainer* container = GTK_CONTAINER (xpaned);
3186                 GtkXPaned* focus;
3187                 GtkXPaned* first;
3188                 GtkXPaned* prev;
3189                 GtkXPaned* next;
3190                 GtkWidget* toplevel;
3191
3192                 gtk_xpaned_find_neighbours (xpaned, &next, &prev);
3193
3194                 if (container->focus_child == xpaned->top_left_child)
3195                 {
3196                         if (reversed)
3197                         {
3198                                 focus = prev;
3199                                 first = xpaned;
3200                         }
3201                         else
3202                         {
3203                                 focus = xpaned;
3204                                 first = xpaned;
3205                         }
3206                 }
3207                 else if (container->focus_child == xpaned->top_right_child)
3208                 {
3209                         if (reversed)
3210                         {
3211                                 focus = xpaned;
3212                                 first = next;
3213                         }
3214                         else
3215                         {
3216                                 focus = next;
3217                                 first = next;
3218                         }
3219                 }
3220                 else
3221                 {
3222                         /* Focus is not inside this xpaned, and we don't have focus.
3223                         * Presumably this happened because the application wants us
3224                         * to start keyboard navigating.
3225                         */
3226                         focus = xpaned;
3227
3228                         if (reversed)
3229                                 first = xpaned;
3230                         else
3231                                 first = next;
3232                 }
3233
3234                 toplevel = gtk_widget_get_toplevel (GTK_WIDGET (xpaned));
3235
3236                 if (GTK_IS_WINDOW (toplevel))
3237                         gtk_xpaned_set_saved_focus (focus, GTK_WINDOW (toplevel)->focus_widget);
3238                 gtk_xpaned_set_first_xpaned (focus, first);
3239                 focus->original_position.x = gtk_xpaned_get_position_x (focus);
3240                 focus->original_position.y = gtk_xpaned_get_position_y (focus); 
3241
3242                 gtk_widget_grab_focus (GTK_WIDGET (focus));
3243         }
3244
3245         return TRUE;
3246 }
3247
3248 static gboolean gtk_xpaned_toggle_handle_focus (GtkXPaned* xpaned)
3249 {
3250         /* This function/signal has the wrong name. It is called when you
3251         * press Tab or Shift-Tab and what we do is act as if
3252         * the user pressed Return and then Tab or Shift-Tab
3253         */
3254         if (gtk_widget_is_focus (GTK_WIDGET (xpaned)))
3255                 gtk_xpaned_accept_position (xpaned);
3256
3257   return FALSE;
3258 }
3259
3260 /*#define __GTK_XPANED_C__*/
3261 /*#include "gtkaliasdef.c"*/