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 glib.c.functions; 33 private import gobject.ObjectG; 34 private import gobject.ParamSpec; 35 private import gobject.Type; 36 private import gobject.Value; 37 private import gobject.c.functions; 38 private import gtk.Application; 39 private import gtk.Widget; 40 private import gtk.c.functions; 41 public import gtk.c.types; 42 public import gtkc.gtktypes; 43 private import gtkd.paths; 44 private import std.string; 45 46 47 /** 48 * A GtkBuilder is an auxiliary object that reads textual descriptions 49 * of a user interface and instantiates the described objects. To create 50 * a GtkBuilder from a user interface description, call 51 * gtk_builder_new_from_file(), gtk_builder_new_from_resource() or 52 * gtk_builder_new_from_string(). 53 * 54 * In the (unusual) case that you want to add user interface 55 * descriptions from multiple sources to the same GtkBuilder you can 56 * call gtk_builder_new() to get an empty builder and populate it by 57 * (multiple) calls to gtk_builder_add_from_file(), 58 * gtk_builder_add_from_resource() or gtk_builder_add_from_string(). 59 * 60 * A GtkBuilder holds a reference to all objects that it has constructed 61 * and drops these references when it is finalized. This finalization can 62 * cause the destruction of non-widget objects or widgets which are not 63 * contained in a toplevel window. For toplevel windows constructed by a 64 * builder, it is the responsibility of the user to call gtk_widget_destroy() 65 * to get rid of them and all the widgets they contain. 66 * 67 * The functions gtk_builder_get_object() and gtk_builder_get_objects() 68 * can be used to access the widgets in the interface by the names assigned 69 * to them inside the UI description. Toplevel windows returned by these 70 * functions will stay around until the user explicitly destroys them 71 * with gtk_widget_destroy(). Other widgets will either be part of a 72 * larger hierarchy constructed by the builder (in which case you should 73 * not have to worry about their lifecycle), or without a parent, in which 74 * case they have to be added to some container to make use of them. 75 * Non-widget objects need to be reffed with g_object_ref() to keep them 76 * beyond the lifespan of the builder. 77 * 78 * The function gtk_builder_connect_signals() and variants thereof can be 79 * used to connect handlers to the named signals in the description. 80 * 81 * # GtkBuilder UI Definitions # {#BUILDER-UI} 82 * 83 * GtkBuilder parses textual descriptions of user interfaces which are 84 * specified in an XML format which can be roughly described by the 85 * RELAX NG schema below. We refer to these descriptions as “GtkBuilder 86 * UI definitions” or just “UI definitions” if the context is clear. 87 * Do not confuse GtkBuilder UI Definitions with 88 * [GtkUIManager UI Definitions][XML-UI], which are more limited in scope. 89 * It is common to use `.ui` as the filename extension for files containing 90 * GtkBuilder UI definitions. 91 * 92 * [RELAX NG Compact Syntax](https://git.gnome.org/browse/gtk+/tree/gtk/gtkbuilder.rnc) 93 * 94 * The toplevel element is <interface>. It optionally takes a “domain” 95 * attribute, which will make the builder look for translated strings 96 * using dgettext() in the domain specified. This can also be done by 97 * calling gtk_builder_set_translation_domain() on the builder. 98 * Objects are described by <object> elements, which can contain 99 * <property> elements to set properties, <signal> elements which 100 * connect signals to handlers, and <child> elements, which describe 101 * child objects (most often widgets inside a container, but also e.g. 102 * actions in an action group, or columns in a tree model). A <child> 103 * element contains an <object> element which describes the child object. 104 * The target toolkit version(s) are described by <requires> elements, 105 * the “lib” attribute specifies the widget library in question (currently 106 * the only supported value is “gtk+”) and the “version” attribute specifies 107 * the target version in the form “<major>.<minor>”. The builder will error 108 * out if the version requirements are not met. 109 * 110 * Typically, the specific kind of object represented by an <object> 111 * element is specified by the “class” attribute. If the type has not 112 * been loaded yet, GTK+ tries to find the get_type() function from the 113 * class name by applying heuristics. This works in most cases, but if 114 * necessary, it is possible to specify the name of the get_type() function 115 * explictly with the "type-func" attribute. As a special case, GtkBuilder 116 * allows to use an object that has been constructed by a #GtkUIManager in 117 * another part of the UI definition by specifying the id of the #GtkUIManager 118 * in the “constructor” attribute and the name of the object in the “id” 119 * attribute. 120 * 121 * Objects may be given a name with the “id” attribute, which allows the 122 * application to retrieve them from the builder with gtk_builder_get_object(). 123 * An id is also necessary to use the object as property value in other 124 * parts of the UI definition. GTK+ reserves ids starting and ending 125 * with ___ (3 underscores) for its own purposes. 126 * 127 * Setting properties of objects is pretty straightforward with the 128 * <property> element: the “name” attribute specifies the name of the 129 * property, and the content of the element specifies the value. 130 * If the “translatable” attribute is set to a true value, GTK+ uses 131 * gettext() (or dgettext() if the builder has a translation domain set) 132 * to find a translation for the value. This happens before the value 133 * is parsed, so it can be used for properties of any type, but it is 134 * probably most useful for string properties. It is also possible to 135 * specify a context to disambiguate short strings, and comments which 136 * may help the translators. 137 * 138 * GtkBuilder can parse textual representations for the most common 139 * property types: characters, strings, integers, floating-point numbers, 140 * booleans (strings like “TRUE”, “t”, “yes”, “y”, “1” are interpreted 141 * as %TRUE, strings like “FALSE”, “f”, “no”, “n”, “0” are interpreted 142 * as %FALSE), enumerations (can be specified by their name, nick or 143 * integer value), flags (can be specified by their name, nick, integer 144 * value, optionally combined with “|”, e.g. “GTK_VISIBLE|GTK_REALIZED”) 145 * and colors (in a format understood by gdk_rgba_parse()). 146 * 147 * GVariants can be specified in the format understood by g_variant_parse(), 148 * and pixbufs can be specified as a filename of an image file to load. 149 * 150 * Objects can be referred to by their name and by default refer to 151 * objects declared in the local xml fragment and objects exposed via 152 * gtk_builder_expose_object(). In general, GtkBuilder allows forward 153 * references to objects — declared in the local xml; an object doesn’t 154 * have to be constructed before it can be referred to. The exception 155 * to this rule is that an object has to be constructed before it can 156 * be used as the value of a construct-only property. 157 * 158 * It is also possible to bind a property value to another object's 159 * property value using the attributes 160 * "bind-source" to specify the source object of the binding, 161 * "bind-property" to specify the source property and optionally 162 * "bind-flags" to specify the binding flags 163 * Internally builder implement this using GBinding objects. 164 * For more information see g_object_bind_property() 165 * 166 * Signal handlers are set up with the <signal> element. The “name” 167 * attribute specifies the name of the signal, and the “handler” attribute 168 * specifies the function to connect to the signal. By default, GTK+ tries 169 * to find the handler using g_module_symbol(), but this can be changed by 170 * passing a custom #GtkBuilderConnectFunc to 171 * gtk_builder_connect_signals_full(). The remaining attributes, “after”, 172 * “swapped” and “object”, have the same meaning as the corresponding 173 * parameters of the g_signal_connect_object() or 174 * g_signal_connect_data() functions. A “last_modification_time” 175 * attribute is also allowed, but it does not have a meaning to the 176 * builder. 177 * 178 * Sometimes it is necessary to refer to widgets which have implicitly 179 * been constructed by GTK+ as part of a composite widget, to set 180 * properties on them or to add further children (e.g. the @vbox of 181 * a #GtkDialog). This can be achieved by setting the “internal-child” 182 * propery of the <child> element to a true value. Note that GtkBuilder 183 * still requires an <object> element for the internal child, even if it 184 * has already been constructed. 185 * 186 * A number of widgets have different places where a child can be added 187 * (e.g. tabs vs. page content in notebooks). This can be reflected in 188 * a UI definition by specifying the “type” attribute on a <child> 189 * The possible values for the “type” attribute are described in the 190 * sections describing the widget-specific portions of UI definitions. 191 * 192 * # A GtkBuilder UI Definition 193 * 194 * |[ 195 * <interface> 196 * <object class="GtkDialog" id="dialog1"> 197 * <child internal-child="vbox"> 198 * <object class="GtkBox" id="vbox1"> 199 * <property name="border-width">10</property> 200 * <child internal-child="action_area"> 201 * <object class="GtkButtonBox" id="hbuttonbox1"> 202 * <property name="border-width">20</property> 203 * <child> 204 * <object class="GtkButton" id="ok_button"> 205 * <property name="label">gtk-ok</property> 206 * <property name="use-stock">TRUE</property> 207 * <signal name="clicked" handler="ok_button_clicked"/> 208 * </object> 209 * </child> 210 * </object> 211 * </child> 212 * </object> 213 * </child> 214 * </object> 215 * </interface> 216 * ]| 217 * 218 * Beyond this general structure, several object classes define their 219 * own XML DTD fragments for filling in the ANY placeholders in the DTD 220 * above. Note that a custom element in a <child> element gets parsed by 221 * the custom tag handler of the parent object, while a custom element in 222 * an <object> element gets parsed by the custom tag handler of the object. 223 * 224 * These XML fragments are explained in the documentation of the 225 * respective objects. 226 * 227 * Additionally, since 3.10 a special <template> tag has been added 228 * to the format allowing one to define a widget class’s components. 229 * See the [GtkWidget documentation][composite-templates] for details. 230 */ 231 public class Builder : ObjectG 232 { 233 /** the main Gtk struct */ 234 protected GtkBuilder* gtkBuilder; 235 236 /** Get the main Gtk struct */ 237 public GtkBuilder* getBuilderStruct(bool transferOwnership = false) 238 { 239 if (transferOwnership) 240 ownedRef = false; 241 return gtkBuilder; 242 } 243 244 /** the main Gtk struct as a void* */ 245 protected override void* getStruct() 246 { 247 return cast(void*)gtkBuilder; 248 } 249 250 protected override void setStruct(GObject* obj) 251 { 252 gtkBuilder = cast(GtkBuilder*)obj; 253 super.setStruct(obj); 254 } 255 256 /** 257 * Sets our main struct and passes it to the parent class. 258 */ 259 public this (GtkBuilder* gtkBuilder, bool ownedRef = false) 260 { 261 this.gtkBuilder = gtkBuilder; 262 super(cast(GObject*)gtkBuilder, ownedRef); 263 } 264 265 /** 266 * Creates a new builder object. 267 * Since 2.12 268 * Throws: ConstructionException GTK+ fails to create the object. 269 */ 270 public this () 271 { 272 // GtkBuilder* gtk_builder_new (void); 273 auto p = gtk_builder_new(); 274 if(p is null) 275 { 276 throw new ConstructionException("null returned by gtk_builder_new()"); 277 } 278 this(cast(GtkBuilder*) p); 279 280 GtkBuilderClass* klass = Type.getInstanceClass!(GtkBuilderClass)( this ); 281 klass.getTypeFromName = >k_builder_real_get_type_from_name_override; 282 } 283 284 /** 285 * This function is a modification of _gtk_builder_resolve_type_lazily from "gtk/gtkbuilder.c". 286 * It is needed because it assumes we are linking at compile time to the gtk libs. 287 * specifically the NULL in g_module_open( NULL, 0 ); 288 * It replaces the default function pointer "get_type_from_name" in GtkBuilderClass. 289 */ 290 extern(C) private static GType gtk_builder_real_get_type_from_name_override ( GtkBuilder* builder, const(char)* name ) 291 { 292 GType gtype; 293 gtype = g_type_from_name( name ); 294 if (gtype != GType.INVALID) 295 { 296 return gtype; 297 } 298 299 /* 300 * Try to map a type name to a _get_type function 301 * and call it, eg: 302 * 303 * GtkWindow -> gtk_window_get_type 304 * GtkHBox -> gtk_hbox_get_type 305 * GtkUIManager -> gtk_ui_manager_get_type 306 * 307 */ 308 char c; 309 string symbol_name; 310 311 for (int i = 0; name[i] != '\0'; i++) 312 { 313 c = name[i]; 314 /* skip if uppercase, first or previous is uppercase */ 315 if ((c == Str.asciiToupper (c) && 316 i > 0 && name[i-1] != Str.asciiToupper (name[i-1])) || 317 (i > 2 && name[i] == Str.asciiToupper (name[i]) && 318 name[i-1] == Str.asciiToupper (name[i-1]) && 319 name[i-2] == Str.asciiToupper (name[i-2])) 320 ) 321 322 symbol_name ~= '_'; 323 symbol_name ~= Str.asciiTolower (c); 324 } 325 symbol_name ~= "_get_type" ; 326 327 /* scan linked librarys for function symbol */ 328 foreach ( lib; importLibs ) 329 { 330 GType function() func; 331 Module mod = Module.open( lib, GModuleFlags.LAZY ); 332 if( mod is null ) 333 continue; 334 335 scope(exit) mod.close(); 336 337 if ( mod.symbol( symbol_name, cast(void**)&func ) ) { 338 return func(); 339 } 340 } 341 342 return GType.INVALID; 343 } 344 345 /** 346 * Gets the object named name. Note that this function does not 347 * increment the reference count of the returned object. 348 * Since 2.12 349 * Params: 350 * name = name of object to get 351 * Returns: the object named name or NULL if it could not be found in the object tree.. transfer none. 352 */ 353 public ObjectG getObject(string name) 354 { 355 // GObject* gtk_builder_get_object (GtkBuilder *builder, const gchar *name); 356 return newFromObject( gtk_builder_get_object(gtkBuilder, Str.toStringz(name)) ); 357 } 358 359 /** 360 * Gets all objects that have been constructed by builder. 361 * Since 2.12 362 * Returns: an array containing all the objects constructed by the GtkBuilder instance. 363 */ 364 public ObjectG[] getObjects() 365 { 366 ObjectG[] objects; 367 368 // GSList* gtk_builder_get_objects (GtkBuilder *builder); 369 GSList* list = gtk_builder_get_objects(gtkBuilder); 370 371 while ( list.next !is null ) 372 { 373 objects ~= newFromObject( cast(GObject*)list.data ); 374 list = list.next; 375 } 376 377 g_slist_free(list); 378 379 return objects; 380 } 381 382 /** 383 * This function creates an D object corresponding to the Struct pointer passed in. 384 */ 385 public ObjectG newFromObject(GObject* cobj) 386 { 387 if(cobj is null) 388 { 389 return null; 390 } 391 392 void* dObj = g_object_get_data(cobj, Str.toStringz("GObject")); 393 394 if ( dObj !is null ) 395 { 396 return cast(ObjectG)dObj; 397 } 398 399 string type = convertClassName(Type.name((cast(GTypeInstance*)cobj).gClass.gType)); 400 ClassInfo ci = cast(ClassInfo)ClassInfo.find(type); 401 402 //Gobject and Gio types both start with g, so try both. 403 if(ci is null && startsWith(type, "gobject")) 404 { 405 ci = cast(ClassInfo)ClassInfo.find("gio"~ type[7..$]); 406 } 407 408 if(ci is null) 409 { 410 return null; 411 } 412 413 ObjectG obj = cast(ObjectG)gtk.c.types._d_newclass(ci); 414 415 obj.__ctor(cobj); 416 417 return obj; 418 } 419 420 /** 421 * Turn the name of a C Type in to the name of the corresponding D type. 422 * Note: If the prefix of the type is "G" this always usses "gobject" as 423 * the prefix, extra care should be taken for types from GIO. 424 */ 425 private string convertClassName(string gName) 426 { 427 string conv; 428 string prefix; 429 430 if ( startsWith(gName, "GtkSource" ) ) prefix = "Gsv"; 431 else if ( startsWith(gName, "Gtk") ) prefix = "Gtk"; 432 else if ( startsWith(gName, "Gdk") ) prefix = "Gdk"; 433 else if ( startsWith(gName, "Gst") ) prefix = "Gst"; 434 else if ( startsWith(gName, "Gda") ) prefix = "Gda"; 435 else if ( startsWith(gName, "Atk") ) prefix = "Atk"; 436 else if ( startsWith(gName, "G") ) prefix = "G"; 437 else if ( startsWith(gName, "Pango") ) prefix = "Pg"; 438 else if ( startsWith(gName, "cairo") ) prefix = "cairo"; 439 440 conv = gName[prefix.length..gName.length]; 441 442 if ( conv == "Object" ) conv ~= prefix; 443 if ( prefix == "Pg" ) conv = "Pg" ~ gName[5..gName.length]; 444 if ( prefix == "cairo") conv = toUpper(gName[6..7]) ~ gName[7..gName.length - 2]; 445 446 prefix = toLower(prefix); 447 448 if( prefix == "gst") prefix = "gstreamer"; 449 if( prefix == "g") prefix = "gobject"; 450 if( prefix == "pg" ) prefix = "pango"; 451 452 return prefix ~"."~ conv ~"."~ conv; 453 } 454 455 private bool startsWith(string str, string prefix) 456 { 457 return str.length >= prefix.length && str[0..prefix.length] == prefix; 458 } 459 460 /** 461 */ 462 463 /** */ 464 public static GType getType() 465 { 466 return gtk_builder_get_type(); 467 } 468 469 /** 470 * Builds the [GtkBuilder UI definition][BUILDER-UI] 471 * in the file @filename. 472 * 473 * If there is an error opening the file or parsing the description then 474 * the program will be aborted. You should only ever attempt to parse 475 * user interface descriptions that are shipped as part of your program. 476 * 477 * Params: 478 * filename = filename of user interface description file 479 * 480 * Returns: a #GtkBuilder containing the described interface 481 * 482 * Since: 3.10 483 * 484 * Throws: ConstructionException GTK+ fails to create the object. 485 */ 486 public this(string filename) 487 { 488 auto p = gtk_builder_new_from_file(Str.toStringz(filename)); 489 490 if(p is null) 491 { 492 throw new ConstructionException("null returned by new_from_file"); 493 } 494 495 this(cast(GtkBuilder*) p, true); 496 } 497 498 /** 499 * Adds the @callback_symbol to the scope of @builder under the given @callback_name. 500 * 501 * Using this function overrides the behavior of gtk_builder_connect_signals() 502 * for any callback symbols that are added. Using this method allows for better 503 * encapsulation as it does not require that callback symbols be declared in 504 * the global namespace. 505 * 506 * Params: 507 * callbackName = The name of the callback, as expected in the XML 508 * callbackSymbol = The callback pointer 509 * 510 * Since: 3.10 511 */ 512 public void addCallbackSymbol(string callbackName, GCallback callbackSymbol) 513 { 514 gtk_builder_add_callback_symbol(gtkBuilder, Str.toStringz(callbackName), callbackSymbol); 515 } 516 517 /** 518 * Parses a file containing a [GtkBuilder UI definition][BUILDER-UI] 519 * and merges it with the current contents of @builder. 520 * 521 * Most users will probably want to use gtk_builder_new_from_file(). 522 * 523 * If an error occurs, 0 will be returned and @error will be assigned a 524 * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_FILE_ERROR 525 * domain. 526 * 527 * It’s not really reasonable to attempt to handle failures of this 528 * call. You should not use this function with untrusted files (ie: 529 * files that are not part of your application). Broken #GtkBuilder 530 * files can easily crash your program, and it’s possible that memory 531 * was leaked leading up to the reported failure. The only reasonable 532 * thing to do when an error is detected is to call g_error(). 533 * 534 * Params: 535 * filename = the name of the file to parse 536 * 537 * Returns: A positive value on success, 0 if an error occurred 538 * 539 * Since: 2.12 540 * 541 * Throws: GException on failure. 542 */ 543 public uint addFromFile(string filename) 544 { 545 GError* err = null; 546 547 auto p = gtk_builder_add_from_file(gtkBuilder, Str.toStringz(filename), &err); 548 549 if (err !is null) 550 { 551 throw new GException( new ErrorG(err) ); 552 } 553 554 return p; 555 } 556 557 /** 558 * Parses a resource file containing a [GtkBuilder UI definition][BUILDER-UI] 559 * and merges it with the current contents of @builder. 560 * 561 * Most users will probably want to use gtk_builder_new_from_resource(). 562 * 563 * If an error occurs, 0 will be returned and @error will be assigned a 564 * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_RESOURCE_ERROR 565 * domain. 566 * 567 * It’s not really reasonable to attempt to handle failures of this 568 * call. The only reasonable thing to do when an error is detected is 569 * to call g_error(). 570 * 571 * Params: 572 * resourcePath = the path of the resource file to parse 573 * 574 * Returns: A positive value on success, 0 if an error occurred 575 * 576 * Since: 3.4 577 * 578 * Throws: GException on failure. 579 */ 580 public uint addFromResource(string resourcePath) 581 { 582 GError* err = null; 583 584 auto p = gtk_builder_add_from_resource(gtkBuilder, Str.toStringz(resourcePath), &err); 585 586 if (err !is null) 587 { 588 throw new GException( new ErrorG(err) ); 589 } 590 591 return p; 592 } 593 594 /** 595 * Parses a string containing a [GtkBuilder UI definition][BUILDER-UI] 596 * and merges it with the current contents of @builder. 597 * 598 * Most users will probably want to use gtk_builder_new_from_string(). 599 * 600 * Upon errors 0 will be returned and @error will be assigned a 601 * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or 602 * #G_VARIANT_PARSE_ERROR domain. 603 * 604 * It’s not really reasonable to attempt to handle failures of this 605 * call. The only reasonable thing to do when an error is detected is 606 * to call g_error(). 607 * 608 * Params: 609 * buffer = the string to parse 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 }