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 gio.InitableIF;
26 
27 private import gio.Cancellable;
28 private import gio.c.functions;
29 public  import gio.c.types;
30 private import glib.ConstructionException;
31 private import glib.ErrorG;
32 private import glib.GException;
33 private import glib.Str;
34 private import gobject.ObjectG;
35 public  import gtkc.giotypes;
36 
37 
38 /**
39  * #GInitable is implemented by objects that can fail during
40  * initialization. If an object implements this interface then
41  * it must be initialized as the first thing after construction,
42  * either via g_initable_init() or g_async_initable_init_async()
43  * (the latter is only available if it also implements #GAsyncInitable).
44  * 
45  * If the object is not initialized, or initialization returns with an
46  * error, then all operations on the object except g_object_ref() and
47  * g_object_unref() are considered to be invalid, and have undefined
48  * behaviour. They will often fail with g_critical() or g_warning(), but
49  * this must not be relied on.
50  * 
51  * Users of objects implementing this are not intended to use
52  * the interface method directly, instead it will be used automatically
53  * in various ways. For C applications you generally just call
54  * g_initable_new() directly, or indirectly via a foo_thing_new() wrapper.
55  * This will call g_initable_init() under the cover, returning %NULL and
56  * setting a #GError on failure (at which point the instance is
57  * unreferenced).
58  * 
59  * For bindings in languages where the native constructor supports
60  * exceptions the binding could check for objects implemention %GInitable
61  * during normal construction and automatically initialize them, throwing
62  * an exception on failure.
63  *
64  * Since: 2.22
65  */
66 public interface InitableIF{
67 	/** Get the main Gtk struct */
68 	public GInitable* getInitableStruct(bool transferOwnership = false);
69 
70 	/** the main Gtk struct as a void* */
71 	protected void* getStruct();
72 
73 
74 	/** */
75 	public static GType getType()
76 	{
77 		return g_initable_get_type();
78 	}
79 
80 	/**
81 	 * Initializes the object implementing the interface.
82 	 *
83 	 * This method is intended for language bindings. If writing in C,
84 	 * g_initable_new() should typically be used instead.
85 	 *
86 	 * The object must be initialized before any real use after initial
87 	 * construction, either with this function or g_async_initable_init_async().
88 	 *
89 	 * Implementations may also support cancellation. If @cancellable is not %NULL,
90 	 * then initialization can be cancelled by triggering the cancellable object
91 	 * from another thread. If the operation was cancelled, the error
92 	 * %G_IO_ERROR_CANCELLED will be returned. If @cancellable is not %NULL and
93 	 * the object doesn't support cancellable initialization the error
94 	 * %G_IO_ERROR_NOT_SUPPORTED will be returned.
95 	 *
96 	 * If the object is not initialized, or initialization returns with an
97 	 * error, then all operations on the object except g_object_ref() and
98 	 * g_object_unref() are considered to be invalid, and have undefined
99 	 * behaviour. See the [introduction][ginitable] for more details.
100 	 *
101 	 * Callers should not assume that a class which implements #GInitable can be
102 	 * initialized multiple times, unless the class explicitly documents itself as
103 	 * supporting this. Generally, a class’ implementation of init() can assume
104 	 * (and assert) that it will only be called once. Previously, this documentation
105 	 * recommended all #GInitable implementations should be idempotent; that
106 	 * recommendation was relaxed in GLib 2.54.
107 	 *
108 	 * If a class explicitly supports being initialized multiple times, it is
109 	 * recommended that the method is idempotent: multiple calls with the same
110 	 * arguments should return the same results. Only the first call initializes
111 	 * the object; further calls return the result of the first call.
112 	 *
113 	 * One reason why a class might need to support idempotent initialization is if
114 	 * it is designed to be used via the singleton pattern, with a
115 	 * #GObjectClass.constructor that sometimes returns an existing instance.
116 	 * In this pattern, a caller would expect to be able to call g_initable_init()
117 	 * on the result of g_object_new(), regardless of whether it is in fact a new
118 	 * instance.
119 	 *
120 	 * Params:
121 	 *     cancellable = optional #GCancellable object, %NULL to ignore.
122 	 *
123 	 * Returns: %TRUE if successful. If an error has occurred, this function will
124 	 *     return %FALSE and set @error appropriately if present.
125 	 *
126 	 * Since: 2.22
127 	 *
128 	 * Throws: GException on failure.
129 	 */
130 	public bool init(Cancellable cancellable);
131 }