← Back to branch summary

~gabriel1984sibiu/gtk+1.2/gtk+1.2

« back to all changes in this revision

Viewing changes to gtk/gtkbin.c

  • Committer: Bazaar Package Importer
  • Author(s): Akira TAGOH
  • Date: 2002-04-15 02:19:49 UTC
  • Revision ID: james.westby@ubuntu.com-20020415021949-eh01yrgh4b85p9z7
Tags: upstream-1.2.10
Import upstream version 1.2.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 (GTK_WIDGET_DRAWABLE (bin))
 
172
    {
 
173
      if (bin->child && GTK_WIDGET_DRAWABLE (bin->child) &&
 
174
          gtk_widget_intersect (bin->child, area, &child_area))
 
175
        gtk_widget_draw (bin->child, &child_area);
 
176
    }
 
177
}
 
178
 
 
179
static gint
 
180
gtk_bin_expose (GtkWidget      *widget,
 
181
                GdkEventExpose *event)
 
182
{
 
183
  GtkBin *bin;
 
184
  GdkEventExpose child_event;
 
185
 
 
186
  g_return_val_if_fail (widget != NULL, FALSE);
 
187
  g_return_val_if_fail (GTK_IS_BIN (widget), FALSE);
 
188
  g_return_val_if_fail (event != NULL, FALSE);
 
189
 
 
190
  if (GTK_WIDGET_DRAWABLE (widget))
 
191
    {
 
192
      bin = GTK_BIN (widget);
 
193
 
 
194
      child_event = *event;
 
195
      if (bin->child && GTK_WIDGET_DRAWABLE (bin->child) &&
 
196
          GTK_WIDGET_NO_WINDOW (bin->child) &&
 
197
          gtk_widget_intersect (bin->child, &event->area, &child_event.area))
 
198
        gtk_widget_event (bin->child, (GdkEvent*) &child_event);
 
199
    }
 
200
 
 
201
  return FALSE;
 
202
}
 
203
 
 
204
 
 
205
static void
 
206
gtk_bin_add (GtkContainer *container,
 
207
             GtkWidget    *child)
 
208
{
 
209
  GtkBin *bin;
 
210
 
 
211
  g_return_if_fail (container != NULL);
 
212
  g_return_if_fail (GTK_IS_BIN (container));
 
213
  g_return_if_fail (child != NULL);
 
214
  g_return_if_fail (GTK_IS_WIDGET (child));
 
215
 
 
216
  bin = GTK_BIN (container);
 
217
  g_return_if_fail (bin->child == NULL);
 
218
 
 
219
  gtk_widget_set_parent (child, GTK_WIDGET (bin));
 
220
  bin->child = child;
 
221
 
 
222
  if (GTK_WIDGET_REALIZED (child->parent))
 
223
    gtk_widget_realize (child);
 
224
 
 
225
  if (GTK_WIDGET_VISIBLE (child->parent) && GTK_WIDGET_VISIBLE (child))
 
226
    {
 
227
      if (GTK_WIDGET_MAPPED (child->parent))
 
228
        gtk_widget_map (child);
 
229
 
 
230
      gtk_widget_queue_resize (child);
 
231
    }
 
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
}