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.CellAreaBox; 26 27 private import glib.ConstructionException; 28 private import gobject.ObjectG; 29 private import gtk.CellArea; 30 private import gtk.CellRenderer; 31 private import gtk.OrientableIF; 32 private import gtk.OrientableT; 33 private import gtkc.gtk; 34 public import gtkc.gtktypes; 35 36 37 /** 38 * The #GtkCellAreaBox renders cell renderers into a row or a column 39 * depending on its #GtkOrientation. 40 * 41 * GtkCellAreaBox uses a notion of packing. Packing 42 * refers to adding cell renderers with reference to a particular position 43 * in a #GtkCellAreaBox. There are two reference positions: the 44 * start and the end of the box. 45 * When the #GtkCellAreaBox is oriented in the %GTK_ORIENTATION_VERTICAL 46 * orientation, the start is defined as the top of the box and the end is 47 * defined as the bottom. In the %GTK_ORIENTATION_HORIZONTAL orientation 48 * start is defined as the left side and the end is defined as the right 49 * side. 50 * 51 * Alignments of #GtkCellRenderers rendered in adjacent rows can be 52 * configured by configuring the #GtkCellAreaBox align child cell property 53 * with gtk_cell_area_cell_set_property() or by specifying the "align" 54 * argument to gtk_cell_area_box_pack_start() and gtk_cell_area_box_pack_end(). 55 */ 56 public class CellAreaBox : CellArea, OrientableIF 57 { 58 /** the main Gtk struct */ 59 protected GtkCellAreaBox* gtkCellAreaBox; 60 61 /** Get the main Gtk struct */ 62 public GtkCellAreaBox* getCellAreaBoxStruct() 63 { 64 return gtkCellAreaBox; 65 } 66 67 /** the main Gtk struct as a void* */ 68 protected override void* getStruct() 69 { 70 return cast(void*)gtkCellAreaBox; 71 } 72 73 protected override void setStruct(GObject* obj) 74 { 75 gtkCellAreaBox = cast(GtkCellAreaBox*)obj; 76 super.setStruct(obj); 77 } 78 79 /** 80 * Sets our main struct and passes it to the parent class. 81 */ 82 public this (GtkCellAreaBox* gtkCellAreaBox, bool ownedRef = false) 83 { 84 this.gtkCellAreaBox = gtkCellAreaBox; 85 super(cast(GtkCellArea*)gtkCellAreaBox, ownedRef); 86 } 87 88 // add the Orientable capabilities 89 mixin OrientableT!(GtkCellAreaBox); 90 91 /** 92 */ 93 94 public static GType getType() 95 { 96 return gtk_cell_area_box_get_type(); 97 } 98 99 /** 100 * Creates a new #GtkCellAreaBox. 101 * 102 * Return: a newly created #GtkCellAreaBox 103 * 104 * Since: 3.0 105 * 106 * Throws: ConstructionException GTK+ fails to create the object. 107 */ 108 public this() 109 { 110 auto p = gtk_cell_area_box_new(); 111 112 if(p is null) 113 { 114 throw new ConstructionException("null returned by new"); 115 } 116 117 this(cast(GtkCellAreaBox*) p); 118 } 119 120 /** 121 * Gets the spacing added between cell renderers. 122 * 123 * Return: the space added between cell renderers in @box. 124 * 125 * Since: 3.0 126 */ 127 public int getSpacing() 128 { 129 return gtk_cell_area_box_get_spacing(gtkCellAreaBox); 130 } 131 132 /** 133 * Adds @renderer to @box, packed with reference to the end of @box. 134 * 135 * The @renderer is packed after (away from end of) any other 136 * #GtkCellRenderer packed with reference to the end of @box. 137 * 138 * Params: 139 * renderer = the #GtkCellRenderer to add 140 * expand = whether @renderer should receive extra space when the area receives 141 * more than its natural size 142 * alig = whether @renderer should be aligned in adjacent rows 143 * fixed = whether @renderer should have the same size in all rows 144 * 145 * Since: 3.0 146 */ 147 public void packEnd(CellRenderer renderer, bool expand, bool alig, bool fixed) 148 { 149 gtk_cell_area_box_pack_end(gtkCellAreaBox, (renderer is null) ? null : renderer.getCellRendererStruct(), expand, alig, fixed); 150 } 151 152 /** 153 * Adds @renderer to @box, packed with reference to the start of @box. 154 * 155 * The @renderer is packed after any other #GtkCellRenderer packed 156 * with reference to the start of @box. 157 * 158 * Params: 159 * renderer = the #GtkCellRenderer to add 160 * expand = whether @renderer should receive extra space when the area receives 161 * more than its natural size 162 * alig = whether @renderer should be aligned in adjacent rows 163 * fixed = whether @renderer should have the same size in all rows 164 * 165 * Since: 3.0 166 */ 167 public void packStart(CellRenderer renderer, bool expand, bool alig, bool fixed) 168 { 169 gtk_cell_area_box_pack_start(gtkCellAreaBox, (renderer is null) ? null : renderer.getCellRendererStruct(), expand, alig, fixed); 170 } 171 172 /** 173 * Sets the spacing to add between cell renderers in @box. 174 * 175 * Params: 176 * spacing = the space to add between #GtkCellRenderers 177 * 178 * Since: 3.0 179 */ 180 public void setSpacing(int spacing) 181 { 182 gtk_cell_area_box_set_spacing(gtkCellAreaBox, spacing); 183 } 184 }