Pileus Git - ~andy/gtk/blob - gtk/gtkbin.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
  20 /*
  21  * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include "gtkbin.h"
  28
  29
  30 static void gtk_bin_class_init (GtkBinClass    *klass);
  31 static void gtk_bin_init       (GtkBin         *bin);
  32 static void gtk_bin_map        (GtkWidget      *widget);
  33 static void gtk_bin_unmap      (GtkWidget      *widget);
  34 static void gtk_bin_draw       (GtkWidget      *widget,
  35                                 GdkRectangle   *area);
  36 static gint gtk_bin_expose     (GtkWidget      *widget,
  37                                 GdkEventExpose *event);
  38 static void gtk_bin_add        (GtkContainer   *container,
  39                                 GtkWidget      *widget);
  40 static void gtk_bin_remove     (GtkContainer   *container,
  41                                 GtkWidget      *widget);
  42 static void gtk_bin_forall     (GtkContainer   *container,
  43                                 gboolean        include_internals,
  44                                 GtkCallback     callback,
  45                                 gpointer        callback_data);
  46 static GtkType gtk_bin_child_type (GtkContainer*container);
  47
  48
  49 static GtkContainerClass *parent_class = NULL;
  50
  51
  52 GtkType
  53 gtk_bin_get_type (void)
  54 {
  55   static guint bin_type = 0;
  56
  57   if (!bin_type)
  58     {
  59       static const GtkTypeInfo bin_info =
  60       {
  61         "GtkBin",
  62         sizeof (GtkBin),
  63         sizeof (GtkBinClass),
  64         (GtkClassInitFunc) gtk_bin_class_init,
  65         (GtkObjectInitFunc) gtk_bin_init,
  66         /* reserved_1 */ NULL,
  67         /* reserved_2 */ NULL,
  68         (GtkClassInitFunc) NULL,
  69       };
  70
  71       bin_type = gtk_type_unique (GTK_TYPE_CONTAINER, &bin_info);
  72     }
  73
  74   return bin_type;
  75 }
  76
  77 static void
  78 gtk_bin_class_init (GtkBinClass *class)
  79 {
  80   GtkObjectClass *object_class;
  81   GtkWidgetClass *widget_class;
  82   GtkContainerClass *container_class;
  83
  84   object_class = (GtkObjectClass*) class;
  85   widget_class = (GtkWidgetClass*) class;
  86   container_class = (GtkContainerClass*) class;
  87
  88   parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
  89
  90   widget_class->map = gtk_bin_map;
  91   widget_class->unmap = gtk_bin_unmap;
  92   widget_class->draw = gtk_bin_draw;
  93   widget_class->expose_event = gtk_bin_expose;
  94
  95   container_class->add = gtk_bin_add;
  96   container_class->remove = gtk_bin_remove;
  97   container_class->forall = gtk_bin_forall;
  98   container_class->child_type = gtk_bin_child_type;
  99 }
 100
 101 static void
 102 gtk_bin_init (GtkBin *bin)
 103 {
 104   GTK_WIDGET_SET_FLAGS (bin, GTK_NO_WINDOW);
 105
 106   bin->child = NULL;
 107 }
 108
 109
 110 static GtkType
 111 gtk_bin_child_type (GtkContainer *container)
 112 {
 113   if (!GTK_BIN (container)->child)
 114     return GTK_TYPE_WIDGET;
 115   else
 116     return GTK_TYPE_NONE;
 117 }
 118
 119 static void
 120 gtk_bin_map (GtkWidget *widget)
 121 {
 122   GtkBin *bin;
 123
 124   g_return_if_fail (widget != NULL);
 125   g_return_if_fail (GTK_IS_BIN (widget));
 126
 127   GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
 128   bin = GTK_BIN (widget);
 129
 130   if (bin->child &&
 131       GTK_WIDGET_VISIBLE (bin->child) &&
 132       !GTK_WIDGET_MAPPED (bin->child))
 133     gtk_widget_map (bin->child);
 134
 135   if (!GTK_WIDGET_NO_WINDOW (widget))
 136     gdk_window_show (widget->window);
 137 }
 138
 139 static void
 140 gtk_bin_unmap (GtkWidget *widget)
 141 {
 142   GtkBin *bin;
 143
 144   g_return_if_fail (widget != NULL);
 145   g_return_if_fail (GTK_IS_BIN (widget));
 146
 147   GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
 148   bin = GTK_BIN (widget);
 149
 150   if (GTK_WIDGET_NO_WINDOW (widget))
 151      gtk_widget_queue_clear (widget);
 152   else
 153     gdk_window_hide (widget->window);
 154
 155   if (bin->child && GTK_WIDGET_MAPPED (bin->child))
 156     gtk_widget_unmap (bin->child);
 157 }
 158
 159 static void
 160 gtk_bin_draw (GtkWidget    *widget,
 161               GdkRectangle *area)
 162 {
 163   GtkBin *bin;
 164   GdkRectangle child_area;
 165
 166   g_return_if_fail (widget != NULL);
 167   g_return_if_fail (GTK_IS_BIN (widget));
 168
 169   bin = GTK_BIN (widget);
 170
 171   if (bin->child && GTK_WIDGET_VISIBLE (bin->child) &&
 172       gtk_widget_intersect (bin->child, area, &child_area))
 173     gtk_widget_draw (bin->child, &child_area);
 174 }
 175
 176 static gint
 177 gtk_bin_expose (GtkWidget      *widget,
 178                 GdkEventExpose *event)
 179 {
 180   GtkBin *bin;
 181   GdkEventExpose child_event;
 182
 183   g_return_val_if_fail (widget != NULL, FALSE);
 184   g_return_val_if_fail (GTK_IS_BIN (widget), FALSE);
 185   g_return_val_if_fail (event != NULL, FALSE);
 186
 187   if (GTK_WIDGET_DRAWABLE (widget))
 188     {
 189       bin = GTK_BIN (widget);
 190
 191       child_event = *event;
 192       if (bin->child &&
 193           GTK_WIDGET_NO_WINDOW (bin->child) &&
 194           gtk_widget_intersect (bin->child, &event->area, &child_event.area))
 195         gtk_widget_event (bin->child, (GdkEvent*) &child_event);
 196     }
 197
 198   return FALSE;
 199 }
 200
 201
 202 static void
 203 gtk_bin_add (GtkContainer *container,
 204              GtkWidget    *child)
 205 {
 206   GtkBin *bin;
 207
 208   g_return_if_fail (container != NULL);
 209   g_return_if_fail (GTK_IS_BIN (container));
 210   g_return_if_fail (child != NULL);
 211   g_return_if_fail (GTK_IS_WIDGET (child));
 212
 213   bin = GTK_BIN (container);
 214   g_return_if_fail (bin->child == NULL);
 215
 216   gtk_widget_set_parent (child, GTK_WIDGET (bin));
 217   bin->child = child;
 218
 219   if (GTK_WIDGET_VISIBLE (child->parent))
 220     {
 221       if (GTK_WIDGET_REALIZED (child->parent) &&
 222           !GTK_WIDGET_REALIZED (child))
 223         gtk_widget_realize (child);
 224
 225       if (GTK_WIDGET_MAPPED (child->parent) &&
 226           !GTK_WIDGET_MAPPED (child))
 227         gtk_widget_map (child);
 228     }
 229
 230   if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (container))
 231     gtk_widget_queue_resize (child);
 232 }
 233
 234 static void
 235 gtk_bin_remove (GtkContainer *container,
 236                 GtkWidget    *child)
 237 {
 238   GtkBin *bin;
 239   gboolean widget_was_visible;
 240
 241   g_return_if_fail (container != NULL);
 242   g_return_if_fail (GTK_IS_BIN (container));
 243   g_return_if_fail (child != NULL);
 244   g_return_if_fail (GTK_IS_WIDGET (child));
 245
 246   bin = GTK_BIN (container);
 247   g_return_if_fail (bin->child == child);
 248
 249   widget_was_visible = GTK_WIDGET_VISIBLE (child);
 250
 251   gtk_widget_unparent (child);
 252   bin->child = NULL;
 253
 254   /* queue resize regardless of GTK_WIDGET_VISIBLE (container),
 255    * since that's what is needed by toplevels, which derive from GtkBin.
 256    */
 257   if (widget_was_visible)
 258     gtk_widget_queue_resize (GTK_WIDGET (container));
 259 }
 260
 261 static void
 262 gtk_bin_forall (GtkContainer *container,
 263                 gboolean      include_internals,
 264                 GtkCallback   callback,
 265                 gpointer      callback_data)
 266 {
 267   GtkBin *bin;
 268
 269   g_return_if_fail (container != NULL);
 270   g_return_if_fail (GTK_IS_BIN (container));
 271   g_return_if_fail (callback != NULL);
 272
 273   bin = GTK_BIN (container);
 274
 275   if (bin->child)
 276     (* callback) (bin->child, callback_data);
 277 }