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