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