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