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     gdk_window_hide (widget->window);
 152
 153   if (bin->child && GTK_WIDGET_MAPPED (bin->child))
 154     gtk_widget_unmap (bin->child);
 155 }
 156
 157 static void
 158 gtk_bin_draw (GtkWidget    *widget,
 159               GdkRectangle *area)
 160 {
 161   GtkBin *bin;
 162   GdkRectangle child_area;
 163
 164   g_return_if_fail (widget != NULL);
 165   g_return_if_fail (GTK_IS_BIN (widget));
 166
 167   bin = GTK_BIN (widget);
 168
 169   if (GTK_WIDGET_DRAWABLE (bin))
 170     {
 171       if (bin->child && GTK_WIDGET_DRAWABLE (bin->child) &&
 172           gtk_widget_intersect (bin->child, area, &child_area))
 173         gtk_widget_draw (bin->child, &child_area);
 174     }
 175 }
 176
 177 static gint
 178 gtk_bin_expose (GtkWidget      *widget,
 179                 GdkEventExpose *event)
 180 {
 181   GtkBin *bin;
 182   GdkEventExpose child_event;
 183
 184   g_return_val_if_fail (widget != NULL, FALSE);
 185   g_return_val_if_fail (GTK_IS_BIN (widget), FALSE);
 186   g_return_val_if_fail (event != NULL, FALSE);
 187
 188   if (GTK_WIDGET_DRAWABLE (widget))
 189     {
 190       bin = GTK_BIN (widget);
 191
 192       child_event = *event;
 193       if (bin->child && GTK_WIDGET_DRAWABLE (bin->child) &&
 194           GTK_WIDGET_NO_WINDOW (bin->child) &&
 195           gtk_widget_intersect (bin->child, &event->area, &child_event.area))
 196         gtk_widget_event (bin->child, (GdkEvent*) &child_event);
 197     }
 198
 199   return FALSE;
 200 }
 201
 202
 203 static void
 204 gtk_bin_add (GtkContainer *container,
 205              GtkWidget    *child)
 206 {
 207   GtkBin *bin;
 208
 209   g_return_if_fail (container != NULL);
 210   g_return_if_fail (GTK_IS_BIN (container));
 211   g_return_if_fail (child != NULL);
 212   g_return_if_fail (GTK_IS_WIDGET (child));
 213
 214   bin = GTK_BIN (container);
 215   g_return_if_fail (bin->child == NULL);
 216
 217   gtk_widget_set_parent (child, GTK_WIDGET (bin));
 218   bin->child = child;
 219
 220   if (GTK_WIDGET_REALIZED (child->parent))
 221     gtk_widget_realize (child);
 222
 223   if (GTK_WIDGET_VISIBLE (child->parent) && GTK_WIDGET_VISIBLE (child))
 224     {
 225       if (GTK_WIDGET_MAPPED (child->parent))
 226         gtk_widget_map (child);
 227
 228       gtk_widget_queue_resize (child);
 229     }
 230 }
 231
 232 static void
 233 gtk_bin_remove (GtkContainer *container,
 234                 GtkWidget    *child)
 235 {
 236   GtkBin *bin;
 237   gboolean widget_was_visible;
 238
 239   g_return_if_fail (container != NULL);
 240   g_return_if_fail (GTK_IS_BIN (container));
 241   g_return_if_fail (child != NULL);
 242   g_return_if_fail (GTK_IS_WIDGET (child));
 243
 244   bin = GTK_BIN (container);
 245   g_return_if_fail (bin->child == child);
 246
 247   widget_was_visible = GTK_WIDGET_VISIBLE (child);
 248
 249   gtk_widget_unparent (child);
 250   bin->child = NULL;
 251
 252   /* queue resize regardless of GTK_WIDGET_VISIBLE (container),
 253    * since that's what is needed by toplevels, which derive from GtkBin.
 254    */
 255   if (widget_was_visible)
 256     gtk_widget_queue_resize (GTK_WIDGET (container));
 257 }
 258
 259 static void
 260 gtk_bin_forall (GtkContainer *container,
 261                 gboolean      include_internals,
 262                 GtkCallback   callback,
 263                 gpointer      callback_data)
 264 {
 265   GtkBin *bin;
 266
 267   g_return_if_fail (container != NULL);
 268   g_return_if_fail (GTK_IS_BIN (container));
 269   g_return_if_fail (callback != NULL);
 270
 271   bin = GTK_BIN (container);
 272
 273   if (bin->child)
 274     (* callback) (bin->child, callback_data);
 275 }