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.Builder;
26 
27 private import glib.ConstructionException;
28 private import glib.ErrorG;
29 private import glib.GException;
30 private import glib.MemorySlice;
31 private import glib.Module;
32 private import glib.Str;
33 private import glib.c.functions;
34 private import gobject.ObjectG;
35 private import gobject.ParamSpec;
36 private import gobject.Type;
37 private import gobject.Value;
38 private import gobject.c.functions;
39 private import gtk.Application;
40 private import gtk.Widget;
41 private import gtk.c.functions;
42 public  import gtk.c.types;
43 public  import gtkc.gtktypes;
44 private import gtkd.paths;
45 private import std.string;
46 
47 
48 /**
49  * A GtkBuilder is an auxiliary object that reads textual descriptions
50  * of a user interface and instantiates the described objects. To create
51  * a GtkBuilder from a user interface description, call
52  * gtk_builder_new_from_file(), gtk_builder_new_from_resource() or
53  * gtk_builder_new_from_string().
54  * 
55  * In the (unusual) case that you want to add user interface
56  * descriptions from multiple sources to the same GtkBuilder you can
57  * call gtk_builder_new() to get an empty builder and populate it by
58  * (multiple) calls to gtk_builder_add_from_file(),
59  * gtk_builder_add_from_resource() or gtk_builder_add_from_string().
60  * 
61  * A GtkBuilder holds a reference to all objects that it has constructed
62  * and drops these references when it is finalized. This finalization can
63  * cause the destruction of non-widget objects or widgets which are not
64  * contained in a toplevel window. For toplevel windows constructed by a
65  * builder, it is the responsibility of the user to call gtk_widget_destroy()
66  * to get rid of them and all the widgets they contain.
67  * 
68  * The functions gtk_builder_get_object() and gtk_builder_get_objects()
69  * can be used to access the widgets in the interface by the names assigned
70  * to them inside the UI description. Toplevel windows returned by these
71  * functions will stay around until the user explicitly destroys them
72  * with gtk_widget_destroy(). Other widgets will either be part of a
73  * larger hierarchy constructed by the builder (in which case you should
74  * not have to worry about their lifecycle), or without a parent, in which
75  * case they have to be added to some container to make use of them.
76  * Non-widget objects need to be reffed with g_object_ref() to keep them
77  * beyond the lifespan of the builder.
78  * 
79  * The function gtk_builder_connect_signals() and variants thereof can be
80  * used to connect handlers to the named signals in the description.
81  * 
82  * # GtkBuilder UI Definitions # {#BUILDER-UI}
83  * 
84  * GtkBuilder parses textual descriptions of user interfaces which are
85  * specified in an XML format which can be roughly described by the
86  * RELAX NG schema below. We refer to these descriptions as “GtkBuilder
87  * UI definitions” or just “UI definitions” if the context is clear.
88  * Do not confuse GtkBuilder UI Definitions with
89  * [GtkUIManager UI Definitions][XML-UI], which are more limited in scope.
90  * It is common to use `.ui` as the filename extension for files containing
91  * GtkBuilder UI definitions.
92  * 
93  * [RELAX NG Compact Syntax](https://git.gnome.org/browse/gtk+/tree/gtk/gtkbuilder.rnc)
94  * 
95  * The toplevel element is <interface>. It optionally takes a “domain”
96  * attribute, which will make the builder look for translated strings
97  * using dgettext() in the domain specified. This can also be done by
98  * calling gtk_builder_set_translation_domain() on the builder.
99  * Objects are described by <object> elements, which can contain
100  * <property> elements to set properties, <signal> elements which
101  * connect signals to handlers, and <child> elements, which describe
102  * child objects (most often widgets inside a container, but also e.g.
103  * actions in an action group, or columns in a tree model). A <child>
104  * element contains an <object> element which describes the child object.
105  * The target toolkit version(s) are described by <requires> elements,
106  * the “lib” attribute specifies the widget library in question (currently
107  * the only supported value is “gtk+”) and the “version” attribute specifies
108  * the target version in the form “<major>.<minor>”. The builder will error
109  * out if the version requirements are not met.
110  * 
111  * Typically, the specific kind of object represented by an <object>
112  * element is specified by the “class” attribute. If the type has not
113  * been loaded yet, GTK+ tries to find the get_type() function from the
114  * class name by applying heuristics. This works in most cases, but if
115  * necessary, it is possible to specify the name of the get_type() function
116  * explictly with the "type-func" attribute. As a special case, GtkBuilder
117  * allows to use an object that has been constructed by a #GtkUIManager in
118  * another part of the UI definition by specifying the id of the #GtkUIManager
119  * in the “constructor” attribute and the name of the object in the “id”
120  * attribute.
121  * 
122  * Objects may be given a name with the “id” attribute, which allows the
123  * application to retrieve them from the builder with gtk_builder_get_object().
124  * An id is also necessary to use the object as property value in other
125  * parts of the UI definition. GTK+ reserves ids starting and ending
126  * with ___ (3 underscores) for its own purposes.
127  * 
128  * Setting properties of objects is pretty straightforward with the
129  * <property> element: the “name” attribute specifies the name of the
130  * property, and the content of the element specifies the value.
131  * If the “translatable” attribute is set to a true value, GTK+ uses
132  * gettext() (or dgettext() if the builder has a translation domain set)
133  * to find a translation for the value. This happens before the value
134  * is parsed, so it can be used for properties of any type, but it is
135  * probably most useful for string properties. It is also possible to
136  * specify a context to disambiguate short strings, and comments which
137  * may help the translators.
138  * 
139  * GtkBuilder can parse textual representations for the most common
140  * property types: characters, strings, integers, floating-point numbers,
141  * booleans (strings like “TRUE”, “t”, “yes”, “y”, “1” are interpreted
142  * as %TRUE, strings like “FALSE”, “f”, “no”, “n”, “0” are interpreted
143  * as %FALSE), enumerations (can be specified by their name, nick or
144  * integer value), flags (can be specified by their name, nick, integer
145  * value, optionally combined with “|”, e.g. “GTK_VISIBLE|GTK_REALIZED”)
146  * and colors (in a format understood by gdk_rgba_parse()).
147  * 
148  * GVariants can be specified in the format understood by g_variant_parse(),
149  * and pixbufs can be specified as a filename of an image file to load.
150  * 
151  * Objects can be referred to by their name and by default refer to
152  * objects declared in the local xml fragment and objects exposed via
153  * gtk_builder_expose_object(). In general, GtkBuilder allows forward
154  * references to objects — declared in the local xml; an object doesn’t
155  * have to be constructed before it can be referred to. The exception
156  * to this rule is that an object has to be constructed before it can
157  * be used as the value of a construct-only property.
158  * 
159  * It is also possible to bind a property value to another object's
160  * property value using the attributes
161  * "bind-source" to specify the source object of the binding,
162  * "bind-property" to specify the source property and optionally
163  * "bind-flags" to specify the binding flags
164  * Internally builder implement this using GBinding objects.
165  * For more information see g_object_bind_property()
166  * 
167  * Signal handlers are set up with the <signal> element. The “name”
168  * attribute specifies the name of the signal, and the “handler” attribute
169  * specifies the function to connect to the signal. By default, GTK+ tries
170  * to find the handler using g_module_symbol(), but this can be changed by
171  * passing a custom #GtkBuilderConnectFunc to
172  * gtk_builder_connect_signals_full(). The remaining attributes, “after”,
173  * “swapped” and “object”, have the same meaning as the corresponding
174  * parameters of the g_signal_connect_object() or
175  * g_signal_connect_data() functions. A “last_modification_time”
176  * attribute is also allowed, but it does not have a meaning to the
177  * builder.
178  * 
179  * Sometimes it is necessary to refer to widgets which have implicitly
180  * been constructed by GTK+ as part of a composite widget, to set
181  * properties on them or to add further children (e.g. the @vbox of
182  * a #GtkDialog). This can be achieved by setting the “internal-child”
183  * propery of the <child> element to a true value. Note that GtkBuilder
184  * still requires an <object> element for the internal child, even if it
185  * has already been constructed.
186  * 
187  * A number of widgets have different places where a child can be added
188  * (e.g. tabs vs. page content in notebooks). This can be reflected in
189  * a UI definition by specifying the “type” attribute on a <child>
190  * The possible values for the “type” attribute are described in the
191  * sections describing the widget-specific portions of UI definitions.
192  * 
193  * # A GtkBuilder UI Definition
194  * 
195  * |[
196  * <interface>
197  * <object class="GtkDialog" id="dialog1">
198  * <child internal-child="vbox">
199  * <object class="GtkBox" id="vbox1">
200  * <property name="border-width">10</property>
201  * <child internal-child="action_area">
202  * <object class="GtkButtonBox" id="hbuttonbox1">
203  * <property name="border-width">20</property>
204  * <child>
205  * <object class="GtkButton" id="ok_button">
206  * <property name="label">gtk-ok</property>
207  * <property name="use-stock">TRUE</property>
208  * <signal name="clicked" handler="ok_button_clicked"/>
209  * </object>
210  * </child>
211  * </object>
212  * </child>
213  * </object>
214  * </child>
215  * </object>
216  * </interface>
217  * ]|
218  * 
219  * Beyond this general structure, several object classes define their
220  * own XML DTD fragments for filling in the ANY placeholders in the DTD
221  * above. Note that a custom element in a <child> element gets parsed by
222  * the custom tag handler of the parent object, while a custom element in
223  * an <object> element gets parsed by the custom tag handler of the object.
224  * 
225  * These XML fragments are explained in the documentation of the
226  * respective objects.
227  * 
228  * Additionally, since 3.10 a special <template> tag has been added
229  * to the format allowing one to define a widget class’s components.
230  * See the [GtkWidget documentation][composite-templates] for details.
231  */
232 public class Builder : ObjectG
233 {
234 	/** the main Gtk struct */
235 	protected GtkBuilder* gtkBuilder;
236 
237 	/** Get the main Gtk struct */
238 	public GtkBuilder* getBuilderStruct(bool transferOwnership = false)
239 	{
240 		if (transferOwnership)
241 			ownedRef = false;
242 		return gtkBuilder;
243 	}
244 
245 	/** the main Gtk struct as a void* */
246 	protected override void* getStruct()
247 	{
248 		return cast(void*)gtkBuilder;
249 	}
250 
251 	/**
252 	 * Sets our main struct and passes it to the parent class.
253 	 */
254 	public this (GtkBuilder* gtkBuilder, bool ownedRef = false)
255 	{
256 		this.gtkBuilder = gtkBuilder;
257 		super(cast(GObject*)gtkBuilder, ownedRef);
258 	}
259 
260 	/**
261 	 * Creates a new builder object.
262 	 * Since 2.12
263 	 * Throws: ConstructionException GTK+ fails to create the object.
264 	 */
265 	public this ()
266 	{
267 		// GtkBuilder* gtk_builder_new (void);
268 		auto p = gtk_builder_new();
269 		if(p is null)
270 		{
271 			throw new ConstructionException("null returned by gtk_builder_new()");
272 		}
273 		this(cast(GtkBuilder*) p);
274 
275 		GtkBuilderClass* klass = Type.getInstanceClass!(GtkBuilderClass)( this );
276 		klass.getTypeFromName = &gtk_builder_real_get_type_from_name_override;
277 	}
278 
279 	/**
280 	 * This function is a modification of _gtk_builder_resolve_type_lazily from "gtk/gtkbuilder.c".
281 	 * It is needed because it assumes we are linking at compile time to the gtk libs.
282 	 * specifically the NULL in g_module_open( NULL, 0 );
283 	 * It replaces the default function pointer "get_type_from_name" in GtkBuilderClass.
284 	 */
285 	extern(C) private static GType gtk_builder_real_get_type_from_name_override ( GtkBuilder* builder, const(char)* name )
286 	{
287 		GType gtype;
288 		gtype = g_type_from_name( name );
289 		if (gtype != GType.INVALID)
290 		{
291 			return gtype;
292 		}
293 
294 		/*
295 		 * Try to map a type name to a _get_type function
296 		 * and call it, eg:
297 		 *
298 		 * GtkWindow -> gtk_window_get_type
299 		 * GtkHBox -> gtk_hbox_get_type
300 		 * GtkUIManager -> gtk_ui_manager_get_type
301 		 *
302 		 */
303 		char   c;
304 		string symbol_name;
305 
306 		for (int i = 0; name[i] != '\0'; i++)
307 		{
308 			c = name[i];
309 			/* skip if uppercase, first or previous is uppercase */
310 			if ((c == Str.asciiToupper (c) &&
311 				i > 0 && name[i-1] != Str.asciiToupper (name[i-1])) ||
312 			(i > 2 && name[i]   == Str.asciiToupper (name[i]) &&
313 			name[i-1] == Str.asciiToupper (name[i-1]) &&
314 			name[i-2] == Str.asciiToupper (name[i-2]))
315 			)
316 
317 			symbol_name ~= '_';
318 			symbol_name ~= Str.asciiTolower (c);
319 		}
320 		symbol_name ~=  "_get_type" ;
321 
322 		/* scan linked librarys for function symbol */
323 		foreach ( lib; importLibs )
324 		{
325 			GType function() func;
326 			Module mod = Module.open( lib, GModuleFlags.LAZY );
327 			if( mod is null )
328 				continue;
329 
330 			scope(exit) mod.close();
331 
332 			if ( mod.symbol( symbol_name, cast(void**)&func ) ) {
333 				return func();
334 		}
335 	}
336 
337 	return GType.INVALID;
338 }
339 
340 /**
341  * Gets all objects that have been constructed by builder.
342  * Since 2.12
343  * Returns: an array containing all the objects constructed by the GtkBuilder instance.
344  */
345 public ObjectG[] getObjects()
346 {
347 	ObjectG[] objects;
348 
349 	// GSList* gtk_builder_get_objects (GtkBuilder *builder);
350 	GSList* list = gtk_builder_get_objects(gtkBuilder);
351 
352 	while ( list.next !is null )
353 	{
354 		objects ~= ObjectG.getDObject!(ObjectG)(cast(GObject*) list.data);
355 		list = list.next;
356 	}
357 
358 	g_slist_free(list);
359 
360 	return objects;
361 }
362 
363 /**
364  */
365 
366 /** */
367 public static GType getType()
368 {
369 	return gtk_builder_get_type();
370 }
371 
372 /**
373  * Builds the [GtkBuilder UI definition][BUILDER-UI]
374  * in the file @filename.
375  *
376  * If there is an error opening the file or parsing the description then
377  * the program will be aborted.  You should only ever attempt to parse
378  * user interface descriptions that are shipped as part of your program.
379  *
380  * Params:
381  *     filename = filename of user interface description file
382  *
383  * Returns: a #GtkBuilder containing the described interface
384  *
385  * Since: 3.10
386  *
387  * Throws: ConstructionException GTK+ fails to create the object.
388  */
389 public this(string filename)
390 {
391 	auto p = gtk_builder_new_from_file(Str.toStringz(filename));
392 
393 	if(p is null)
394 	{
395 		throw new ConstructionException("null returned by new_from_file");
396 	}
397 
398 	this(cast(GtkBuilder*) p, true);
399 }
400 
401 /**
402  * Adds the @callback_symbol to the scope of @builder under the given @callback_name.
403  *
404  * Using this function overrides the behavior of gtk_builder_connect_signals()
405  * for any callback symbols that are added. Using this method allows for better
406  * encapsulation as it does not require that callback symbols be declared in
407  * the global namespace.
408  *
409  * Params:
410  *     callbackName = The name of the callback, as expected in the XML
411  *     callbackSymbol = The callback pointer
412  *
413  * Since: 3.10
414  */
415 public void addCallbackSymbol(string callbackName, GCallback callbackSymbol)
416 {
417 	gtk_builder_add_callback_symbol(gtkBuilder, Str.toStringz(callbackName), callbackSymbol);
418 }
419 
420 /**
421  * Parses a file containing a [GtkBuilder UI definition][BUILDER-UI]
422  * and merges it with the current contents of @builder.
423  *
424  * Most users will probably want to use gtk_builder_new_from_file().
425  *
426  * If an error occurs, 0 will be returned and @error will be assigned a
427  * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_FILE_ERROR
428  * domain.
429  *
430  * It’s not really reasonable to attempt to handle failures of this
431  * call. You should not use this function with untrusted files (ie:
432  * files that are not part of your application). Broken #GtkBuilder
433  * files can easily crash your program, and it’s possible that memory
434  * was leaked leading up to the reported failure. The only reasonable
435  * thing to do when an error is detected is to call g_error().
436  *
437  * Params:
438  *     filename = the name of the file to parse
439  *
440  * Returns: A positive value on success, 0 if an error occurred
441  *
442  * Since: 2.12
443  *
444  * Throws: GException on failure.
445  */
446 public uint addFromFile(string filename)
447 {
448 	GError* err = null;
449 
450 	auto p = gtk_builder_add_from_file(gtkBuilder, Str.toStringz(filename), &err);
451 
452 	if (err !is null)
453 	{
454 		throw new GException( new ErrorG(err) );
455 	}
456 
457 	return p;
458 }
459 
460 /**
461  * Parses a resource file containing a [GtkBuilder UI definition][BUILDER-UI]
462  * and merges it with the current contents of @builder.
463  *
464  * Most users will probably want to use gtk_builder_new_from_resource().
465  *
466  * If an error occurs, 0 will be returned and @error will be assigned a
467  * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_RESOURCE_ERROR
468  * domain.
469  *
470  * It’s not really reasonable to attempt to handle failures of this
471  * call.  The only reasonable thing to do when an error is detected is
472  * to call g_error().
473  *
474  * Params:
475  *     resourcePath = the path of the resource file to parse
476  *
477  * Returns: A positive value on success, 0 if an error occurred
478  *
479  * Since: 3.4
480  *
481  * Throws: GException on failure.
482  */
483 public uint addFromResource(string resourcePath)
484 {
485 	GError* err = null;
486 
487 	auto p = gtk_builder_add_from_resource(gtkBuilder, Str.toStringz(resourcePath), &err);
488 
489 	if (err !is null)
490 	{
491 		throw new GException( new ErrorG(err) );
492 	}
493 
494 	return p;
495 }
496 
497 /**
498  * Parses a string containing a [GtkBuilder UI definition][BUILDER-UI]
499  * and merges it with the current contents of @builder.
500  *
501  * Most users will probably want to use gtk_builder_new_from_string().
502  *
503  * Upon errors 0 will be returned and @error will be assigned a
504  * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or
505  * #G_VARIANT_PARSE_ERROR domain.
506  *
507  * It’s not really reasonable to attempt to handle failures of this
508  * call.  The only reasonable thing to do when an error is detected is
509  * to call g_error().
510  *
511  * Params:
512  *     buffer = the string to parse
513  *
514  * Returns: A positive value on success, 0 if an error occurred
515  *
516  * Since: 2.12
517  *
518  * Throws: GException on failure.
519  */
520 public uint addFromString(string buffer)
521 {
522 	GError* err = null;
523 
524 	auto p = gtk_builder_add_from_string(gtkBuilder, Str.toStringz(buffer), cast(size_t)buffer.length, &err);
525 
526 	if (err !is null)
527 	{
528 		throw new GException( new ErrorG(err) );
529 	}
530 
531 	return p;
532 }
533 
534 /**
535  * Parses a file containing a [GtkBuilder UI definition][BUILDER-UI]
536  * building only the requested objects and merges
537  * them with the current contents of @builder.
538  *
539  * Upon errors 0 will be returned and @error will be assigned a
540  * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_FILE_ERROR
541  * domain.
542  *
543  * If you are adding an object that depends on an object that is not
544  * its child (for instance a #GtkTreeView that depends on its
545  * #GtkTreeModel), you have to explicitly list all of them in @object_ids.
546  *
547  * Params:
548  *     filename = the name of the file to parse
549  *     objectIds = nul-terminated array of objects to build
550  *
551  * Returns: A positive value on success, 0 if an error occurred
552  *
553  * Since: 2.14
554  *
555  * Throws: GException on failure.
556  */
557 public uint addObjectsFromFile(string filename, string[] objectIds)
558 {
559 	GError* err = null;
560 
561 	auto p = gtk_builder_add_objects_from_file(gtkBuilder, Str.toStringz(filename), Str.toStringzArray(objectIds), &err);
562 
563 	if (err !is null)
564 	{
565 		throw new GException( new ErrorG(err) );
566 	}
567 
568 	return p;
569 }
570 
571 /**
572  * Parses a resource file containing a [GtkBuilder UI definition][BUILDER-UI]
573  * building only the requested objects and merges
574  * them with the current contents of @builder.
575  *
576  * Upon errors 0 will be returned and @error will be assigned a
577  * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_RESOURCE_ERROR
578  * domain.
579  *
580  * If you are adding an object that depends on an object that is not
581  * its child (for instance a #GtkTreeView that depends on its
582  * #GtkTreeModel), you have to explicitly list all of them in @object_ids.
583  *
584  * Params:
585  *     resourcePath = the path of the resource file to parse
586  *     objectIds = nul-terminated array of objects to build
587  *
588  * Returns: A positive value on success, 0 if an error occurred
589  *
590  * Since: 3.4
591  *
592  * Throws: GException on failure.
593  */
594 public uint addObjectsFromResource(string resourcePath, string[] objectIds)
595 {
596 	GError* err = null;
597 
598 	auto p = gtk_builder_add_objects_from_resource(gtkBuilder, Str.toStringz(resourcePath), Str.toStringzArray(objectIds), &err);
599 
600 	if (err !is null)
601 	{
602 		throw new GException( new ErrorG(err) );
603 	}
604 
605 	return p;
606 }
607 
608 /**
609  * Parses a string containing a [GtkBuilder UI definition][BUILDER-UI]
610  * building only the requested objects and merges
611  * them with the current contents of @builder.
612  *
613  * Upon errors 0 will be returned and @error will be assigned a
614  * #GError from the #GTK_BUILDER_ERROR or #G_MARKUP_ERROR domain.
615  *
616  * If you are adding an object that depends on an object that is not
617  * its child (for instance a #GtkTreeView that depends on its
618  * #GtkTreeModel), you have to explicitly list all of them in @object_ids.
619  *
620  * Params:
621  *     buffer = the string to parse
622  *     length = the length of @buffer (may be -1 if @buffer is nul-terminated)
623  *     objectIds = nul-terminated array of objects to build
624  *
625  * Returns: A positive value on success, 0 if an error occurred
626  *
627  * Since: 2.14
628  *
629  * Throws: GException on failure.
630  */
631 public uint addObjectsFromString(string buffer, size_t length, string[] objectIds)
632 {
633 	GError* err = null;
634 
635 	auto p = gtk_builder_add_objects_from_string(gtkBuilder, Str.toStringz(buffer), length, Str.toStringzArray(objectIds), &err);
636 
637 	if (err !is null)
638 	{
639 		throw new GException( new ErrorG(err) );
640 	}
641 
642 	return p;
643 }
644 
645 /**
646  * This method is a simpler variation of gtk_builder_connect_signals_full().
647  * It uses symbols explicitly added to @builder with prior calls to
648  * gtk_builder_add_callback_symbol(). In the case that symbols are not
649  * explicitly added; it uses #GModule’s introspective features (by opening the module %NULL)
650  * to look at the application’s symbol table. From here it tries to match
651  * the signal handler names given in the interface description with
652  * symbols in the application and connects the signals. Note that this
653  * function can only be called once, subsequent calls will do nothing.
654  *
655  * Note that unless gtk_builder_add_callback_symbol() is called for
656  * all signal callbacks which are referenced by the loaded XML, this
657  * function will require that #GModule be supported on the platform.
658  *
659  * If you rely on #GModule support to lookup callbacks in the symbol table,
660  * the following details should be noted:
661  *
662  * When compiling applications for Windows, you must declare signal callbacks
663  * with #G_MODULE_EXPORT, or they will not be put in the symbol table.
664  * On Linux and Unices, this is not necessary; applications should instead
665  * be compiled with the -Wl,--export-dynamic CFLAGS, and linked against
666  * gmodule-export-2.0.
667  *
668  * Params:
669  *     userData = user data to pass back with all signals
670  *
671  * Since: 2.12
672  */
673 public void connectSignals(void* userData)
674 {
675 	gtk_builder_connect_signals(gtkBuilder, userData);
676 }
677 
678 /**
679  * This function can be thought of the interpreted language binding
680  * version of gtk_builder_connect_signals(), except that it does not
681  * require GModule to function correctly.
682  *
683  * Params:
684  *     func = the function used to connect the signals
685  *     userData = arbitrary data that will be passed to the connection function
686  *
687  * Since: 2.12
688  */
689 public void connectSignalsFull(GtkBuilderConnectFunc func, void* userData)
690 {
691 	gtk_builder_connect_signals_full(gtkBuilder, func, userData);
692 }
693 
694 /**
695  * Add @object to the @builder object pool so it can be referenced just like any
696  * other object built by builder.
697  *
698  * Params:
699  *     name = the name of the object exposed to the builder
700  *     object = the object to expose
701  *
702  * Since: 3.8
703  */
704 public void exposeObject(string name, ObjectG object)
705 {
706 	gtk_builder_expose_object(gtkBuilder, Str.toStringz(name), (object is null) ? null : object.getObjectGStruct());
707 }
708 
709 /**
710  * Main private entry point for building composite container
711  * components from template XML.
712  *
713  * This is exported purely to let gtk-builder-tool validate
714  * templates, applications have no need to call this function.
715  *
716  * Params:
717  *     widget = the widget that is being extended
718  *     templateType = the type that the template is for
719  *     buffer = the string to parse
720  *     length = the length of @buffer (may be -1 if @buffer is nul-terminated)
721  *
722  * Returns: A positive value on success, 0 if an error occurred
723  *
724  * Throws: GException on failure.
725  */
726 public uint extendWithTemplate(Widget widget, GType templateType, string buffer, size_t length)
727 {
728 	GError* err = null;
729 
730 	auto p = gtk_builder_extend_with_template(gtkBuilder, (widget is null) ? null : widget.getWidgetStruct(), templateType, Str.toStringz(buffer), length, &err);
731 
732 	if (err !is null)
733 	{
734 		throw new GException( new ErrorG(err) );
735 	}
736 
737 	return p;
738 }
739 
740 /**
741  * Gets the #GtkApplication associated with the builder.
742  *
743  * The #GtkApplication is used for creating action proxies as requested
744  * from XML that the builder is loading.
745  *
746  * By default, the builder uses the default application: the one from
747  * g_application_get_default(). If you want to use another application
748  * for constructing proxies, use gtk_builder_set_application().
749  *
750  * Returns: the application being used by the builder,
751  *     or %NULL
752  *
753  * Since: 3.10
754  */
755 public Application getApplication()
756 {
757 	auto p = gtk_builder_get_application(gtkBuilder);
758 
759 	if(p is null)
760 	{
761 		return null;
762 	}
763 
764 	return ObjectG.getDObject!(Application)(cast(GtkApplication*) p);
765 }
766 
767 /**
768  * Gets the object named @name. Note that this function does not
769  * increment the reference count of the returned object.
770  *
771  * Params:
772  *     name = name of object to get
773  *
774  * Returns: the object named @name or %NULL if
775  *     it could not be found in the object tree.
776  *
777  * Since: 2.12
778  */
779 public ObjectG getObject(string name)
780 {
781 	auto p = gtk_builder_get_object(gtkBuilder, Str.toStringz(name));
782 
783 	if(p is null)
784 	{
785 		return null;
786 	}
787 
788 	return ObjectG.getDObject!(ObjectG)(cast(GObject*) p);
789 }
790 
791 /**
792  * Gets the translation domain of @builder.
793  *
794  * Returns: the translation domain. This string is owned
795  *     by the builder object and must not be modified or freed.
796  *
797  * Since: 2.12
798  */
799 public string getTranslationDomain()
800 {
801 	return Str.toString(gtk_builder_get_translation_domain(gtkBuilder));
802 }
803 
804 /**
805  * Looks up a type by name, using the virtual function that
806  * #GtkBuilder has for that purpose. This is mainly used when
807  * implementing the #GtkBuildable interface on a type.
808  *
809  * Params:
810  *     typeName = type name to lookup
811  *
812  * Returns: the #GType found for @type_name or #G_TYPE_INVALID
813  *     if no type was found
814  *
815  * Since: 2.12
816  */
817 public GType getTypeFromName(string typeName)
818 {
819 	return gtk_builder_get_type_from_name(gtkBuilder, Str.toStringz(typeName));
820 }
821 
822 /**
823  * Fetches a symbol previously added to @builder
824  * with gtk_builder_add_callback_symbols()
825  *
826  * This function is intended for possible use in language bindings
827  * or for any case that one might be cusomizing signal connections
828  * using gtk_builder_connect_signals_full()
829  *
830  * Params:
831  *     callbackName = The name of the callback
832  *
833  * Returns: The callback symbol in @builder for @callback_name, or %NULL
834  *
835  * Since: 3.10
836  */
837 public GCallback lookupCallbackSymbol(string callbackName)
838 {
839 	return gtk_builder_lookup_callback_symbol(gtkBuilder, Str.toStringz(callbackName));
840 }
841 
842 /**
843  * Sets the application associated with @builder.
844  *
845  * You only need this function if there is more than one #GApplication
846  * in your process. @application cannot be %NULL.
847  *
848  * Params:
849  *     application = a #GtkApplication
850  *
851  * Since: 3.10
852  */
853 public void setApplication(Application application)
854 {
855 	gtk_builder_set_application(gtkBuilder, (application is null) ? null : application.getGtkApplicationStruct());
856 }
857 
858 /**
859  * Sets the translation domain of @builder.
860  * See #GtkBuilder:translation-domain.
861  *
862  * Params:
863  *     domain = the translation domain or %NULL
864  *
865  * Since: 2.12
866  */
867 public void setTranslationDomain(string domain)
868 {
869 	gtk_builder_set_translation_domain(gtkBuilder, Str.toStringz(domain));
870 }
871 
872 /**
873  * This function demarshals a value from a string. This function
874  * calls g_value_init() on the @value argument, so it need not be
875  * initialised beforehand.
876  *
877  * This function can handle char, uchar, boolean, int, uint, long,
878  * ulong, enum, flags, float, double, string, #GdkColor, #GdkRGBA and
879  * #GtkAdjustment type values. Support for #GtkWidget type values is
880  * still to come.
881  *
882  * Upon errors %FALSE will be returned and @error will be assigned a
883  * #GError from the #GTK_BUILDER_ERROR domain.
884  *
885  * Params:
886  *     pspec = the #GParamSpec for the property
887  *     str = the string representation of the value
888  *     value = the #GValue to store the result in
889  *
890  * Returns: %TRUE on success
891  *
892  * Since: 2.12
893  *
894  * Throws: GException on failure.
895  */
896 public bool valueFromString(ParamSpec pspec, string str, out Value value)
897 {
898 	GValue* outvalue = sliceNew!GValue();
899 	GError* err = null;
900 
901 	auto p = gtk_builder_value_from_string(gtkBuilder, (pspec is null) ? null : pspec.getParamSpecStruct(), Str.toStringz(str), outvalue, &err) != 0;
902 
903 	if (err !is null)
904 	{
905 		throw new GException( new ErrorG(err) );
906 	}
907 
908 	value = ObjectG.getDObject!(Value)(outvalue, true);
909 
910 	return p;
911 }
912 
913 /**
914  * Like gtk_builder_value_from_string(), this function demarshals
915  * a value from a string, but takes a #GType instead of #GParamSpec.
916  * This function calls g_value_init() on the @value argument, so it
917  * need not be initialised beforehand.
918  *
919  * Upon errors %FALSE will be returned and @error will be assigned a
920  * #GError from the #GTK_BUILDER_ERROR domain.
921  *
922  * Params:
923  *     type = the #GType of the value
924  *     str = the string representation of the value
925  *     value = the #GValue to store the result in
926  *
927  * Returns: %TRUE on success
928  *
929  * Since: 2.12
930  *
931  * Throws: GException on failure.
932  */
933 public bool valueFromStringType(GType type, string str, out Value value)
934 {
935 	GValue* outvalue = sliceNew!GValue();
936 	GError* err = null;
937 
938 	auto p = gtk_builder_value_from_string_type(gtkBuilder, type, Str.toStringz(str), outvalue, &err) != 0;
939 
940 	if (err !is null)
941 	{
942 		throw new GException( new ErrorG(err) );
943 	}
944 
945 	value = ObjectG.getDObject!(Value)(outvalue, true);
946 
947 	return p;
948 }
949 }