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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19 #include "gtkvpaned.h"
  20 #include "gtkmain.h"
  21 #include "gtksignal.h"
  22
  23 static void gtk_vpaned_class_init       (GtkVPanedClass *klass);
  24 static void gtk_vpaned_init             (GtkVPaned      *vpaned);
  25 static void gtk_vpaned_size_request     (GtkWidget      *widget,
  26                                          GtkRequisition *requisition);
  27 static void gtk_vpaned_size_allocate    (GtkWidget          *widget,
  28                                          GtkAllocation      *allocation);
  29 static void gtk_vpaned_draw             (GtkWidget    *widget,
  30                                          GdkRectangle *area);
  31 static void gtk_vpaned_xor_line         (GtkPaned *paned);
  32 static gint gtk_vpaned_button_press     (GtkWidget *widget,
  33                                          GdkEventButton *event);
  34 static gint gtk_vpaned_button_release   (GtkWidget *widget,
  35                                          GdkEventButton *event);
  36 static gint gtk_vpaned_motion           (GtkWidget *widget,
  37                                          GdkEventMotion *event);
  38
  39 guint
  40 gtk_vpaned_get_type (void)
  41 {
  42   static guint vpaned_type = 0;
  43
  44   if (!vpaned_type)
  45     {
  46       static const GtkTypeInfo vpaned_info =
  47       {
  48         "GtkVPaned",
  49         sizeof (GtkVPaned),
  50         sizeof (GtkVPanedClass),
  51         (GtkClassInitFunc) gtk_vpaned_class_init,
  52         (GtkObjectInitFunc) gtk_vpaned_init,
  53         /* reserved_1 */ NULL,
  54         /* reserved_2 */ NULL,
  55         (GtkClassInitFunc) NULL,
  56       };
  57
  58       vpaned_type = gtk_type_unique (gtk_paned_get_type (), &vpaned_info);
  59     }
  60
  61   return vpaned_type;
  62 }
  63
  64 static void
  65 gtk_vpaned_class_init (GtkVPanedClass *class)
  66 {
  67   GtkWidgetClass *widget_class;
  68
  69   widget_class = (GtkWidgetClass*) class;
  70
  71   widget_class->size_request = gtk_vpaned_size_request;
  72   widget_class->size_allocate = gtk_vpaned_size_allocate;
  73   widget_class->draw = gtk_vpaned_draw;
  74   widget_class->button_press_event = gtk_vpaned_button_press;
  75   widget_class->button_release_event = gtk_vpaned_button_release;
  76   widget_class->motion_notify_event = gtk_vpaned_motion;
  77 }
  78
  79 static void
  80 gtk_vpaned_init (GtkVPaned *vpaned)
  81 {
  82 }
  83
  84 GtkWidget*
  85 gtk_vpaned_new (void)
  86 {
  87   GtkVPaned *vpaned;
  88
  89   vpaned = gtk_type_new (gtk_vpaned_get_type ());
  90
  91   return GTK_WIDGET (vpaned);
  92 }
  93
  94 static void
  95 gtk_vpaned_size_request (GtkWidget      *widget,
  96                          GtkRequisition *requisition)
  97 {
  98   GtkPaned *paned;
  99
 100   g_return_if_fail (widget != NULL);
 101   g_return_if_fail (GTK_IS_VPANED (widget));
 102   g_return_if_fail (requisition != NULL);
 103
 104   paned = GTK_PANED (widget);
 105   requisition->width = 0;
 106   requisition->height = 0;
 107
 108   if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1))
 109     {
 110       gtk_widget_size_request (paned->child1, &paned->child1->requisition);
 111
 112       requisition->height = paned->child1->requisition.height;
 113       requisition->width = paned->child1->requisition.width;
 114     }
 115
 116   if (paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
 117     {
 118       gtk_widget_size_request (paned->child2, &paned->child2->requisition);
 119
 120       requisition->width = MAX (requisition->width,
 121                                 paned->child2->requisition.width);
 122       requisition->height += paned->child2->requisition.height;
 123     }
 124
 125   requisition->height += GTK_CONTAINER (paned)->border_width * 2 + paned->gutter_size;
 126   requisition->width += GTK_CONTAINER (paned)->border_width * 2;
 127 }
 128
 129 static void
 130 gtk_vpaned_size_allocate (GtkWidget     *widget,
 131                           GtkAllocation *allocation)
 132 {
 133   GtkPaned *paned;
 134   GtkAllocation child1_allocation;
 135   GtkAllocation child2_allocation;
 136   guint16 border_width;
 137
 138   g_return_if_fail (widget != NULL);
 139   g_return_if_fail (GTK_IS_VPANED (widget));
 140   g_return_if_fail (allocation != NULL);
 141
 142   widget->allocation = *allocation;
 143
 144   paned = GTK_PANED (widget);
 145   border_width = GTK_CONTAINER (widget)->border_width;
 146
 147   gtk_paned_compute_position (paned,
 148                               widget->allocation.height
 149                                 - paned->gutter_size
 150                                 - 2 * border_width,
 151                               paned->child1->requisition.height,
 152                               paned->child2->requisition.height);
 153
 154   /* Move the handle before the children so we don't get extra expose events */
 155
 156   paned->handle_xpos = allocation->width - border_width - 2 * paned->handle_size;
 157   paned->handle_ypos = paned->child1_size + border_width + paned->gutter_size / 2 - paned->handle_size / 2;
 158
 159   if (GTK_WIDGET_REALIZED (widget))
 160     {
 161       gdk_window_move_resize (widget->window,
 162                               allocation->x, allocation->y,
 163                               allocation->width, allocation->height);
 164
 165       gdk_window_move (paned->handle, paned->handle_xpos, paned->handle_ypos);
 166     }
 167
 168   if (GTK_WIDGET_MAPPED (widget))
 169     {
 170       gdk_window_clear_area (widget->window,
 171                              paned->groove_rectangle.x,
 172                              paned->groove_rectangle.y,
 173                              paned->groove_rectangle.width,
 174                              paned->groove_rectangle.height);
 175     }
 176
 177   child1_allocation.width = child2_allocation.width = MAX (1, allocation->width - border_width * 2);
 178   child1_allocation.height = paned->child1_size;
 179   child1_allocation.x = child2_allocation.x = border_width;
 180   child1_allocation.y = border_width;
 181
 182   paned->groove_rectangle.y = child1_allocation.y
 183     + child1_allocation.height + paned->gutter_size / 2 - 1;
 184   paned->groove_rectangle.x = 0;
 185   paned->groove_rectangle.height = 2;
 186   paned->groove_rectangle.width = allocation->width;
 187
 188   child2_allocation.y = paned->groove_rectangle.y + paned->gutter_size / 2 + 1;
 189   child2_allocation.height = MAX (1, allocation->height
 190     - child2_allocation.y - border_width);
 191
 192   /* Now allocate the childen, making sure, when resizing not to
 193    * overlap the windows */
 194   if (GTK_WIDGET_MAPPED(widget) &&
 195       paned->child1 && GTK_WIDGET_VISIBLE (paned->child1) &&
 196       paned->child1->allocation.height < child1_allocation.height)
 197     {
 198       if (paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
 199         gtk_widget_size_allocate (paned->child2, &child2_allocation);
 200       gtk_widget_size_allocate (paned->child1, &child1_allocation);
 201     }
 202   else
 203     {
 204       if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1))
 205         gtk_widget_size_allocate (paned->child1, &child1_allocation);
 206       if (paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
 207         gtk_widget_size_allocate (paned->child2, &child2_allocation);
 208     }
 209 }
 210
 211 static void
 212 gtk_vpaned_draw (GtkWidget    *widget,
 213                 GdkRectangle *area)
 214 {
 215   GtkPaned *paned;
 216   GdkRectangle child_area;
 217   guint16 border_width;
 218
 219   g_return_if_fail (widget != NULL);
 220   g_return_if_fail (GTK_IS_PANED (widget));
 221
 222   if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget))
 223     {
 224       paned = GTK_PANED (widget);
 225       border_width = GTK_CONTAINER (paned)->border_width;
 226
 227       gdk_window_clear_area (widget->window,
 228                              area->x, area->y, area->width, area->height);
 229       if (paned->child1 &&
 230           gtk_widget_intersect (paned->child1, area, &child_area))
 231         gtk_widget_draw (paned->child1, &child_area);
 232       if (paned->child2 &&
 233           gtk_widget_intersect (paned->child2, area, &child_area))
 234         gtk_widget_draw (paned->child2, &child_area);
 235
 236       gtk_paint_hline(widget->style, widget->window, GTK_STATE_NORMAL,
 237                       area, widget, "vpaned",
 238                       0, widget->allocation.width - 1,
 239                       border_width + paned->child1_size + paned->gutter_size / 2 - 1);
 240     }
 241 }
 242
 243 static void
 244 gtk_vpaned_xor_line (GtkPaned *paned)
 245 {
 246   GtkWidget *widget;
 247   GdkGCValues values;
 248   guint16 ypos;
 249
 250   widget = GTK_WIDGET(paned);
 251
 252   if (!paned->xor_gc)
 253     {
 254       values.foreground = widget->style->white;
 255       values.function = GDK_XOR;
 256       values.subwindow_mode = GDK_INCLUDE_INFERIORS;
 257       paned->xor_gc = gdk_gc_new_with_values (widget->window,
 258                                               &values,
 259                                               GDK_GC_FOREGROUND |
 260                                               GDK_GC_FUNCTION |
 261                                               GDK_GC_SUBWINDOW);
 262     }
 263
 264   ypos = paned->child1_size
 265     + GTK_CONTAINER (paned)->border_width + paned->gutter_size / 2;
 266
 267   gdk_draw_line (widget->window, paned->xor_gc,
 268                  0,
 269                  ypos,
 270                  widget->allocation.width - 1,
 271                  ypos);
 272 }
 273
 274 static gint
 275 gtk_vpaned_button_press (GtkWidget *widget, GdkEventButton *event)
 276 {
 277   GtkPaned *paned;
 278
 279   g_return_val_if_fail (widget != NULL,FALSE);
 280   g_return_val_if_fail (GTK_IS_PANED (widget),FALSE);
 281
 282   paned = GTK_PANED (widget);
 283
 284   if (!paned->in_drag &&
 285       (event->window == paned->handle) && (event->button == 1))
 286     {
 287       paned->in_drag = TRUE;
 288       /* We need a server grab here, not gtk_grab_add(), since
 289        * we don't want to pass events on to the widget's children */
 290       gdk_pointer_grab (paned->handle, FALSE,
 291                         GDK_POINTER_MOTION_HINT_MASK
 292                         | GDK_BUTTON1_MOTION_MASK
 293                         | GDK_BUTTON_RELEASE_MASK,
 294                         NULL, NULL, event->time);
 295       paned->child1_size += event->y - paned->handle_size / 2;
 296       paned->child1_size = CLAMP (paned->child1_size, 0,
 297                                   widget->allocation.height - paned->gutter_size
 298                                   - 2 * GTK_CONTAINER (paned)->border_width);
 299       gtk_vpaned_xor_line (paned);
 300     }
 301
 302   return TRUE;
 303 }
 304
 305 static gint
 306 gtk_vpaned_button_release (GtkWidget *widget, GdkEventButton *event)
 307 {
 308   GtkPaned *paned;
 309
 310   g_return_val_if_fail (widget != NULL, FALSE);
 311   g_return_val_if_fail (GTK_IS_PANED (widget), FALSE);
 312
 313   paned = GTK_PANED (widget);
 314
 315   if (paned->in_drag && (event->button == 1))
 316     {
 317       gtk_vpaned_xor_line (paned);
 318       paned->in_drag = FALSE;
 319       paned->position_set = TRUE;
 320       gdk_pointer_ungrab (event->time);
 321       gtk_widget_queue_resize (GTK_WIDGET (paned));
 322     }
 323
 324   return TRUE;
 325 }
 326
 327 static gint
 328 gtk_vpaned_motion (GtkWidget *widget, GdkEventMotion *event)
 329 {
 330   GtkPaned *paned;
 331   gint y;
 332
 333   g_return_val_if_fail (widget != NULL, FALSE);
 334   g_return_val_if_fail (GTK_IS_PANED (widget), FALSE);
 335
 336   if (event->is_hint || event->window != widget->window)
 337       gtk_widget_get_pointer(widget, NULL, &y);
 338   else
 339       y = event->y;
 340
 341   paned = GTK_PANED (widget);
 342
 343   if (paned->in_drag)
 344     {
 345       gint size = y - GTK_CONTAINER (paned)->border_width - paned->gutter_size/2;
 346
 347       gtk_vpaned_xor_line (paned);
 348       paned->child1_size = CLAMP (size,
 349                                   paned->min_position,
 350                                   paned->max_position);
 351       gtk_vpaned_xor_line (paned);
 352     }
 353
 354   return TRUE;
 355 }