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.DBusInterfaceSkeleton;
26 
27 private import gio.DBusConnection;
28 private import gio.DBusInterfaceIF;
29 private import gio.DBusInterfaceInfo;
30 private import gio.DBusInterfaceT;
31 private import gio.DBusMethodInvocation;
32 private import glib.ErrorG;
33 private import glib.GException;
34 private import glib.ListG;
35 private import glib.Str;
36 private import glib.Variant;
37 private import gobject.ObjectG;
38 private import gobject.Signals;
39 private import gtkc.gio;
40 public  import gtkc.giotypes;
41 private import std.algorithm;
42 
43 
44 /**
45  * Abstract base class for D-Bus interfaces on the service side.
46  *
47  * Since: 2.30
48  */
49 public class DBusInterfaceSkeleton : ObjectG, DBusInterfaceIF
50 {
51 	/** the main Gtk struct */
52 	protected GDBusInterfaceSkeleton* gDBusInterfaceSkeleton;
53 
54 	/** Get the main Gtk struct */
55 	public GDBusInterfaceSkeleton* getDBusInterfaceSkeletonStruct()
56 	{
57 		return gDBusInterfaceSkeleton;
58 	}
59 
60 	/** the main Gtk struct as a void* */
61 	protected override void* getStruct()
62 	{
63 		return cast(void*)gDBusInterfaceSkeleton;
64 	}
65 
66 	protected override void setStruct(GObject* obj)
67 	{
68 		gDBusInterfaceSkeleton = cast(GDBusInterfaceSkeleton*)obj;
69 		super.setStruct(obj);
70 	}
71 
72 	/**
73 	 * Sets our main struct and passes it to the parent class.
74 	 */
75 	public this (GDBusInterfaceSkeleton* gDBusInterfaceSkeleton, bool ownedRef = false)
76 	{
77 		this.gDBusInterfaceSkeleton = gDBusInterfaceSkeleton;
78 		super(cast(GObject*)gDBusInterfaceSkeleton, ownedRef);
79 	}
80 
81 	// add the DBusInterface capabilities
82 	mixin DBusInterfaceT!(GDBusInterfaceSkeleton);
83 
84 
85 	/** */
86 	public static GType getType()
87 	{
88 		return g_dbus_interface_skeleton_get_type();
89 	}
90 
91 	/**
92 	 * Exports @interface_ at @object_path on @connection.
93 	 *
94 	 * This can be called multiple times to export the same @interface_
95 	 * onto multiple connections however the @object_path provided must be
96 	 * the same for all connections.
97 	 *
98 	 * Use g_dbus_interface_skeleton_unexport() to unexport the object.
99 	 *
100 	 * Params:
101 	 *     connection = A #GDBusConnection to export @interface_ on.
102 	 *     objectPath = The path to export the interface at.
103 	 *
104 	 * Returns: %TRUE if the interface was exported on @connection, otherwise %FALSE with
105 	 *     @error set.
106 	 *
107 	 * Since: 2.30
108 	 *
109 	 * Throws: GException on failure.
110 	 */
111 	public bool expor(DBusConnection connection, string objectPath)
112 	{
113 		GError* err = null;
114 		
115 		auto p = g_dbus_interface_skeleton_export(gDBusInterfaceSkeleton, (connection is null) ? null : connection.getDBusConnectionStruct(), Str.toStringz(objectPath), &err) != 0;
116 		
117 		if (err !is null)
118 		{
119 			throw new GException( new ErrorG(err) );
120 		}
121 		
122 		return p;
123 	}
124 
125 	/**
126 	 * If @interface_ has outstanding changes, request for these changes to be
127 	 * emitted immediately.
128 	 *
129 	 * For example, an exported D-Bus interface may queue up property
130 	 * changes and emit the
131 	 * `org.freedesktop.DBus.Properties::Propert``
132 	 * signal later (e.g. in an idle handler). This technique is useful
133 	 * for collapsing multiple property changes into one.
134 	 *
135 	 * Since: 2.30
136 	 */
137 	public void flush()
138 	{
139 		g_dbus_interface_skeleton_flush(gDBusInterfaceSkeleton);
140 	}
141 
142 	/**
143 	 * Gets the first connection that @interface_ is exported on, if any.
144 	 *
145 	 * Returns: A #GDBusConnection or %NULL if @interface_ is
146 	 *     not exported anywhere. Do not free, the object belongs to @interface_.
147 	 *
148 	 * Since: 2.30
149 	 */
150 	public DBusConnection getConnection()
151 	{
152 		auto p = g_dbus_interface_skeleton_get_connection(gDBusInterfaceSkeleton);
153 		
154 		if(p is null)
155 		{
156 			return null;
157 		}
158 		
159 		return ObjectG.getDObject!(DBusConnection)(cast(GDBusConnection*) p);
160 	}
161 
162 	/**
163 	 * Gets a list of the connections that @interface_ is exported on.
164 	 *
165 	 * Returns: A list of
166 	 *     all the connections that @interface_ is exported on. The returned
167 	 *     list should be freed with g_list_free() after each element has
168 	 *     been freed with g_object_unref().
169 	 *
170 	 * Since: 2.32
171 	 */
172 	public ListG getConnections()
173 	{
174 		auto p = g_dbus_interface_skeleton_get_connections(gDBusInterfaceSkeleton);
175 		
176 		if(p is null)
177 		{
178 			return null;
179 		}
180 		
181 		return new ListG(cast(GList*) p, true);
182 	}
183 
184 	/**
185 	 * Gets the #GDBusInterfaceSkeletonFlags that describes what the behavior
186 	 * of @interface_
187 	 *
188 	 * Returns: One or more flags from the #GDBusInterfaceSkeletonFlags enumeration.
189 	 *
190 	 * Since: 2.30
191 	 */
192 	public GDBusInterfaceSkeletonFlags getFlags()
193 	{
194 		return g_dbus_interface_skeleton_get_flags(gDBusInterfaceSkeleton);
195 	}
196 
197 	/**
198 	 * Gets D-Bus introspection information for the D-Bus interface
199 	 * implemented by @interface_.
200 	 *
201 	 * Returns: A #GDBusInterfaceInfo (never %NULL). Do not free.
202 	 *
203 	 * Since: 2.30
204 	 */
205 	public DBusInterfaceInfo getInfo()
206 	{
207 		auto p = g_dbus_interface_skeleton_get_info(gDBusInterfaceSkeleton);
208 		
209 		if(p is null)
210 		{
211 			return null;
212 		}
213 		
214 		return ObjectG.getDObject!(DBusInterfaceInfo)(cast(GDBusInterfaceInfo*) p);
215 	}
216 
217 	/**
218 	 * Gets the object path that @interface_ is exported on, if any.
219 	 *
220 	 * Returns: A string owned by @interface_ or %NULL if @interface_ is not exported
221 	 *     anywhere. Do not free, the string belongs to @interface_.
222 	 *
223 	 * Since: 2.30
224 	 */
225 	public string getObjectPath()
226 	{
227 		return Str.toString(g_dbus_interface_skeleton_get_object_path(gDBusInterfaceSkeleton));
228 	}
229 
230 	/**
231 	 * Gets all D-Bus properties for @interface_.
232 	 *
233 	 * Returns: A #GVariant of type
234 	 *     ['a{sv}'][G-VARIANT-TYPE-VARDICT:CAPS].
235 	 *     Free with g_variant_unref().
236 	 *
237 	 * Since: 2.30
238 	 */
239 	public Variant getProperties()
240 	{
241 		auto p = g_dbus_interface_skeleton_get_properties(gDBusInterfaceSkeleton);
242 		
243 		if(p is null)
244 		{
245 			return null;
246 		}
247 		
248 		return new Variant(cast(GVariant*) p, true);
249 	}
250 
251 	/**
252 	 * Gets the interface vtable for the D-Bus interface implemented by
253 	 * @interface_. The returned function pointers should expect @interface_
254 	 * itself to be passed as @user_data.
255 	 *
256 	 * Returns: A #GDBusInterfaceVTable (never %NULL).
257 	 *
258 	 * Since: 2.30
259 	 */
260 	public GDBusInterfaceVTable* getVtable()
261 	{
262 		return g_dbus_interface_skeleton_get_vtable(gDBusInterfaceSkeleton);
263 	}
264 
265 	/**
266 	 * Checks if @interface_ is exported on @connection.
267 	 *
268 	 * Params:
269 	 *     connection = A #GDBusConnection.
270 	 *
271 	 * Returns: %TRUE if @interface_ is exported on @connection, %FALSE otherwise.
272 	 *
273 	 * Since: 2.32
274 	 */
275 	public bool hasConnection(DBusConnection connection)
276 	{
277 		return g_dbus_interface_skeleton_has_connection(gDBusInterfaceSkeleton, (connection is null) ? null : connection.getDBusConnectionStruct()) != 0;
278 	}
279 
280 	/**
281 	 * Sets flags describing what the behavior of @skeleton should be.
282 	 *
283 	 * Params:
284 	 *     flags = Flags from the #GDBusInterfaceSkeletonFlags enumeration.
285 	 *
286 	 * Since: 2.30
287 	 */
288 	public void setFlags(GDBusInterfaceSkeletonFlags flags)
289 	{
290 		g_dbus_interface_skeleton_set_flags(gDBusInterfaceSkeleton, flags);
291 	}
292 
293 	/**
294 	 * Stops exporting @interface_ on all connections it is exported on.
295 	 *
296 	 * To unexport @interface_ from only a single connection, use
297 	 * g_dbus_interface_skeleton_unexport_from_connection()
298 	 *
299 	 * Since: 2.30
300 	 */
301 	public void unexport()
302 	{
303 		g_dbus_interface_skeleton_unexport(gDBusInterfaceSkeleton);
304 	}
305 
306 	/**
307 	 * Stops exporting @interface_ on @connection.
308 	 *
309 	 * To stop exporting on all connections the interface is exported on,
310 	 * use g_dbus_interface_skeleton_unexport().
311 	 *
312 	 * Params:
313 	 *     connection = A #GDBusConnection.
314 	 *
315 	 * Since: 2.32
316 	 */
317 	public void unexportFromConnection(DBusConnection connection)
318 	{
319 		g_dbus_interface_skeleton_unexport_from_connection(gDBusInterfaceSkeleton, (connection is null) ? null : connection.getDBusConnectionStruct());
320 	}
321 
322 	protected class OnGAuthorizeMethodDelegateWrapper
323 	{
324 		static OnGAuthorizeMethodDelegateWrapper[] listeners;
325 		bool delegate(DBusMethodInvocation, DBusInterfaceSkeleton) dlg;
326 		gulong handlerId;
327 		
328 		this(bool delegate(DBusMethodInvocation, DBusInterfaceSkeleton) dlg)
329 		{
330 			this.dlg = dlg;
331 			this.listeners ~= this;
332 		}
333 		
334 		void remove(OnGAuthorizeMethodDelegateWrapper source)
335 		{
336 			foreach(index, wrapper; listeners)
337 			{
338 				if (wrapper.handlerId == source.handlerId)
339 				{
340 					listeners[index] = null;
341 					listeners = std.algorithm.remove(listeners, index);
342 					break;
343 				}
344 			}
345 		}
346 	}
347 
348 	/**
349 	 * Emitted when a method is invoked by a remote caller and used to
350 	 * determine if the method call is authorized.
351 	 *
352 	 * Note that this signal is emitted in a thread dedicated to
353 	 * handling the method call so handlers are allowed to perform
354 	 * blocking IO. This means that it is appropriate to call e.g.
355 	 * [polkit_authority_check_authorization_sync()](http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#polkit-authority-check-authorization-sync)
356 	 * with the
357 	 * [POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION](http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#POLKIT-CHECK-AUTHORIZATION-FLAGS-ALLOW-USER-INTERACTION:CAPS)
358 	 * flag set.
359 	 *
360 	 * If %FALSE is returned then no further handlers are run and the
361 	 * signal handler must take a reference to @invocation and finish
362 	 * handling the call (e.g. return an error via
363 	 * g_dbus_method_invocation_return_error()).
364 	 *
365 	 * Otherwise, if %TRUE is returned, signal emission continues. If no
366 	 * handlers return %FALSE, then the method is dispatched. If
367 	 * @interface has an enclosing #GDBusObjectSkeleton, then the
368 	 * #GDBusObjectSkeleton::authorize-method signal handlers run before
369 	 * the handlers for this signal.
370 	 *
371 	 * The default class handler just returns %TRUE.
372 	 *
373 	 * Please note that the common case is optimized: if no signals
374 	 * handlers are connected and the default class handler isn't
375 	 * overridden (for both @interface and the enclosing
376 	 * #GDBusObjectSkeleton, if any) and #GDBusInterfaceSkeleton:g-flags does
377 	 * not have the
378 	 * %G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD
379 	 * flags set, no dedicated thread is ever used and the call will be
380 	 * handled in the same thread as the object that @interface belongs
381 	 * to was exported in.
382 	 *
383 	 * Params:
384 	 *     invocation = A #GDBusMethodInvocation.
385 	 *
386 	 * Returns: %TRUE if the call is authorized, %FALSE otherwise.
387 	 *
388 	 * Since: 2.30
389 	 */
390 	gulong addOnGAuthorizeMethod(bool delegate(DBusMethodInvocation, DBusInterfaceSkeleton) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
391 	{
392 		auto wrapper = new OnGAuthorizeMethodDelegateWrapper(dlg);
393 		wrapper.handlerId = Signals.connectData(
394 			this,
395 			"g-authorize-method",
396 			cast(GCallback)&callBackGAuthorizeMethod,
397 			cast(void*)wrapper,
398 			cast(GClosureNotify)&callBackGAuthorizeMethodDestroy,
399 			connectFlags);
400 		return wrapper.handlerId;
401 	}
402 	
403 	extern(C) static int callBackGAuthorizeMethod(GDBusInterfaceSkeleton* dbusinterfaceskeletonStruct, GDBusMethodInvocation* invocation, OnGAuthorizeMethodDelegateWrapper wrapper)
404 	{
405 		return wrapper.dlg(ObjectG.getDObject!(DBusMethodInvocation)(invocation), wrapper.outer);
406 	}
407 	
408 	extern(C) static void callBackGAuthorizeMethodDestroy(OnGAuthorizeMethodDelegateWrapper wrapper, GClosure* closure)
409 	{
410 		wrapper.remove(wrapper);
411 	}
412 }