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  * Conversion parameters:
26  * inFile  = GInitable.html
27  * outPack = gio
28  * outFile = InitableIF
29  * strct   = GInitable
30  * realStrct=
31  * ctorStrct=
32  * clss    = InitableT
33  * interf  = InitableIF
34  * class Code: No
35  * interface Code: No
36  * template for:
37  * extend  = 
38  * implements:
39  * prefixes:
40  * 	- g_initable_
41  * omit structs:
42  * omit prefixes:
43  * omit code:
44  * omit signals:
45  * imports:
46  * 	- glib.Str
47  * 	- glib.ErrorG
48  * 	- glib.GException
49  * 	- gobject.ObjectG
50  * 	- gio.Cancellable
51  * structWrap:
52  * 	- GCancellable* -> Cancellable
53  * 	- GObject* -> ObjectG
54  * module aliases:
55  * local aliases:
56  * overrides:
57  */
58 
59 module gio.InitableIF;
60 
61 public  import gtkc.giotypes;
62 
63 private import gtkc.gio;
64 private import glib.ConstructionException;
65 private import gobject.ObjectG;
66 
67 
68 private import glib.Str;
69 private import glib.ErrorG;
70 private import glib.GException;
71 private import gobject.ObjectG;
72 private import gio.Cancellable;
73 
74 
75 
76 
77 /**
78  * Description
79  * GInitable is implemented by objects that can fail during
80  * initialization. If an object implements this interface the
81  * g_initable_init() function must be called as the first thing
82  * after construction. If g_initable_init() is not called, or if
83  * it returns an error, all further operations on the object
84  * should fail, generally with a G_IO_ERROR_NOT_INITIALIZED error.
85  * Users of objects implementing this are not intended to use
86  * the interface method directly, instead it will be used automatically
87  * in various ways. For C applications you generally just call
88  * g_initable_new() directly, or indirectly via a foo_thing_new() wrapper.
89  * This will call g_initable_init() under the cover, returning NULL and
90  * setting a GError on failure (at which point the instance is
91  * unreferenced).
92  * For bindings in languages where the native constructor supports
93  * exceptions the binding could check for objects implemention GInitable
94  * during normal construction and automatically initialize them, throwing
95  * an exception on failure.
96  */
97 public interface InitableIF
98 {
99 	
100 	
101 	public GInitable* getInitableTStruct();
102 	
103 	/** the main Gtk struct as a void* */
104 	protected void* getStruct();
105 	
106 	
107 	/**
108 	 */
109 	
110 	/**
111 	 * Initializes the object implementing the interface. This must be
112 	 * done before any real use of the object after initial construction.
113 	 * Implementations may also support cancellation. If cancellable is not NULL,
114 	 * then initialization can be cancelled by triggering the cancellable object
115 	 * from another thread. If the operation was cancelled, the error
116 	 * G_IO_ERROR_CANCELLED will be returned. If cancellable is not NULL and
117 	 * the object doesn't support cancellable initialization the error
118 	 * G_IO_ERROR_NOT_SUPPORTED will be returned.
119 	 * If this function is not called, or returns with an error then all
120 	 * operations on the object should fail, generally returning the
121 	 * error G_IO_ERROR_NOT_INITIALIZED.
122 	 * Implementations of this method must be idempotent, i.e. multiple calls
123 	 * to this function with the same argument should return the same results.
124 	 * Only the first call initializes the object, further calls return the result
125 	 * of the first call. This is so that its safe to implement the singleton
126 	 * pattern in the GObject constructor function.
127 	 * Since 2.22
128 	 * Params:
129 	 * cancellable = optional GCancellable object, NULL to ignore.
130 	 * Returns: TRUE if successful. If an error has occurred, this function will return FALSE and set error appropriately if present.
131 	 * Throws: GException on failure.
132 	 */
133 	public int init(Cancellable cancellable);
134 	
135 	/**
136 	 * Helper function for constructing GInitiable object. This is
137 	 * similar to g_object_new_valist() but also initializes the object
138 	 * and returns NULL, setting an error on failure.
139 	 * Since 2.22
140 	 * Params:
141 	 * objectType = a GType supporting GInitable.
142 	 * firstPropertyName = the name of the first property, followed by
143 	 * the value, and other property value pairs, and ended by NULL.
144 	 * varArgs = The var args list generated from first_property_name.
145 	 * cancellable = optional GCancellable object, NULL to ignore.
146 	 * Returns: a newly allocated GObject, or NULL on error. [transfer full]
147 	 * Throws: GException on failure.
148 	 */
149 	public static ObjectG newValist(GType objectType, string firstPropertyName, void* varArgs, Cancellable cancellable);
150 	
151 	/**
152 	 * Helper function for constructing GInitiable object. This is
153 	 * similar to g_object_newv() but also initializes the object
154 	 * and returns NULL, setting an error on failure.
155 	 * Since 2.22
156 	 * Params:
157 	 * objectType = a GType supporting GInitable.
158 	 * parameters = the parameters to use to construct the object
159 	 * cancellable = optional GCancellable object, NULL to ignore.
160 	 * Returns: a newly allocated GObject, or NULL on error. [transfer full]
161 	 * Throws: GException on failure.
162 	 */
163 	public static void* newv(GType objectType, GParameter[] parameters, Cancellable cancellable);
164 }