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.WidgetClass;
26 
27 private import glib.Bytes;
28 private import glib.Str;
29 private import gobject.ObjectG;
30 private import gobject.ParamSpec;
31 private import gtkc.gtk;
32 public  import gtkc.gtktypes;
33 
34 
35 public class WidgetClass
36 {
37 	/** the main Gtk struct */
38 	protected GtkWidgetClass* gtkWidgetClass;
39 
40 	/** Get the main Gtk struct */
41 	public GtkWidgetClass* getWidgetClassStruct()
42 	{
43 		return gtkWidgetClass;
44 	}
45 
46 	/** the main Gtk struct as a void* */
47 	protected void* getStruct()
48 	{
49 		return cast(void*)gtkWidgetClass;
50 	}
51 
52 	/**
53 	 * Sets our main struct and passes it to the parent class.
54 	 */
55 	public this (GtkWidgetClass* gtkWidgetClass)
56 	{
57 		this.gtkWidgetClass = gtkWidgetClass;
58 	}
59 
60 	/**
61 	 */
62 
63 	/**
64 	 * Declares a @callback_symbol to handle @callback_name from the template XML
65 	 * defined for @widget_type. See gtk_builder_add_callback_symbol().
66 	 *
67 	 * Note that this must be called from a composite widget classes class
68 	 * initializer after calling gtk_widget_class_set_template().
69 	 *
70 	 * Params:
71 	 *     callbackName = The name of the callback as expected in the template XML
72 	 *     callbackSymbol = The callback symbol
73 	 *
74 	 * Since: 3.10
75 	 */
76 	public void bindTemplateCallbackFull(string callbackName, GCallback callbackSymbol)
77 	{
78 		gtk_widget_class_bind_template_callback_full(gtkWidgetClass, Str.toStringz(callbackName), callbackSymbol);
79 	}
80 
81 	/**
82 	 * Automatically assign an object declared in the class template XML to be set to a location
83 	 * on a freshly built instance’s private data, or alternatively accessible via gtk_widget_get_template_child().
84 	 *
85 	 * The struct can point either into the public instance, then you should use G_STRUCT_OFFSET(WidgetType, member)
86 	 * for @struct_offset,  or in the private struct, then you should use G_PRIVATE_OFFSET(WidgetType, member).
87 	 *
88 	 * An explicit strong reference will be held automatically for the duration of your
89 	 * instance’s life cycle, it will be released automatically when #GObjectClass.dispose() runs
90 	 * on your instance and if a @struct_offset that is != 0 is specified, then the automatic location
91 	 * in your instance public or private data will be set to %NULL. You can however access an automated child
92 	 * pointer the first time your classes #GObjectClass.dispose() runs, or alternatively in
93 	 * #GtkWidgetClass.destroy().
94 	 *
95 	 * If @internal_child is specified, #GtkBuildableIface.get_internal_child() will be automatically
96 	 * implemented by the #GtkWidget class so there is no need to implement it manually.
97 	 *
98 	 * The wrapper macros gtk_widget_class_bind_template_child(), gtk_widget_class_bind_template_child_internal(),
99 	 * gtk_widget_class_bind_template_child_private() and gtk_widget_class_bind_template_child_internal_private()
100 	 * might be more convenient to use.
101 	 *
102 	 * Note that this must be called from a composite widget classes class
103 	 * initializer after calling gtk_widget_class_set_template().
104 	 *
105 	 * Params:
106 	 *     name = The “id” of the child defined in the template XML
107 	 *     internalChild = Whether the child should be accessible as an “internal-child”
108 	 *         when this class is used in GtkBuilder XML
109 	 *     structOffset = The structure offset into the composite widget’s instance public or private structure
110 	 *         where the automated child pointer should be set, or 0 to not assign the pointer.
111 	 *
112 	 * Since: 3.10
113 	 */
114 	public void bindTemplateChildFull(string name, bool internalChild, ptrdiff_t structOffset)
115 	{
116 		gtk_widget_class_bind_template_child_full(gtkWidgetClass, Str.toStringz(name), internalChild, structOffset);
117 	}
118 
119 	/**
120 	 * Finds a style property of a widget class by name.
121 	 *
122 	 * Params:
123 	 *     propertyName = the name of the style property to find
124 	 *
125 	 * Return: the #GParamSpec of the style property or
126 	 *     %NULL if @class has no style property with that name.
127 	 *
128 	 * Since: 2.2
129 	 */
130 	public ParamSpec findStyleProperty(string propertyName)
131 	{
132 		auto p = gtk_widget_class_find_style_property(gtkWidgetClass, Str.toStringz(propertyName));
133 		
134 		if(p is null)
135 		{
136 			return null;
137 		}
138 		
139 		return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p);
140 	}
141 
142 	/**
143 	 * Installs a style property on a widget class. The parser for the
144 	 * style property is determined by the value type of @pspec.
145 	 *
146 	 * Params:
147 	 *     pspec = the #GParamSpec for the property
148 	 */
149 	public void installStyleProperty(ParamSpec pspec)
150 	{
151 		gtk_widget_class_install_style_property(gtkWidgetClass, (pspec is null) ? null : pspec.getParamSpecStruct());
152 	}
153 
154 	/**
155 	 * Installs a style property on a widget class.
156 	 *
157 	 * Params:
158 	 *     pspec = the #GParamSpec for the style property
159 	 *     parser = the parser for the style property
160 	 */
161 	public void installStylePropertyParser(ParamSpec pspec, GtkRcPropertyParser parser)
162 	{
163 		gtk_widget_class_install_style_property_parser(gtkWidgetClass, (pspec is null) ? null : pspec.getParamSpecStruct(), parser);
164 	}
165 
166 	/**
167 	 * Returns all style properties of a widget class.
168 	 *
169 	 * Params:
170 	 *     nProperties = location to return the number of style properties found
171 	 *
172 	 * Return: a
173 	 *     newly allocated array of #GParamSpec*. The array must be
174 	 *     freed with g_free().
175 	 *
176 	 * Since: 2.2
177 	 */
178 	public ParamSpec[] listStyleProperties()
179 	{
180 		uint nProperties;
181 		
182 		auto p = gtk_widget_class_list_style_properties(gtkWidgetClass, &nProperties);
183 		
184 		if(p is null)
185 		{
186 			return null;
187 		}
188 		
189 		ParamSpec[] arr = new ParamSpec[nProperties];
190 		for(int i = 0; i < nProperties; i++)
191 		{
192 			arr[i] = ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p[i]);
193 		}
194 		
195 		return arr;
196 	}
197 
198 	/**
199 	 * Sets the default #AtkRole to be set on accessibles created for
200 	 * widgets of @widget_class. Accessibles may decide to not honor this
201 	 * setting if their role reporting is more refined. Calls to
202 	 * gtk_widget_class_set_accessible_type() will reset this value.
203 	 *
204 	 * In cases where you want more fine-grained control over the role of
205 	 * accessibles created for @widget_class, you should provide your own
206 	 * accessible type and use gtk_widget_class_set_accessible_type()
207 	 * instead.
208 	 *
209 	 * If @role is #ATK_ROLE_INVALID, the default role will not be changed
210 	 * and the accessible’s default role will be used instead.
211 	 *
212 	 * This function should only be called from class init functions of widgets.
213 	 *
214 	 * Params:
215 	 *     role = The role to use for accessibles created for @widget_class
216 	 *
217 	 * Since: 3.2
218 	 */
219 	public void setAccessibleRole(AtkRole role)
220 	{
221 		gtk_widget_class_set_accessible_role(gtkWidgetClass, role);
222 	}
223 
224 	/**
225 	 * Sets the type to be used for creating accessibles for widgets of
226 	 * @widget_class. The given @type must be a subtype of the type used for
227 	 * accessibles of the parent class.
228 	 *
229 	 * This function should only be called from class init functions of widgets.
230 	 *
231 	 * Params:
232 	 *     type = The object type that implements the accessible for @widget_class
233 	 *
234 	 * Since: 3.2
235 	 */
236 	public void setAccessibleType(GType type)
237 	{
238 		gtk_widget_class_set_accessible_type(gtkWidgetClass, type);
239 	}
240 
241 	/**
242 	 * For use in lanuage bindings, this will override the default #GtkBuilderConnectFunc to be
243 	 * used when parsing GtkBuilder xml from this class’s template data.
244 	 *
245 	 * Note that this must be called from a composite widget classes class
246 	 * initializer after calling gtk_widget_class_set_template().
247 	 *
248 	 * Params:
249 	 *     connectFunc = The #GtkBuilderConnectFunc to use when connecting signals in the class template
250 	 *     connectData = The data to pass to @connect_func
251 	 *     connectDataDestroy = The #GDestroyNotify to free @connect_data, this will only be used at
252 	 *         class finalization time, when no classes of type @widget_type are in use anymore.
253 	 *
254 	 * Since: 3.10
255 	 */
256 	public void setConnectFunc(GtkBuilderConnectFunc connectFunc, void* connectData, GDestroyNotify connectDataDestroy)
257 	{
258 		gtk_widget_class_set_connect_func(gtkWidgetClass, connectFunc, connectData, connectDataDestroy);
259 	}
260 
261 	/**
262 	 * This should be called at class initialization time to specify
263 	 * the GtkBuilder XML to be used to extend a widget.
264 	 *
265 	 * For convenience, gtk_widget_class_set_template_from_resource() is also provided.
266 	 *
267 	 * Note that any class that installs templates must call gtk_widget_init_template()
268 	 * in the widget’s instance initializer.
269 	 *
270 	 * Params:
271 	 *     templateBytes = A #GBytes holding the #GtkBuilder XML
272 	 *
273 	 * Since: 3.10
274 	 */
275 	public void setTemplate(Bytes templateBytes)
276 	{
277 		gtk_widget_class_set_template(gtkWidgetClass, (templateBytes is null) ? null : templateBytes.getBytesStruct());
278 	}
279 
280 	/**
281 	 * A convenience function to call gtk_widget_class_set_template().
282 	 *
283 	 * Note that any class that installs templates must call gtk_widget_init_template()
284 	 * in the widget’s instance initializer.
285 	 *
286 	 * Params:
287 	 *     resourceName = The name of the resource to load the template from
288 	 *
289 	 * Since: 3.10
290 	 */
291 	public void setTemplateFromResource(string resourceName)
292 	{
293 		gtk_widget_class_set_template_from_resource(gtkWidgetClass, Str.toStringz(resourceName));
294 	}
295 }