1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19 
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 
25 module gtk.Container;
26 
27 private import cairo.Context;
28 private import glib.ListG;
29 private import glib.Str;
30 private import gobject.ObjectG;
31 private import gobject.ParamSpec;
32 private import gobject.Signals;
33 private import gobject.Value;
34 private import gtk.Adjustment;
35 private import gtk.Widget;
36 private import gtk.WidgetPath;
37 private import gtk.c.functions;
38 public  import gtk.c.types;
39 public  import gtkc.gtktypes;
40 private import std.algorithm;
41 
42 
43 /**
44  * A GTK+ user interface is constructed by nesting widgets inside widgets.
45  * Container widgets are the inner nodes in the resulting tree of widgets:
46  * they contain other widgets. So, for example, you might have a #GtkWindow
47  * containing a #GtkFrame containing a #GtkLabel. If you wanted an image instead
48  * of a textual label inside the frame, you might replace the #GtkLabel widget
49  * with a #GtkImage widget.
50  * 
51  * There are two major kinds of container widgets in GTK+. Both are subclasses
52  * of the abstract GtkContainer base class.
53  * 
54  * The first type of container widget has a single child widget and derives
55  * from #GtkBin. These containers are decorators, which
56  * add some kind of functionality to the child. For example, a #GtkButton makes
57  * its child into a clickable button; a #GtkFrame draws a frame around its child
58  * and a #GtkWindow places its child widget inside a top-level window.
59  * 
60  * The second type of container can have more than one child; its purpose is to
61  * manage layout. This means that these containers assign
62  * sizes and positions to their children. For example, a #GtkHBox arranges its
63  * children in a horizontal row, and a #GtkGrid arranges the widgets it contains
64  * in a two-dimensional grid.
65  * 
66  * For implementations of #GtkContainer the virtual method #GtkContainerClass.forall()
67  * is always required, since it's used for drawing and other internal operations
68  * on the children.
69  * If the #GtkContainer implementation expect to have non internal children
70  * it's needed to implement both #GtkContainerClass.add() and #GtkContainerClass.remove().
71  * If the GtkContainer implementation has internal children, they should be added
72  * with gtk_widget_set_parent() on init() and removed with gtk_widget_unparent()
73  * in the #GtkWidgetClass.destroy() implementation.
74  * See more about implementing custom widgets at https://wiki.gnome.org/HowDoI/CustomWidgets
75  * 
76  * # Height for width geometry management
77  * 
78  * GTK+ uses a height-for-width (and width-for-height) geometry management system.
79  * Height-for-width means that a widget can change how much vertical space it needs,
80  * depending on the amount of horizontal space that it is given (and similar for
81  * width-for-height).
82  * 
83  * There are some things to keep in mind when implementing container widgets
84  * that make use of GTK+’s height for width geometry management system. First,
85  * it’s important to note that a container must prioritize one of its
86  * dimensions, that is to say that a widget or container can only have a
87  * #GtkSizeRequestMode that is %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH or
88  * %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT. However, every widget and container
89  * must be able to respond to the APIs for both dimensions, i.e. even if a
90  * widget has a request mode that is height-for-width, it is possible that
91  * its parent will request its sizes using the width-for-height APIs.
92  * 
93  * To ensure that everything works properly, here are some guidelines to follow
94  * when implementing height-for-width (or width-for-height) containers.
95  * 
96  * Each request mode involves 2 virtual methods. Height-for-width apis run
97  * through gtk_widget_get_preferred_width() and then through gtk_widget_get_preferred_height_for_width().
98  * When handling requests in the opposite #GtkSizeRequestMode it is important that
99  * every widget request at least enough space to display all of its content at all times.
100  * 
101  * When gtk_widget_get_preferred_height() is called on a container that is height-for-width,
102  * the container must return the height for its minimum width. This is easily achieved by
103  * simply calling the reverse apis implemented for itself as follows:
104  * 
105  * |[<!-- language="C" -->
106  * static void
107  * foo_container_get_preferred_height (GtkWidget *widget,
108  * gint *min_height,
109  * gint *nat_height)
110  * {
111  * if (i_am_in_height_for_width_mode)
112  * {
113  * gint min_width;
114  * 
115  * GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
116  * &min_width,
117  * NULL);
118  * GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width
119  * (widget,
120  * min_width,
121  * min_height,
122  * nat_height);
123  * }
124  * else
125  * {
126  * ... many containers support both request modes, execute the
127  * real width-for-height request here by returning the
128  * collective heights of all widgets that are stacked
129  * vertically (or whatever is appropriate for this container)
130  * ...
131  * }
132  * }
133  * ]|
134  * 
135  * Similarly, when gtk_widget_get_preferred_width_for_height() is called for a container or widget
136  * that is height-for-width, it then only needs to return the base minimum width like so:
137  * 
138  * |[<!-- language="C" -->
139  * static void
140  * foo_container_get_preferred_width_for_height (GtkWidget *widget,
141  * gint for_height,
142  * gint *min_width,
143  * gint *nat_width)
144  * {
145  * if (i_am_in_height_for_width_mode)
146  * {
147  * GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
148  * min_width,
149  * nat_width);
150  * }
151  * else
152  * {
153  * ... execute the real width-for-height request here based on
154  * the required width of the children collectively if the
155  * container were to be allocated the said height ...
156  * }
157  * }
158  * ]|
159  * 
160  * Height for width requests are generally implemented in terms of a virtual allocation
161  * of widgets in the input orientation. Assuming an height-for-width request mode, a container
162  * would implement the get_preferred_height_for_width() virtual function by first calling
163  * gtk_widget_get_preferred_width() for each of its children.
164  * 
165  * For each potential group of children that are lined up horizontally, the values returned by
166  * gtk_widget_get_preferred_width() should be collected in an array of #GtkRequestedSize structures.
167  * Any child spacing should be removed from the input @for_width and then the collective size should be
168  * allocated using the gtk_distribute_natural_allocation() convenience function.
169  * 
170  * The container will then move on to request the preferred height for each child by using
171  * gtk_widget_get_preferred_height_for_width() and using the sizes stored in the #GtkRequestedSize array.
172  * 
173  * To allocate a height-for-width container, it’s again important
174  * to consider that a container must prioritize one dimension over the other. So if
175  * a container is a height-for-width container it must first allocate all widgets horizontally
176  * using a #GtkRequestedSize array and gtk_distribute_natural_allocation() and then add any
177  * extra space (if and where appropriate) for the widget to expand.
178  * 
179  * After adding all the expand space, the container assumes it was allocated sufficient
180  * height to fit all of its content. At this time, the container must use the total horizontal sizes
181  * of each widget to request the height-for-width of each of its children and store the requests in a
182  * #GtkRequestedSize array for any widgets that stack vertically (for tabular containers this can
183  * be generalized into the heights and widths of rows and columns).
184  * The vertical space must then again be distributed using gtk_distribute_natural_allocation()
185  * while this time considering the allocated height of the widget minus any vertical spacing
186  * that the container adds. Then vertical expand space should be added where appropriate and available
187  * and the container should go on to actually allocating the child widgets.
188  * 
189  * See [GtkWidget’s geometry management section][geometry-management]
190  * to learn more about implementing height-for-width geometry management for widgets.
191  * 
192  * # Child properties
193  * 
194  * GtkContainer introduces child properties.
195  * These are object properties that are not specific
196  * to either the container or the contained widget, but rather to their relation.
197  * Typical examples of child properties are the position or pack-type of a widget
198  * which is contained in a #GtkBox.
199  * 
200  * Use gtk_container_class_install_child_property() to install child properties
201  * for a container class and gtk_container_class_find_child_property() or
202  * gtk_container_class_list_child_properties() to get information about existing
203  * child properties.
204  * 
205  * To set the value of a child property, use gtk_container_child_set_property(),
206  * gtk_container_child_set() or gtk_container_child_set_valist().
207  * To obtain the value of a child property, use
208  * gtk_container_child_get_property(), gtk_container_child_get() or
209  * gtk_container_child_get_valist(). To emit notification about child property
210  * changes, use gtk_widget_child_notify().
211  * 
212  * # GtkContainer as GtkBuildable
213  * 
214  * The GtkContainer implementation of the GtkBuildable interface supports
215  * a <packing> element for children, which can contain multiple <property>
216  * elements that specify child properties for the child.
217  * 
218  * Since 2.16, child properties can also be marked as translatable using
219  * the same “translatable”, “comments” and “context” attributes that are used
220  * for regular properties.
221  * 
222  * Since 3.16, containers can have a <focus-chain> element containing multiple
223  * <widget> elements, one for each child that should be added to the focus
224  * chain. The ”name” attribute gives the id of the widget.
225  * 
226  * An example of these properties in UI definitions:
227  * |[
228  * <object class="GtkBox">
229  * <child>
230  * <object class="GtkEntry" id="entry1"/>
231  * <packing>
232  * <property name="pack-type">start</property>
233  * </packing>
234  * </child>
235  * <child>
236  * <object class="GtkEntry" id="entry2"/>
237  * </child>
238  * <focus-chain>
239  * <widget name="entry1"/>
240  * <widget name="entry2"/>
241  * </focus-chain>
242  * </object>
243  * ]|
244  */
245 public class Container : Widget
246 {
247 	/** the main Gtk struct */
248 	protected GtkContainer* gtkContainer;
249 
250 	/** Get the main Gtk struct */
251 	public GtkContainer* getContainerStruct(bool transferOwnership = false)
252 	{
253 		if (transferOwnership)
254 			ownedRef = false;
255 		return gtkContainer;
256 	}
257 
258 	/** the main Gtk struct as a void* */
259 	protected override void* getStruct()
260 	{
261 		return cast(void*)gtkContainer;
262 	}
263 
264 	/**
265 	 * Sets our main struct and passes it to the parent class.
266 	 */
267 	public this (GtkContainer* gtkContainer, bool ownedRef = false)
268 	{
269 		this.gtkContainer = gtkContainer;
270 		super(cast(GtkWidget*)gtkContainer, ownedRef);
271 	}
272 
273 	/**
274 	 * Removes all widgets from the container
275 	 */
276 	void removeAll()
277 	{
278 		GList* gList = gtk_container_get_children(getContainerStruct());
279 		while ( gList !is null )
280 		{
281 			gtk_container_remove(getContainerStruct(), cast(GtkWidget*)gList.data);
282 			gList = gList.next;
283 		}
284 	}
285 
286 	/**
287 	 */
288 
289 	/** */
290 	public static GType getType()
291 	{
292 		return gtk_container_get_type();
293 	}
294 
295 	/**
296 	 * Adds @widget to @container. Typically used for simple containers
297 	 * such as #GtkWindow, #GtkFrame, or #GtkButton; for more complicated
298 	 * layout containers such as #GtkBox or #GtkGrid, this function will
299 	 * pick default packing parameters that may not be correct.  So
300 	 * consider functions such as gtk_box_pack_start() and
301 	 * gtk_grid_attach() as an alternative to gtk_container_add() in
302 	 * those cases. A widget may be added to only one container at a time;
303 	 * you can’t place the same widget inside two different containers.
304 	 *
305 	 * Note that some containers, such as #GtkScrolledWindow or #GtkListBox,
306 	 * may add intermediate children between the added widget and the
307 	 * container.
308 	 *
309 	 * Params:
310 	 *     widget = a widget to be placed inside @container
311 	 */
312 	public void add(Widget widget)
313 	{
314 		gtk_container_add(gtkContainer, (widget is null) ? null : widget.getWidgetStruct());
315 	}
316 
317 	/** */
318 	public void checkResize()
319 	{
320 		gtk_container_check_resize(gtkContainer);
321 	}
322 
323 	/**
324 	 * Gets the value of a child property for @child and @container.
325 	 *
326 	 * Params:
327 	 *     child = a widget which is a child of @container
328 	 *     propertyName = the name of the property to get
329 	 *     value = a location to return the value
330 	 */
331 	public void childGetProperty(Widget child, string propertyName, Value value)
332 	{
333 		gtk_container_child_get_property(gtkContainer, (child is null) ? null : child.getWidgetStruct(), Str.toStringz(propertyName), (value is null) ? null : value.getValueStruct());
334 	}
335 
336 	/**
337 	 * Gets the values of one or more child properties for @child and @container.
338 	 *
339 	 * Params:
340 	 *     child = a widget which is a child of @container
341 	 *     firstPropertyName = the name of the first property to get
342 	 *     varArgs = return location for the first property, followed
343 	 *         optionally by more name/return location pairs, followed by %NULL
344 	 */
345 	public void childGetValist(Widget child, string firstPropertyName, void* varArgs)
346 	{
347 		gtk_container_child_get_valist(gtkContainer, (child is null) ? null : child.getWidgetStruct(), Str.toStringz(firstPropertyName), varArgs);
348 	}
349 
350 	/**
351 	 * Emits a #GtkWidget::child-notify signal for the
352 	 * [child property][child-properties]
353 	 * @child_property on the child.
354 	 *
355 	 * This is an analogue of g_object_notify() for child properties.
356 	 *
357 	 * Also see gtk_widget_child_notify().
358 	 *
359 	 * Params:
360 	 *     child = the child widget
361 	 *     childProperty = the name of a child property installed on
362 	 *         the class of @container
363 	 *
364 	 * Since: 3.2
365 	 */
366 	public void childNotify(Widget child, string childProperty)
367 	{
368 		gtk_container_child_notify(gtkContainer, (child is null) ? null : child.getWidgetStruct(), Str.toStringz(childProperty));
369 	}
370 
371 	/**
372 	 * Emits a #GtkWidget::child-notify signal for the
373 	 * [child property][child-properties] specified by
374 	 * @pspec on the child.
375 	 *
376 	 * This is an analogue of g_object_notify_by_pspec() for child properties.
377 	 *
378 	 * Params:
379 	 *     child = the child widget
380 	 *     pspec = the #GParamSpec of a child property instealled on
381 	 *         the class of @container
382 	 *
383 	 * Since: 3.18
384 	 */
385 	public void childNotifyByPspec(Widget child, ParamSpec pspec)
386 	{
387 		gtk_container_child_notify_by_pspec(gtkContainer, (child is null) ? null : child.getWidgetStruct(), (pspec is null) ? null : pspec.getParamSpecStruct());
388 	}
389 
390 	/**
391 	 * Sets a child property for @child and @container.
392 	 *
393 	 * Params:
394 	 *     child = a widget which is a child of @container
395 	 *     propertyName = the name of the property to set
396 	 *     value = the value to set the property to
397 	 */
398 	public void childSetProperty(Widget child, string propertyName, Value value)
399 	{
400 		gtk_container_child_set_property(gtkContainer, (child is null) ? null : child.getWidgetStruct(), Str.toStringz(propertyName), (value is null) ? null : value.getValueStruct());
401 	}
402 
403 	/**
404 	 * Sets one or more child properties for @child and @container.
405 	 *
406 	 * Params:
407 	 *     child = a widget which is a child of @container
408 	 *     firstPropertyName = the name of the first property to set
409 	 *     varArgs = a %NULL-terminated list of property names and values, starting
410 	 *         with @first_prop_name
411 	 */
412 	public void childSetValist(Widget child, string firstPropertyName, void* varArgs)
413 	{
414 		gtk_container_child_set_valist(gtkContainer, (child is null) ? null : child.getWidgetStruct(), Str.toStringz(firstPropertyName), varArgs);
415 	}
416 
417 	/**
418 	 * Returns the type of the children supported by the container.
419 	 *
420 	 * Note that this may return %G_TYPE_NONE to indicate that no more
421 	 * children can be added, e.g. for a #GtkPaned which already has two
422 	 * children.
423 	 *
424 	 * Returns: a #GType.
425 	 */
426 	public GType childType()
427 	{
428 		return gtk_container_child_type(gtkContainer);
429 	}
430 
431 	/**
432 	 * Invokes @callback on each direct child of @container, including
433 	 * children that are considered “internal” (implementation details
434 	 * of the container). “Internal” children generally weren’t added
435 	 * by the user of the container, but were added by the container
436 	 * implementation itself.
437 	 *
438 	 * Most applications should use gtk_container_foreach(), rather
439 	 * than gtk_container_forall().
440 	 *
441 	 * Params:
442 	 *     callback = a callback
443 	 *     callbackData = callback user data
444 	 */
445 	public void forall(GtkCallback callback, void* callbackData)
446 	{
447 		gtk_container_forall(gtkContainer, callback, callbackData);
448 	}
449 
450 	/**
451 	 * Invokes @callback on each non-internal child of @container.
452 	 * See gtk_container_forall() for details on what constitutes
453 	 * an “internal” child. For all practical purposes, this function
454 	 * should iterate over precisely those child widgets that were
455 	 * added to the container by the application with explicit add()
456 	 * calls.
457 	 *
458 	 * Most applications should use gtk_container_foreach(),
459 	 * rather than gtk_container_forall().
460 	 *
461 	 * Params:
462 	 *     callback = a callback
463 	 *     callbackData = callback user data
464 	 */
465 	public void foreac(GtkCallback callback, void* callbackData)
466 	{
467 		gtk_container_foreach(gtkContainer, callback, callbackData);
468 	}
469 
470 	/**
471 	 * Retrieves the border width of the container. See
472 	 * gtk_container_set_border_width().
473 	 *
474 	 * Returns: the current border width
475 	 */
476 	public uint getBorderWidth()
477 	{
478 		return gtk_container_get_border_width(gtkContainer);
479 	}
480 
481 	/**
482 	 * Returns the container’s non-internal children. See
483 	 * gtk_container_forall() for details on what constitutes an "internal" child.
484 	 *
485 	 * Returns: a newly-allocated list of the container’s non-internal children.
486 	 */
487 	public ListG getChildren()
488 	{
489 		auto p = gtk_container_get_children(gtkContainer);
490 
491 		if(p is null)
492 		{
493 			return null;
494 		}
495 
496 		return new ListG(cast(GList*) p);
497 	}
498 
499 	/**
500 	 * Retrieves the focus chain of the container, if one has been
501 	 * set explicitly. If no focus chain has been explicitly
502 	 * set, GTK+ computes the focus chain based on the positions
503 	 * of the children. In that case, GTK+ stores %NULL in
504 	 * @focusable_widgets and returns %FALSE.
505 	 *
506 	 * Params:
507 	 *     focusableWidgets = location
508 	 *         to store the focus chain of the
509 	 *         container, or %NULL. You should free this list
510 	 *         using g_list_free() when you are done with it, however
511 	 *         no additional reference count is added to the
512 	 *         individual widgets in the focus chain.
513 	 *
514 	 * Returns: %TRUE if the focus chain of the container
515 	 *     has been set explicitly.
516 	 */
517 	public bool getFocusChain(out ListG focusableWidgets)
518 	{
519 		GList* outfocusableWidgets = null;
520 
521 		auto p = gtk_container_get_focus_chain(gtkContainer, &outfocusableWidgets) != 0;
522 
523 		focusableWidgets = new ListG(outfocusableWidgets);
524 
525 		return p;
526 	}
527 
528 	/**
529 	 * Returns the current focus child widget inside @container. This is not the
530 	 * currently focused widget. That can be obtained by calling
531 	 * gtk_window_get_focus().
532 	 *
533 	 * Returns: The child widget which will receive the
534 	 *     focus inside @container when the @container is focused,
535 	 *     or %NULL if none is set.
536 	 *
537 	 * Since: 2.14
538 	 */
539 	public Widget getFocusChild()
540 	{
541 		auto p = gtk_container_get_focus_child(gtkContainer);
542 
543 		if(p is null)
544 		{
545 			return null;
546 		}
547 
548 		return ObjectG.getDObject!(Widget)(cast(GtkWidget*) p);
549 	}
550 
551 	/**
552 	 * Retrieves the horizontal focus adjustment for the container. See
553 	 * gtk_container_set_focus_hadjustment ().
554 	 *
555 	 * Returns: the horizontal focus adjustment, or %NULL if
556 	 *     none has been set.
557 	 */
558 	public Adjustment getFocusHadjustment()
559 	{
560 		auto p = gtk_container_get_focus_hadjustment(gtkContainer);
561 
562 		if(p is null)
563 		{
564 			return null;
565 		}
566 
567 		return ObjectG.getDObject!(Adjustment)(cast(GtkAdjustment*) p);
568 	}
569 
570 	/**
571 	 * Retrieves the vertical focus adjustment for the container. See
572 	 * gtk_container_set_focus_vadjustment().
573 	 *
574 	 * Returns: the vertical focus adjustment, or
575 	 *     %NULL if none has been set.
576 	 */
577 	public Adjustment getFocusVadjustment()
578 	{
579 		auto p = gtk_container_get_focus_vadjustment(gtkContainer);
580 
581 		if(p is null)
582 		{
583 			return null;
584 		}
585 
586 		return ObjectG.getDObject!(Adjustment)(cast(GtkAdjustment*) p);
587 	}
588 
589 	/**
590 	 * Returns a newly created widget path representing all the widget hierarchy
591 	 * from the toplevel down to and including @child.
592 	 *
593 	 * Params:
594 	 *     child = a child of @container
595 	 *
596 	 * Returns: A newly created #GtkWidgetPath
597 	 */
598 	public WidgetPath getPathForChild(Widget child)
599 	{
600 		auto p = gtk_container_get_path_for_child(gtkContainer, (child is null) ? null : child.getWidgetStruct());
601 
602 		if(p is null)
603 		{
604 			return null;
605 		}
606 
607 		return ObjectG.getDObject!(WidgetPath)(cast(GtkWidgetPath*) p, true);
608 	}
609 
610 	/**
611 	 * Returns the resize mode for the container. See
612 	 * gtk_container_set_resize_mode ().
613 	 *
614 	 * Deprecated: Resize modes are deprecated. They aren’t necessary
615 	 * anymore since frame clocks and might introduce obscure bugs if
616 	 * used.
617 	 *
618 	 * Returns: the current resize mode
619 	 */
620 	public GtkResizeMode getResizeMode()
621 	{
622 		return gtk_container_get_resize_mode(gtkContainer);
623 	}
624 
625 	/**
626 	 * When a container receives a call to the draw function, it must send
627 	 * synthetic #GtkWidget::draw calls to all children that don’t have their
628 	 * own #GdkWindows. This function provides a convenient way of doing this.
629 	 * A container, when it receives a call to its #GtkWidget::draw function,
630 	 * calls gtk_container_propagate_draw() once for each child, passing in
631 	 * the @cr the container received.
632 	 *
633 	 * gtk_container_propagate_draw() takes care of translating the origin of @cr,
634 	 * and deciding whether the draw needs to be sent to the child. It is a
635 	 * convenient and optimized way of getting the same effect as calling
636 	 * gtk_widget_draw() on the child directly.
637 	 *
638 	 * In most cases, a container can simply either inherit the
639 	 * #GtkWidget::draw implementation from #GtkContainer, or do some drawing
640 	 * and then chain to the ::draw implementation from #GtkContainer.
641 	 *
642 	 * Params:
643 	 *     child = a child of @container
644 	 *     cr = Cairo context as passed to the container. If you want to use @cr
645 	 *         in container’s draw function, consider using cairo_save() and
646 	 *         cairo_restore() before calling this function.
647 	 */
648 	public void propagateDraw(Widget child, Context cr)
649 	{
650 		gtk_container_propagate_draw(gtkContainer, (child is null) ? null : child.getWidgetStruct(), (cr is null) ? null : cr.getContextStruct());
651 	}
652 
653 	/**
654 	 * Removes @widget from @container. @widget must be inside @container.
655 	 * Note that @container will own a reference to @widget, and that this
656 	 * may be the last reference held; so removing a widget from its
657 	 * container can destroy that widget. If you want to use @widget
658 	 * again, you need to add a reference to it before removing it from
659 	 * a container, using g_object_ref(). If you don’t want to use @widget
660 	 * again it’s usually more efficient to simply destroy it directly
661 	 * using gtk_widget_destroy() since this will remove it from the
662 	 * container and help break any circular reference count cycles.
663 	 *
664 	 * Params:
665 	 *     widget = a current child of @container
666 	 */
667 	public void remove(Widget widget)
668 	{
669 		gtk_container_remove(gtkContainer, (widget is null) ? null : widget.getWidgetStruct());
670 	}
671 
672 	/** */
673 	public void resizeChildren()
674 	{
675 		gtk_container_resize_children(gtkContainer);
676 	}
677 
678 	/**
679 	 * Sets the border width of the container.
680 	 *
681 	 * The border width of a container is the amount of space to leave
682 	 * around the outside of the container. The only exception to this is
683 	 * #GtkWindow; because toplevel windows can’t leave space outside,
684 	 * they leave the space inside. The border is added on all sides of
685 	 * the container. To add space to only one side, use a specific
686 	 * #GtkWidget:margin property on the child widget, for example
687 	 * #GtkWidget:margin-top.
688 	 *
689 	 * Params:
690 	 *     borderWidth = amount of blank space to leave outside
691 	 *         the container. Valid values are in the range 0-65535 pixels.
692 	 */
693 	public void setBorderWidth(uint borderWidth)
694 	{
695 		gtk_container_set_border_width(gtkContainer, borderWidth);
696 	}
697 
698 	/**
699 	 * Sets a focus chain, overriding the one computed automatically by GTK+.
700 	 *
701 	 * In principle each widget in the chain should be a descendant of the
702 	 * container, but this is not enforced by this method, since it’s allowed
703 	 * to set the focus chain before you pack the widgets, or have a widget
704 	 * in the chain that isn’t always packed. The necessary checks are done
705 	 * when the focus chain is actually traversed.
706 	 *
707 	 * Params:
708 	 *     focusableWidgets = the new focus chain
709 	 */
710 	public void setFocusChain(ListG focusableWidgets)
711 	{
712 		gtk_container_set_focus_chain(gtkContainer, (focusableWidgets is null) ? null : focusableWidgets.getListGStruct());
713 	}
714 
715 	/**
716 	 * Sets, or unsets if @child is %NULL, the focused child of @container.
717 	 *
718 	 * This function emits the GtkContainer::set_focus_child signal of
719 	 * @container. Implementations of #GtkContainer can override the
720 	 * default behaviour by overriding the class closure of this signal.
721 	 *
722 	 * This is function is mostly meant to be used by widgets. Applications can use
723 	 * gtk_widget_grab_focus() to manually set the focus to a specific widget.
724 	 *
725 	 * Params:
726 	 *     child = a #GtkWidget, or %NULL
727 	 */
728 	public void setFocusChild(Widget child)
729 	{
730 		gtk_container_set_focus_child(gtkContainer, (child is null) ? null : child.getWidgetStruct());
731 	}
732 
733 	/**
734 	 * Hooks up an adjustment to focus handling in a container, so when a child
735 	 * of the container is focused, the adjustment is scrolled to show that
736 	 * widget. This function sets the horizontal alignment.
737 	 * See gtk_scrolled_window_get_hadjustment() for a typical way of obtaining
738 	 * the adjustment and gtk_container_set_focus_vadjustment() for setting
739 	 * the vertical adjustment.
740 	 *
741 	 * The adjustments have to be in pixel units and in the same coordinate
742 	 * system as the allocation for immediate children of the container.
743 	 *
744 	 * Params:
745 	 *     adjustment = an adjustment which should be adjusted when the focus is
746 	 *         moved among the descendents of @container
747 	 */
748 	public void setFocusHadjustment(Adjustment adjustment)
749 	{
750 		gtk_container_set_focus_hadjustment(gtkContainer, (adjustment is null) ? null : adjustment.getAdjustmentStruct());
751 	}
752 
753 	/**
754 	 * Hooks up an adjustment to focus handling in a container, so when a
755 	 * child of the container is focused, the adjustment is scrolled to
756 	 * show that widget. This function sets the vertical alignment. See
757 	 * gtk_scrolled_window_get_vadjustment() for a typical way of obtaining
758 	 * the adjustment and gtk_container_set_focus_hadjustment() for setting
759 	 * the horizontal adjustment.
760 	 *
761 	 * The adjustments have to be in pixel units and in the same coordinate
762 	 * system as the allocation for immediate children of the container.
763 	 *
764 	 * Params:
765 	 *     adjustment = an adjustment which should be adjusted when the focus
766 	 *         is moved among the descendents of @container
767 	 */
768 	public void setFocusVadjustment(Adjustment adjustment)
769 	{
770 		gtk_container_set_focus_vadjustment(gtkContainer, (adjustment is null) ? null : adjustment.getAdjustmentStruct());
771 	}
772 
773 	/**
774 	 * Sets the @reallocate_redraws flag of the container to the given value.
775 	 *
776 	 * Containers requesting reallocation redraws get automatically
777 	 * redrawn if any of their children changed allocation.
778 	 *
779 	 * Deprecated: Call gtk_widget_queue_draw() in your size_allocate handler.
780 	 *
781 	 * Params:
782 	 *     needsRedraws = the new value for the container’s @reallocate_redraws flag
783 	 */
784 	public void setReallocateRedraws(bool needsRedraws)
785 	{
786 		gtk_container_set_reallocate_redraws(gtkContainer, needsRedraws);
787 	}
788 
789 	/**
790 	 * Sets the resize mode for the container.
791 	 *
792 	 * The resize mode of a container determines whether a resize request
793 	 * will be passed to the container’s parent, queued for later execution
794 	 * or executed immediately.
795 	 *
796 	 * Deprecated: Resize modes are deprecated. They aren’t necessary
797 	 * anymore since frame clocks and might introduce obscure bugs if
798 	 * used.
799 	 *
800 	 * Params:
801 	 *     resizeMode = the new resize mode
802 	 */
803 	public void setResizeMode(GtkResizeMode resizeMode)
804 	{
805 		gtk_container_set_resize_mode(gtkContainer, resizeMode);
806 	}
807 
808 	/**
809 	 * Removes a focus chain explicitly set with gtk_container_set_focus_chain().
810 	 */
811 	public void unsetFocusChain()
812 	{
813 		gtk_container_unset_focus_chain(gtkContainer);
814 	}
815 
816 	/** */
817 	gulong addOnAdd(void delegate(Widget, Container) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
818 	{
819 		return Signals.connect(this, "add", dlg, connectFlags ^ ConnectFlags.SWAPPED);
820 	}
821 
822 	/** */
823 	gulong addOnCheckResize(void delegate(Container) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
824 	{
825 		return Signals.connect(this, "check-resize", dlg, connectFlags ^ ConnectFlags.SWAPPED);
826 	}
827 
828 	/** */
829 	gulong addOnRemove(void delegate(Widget, Container) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
830 	{
831 		return Signals.connect(this, "remove", dlg, connectFlags ^ ConnectFlags.SWAPPED);
832 	}
833 
834 	/** */
835 	gulong addOnSetFocusChild(void delegate(Widget, Container) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
836 	{
837 		return Signals.connect(this, "set-focus-child", dlg, connectFlags ^ ConnectFlags.SWAPPED);
838 	}
839 }