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