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