gtkD/src/glade/Glade.d

   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 as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * gtkD is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with gtkD; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 /*
  24  * Conversion parameters:
  25  * inFile  = GladeXML.html
  26  * outPack = glade
  27  * outFile = Glade
  28  * strct   = GladeXML
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = Glade
  32  * interf  =
  33  * class Code: Yes
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - glade_xml_
  40  * omit structs:
  41  * omit prefixes:
  42  * omit code:
  43  *      - glade_xml_signal_autoconnect
  44  *      - glade_xml_signal_connect_data
  45  *      - glade_xml_signal_connect
  46  *      - glade_xml_signal_connect_full
  47  *      - glade_xml_signal_autoconnect_full
  48  *      - GladeXMLConnectFunc
  49  *      - GladeXMLCustomWidgetHandler
  50  *      - glade_set_custom_handler
  51  *      - glade_xml_get_widget
  52  *      - glade_xml_new
  53  *      - glade_xml_get_widget_prefix
  54  * imports:
  55  *      - gtk.Widget
  56  *      - gobject.ObjectG
  57  *      - glib.ListG
  58  *      - glib.Str
  59  * structWrap:
  60  *      - GList* -> ListG
  61  *      - GObject* -> ObjectG
  62  *      - GladeXML* -> Glade
  63  *      - GtkWidget* -> Widget
  64  * module aliases:
  65  * local aliases:
  66  */
  67
  68 module glade.Glade;
  69
  70 version(noAssert)
  71 {
  72         version(Tango)
  73         {
  74                 import tango.io.Stdout; // use the tango loging?
  75         }
  76 }
  77
  78 private import gtkc.gladetypes;
  79
  80 private import gtkc.glade;
  81
  82
  83 private import gtk.Widget;
  84 private import gobject.ObjectG;
  85 private import glib.ListG;
  86 private import glib.Str;
  87
  88
  89
  90
  91 /**
  92  * Description
  93  * This object represents an `instantiation' of an XML interface description.
  94  * When one of these objects is created, the XML file is read, and the
  95  * interface is created. The GladeXML object then provides an interface for
  96  * accessing the widgets in the interface by the names assigned to them
  97  * inside the XML description.
  98  * The GladeXML object can also be used to connect handlers to the named
  99  * signals in the description. Libglade also provides an interface by which
 100  * it can look up the signal handler names in the program's symbol table and
 101  * automatically connect as many handlers up as it can that way.
 102  */
 103 private import gobject.ObjectG;
 104 public class Glade : ObjectG
 105 {
 106
 107         /** the main Gtk struct */
 108         protected GladeXML* gladeXML;
 109
 110
 111         public GladeXML* getGladeStruct()
 112         {
 113                 return gladeXML;
 114         }
 115
 116
 117         /** the main Gtk struct as a void* */
 118         protected void* getStruct()
 119         {
 120                 return cast(void*)gladeXML;
 121         }
 122
 123         /**
 124          * Sets our main struct and passes it to the parent class
 125          */
 126         public this (GladeXML* gladeXML)
 127         {
 128                 version(noAssert)
 129                 {
 130                         if ( gladeXML is null )
 131                         {
 132                                 int zero = 0;
 133                                 version(Tango)
 134                                 {
 135                                         Stdout("struct gladeXML is null on constructor").newline;
 136                                 }
 137                                 else
 138                                 {
 139                                         printf("struct gladeXML is null on constructor");
 140                                 }
 141                                 zero = zero / zero;
 142                         }
 143                 }
 144                 else
 145                 {
 146                         assert(gladeXML !is null, "struct gladeXML is null on constructor");
 147                 }
 148                 super(cast(GObject*)gladeXML);
 149                 this.gladeXML = gladeXML;
 150         }
 151
 152         /**
 153          * This function is used to get a pointer to the GtkWidget corresponding to
 154          * name in the interface description. You would use this if you have to do
 155          * anything to the widget after loading.
 156          * self:
 157          *  the GladeXML object.
 158          * name:
 159          *  the name of the widget.
 160          * Returns:
 161          *  the widget matching name, or NULL if none exists.
 162          */
 163         public Widget getWidget(char[] name)
 164         {
 165                 // GtkWidget* glade_xml_get_widget (GladeXML *self,  const char *name);
 166                 return newFromWidget(cast(void *) glade_xml_get_widget(gladeXML, Str.toStringz(name)) );
 167         }
 168
 169
 170
 171
 172
 173
 174         /**
 175          * Creates a new GladeXML object (and the corresponding widgets) from the
 176          * XML file fname. Optionally it will only build the interface from the
 177          * widget node root (if it is not NULL). This feature is useful if you
 178          * only want to build say a toolbar or menu from the XML file, but not the
 179          * window it is embedded in. Note also that the XML parse tree is cached
 180          * to speed up creating another GladeXML object for the same file
 181          * fname:
 182          *  the XML file name.
 183          * root:
 184          *  the widget node in fname to start building from (or NULL)
 185          * domain:
 186          *  the translation domain for the XML file (or NULL for default)
 187          * Returns:
 188          *  the newly created GladeXML object, or NULL on failure.
 189          */
 190         public this (char[] fname, char[] root = null, char[] domain=null)
 191         {
 192                 // GladeXML* glade_xml_new (const char *fname,  const char *root,  const char *domain);
 193                 this(cast(GladeXML*)glade_xml_new(Str.toStringz(fname),
 194                 root ? Str.toStringz(root) : null,
 195                 domain ? Str.toStringz(domain) : null) );
 196         }
 197
 198         /**
 199          * This function is used to get a list of pointers to the GtkWidget(s)
 200          * with names that start with the string name in the interface description.
 201          * You would use this if you have to do something to all of these widgets
 202          * after loading.
 203          * self:
 204          *  the GladeXML object.
 205          * name:
 206          *  the name of the widget.
 207          * Returns:
 208          *  A list of the widget that match name as the start of their
 209          * name, or NULL if none exists.
 210          */
 211         public Widget[] getWidgetPrefix(char[] name)
 212         {
 213                 // GList* glade_xml_get_widget_prefix (GladeXML *self,  const char *name);
 214                 Widget[] ret;
 215                 ListG widgets = new ListG( glade_xml_get_widget_prefix(gladeXML, Str.toStringz(name)) );
 216                 for (int i=0;i < widgets.length; i++) {
 217                         ret ~= newFromWidget( cast(void *)widgets.nthData(i) );
 218                 }
 219                 return widgets.length ? ret : null;
 220         }
 221
 222
 223         /**
 224          * Utilitiy method to create objects that are castable.
 225          *
 226          */
 227         private import gobject.Type;
 228         private import gtk.Container;
 229         private import gtk.Bin;
 230         private import gtk.Window;
 231         private import gtk.Dialog;
 232         private import gtk.AboutDialog;
 233         private import gtk.ColorSelectionDialog;
 234         private import gtk.FileChooserDialog;
 235         private import gtk.FileSelection;
 236         private import gtk.FontSelectionDialog;
 237         private import gtk.InputDialog;
 238         private import gtk.MessageDialog;
 239         //private import gtk.PageSetupUnixDialog;
 240         //private import gtk.PrintUnixDialog;
 241         //private import gtk.RecentChooserDialog;
 242         private import gtk.Assistant;
 243         private import gtk.Plug;
 244         private import gtk.Alignment;
 245         private import gtk.Frame;
 246         private import gtk.AspectFrame;
 247         private import gtk.Button;
 248         private import gtk.ToggleButton;
 249         private import gtk.CheckButton;
 250         private import gtk.RadioButton;
 251         private import gtk.ColorButton;
 252         private import gtk.FontButton;
 253         //private import gtk.LinkButton;
 254         //private import gtk.OptionMenu;
 255         private import gtk.Item;
 256         private import gtk.MenuItem;
 257         private import gtk.CheckMenuItem;
 258         private import gtk.RadioMenuItem;
 259         private import gtk.ImageMenuItem;
 260         private import gtk.SeparatorMenuItem;
 261         private import gtk.TearoffMenuItem;
 262         //private import gtk.ListItem;
 263         //private import gtk.TreeItem;
 264         private import gtk.ComboBox;
 265         private import gtk.ComboBoxEntry;
 266         private import gtk.EventBox;
 267         private import gtk.Expander;
 268         private import gtk.HandleBox;
 269         private import gtk.ToolItem;
 270         private import gtk.ToolButton;
 271         private import gtk.MenuToolButton;
 272         private import gtk.ToggleToolButton;
 273         private import gtk.RadioToolButton;
 274         private import gtk.SeparatorToolItem;
 275         private import gtk.ScrolledWindow;
 276         private import gtk.Viewport;
 277         private import gtk.Box;
 278         private import gtk.ButtonBox;
 279         private import gtk.HButtonBox;
 280         private import gtk.VButtonBox;
 281         private import gtk.VBox;
 282         private import gtk.ColorSelection;
 283         private import gtk.FileChooserWidget;
 284         private import gtk.FontSelection;
 285         private import gtk.GammaCurve;
 286         //private import gtk.RecentChooserWidget;
 287         private import gtk.HBox;
 288         //private import gtk.Combo;
 289         private import gtk.FileChooserButton;
 290         private import gtk.Statusbar;
 291         //private import gtk.CList;
 292         //private import gtk.CTree;
 293         private import gtk.Fixed;
 294         private import gtk.Paned;
 295         private import gtk.HPaned;
 296         private import gtk.VPaned;
 297         private import gtk.IconView;
 298         private import gtk.Layout;
 299         //private import gtk.List;
 300         private import gtk.MenuShell;
 301         private import gtk.MenuBar;
 302         private import gtk.Menu;
 303         //private import gtk.RecentChooserMenu;
 304         private import gtk.Notebook;
 305         private import gtk.Socket;
 306         private import gtk.Table;
 307         private import gtk.TextView;
 308         private import gtk.Toolbar;
 309         //private import gtk.Tree;
 310         private import gtk.TreeView;
 311         private import gtk.Misc;
 312         private import gtk.Label;
 313         private import gtk.AccelLabel;
 314         //private import gtk.TipsQuery;
 315         private import gtk.Arrow;
 316         private import gtk.Image;
 317         //private import gtk.Pixmap;
 318         private import gtk.Calendar;
 319         private import gtk.CellView;
 320         private import gtk.DrawingArea;
 321         private import gtk.Curve;
 322         private import gtk.Entry;
 323         private import gtk.SpinButton;
 324         private import gtk.Ruler;
 325         private import gtk.HRuler;
 326         private import gtk.VRuler;
 327         private import gtk.Range;
 328         private import gtk.Scale;
 329         private import gtk.HScale;
 330         private import gtk.VScale;
 331         private import gtk.Scrollbar;
 332         private import gtk.HScrollbar;
 333         private import gtk.VScrollbar;
 334         private import gtk.Separator;
 335         private import gtk.HSeparator;
 336         private import gtk.VSeparator;
 337         private import gtk.Invisible;
 338         //private import gtk.OldEditable;
 339         //private import gtk.Text;
 340         //private import gtk.Preview;
 341         private import gtk.Progress;
 342         private import gtk.ProgressBar;
 343
 344         Widget newFromWidget(void * ptr)
 345         {
 346                 if (ptr is null) {
 347                         return null;
 348                 }
 349
 350                 int* pt =cast(int*)ptr;
 351
 352                 int* pt2 =cast(int*) (cast(int*)(*pt));
 353                 uint utype =  cast(uint)(*pt2);
 354
 355                 char[] tname = Type.name(cast(GType)utype);
 356
 357                 switch(tname) {
 358                         case "GtkContainer": return new Container(cast(GtkContainer *)ptr);
 359                         case "GtkBin": return new Bin(cast(GtkBin *)ptr);
 360                         case "GtkWindow": return new Window(cast(GtkWindow *)ptr);
 361                         case "GtkDialog": return new Dialog(cast(GtkDialog *)ptr);
 362                         case "GtkAboutDialog": return new AboutDialog(cast(GtkAboutDialog *)ptr);
 363                         case "GtkColorSelectionDialog": return new ColorSelectionDialog(cast(GtkColorSelectionDialog *)ptr);
 364                         case "GtkFileChooserDialog": return new FileChooserDialog(cast(GtkFileChooserDialog *)ptr);
 365                         case "GtkFileSelection": return new FileSelection(cast(GtkFileSelection *)ptr);
 366                         case "GtkFontSelectionDialog": return new FontSelectionDialog(cast(GtkFontSelectionDialog *)ptr);
 367                         case "GtkInputDialog": return new InputDialog(cast(GtkInputDialog *)ptr);
 368                         case "GtkMessageDialog": return new MessageDialog(cast(GtkMessageDialog *)ptr);
 369                         //case "GtkPageSetupUnixDialog": return new PageSetupUnixDialog(cast(GtkPageSetupUnixDialog *)ptr);
 370                         //case "GtkPrintUnixDialog": return new PrintUnixDialog(cast(GtkPrintUnixDialog *)ptr);
 371                         //case "GtkRecentChooserDialog": return new RecentChooserDialog(cast(GtkRecentChooserDialog *)ptr);
 372                         case "GtkAssistant": return new Assistant(cast(GtkAssistant *)ptr);
 373                         case "GtkPlug": return new Plug(cast(GtkPlug *)ptr);
 374                         case "GtkAlignment": return new Alignment(cast(GtkAlignment *)ptr);
 375                         case "GtkFrame": return new Frame(cast(GtkFrame *)ptr);
 376                         case "GtkAspectFrame": return new AspectFrame(cast(GtkAspectFrame *)ptr);
 377                         case "GtkButton": return new Button(cast(GtkButton *)ptr);
 378                         case "GtkToggleButton": return new ToggleButton(cast(GtkToggleButton *)ptr);
 379                         case "GtkCheckButton": return new CheckButton(cast(GtkCheckButton *)ptr);
 380                         case "GtkRadioButton": return new RadioButton(cast(GtkRadioButton *)ptr);
 381                         case "GtkColorButton": return new ColorButton(cast(GtkColorButton *)ptr);
 382                         case "GtkFontButton": return new FontButton(cast(GtkFontButton *)ptr);
 383                         //case "GtkLinkButton": return new LinkButton(cast(GtkLinkButton *)ptr);
 384                         //case "GtkOptionMenu": return new OptionMenu(cast(GtkOptionMenu *)ptr);
 385                         case "GtkItem": return new Item(cast(GtkItem *)ptr);
 386                         case "GtkMenuItem": return new MenuItem(cast(GtkMenuItem *)ptr);
 387                         case "GtkCheckMenuItem": return new CheckMenuItem(cast(GtkCheckMenuItem *)ptr);
 388                         case "GtkRadioMenuItem": return new RadioMenuItem(cast(GtkRadioMenuItem *)ptr);
 389                         case "GtkImageMenuItem": return new ImageMenuItem(cast(GtkImageMenuItem *)ptr);
 390                         case "GtkSeparatorMenuItem": return new SeparatorMenuItem(cast(GtkSeparatorMenuItem *)ptr);
 391                         case "GtkTearoffMenuItem": return new TearoffMenuItem(cast(GtkTearoffMenuItem *)ptr);
 392                         //case "GtkListItem": return new ListItem(cast(GtkListItem *)ptr);
 393                         //case "GtkTreeItem": return new TreeItem(cast(GtkTreeItem *)ptr);
 394                         case "GtkComboBox": return new ComboBox(cast(GtkComboBox *)ptr);
 395                         case "GtkComboBoxEntry": return new ComboBoxEntry(cast(GtkComboBoxEntry *)ptr);
 396                         case "GtkEventBox": return new EventBox(cast(GtkEventBox *)ptr);
 397                         case "GtkExpander": return new Expander(cast(GtkExpander *)ptr);
 398                         case "GtkHandleBox": return new HandleBox(cast(GtkHandleBox *)ptr);
 399                         case "GtkToolItem": return new ToolItem(cast(GtkToolItem *)ptr);
 400                         case "GtkToolButton": return new ToolButton(cast(GtkToolButton *)ptr);
 401                         case "GtkMenuToolButton": return new MenuToolButton(cast(GtkMenuToolButton *)ptr);
 402                         case "GtkToggleToolButton": return new ToggleToolButton(cast(GtkToggleToolButton *)ptr);
 403                         case "GtkRadioToolButton": return new RadioToolButton(cast(GtkRadioToolButton *)ptr);
 404                         case "GtkSeparatorToolItem": return new SeparatorToolItem(cast(GtkSeparatorToolItem *)ptr);
 405                         case "GtkScrolledWindow": return new ScrolledWindow(cast(GtkScrolledWindow *)ptr);
 406                         case "GtkViewport": return new Viewport(cast(GtkViewport *)ptr);
 407                         case "GtkBox": return new Box(cast(GtkBox *)ptr);
 408                         case "GtkButtonBox": return new ButtonBox(cast(GtkButtonBox *)ptr);
 409                         case "GtkHButtonBox": return new HButtonBox(cast(GtkHButtonBox *)ptr);
 410                         case "GtkVButtonBox": return new VButtonBox(cast(GtkVButtonBox *)ptr);
 411                         case "GtkVBox": return new VBox(cast(GtkVBox *)ptr);
 412                         case "GtkColorSelection": return new ColorSelection(cast(GtkColorSelection *)ptr);
 413                         case "GtkFileChooserWidget": return new FileChooserWidget(cast(GtkFileChooserWidget *)ptr);
 414                         case "GtkFontSelection": return new FontSelection(cast(GtkFontSelection *)ptr);
 415                         case "GtkGammaCurve": return new GammaCurve(cast(GtkGammaCurve *)ptr);
 416                         //case "GtkRecentChooserWidget": return new RecentChooserWidget(cast(GtkRecentChooserWidget *)ptr);
 417                         case "GtkHBox": return new HBox(cast(GtkHBox *)ptr);
 418                         //case "GtkCombo": return new Combo(cast(GtkCombo *)ptr);
 419                         case "GtkFileChooserButton": return new FileChooserButton(cast(GtkFileChooserButton *)ptr);
 420                         case "GtkStatusbar": return new Statusbar(cast(GtkStatusbar *)ptr);
 421                         //case "GtkCList": return new CList(cast(GtkCList *)ptr);
 422                         //case "GtkCTree": return new CTree(cast(GtkCTree *)ptr);
 423                         case "GtkFixed": return new Fixed(cast(GtkFixed *)ptr);
 424                         case "GtkPaned": return new Paned(cast(GtkPaned *)ptr);
 425                         case "GtkHPaned": return new HPaned(cast(GtkHPaned *)ptr);
 426                         case "GtkVPaned": return new VPaned(cast(GtkVPaned *)ptr);
 427                         case "GtkIconView": return new IconView(cast(GtkIconView *)ptr);
 428                         case "GtkLayout": return new Layout(cast(GtkLayout *)ptr);
 429                         //case "GtkList": return new List(cast(GtkList *)ptr);
 430                         case "GtkMenuShell": return new MenuShell(cast(GtkMenuShell *)ptr);
 431                         case "GtkMenuBar": return new MenuBar(cast(GtkMenuBar *)ptr);
 432                         case "GtkMenu": return new Menu(cast(GtkMenu *)ptr);
 433                         //case "GtkRecentChooserMenu": return new RecentChooserMenu(cast(GtkRecentChooserMenu *)ptr);
 434                         case "GtkNotebook": return new Notebook(cast(GtkNotebook *)ptr);
 435                         case "GtkSocket": return new Socket(cast(GtkSocket *)ptr);
 436                         case "GtkTable": return new Table(cast(GtkTable *)ptr);
 437                         case "GtkTextView": return new TextView(cast(GtkTextView *)ptr);
 438                         case "GtkToolbar": return new Toolbar(cast(GtkToolbar *)ptr);
 439                         //case "GtkTree": return new Tree(cast(GtkTree *)ptr);
 440                         case "GtkTreeView": return new TreeView(cast(GtkTreeView *)ptr);
 441                         case "GtkMisc": return new Misc(cast(GtkMisc *)ptr);
 442                         case "GtkLabel": return new Label(cast(GtkLabel *)ptr);
 443                         case "GtkAccelLabel": return new AccelLabel(cast(GtkAccelLabel *)ptr);
 444                         //case "GtkTipsQuery": return new TipsQuery(cast(GtkTipsQuery *)ptr);
 445                         case "GtkArrow": return new Arrow(cast(GtkArrow *)ptr);
 446                         case "GtkImage": return new Image(cast(GtkImage *)ptr);
 447                         //case "GtkPixmap": return new Pixmap(cast(GtkPixmap *)ptr);
 448                         case "GtkCalendar": return new Calendar(cast(GtkCalendar *)ptr);
 449                         case "GtkCellView": return new CellView(cast(GtkCellView *)ptr);
 450                         case "GtkDrawingArea": return new DrawingArea(cast(GtkDrawingArea *)ptr);
 451                         case "GtkCurve": return new Curve(cast(GtkCurve *)ptr);
 452                         case "GtkEntry": return new Entry(cast(GtkEntry *)ptr);
 453                         case "GtkSpinButton": return new SpinButton(cast(GtkSpinButton *)ptr);
 454                         case "GtkRuler": return new Ruler(cast(GtkRuler *)ptr);
 455                         case "GtkHRuler": return new HRuler(cast(GtkHRuler *)ptr);
 456                         case "GtkVRuler": return new VRuler(cast(GtkVRuler *)ptr);
 457                         case "GtkRange": return new Range(cast(GtkRange *)ptr);
 458                         case "GtkScale": return new Scale(cast(GtkScale *)ptr);
 459                         case "GtkHScale": return new HScale(cast(GtkHScale *)ptr);
 460                         case "GtkVScale": return new VScale(cast(GtkVScale *)ptr);
 461                         case "GtkScrollbar": return new Scrollbar(cast(GtkScrollbar *)ptr);
 462                         case "GtkHScrollbar": return new HScrollbar(cast(GtkHScrollbar *)ptr);
 463                         case "GtkVScrollbar": return new VScrollbar(cast(GtkVScrollbar *)ptr);
 464                         case "GtkSeparator": return new Separator(cast(GtkSeparator *)ptr);
 465                         case "GtkHSeparator": return new HSeparator(cast(GtkHSeparator *)ptr);
 466                         case "GtkVSeparator": return new VSeparator(cast(GtkVSeparator *)ptr);
 467                         case "GtkInvisible": return new Invisible(cast(GtkInvisible *)ptr);
 468                         //case "GtkOldEditable": return new OldEditable(cast(GtkOldEditable *)ptr);
 469                         //case "GtkText": return new Text(cast(GtkText *)ptr);
 470                         //case "GtkPreview": return new Preview(cast(GtkPreview *)ptr);
 471                         case "GtkProgress": return new Progress(cast(GtkProgress *)ptr);
 472                         case "GtkProgressBar": return new ProgressBar(cast(GtkProgressBar *)ptr);
 473                         default: return null;
 474                 }
 475
 476         }
 477
 478
 479
 480
 481
 482
 483
 484
 485         /**
 486          * Description
 487          * These routines are used to initialise libglade, and to load addon modules
 488          * that recognise extra widget sets. The glade_init
 489          * routine must be called before any libglade routines are used, and the
 490          * glade_load_module routine would be used to load
 491          * extra modules.
 492          */
 493
 494
 495
 496
 497         /**
 498          * Creates a new GladeXML object (and the corresponding widgets) from the
 499          * buffer buffer. Optionally it will only build the interface from the
 500          * widget node root (if it is not NULL). This feature is useful if you
 501          * only want to build say a toolbar or menu from the XML document, but not the
 502          * window it is embedded in.
 503          * buffer:
 504          *  the memory buffer containing the XML document.
 505          * size:
 506          *  the size of the buffer.
 507          * root:
 508          *  the widget node in buffer to start building from (or NULL)
 509          * domain:
 510          *  the translation domain to use for this interface (or NULL)
 511          * Returns:
 512          *  the newly created GladeXML object, or NULL on failure.
 513          */
 514         public this (char[] buffer, int size, char[] root, char[] domain)
 515         {
 516                 // GladeXML* glade_xml_new_from_buffer (const char *buffer,  int size,  const char *root,  const char *domain);
 517                 this(cast(GladeXML*)glade_xml_new_from_buffer(Str.toStringz(buffer), size, Str.toStringz(root), Str.toStringz(domain)) );
 518         }
 519
 520         /**
 521          * This routine can be used by bindings (such as gtk--) to help construct
 522          * a GladeXML object, if it is needed.
 523          * self:
 524          *  the GladeXML object
 525          * fname:
 526          *  the XML filename
 527          * root:
 528          *  the root widget node (or NULL for none)
 529          * domain:
 530          *  the translation domain (or NULL for the default)
 531          * Returns:
 532          *  TRUE if the construction succeeded.
 533          */
 534         public int construct(char[] fname, char[] root, char[] domain)
 535         {
 536                 // gboolean glade_xml_construct (GladeXML *self,  const char *fname,  const char *root,  const char *domain);
 537                 return glade_xml_construct(gladeXML, Str.toStringz(fname), Str.toStringz(root), Str.toStringz(domain));
 538         }
 539
 540
 541
 542
 543
 544
 545         /**
 546          * Used to get the name of a widget that was generated by a GladeXML object.
 547          * widget:
 548          *  the widget
 549          * Returns:
 550          *  the name of the widget.
 551          */
 552         public static char[] gladeGetWidgetName(Widget widget)
 553         {
 554                 // const char* glade_get_widget_name (GtkWidget *widget);
 555                 return Str.toString(glade_get_widget_name((widget is null) ? null : widget.getWidgetStruct()) );
 556         }
 557
 558         /**
 559          * This function is used to get the GladeXML object that built this widget.
 560          * widget:
 561          *  the widget
 562          * Returns:
 563          *  the GladeXML object that built this widget.
 564          */
 565         public static Glade gladeGetWidgetTree(Widget widget)
 566         {
 567                 // GladeXML* glade_get_widget_tree (GtkWidget *widget);
 568                 return new Glade( glade_get_widget_tree((widget is null) ? null : widget.getWidgetStruct()) );
 569         }
 570
 571
 572
 573
 574
 575
 576         /**
 577          * It used to be necessary to call glade_init() before creating
 578          * GladeXML objects. This is now no longer the case, as libglade will
 579          * be initialised on demand now. Calling glade_init() manually will
 580          * not cause any problems though.
 581          */
 582         public static void init()
 583         {
 584                 // void glade_init (void);
 585                 glade_init();
 586         }
 587
 588         /**
 589          * Ensure that a required library is available. If it is not already
 590          * available, libglade will attempt to dynamically load a module that
 591          * contains the handlers for that library.
 592          * library:
 593          *  the required library
 594          */
 595         public static void require(char[] library)
 596         {
 597                 // void glade_require (const gchar *library);
 598                 glade_require(Str.toStringz(library));
 599         }
 600
 601         /**
 602          * This function should be called by a module to assert that it
 603          * provides wrappers for a particular library. This should be called
 604          * by the register_widgets() function of a libglade module so that it
 605          * isn't loaded twice, for instance.
 606          * library:
 607          *  the provided library
 608          */
 609         public static void provide(char[] library)
 610         {
 611                 // void glade_provide (const gchar *library);
 612                 glade_provide(Str.toStringz(library));
 613         }
 614 }