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