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 @container is focused, 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 }