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.CellLayoutIF;
26 
27 private import glib.ListG;
28 private import glib.Str;
29 private import gobject.ObjectG;
30 private import gtk.CellArea;
31 private import gtk.CellRenderer;
32 private import gtkc.gtk;
33 public  import gtkc.gtktypes;
34 
35 
36 /**
37  * #GtkCellLayout is an interface to be implemented by all objects which
38  * want to provide a #GtkTreeViewColumn like API for packing cells,
39  * setting attributes and data funcs.
40  * 
41  * One of the notable features provided by implementations of
42  * GtkCellLayout are attributes. Attributes let you set the properties
43  * in flexible ways. They can just be set to constant values like regular
44  * properties. But they can also be mapped to a column of the underlying
45  * tree model with gtk_cell_layout_set_attributes(), which means that the value
46  * of the attribute can change from cell to cell as they are rendered by
47  * the cell renderer. Finally, it is possible to specify a function with
48  * gtk_cell_layout_set_cell_data_func() that is called to determine the
49  * value of the attribute for each cell that is rendered.
50  * 
51  * # GtkCellLayouts as GtkBuildable
52  * 
53  * Implementations of GtkCellLayout which also implement the GtkBuildable
54  * interface (#GtkCellView, #GtkIconView, #GtkComboBox,
55  * #GtkEntryCompletion, #GtkTreeViewColumn) accept GtkCellRenderer objects
56  * as <child> elements in UI definitions. They support a custom <attributes>
57  * element for their children, which can contain multiple <attribute>
58  * elements. Each <attribute> element has a name attribute which specifies
59  * a property of the cell renderer; the content of the element is the
60  * attribute value.
61  * 
62  * This is an example of a UI definition fragment specifying attributes:
63  * |[
64  * <object class="GtkCellView">
65  * <child>
66  * <object class="GtkCellRendererText"/>
67  * <attributes>
68  * <attribute name="text">0</attribute>
69  * </attributes>
70  * </child>"
71  * </object>
72  * ]|
73  * 
74  * Furthermore for implementations of GtkCellLayout that use a #GtkCellArea
75  * to lay out cells (all GtkCellLayouts in GTK+ use a GtkCellArea)
76  * [cell properties][cell-properties] can also be defined in the format by
77  * specifying the custom <cell-packing> attribute which can contain multiple
78  * <property> elements defined in the normal way.
79  * 
80  * Here is a UI definition fragment specifying cell properties:
81  * 
82  * |[
83  * <object class="GtkTreeViewColumn">
84  * <child>
85  * <object class="GtkCellRendererText"/>
86  * <cell-packing>
87  * <property name="align">True</property>
88  * <property name="expand">False</property>
89  * </cell-packing>
90  * </child>"
91  * </object>
92  * ]|
93  * 
94  * # Subclassing GtkCellLayout implementations
95  * 
96  * When subclassing a widget that implements #GtkCellLayout like
97  * #GtkIconView or #GtkComboBox, there are some considerations related
98  * to the fact that these widgets internally use a #GtkCellArea.
99  * The cell area is exposed as a construct-only property by these
100  * widgets. This means that it is possible to e.g. do
101  * 
102  * |[<!-- language="C" -->
103  * combo = g_object_new (GTK_TYPE_COMBO_BOX, "cell-area", my_cell_area, NULL);
104  * ]|
105  * 
106  * to use a custom cell area with a combo box. But construct properties
107  * are only initialized after instance init()
108  * functions have run, which means that using functions which rely on
109  * the existence of the cell area in your subclass’ init() function will
110  * cause the default cell area to be instantiated. In this case, a provided
111  * construct property value will be ignored (with a warning, to alert
112  * you to the problem).
113  * 
114  * |[<!-- language="C" -->
115  * static void
116  * my_combo_box_init (MyComboBox *b)
117  * {
118  * GtkCellRenderer *cell;
119  * 
120  * cell = gtk_cell_renderer_pixbuf_new ();
121  * // The following call causes the default cell area for combo boxes,
122  * // a GtkCellAreaBox, to be instantiated
123  * gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (b), cell, FALSE);
124  * ...
125  * }
126  * 
127  * GtkWidget *
128  * my_combo_box_new (GtkCellArea *area)
129  * {
130  * // This call is going to cause a warning about area being ignored
131  * return g_object_new (MY_TYPE_COMBO_BOX, "cell-area", area, NULL);
132  * }
133  * ]|
134  * 
135  * If supporting alternative cell areas with your derived widget is
136  * not important, then this does not have to concern you. If you want
137  * to support alternative cell areas, you can do so by moving the
138  * problematic calls out of init() and into a constructor()
139  * for your class.
140  */
141 public interface CellLayoutIF{
142 	/** Get the main Gtk struct */
143 	public GtkCellLayout* getCellLayoutStruct();
144 
145 	/** the main Gtk struct as a void* */
146 	protected void* getStruct();
147 
148 
149 	/**
150 	 * Adds an attribute mapping to the list in @cell_layout.
151 	 *
152 	 * The @column is the column of the model to get a value from, and the
153 	 * @attribute is the parameter on @cell to be set from the value. So for
154 	 * example if column 2 of the model contains strings, you could have the
155 	 * “text” attribute of a #GtkCellRendererText get its values from column 2.
156 	 *
157 	 * Params:
158 	 *     cell = a #GtkCellRenderer
159 	 *     attribute = an attribute on the renderer
160 	 *     column = the column position on the model to get the attribute from
161 	 *
162 	 * Since: 2.4
163 	 */
164 	public void addAttribute(CellRenderer cell, string attribute, int column);
165 
166 	/**
167 	 * Unsets all the mappings on all renderers on @cell_layout and
168 	 * removes all renderers from @cell_layout.
169 	 *
170 	 * Since: 2.4
171 	 */
172 	public void clear();
173 
174 	/**
175 	 * Clears all existing attributes previously set with
176 	 * gtk_cell_layout_set_attributes().
177 	 *
178 	 * Params:
179 	 *     cell = a #GtkCellRenderer to clear the attribute mapping on
180 	 *
181 	 * Since: 2.4
182 	 */
183 	public void clearAttributes(CellRenderer cell);
184 
185 	/**
186 	 * Returns the underlying #GtkCellArea which might be @cell_layout
187 	 * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
188 	 * is used by @cell_layout.
189 	 *
190 	 * Returns: the cell area used by @cell_layout,
191 	 *     or %NULL in case no cell area is used.
192 	 *
193 	 * Since: 3.0
194 	 */
195 	public CellArea getArea();
196 
197 	/**
198 	 * Returns the cell renderers which have been added to @cell_layout.
199 	 *
200 	 * Returns: a list of cell renderers. The list, but not the renderers has
201 	 *     been newly allocated and should be freed with g_list_free()
202 	 *     when no longer needed.
203 	 *
204 	 * Since: 2.12
205 	 */
206 	public ListG getCells();
207 
208 	/**
209 	 * Adds the @cell to the end of @cell_layout. If @expand is %FALSE, then the
210 	 * @cell is allocated no more space than it needs. Any unused space is
211 	 * divided evenly between cells for which @expand is %TRUE.
212 	 *
213 	 * Note that reusing the same cell renderer is not supported.
214 	 *
215 	 * Params:
216 	 *     cell = a #GtkCellRenderer
217 	 *     expand = %TRUE if @cell is to be given extra space allocated to @cell_layout
218 	 *
219 	 * Since: 2.4
220 	 */
221 	public void packEnd(CellRenderer cell, bool expand);
222 
223 	/**
224 	 * Packs the @cell into the beginning of @cell_layout. If @expand is %FALSE,
225 	 * then the @cell is allocated no more space than it needs. Any unused space
226 	 * is divided evenly between cells for which @expand is %TRUE.
227 	 *
228 	 * Note that reusing the same cell renderer is not supported.
229 	 *
230 	 * Params:
231 	 *     cell = a #GtkCellRenderer
232 	 *     expand = %TRUE if @cell is to be given extra space allocated to @cell_layout
233 	 *
234 	 * Since: 2.4
235 	 */
236 	public void packStart(CellRenderer cell, bool expand);
237 
238 	/**
239 	 * Re-inserts @cell at @position.
240 	 *
241 	 * Note that @cell has already to be packed into @cell_layout
242 	 * for this to function properly.
243 	 *
244 	 * Params:
245 	 *     cell = a #GtkCellRenderer to reorder
246 	 *     position = new position to insert @cell at
247 	 *
248 	 * Since: 2.4
249 	 */
250 	public void reorder(CellRenderer cell, int position);
251 
252 	/**
253 	 * Sets the #GtkCellLayoutDataFunc to use for @cell_layout.
254 	 *
255 	 * This function is used instead of the standard attributes mapping
256 	 * for setting the column value, and should set the value of @cell_layout’s
257 	 * cell renderer(s) as appropriate.
258 	 *
259 	 * @func may be %NULL to remove a previously set function.
260 	 *
261 	 * Params:
262 	 *     cell = a #GtkCellRenderer
263 	 *     func = the #GtkCellLayoutDataFunc to use, or %NULL
264 	 *     funcData = user data for @func
265 	 *     destroy = destroy notify for @func_data
266 	 *
267 	 * Since: 2.4
268 	 */
269 	public void setCellDataFunc(CellRenderer cell, GtkCellLayoutDataFunc func, void* funcData, GDestroyNotify destroy);
270 }