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.CellAreaContext; 26 27 private import gobject.ObjectG; 28 private import gtk.CellArea; 29 private import gtkc.gtk; 30 public import gtkc.gtktypes; 31 32 33 /** 34 * The #GtkCellAreaContext object is created by a given #GtkCellArea 35 * implementation via its #GtkCellAreaClass.create_context() virtual 36 * method and is used to store cell sizes and alignments for a series of 37 * #GtkTreeModel rows that are requested and rendered in the same context. 38 * 39 * #GtkCellLayout widgets can create any number of contexts in which to 40 * request and render groups of data rows. However, it’s important that the 41 * same context which was used to request sizes for a given #GtkTreeModel 42 * row also be used for the same row when calling other #GtkCellArea APIs 43 * such as gtk_cell_area_render() and gtk_cell_area_event(). 44 */ 45 public class CellAreaContext : ObjectG 46 { 47 /** the main Gtk struct */ 48 protected GtkCellAreaContext* gtkCellAreaContext; 49 50 /** Get the main Gtk struct */ 51 public GtkCellAreaContext* getCellAreaContextStruct() 52 { 53 return gtkCellAreaContext; 54 } 55 56 /** the main Gtk struct as a void* */ 57 protected override void* getStruct() 58 { 59 return cast(void*)gtkCellAreaContext; 60 } 61 62 protected override void setStruct(GObject* obj) 63 { 64 gtkCellAreaContext = cast(GtkCellAreaContext*)obj; 65 super.setStruct(obj); 66 } 67 68 /** 69 * Sets our main struct and passes it to the parent class. 70 */ 71 public this (GtkCellAreaContext* gtkCellAreaContext, bool ownedRef = false) 72 { 73 this.gtkCellAreaContext = gtkCellAreaContext; 74 super(cast(GObject*)gtkCellAreaContext, ownedRef); 75 } 76 77 78 /** */ 79 public static GType getType() 80 { 81 return gtk_cell_area_context_get_type(); 82 } 83 84 /** 85 * Allocates a width and/or a height for all rows which are to be 86 * rendered with @context. 87 * 88 * Usually allocation is performed only horizontally or sometimes 89 * vertically since a group of rows are usually rendered side by 90 * side vertically or horizontally and share either the same width 91 * or the same height. Sometimes they are allocated in both horizontal 92 * and vertical orientations producing a homogeneous effect of the 93 * rows. This is generally the case for #GtkTreeView when 94 * #GtkTreeView:fixed-height-mode is enabled. 95 * 96 * Since 3.0 97 * 98 * Params: 99 * width = the allocated width for all #GtkTreeModel rows rendered 100 * with @context, or -1. 101 * height = the allocated height for all #GtkTreeModel rows rendered 102 * with @context, or -1. 103 */ 104 public void allocate(int width, int height) 105 { 106 gtk_cell_area_context_allocate(gtkCellAreaContext, width, height); 107 } 108 109 /** 110 * Fetches the current allocation size for @context. 111 * 112 * If the context was not allocated in width or height, or if the 113 * context was recently reset with gtk_cell_area_context_reset(), 114 * the returned value will be -1. 115 * 116 * Params: 117 * width = location to store the allocated width, or %NULL 118 * height = location to store the allocated height, or %NULL 119 * 120 * Since: 3.0 121 */ 122 public void getAllocation(out int width, out int height) 123 { 124 gtk_cell_area_context_get_allocation(gtkCellAreaContext, &width, &height); 125 } 126 127 /** 128 * Fetches the #GtkCellArea this @context was created by. 129 * 130 * This is generally unneeded by layouting widgets; however, 131 * it is important for the context implementation itself to 132 * fetch information about the area it is being used for. 133 * 134 * For instance at #GtkCellAreaContextClass.allocate() time 135 * it’s important to know details about any cell spacing 136 * that the #GtkCellArea is configured with in order to 137 * compute a proper allocation. 138 * 139 * Return: the #GtkCellArea this context was created by. 140 * 141 * Since: 3.0 142 */ 143 public CellArea getArea() 144 { 145 auto p = gtk_cell_area_context_get_area(gtkCellAreaContext); 146 147 if(p is null) 148 { 149 return null; 150 } 151 152 return ObjectG.getDObject!(CellArea)(cast(GtkCellArea*) p); 153 } 154 155 /** 156 * Gets the accumulative preferred height for all rows which have been 157 * requested with this context. 158 * 159 * After gtk_cell_area_context_reset() is called and/or before ever 160 * requesting the size of a #GtkCellArea, the returned values are 0. 161 * 162 * Params: 163 * minimumHeight = location to store the minimum height, 164 * or %NULL 165 * naturalHeight = location to store the natural height, 166 * or %NULL 167 * 168 * Since: 3.0 169 */ 170 public void getPreferredHeight(out int minimumHeight, out int naturalHeight) 171 { 172 gtk_cell_area_context_get_preferred_height(gtkCellAreaContext, &minimumHeight, &naturalHeight); 173 } 174 175 /** 176 * Gets the accumulative preferred height for @width for all rows 177 * which have been requested for the same said @width with this context. 178 * 179 * After gtk_cell_area_context_reset() is called and/or before ever 180 * requesting the size of a #GtkCellArea, the returned values are -1. 181 * 182 * Params: 183 * width = a proposed width for allocation 184 * minimumHeight = location to store the minimum height, 185 * or %NULL 186 * naturalHeight = location to store the natural height, 187 * or %NULL 188 * 189 * Since: 3.0 190 */ 191 public void getPreferredHeightForWidth(int width, out int minimumHeight, out int naturalHeight) 192 { 193 gtk_cell_area_context_get_preferred_height_for_width(gtkCellAreaContext, width, &minimumHeight, &naturalHeight); 194 } 195 196 /** 197 * Gets the accumulative preferred width for all rows which have been 198 * requested with this context. 199 * 200 * After gtk_cell_area_context_reset() is called and/or before ever 201 * requesting the size of a #GtkCellArea, the returned values are 0. 202 * 203 * Params: 204 * minimumWidth = location to store the minimum width, 205 * or %NULL 206 * naturalWidth = location to store the natural width, 207 * or %NULL 208 * 209 * Since: 3.0 210 */ 211 public void getPreferredWidth(out int minimumWidth, out int naturalWidth) 212 { 213 gtk_cell_area_context_get_preferred_width(gtkCellAreaContext, &minimumWidth, &naturalWidth); 214 } 215 216 /** 217 * Gets the accumulative preferred width for @height for all rows which 218 * have been requested for the same said @height with this context. 219 * 220 * After gtk_cell_area_context_reset() is called and/or before ever 221 * requesting the size of a #GtkCellArea, the returned values are -1. 222 * 223 * Params: 224 * height = a proposed height for allocation 225 * minimumWidth = location to store the minimum width, 226 * or %NULL 227 * naturalWidth = location to store the natural width, 228 * or %NULL 229 * 230 * Since: 3.0 231 */ 232 public void getPreferredWidthForHeight(int height, out int minimumWidth, out int naturalWidth) 233 { 234 gtk_cell_area_context_get_preferred_width_for_height(gtkCellAreaContext, height, &minimumWidth, &naturalWidth); 235 } 236 237 /** 238 * Causes the minimum and/or natural height to grow if the new 239 * proposed sizes exceed the current minimum and natural height. 240 * 241 * This is used by #GtkCellAreaContext implementations during 242 * the request process over a series of #GtkTreeModel rows to 243 * progressively push the requested height over a series of 244 * gtk_cell_area_get_preferred_height() requests. 245 * 246 * Params: 247 * minimumHeight = the proposed new minimum height for @context 248 * naturalHeight = the proposed new natural height for @context 249 * 250 * Since: 3.0 251 */ 252 public void pushPreferredHeight(int minimumHeight, int naturalHeight) 253 { 254 gtk_cell_area_context_push_preferred_height(gtkCellAreaContext, minimumHeight, naturalHeight); 255 } 256 257 /** 258 * Causes the minimum and/or natural width to grow if the new 259 * proposed sizes exceed the current minimum and natural width. 260 * 261 * This is used by #GtkCellAreaContext implementations during 262 * the request process over a series of #GtkTreeModel rows to 263 * progressively push the requested width over a series of 264 * gtk_cell_area_get_preferred_width() requests. 265 * 266 * Params: 267 * minimumWidth = the proposed new minimum width for @context 268 * naturalWidth = the proposed new natural width for @context 269 * 270 * Since: 3.0 271 */ 272 public void pushPreferredWidth(int minimumWidth, int naturalWidth) 273 { 274 gtk_cell_area_context_push_preferred_width(gtkCellAreaContext, minimumWidth, naturalWidth); 275 } 276 277 /** 278 * Resets any previously cached request and allocation 279 * data. 280 * 281 * When underlying #GtkTreeModel data changes its 282 * important to reset the context if the content 283 * size is allowed to shrink. If the content size 284 * is only allowed to grow (this is usually an option 285 * for views rendering large data stores as a measure 286 * of optimization), then only the row that changed 287 * or was inserted needs to be (re)requested with 288 * gtk_cell_area_get_preferred_width(). 289 * 290 * When the new overall size of the context requires 291 * that the allocated size changes (or whenever this 292 * allocation changes at all), the variable row 293 * sizes need to be re-requested for every row. 294 * 295 * For instance, if the rows are displayed all with 296 * the same width from top to bottom then a change 297 * in the allocated width necessitates a recalculation 298 * of all the displayed row heights using 299 * gtk_cell_area_get_preferred_height_for_width(). 300 * 301 * Since 3.0 302 */ 303 public void reset() 304 { 305 gtk_cell_area_context_reset(gtkCellAreaContext); 306 } 307 }