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.AppInfoT;
26 
27 public  import gio.AppInfo;
28 public  import gio.AppInfoIF;
29 public  import gio.AppLaunchContext;
30 public  import gio.FileIF;
31 public  import gio.Icon;
32 public  import gio.IconIF;
33 public  import glib.ErrorG;
34 public  import glib.GException;
35 public  import glib.ListG;
36 public  import glib.Str;
37 public  import gobject.ObjectG;
38 public  import gtkc.gio;
39 public  import gtkc.giotypes;
40 
41 
42 /**
43  * #GAppInfo and #GAppLaunchContext are used for describing and launching
44  * applications installed on the system.
45  * 
46  * As of GLib 2.20, URIs will always be converted to POSIX paths
47  * (using g_file_get_path()) when using g_app_info_launch() even if
48  * the application requested an URI and not a POSIX path. For example
49  * for an desktop-file based application with Exec key `totem
50  * %U` and a single URI, `sftp://foo/file.avi`, then
51  * `/home/user/.gvfs/sftp on foo/file.avi` will be passed. This will
52  * only work if a set of suitable GIO extensions (such as gvfs 2.26
53  * compiled with FUSE support), is available and operational; if this
54  * is not the case, the URI will be passed unmodified to the application.
55  * Some URIs, such as `mailto:`, of course cannot be mapped to a POSIX
56  * path (in gvfs there's no FUSE mount for it); such URIs will be
57  * passed unmodified to the application.
58  * 
59  * Specifically for gvfs 2.26 and later, the POSIX URI will be mapped
60  * back to the GIO URI in the #GFile constructors (since gvfs
61  * implements the #GVfs extension point). As such, if the application
62  * needs to examine the URI, it needs to use g_file_get_uri() or
63  * similar on #GFile. In other words, an application cannot assume
64  * that the URI passed to e.g. g_file_new_for_commandline_arg() is
65  * equal to the result of g_file_get_uri(). The following snippet
66  * illustrates this:
67  * 
68  * |[
69  * GFile *f;
70  * char *uri;
71  * 
72  * file = g_file_new_for_commandline_arg (uri_from_commandline);
73  * 
74  * uri = g_file_get_uri (file);
75  * strcmp (uri, uri_from_commandline) == 0;
76  * g_free (uri);
77  * 
78  * if (g_file_has_uri_scheme (file, "cdda"))
79  * {
80  * // do something special with uri
81  * }
82  * g_object_unref (file);
83  * ]|
84  * 
85  * This code will work when both `cdda://sr0/Track 1.wav` and
86  * `/home/user/.gvfs/cdda on sr0/Track 1.wav` is passed to the
87  * application. It should be noted that it's generally not safe
88  * for applications to rely on the format of a particular URIs.
89  * Different launcher applications (e.g. file managers) may have
90  * different ideas of what a given URI means.
91  */
92 public template AppInfoT(TStruct)
93 {
94 	/** Get the main Gtk struct */
95 	public GAppInfo* getAppInfoStruct()
96 	{
97 		return cast(GAppInfo*)getStruct();
98 	}
99 
100 
101 	/**
102 	 * Creates a new #GAppInfo from the given information.
103 	 *
104 	 * Note that for @commandline, the quoting rules of the Exec key of the
105 	 * [freedesktop.org Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec)
106 	 * are applied. For example, if the @commandline contains
107 	 * percent-encoded URIs, the percent-character must be doubled in order to prevent it from
108 	 * being swallowed by Exec key unquoting. See the specification for exact quoting rules.
109 	 *
110 	 * Params:
111 	 *     commandline = the commandline to use
112 	 *     applicationName = the application name, or %NULL to use @commandline
113 	 *     flags = flags that can specify details of the created #GAppInfo
114 	 *
115 	 * Return: new #GAppInfo for given command.
116 	 *
117 	 * Throws: GException on failure.
118 	 */
119 	public static AppInfoIF createFromCommandline(string commandline, string applicationName, GAppInfoCreateFlags flags)
120 	{
121 		GError* err = null;
122 		
123 		auto p = g_app_info_create_from_commandline(Str.toStringz(commandline), Str.toStringz(applicationName), flags, &err);
124 		
125 		if (err !is null)
126 		{
127 			throw new GException( new ErrorG(err) );
128 		}
129 		
130 		if(p is null)
131 		{
132 			return null;
133 		}
134 		
135 		return ObjectG.getDObject!(AppInfo, AppInfoIF)(cast(GAppInfo*) p);
136 	}
137 
138 	/**
139 	 * Gets a list of all of the applications currently registered
140 	 * on this system.
141 	 *
142 	 * For desktop files, this includes applications that have
143 	 * `NoDisplay=true` set or are excluded from display by means
144 	 * of `OnlyShowIn` or `NotShowIn`. See g_app_info_should_show().
145 	 * The returned list does not include applications which have
146 	 * the `Hidden` key set.
147 	 *
148 	 * Return: a newly allocated #GList of references to #GAppInfos.
149 	 */
150 	public static ListG getAll()
151 	{
152 		auto p = g_app_info_get_all();
153 		
154 		if(p is null)
155 		{
156 			return null;
157 		}
158 		
159 		return new ListG(cast(GList*) p);
160 	}
161 
162 	/**
163 	 * Gets a list of all #GAppInfos for a given content type,
164 	 * including the recommended and fallback #GAppInfos. See
165 	 * g_app_info_get_recommended_for_type() and
166 	 * g_app_info_get_fallback_for_type().
167 	 *
168 	 * Params:
169 	 *     contentType = the content type to find a #GAppInfo for
170 	 *
171 	 * Return: #GList of #GAppInfos
172 	 *     for given @content_type or %NULL on error.
173 	 */
174 	public static ListG getAllForType(string contentType)
175 	{
176 		auto p = g_app_info_get_all_for_type(Str.toStringz(contentType));
177 		
178 		if(p is null)
179 		{
180 			return null;
181 		}
182 		
183 		return new ListG(cast(GList*) p);
184 	}
185 
186 	/**
187 	 * Gets the default #GAppInfo for a given content type.
188 	 *
189 	 * Params:
190 	 *     contentType = the content type to find a #GAppInfo for
191 	 *     mustSupportUris = if %TRUE, the #GAppInfo is expected to
192 	 *         support URIs
193 	 *
194 	 * Return: #GAppInfo for given @content_type or
195 	 *     %NULL on error.
196 	 */
197 	public static AppInfoIF getDefaultForType(string contentType, bool mustSupportUris)
198 	{
199 		auto p = g_app_info_get_default_for_type(Str.toStringz(contentType), mustSupportUris);
200 		
201 		if(p is null)
202 		{
203 			return null;
204 		}
205 		
206 		return ObjectG.getDObject!(AppInfo, AppInfoIF)(cast(GAppInfo*) p);
207 	}
208 
209 	/**
210 	 * Gets the default application for handling URIs with
211 	 * the given URI scheme. A URI scheme is the initial part
212 	 * of the URI, up to but not including the ':', e.g. "http",
213 	 * "ftp" or "sip".
214 	 *
215 	 * Params:
216 	 *     uriScheme = a string containing a URI scheme.
217 	 *
218 	 * Return: #GAppInfo for given @uri_scheme or %NULL on error.
219 	 */
220 	public static AppInfoIF getDefaultForUriScheme(string uriScheme)
221 	{
222 		auto p = g_app_info_get_default_for_uri_scheme(Str.toStringz(uriScheme));
223 		
224 		if(p is null)
225 		{
226 			return null;
227 		}
228 		
229 		return ObjectG.getDObject!(AppInfo, AppInfoIF)(cast(GAppInfo*) p);
230 	}
231 
232 	/**
233 	 * Gets a list of fallback #GAppInfos for a given content type, i.e.
234 	 * those applications which claim to support the given content type
235 	 * by MIME type subclassing and not directly.
236 	 *
237 	 * Params:
238 	 *     contentType = the content type to find a #GAppInfo for
239 	 *
240 	 * Return: #GList of #GAppInfos
241 	 *     for given @content_type or %NULL on error.
242 	 *
243 	 * Since: 2.28
244 	 */
245 	public static ListG getFallbackForType(string contentType)
246 	{
247 		auto p = g_app_info_get_fallback_for_type(Str.toStringz(contentType));
248 		
249 		if(p is null)
250 		{
251 			return null;
252 		}
253 		
254 		return new ListG(cast(GList*) p);
255 	}
256 
257 	/**
258 	 * Gets a list of recommended #GAppInfos for a given content type, i.e.
259 	 * those applications which claim to support the given content type exactly,
260 	 * and not by MIME type subclassing.
261 	 * Note that the first application of the list is the last used one, i.e.
262 	 * the last one for which g_app_info_set_as_last_used_for_type() has been
263 	 * called.
264 	 *
265 	 * Params:
266 	 *     contentType = the content type to find a #GAppInfo for
267 	 *
268 	 * Return: #GList of #GAppInfos
269 	 *     for given @content_type or %NULL on error.
270 	 *
271 	 * Since: 2.28
272 	 */
273 	public static ListG getRecommendedForType(string contentType)
274 	{
275 		auto p = g_app_info_get_recommended_for_type(Str.toStringz(contentType));
276 		
277 		if(p is null)
278 		{
279 			return null;
280 		}
281 		
282 		return new ListG(cast(GList*) p);
283 	}
284 
285 	/**
286 	 * Utility function that launches the default application
287 	 * registered to handle the specified uri. Synchronous I/O
288 	 * is done on the uri to detect the type of the file if
289 	 * required.
290 	 *
291 	 * Params:
292 	 *     uri = the uri to show
293 	 *     launchContext = an optional #GAppLaunchContext.
294 	 *
295 	 * Return: %TRUE on success, %FALSE on error.
296 	 *
297 	 * Throws: GException on failure.
298 	 */
299 	public static bool launchDefaultForUri(string uri, AppLaunchContext launchContext)
300 	{
301 		GError* err = null;
302 		
303 		auto p = g_app_info_launch_default_for_uri(Str.toStringz(uri), (launchContext is null) ? null : launchContext.getAppLaunchContextStruct(), &err) != 0;
304 		
305 		if (err !is null)
306 		{
307 			throw new GException( new ErrorG(err) );
308 		}
309 		
310 		return p;
311 	}
312 
313 	/**
314 	 * Removes all changes to the type associations done by
315 	 * g_app_info_set_as_default_for_type(),
316 	 * g_app_info_set_as_default_for_extension(),
317 	 * g_app_info_add_supports_type() or
318 	 * g_app_info_remove_supports_type().
319 	 *
320 	 * Params:
321 	 *     contentType = a content type
322 	 *
323 	 * Since: 2.20
324 	 */
325 	public static void resetTypeAssociations(string contentType)
326 	{
327 		g_app_info_reset_type_associations(Str.toStringz(contentType));
328 	}
329 
330 	/**
331 	 * Adds a content type to the application information to indicate the
332 	 * application is capable of opening files with the given content type.
333 	 *
334 	 * Params:
335 	 *     contentType = a string.
336 	 *
337 	 * Return: %TRUE on success, %FALSE on error.
338 	 *
339 	 * Throws: GException on failure.
340 	 */
341 	public bool addSupportsType(string contentType)
342 	{
343 		GError* err = null;
344 		
345 		auto p = g_app_info_add_supports_type(getAppInfoStruct(), Str.toStringz(contentType), &err) != 0;
346 		
347 		if (err !is null)
348 		{
349 			throw new GException( new ErrorG(err) );
350 		}
351 		
352 		return p;
353 	}
354 
355 	/**
356 	 * Obtains the information whether the #GAppInfo can be deleted.
357 	 * See g_app_info_delete().
358 	 *
359 	 * Return: %TRUE if @appinfo can be deleted
360 	 *
361 	 * Since: 2.20
362 	 */
363 	public bool canDelete()
364 	{
365 		return g_app_info_can_delete(getAppInfoStruct()) != 0;
366 	}
367 
368 	/**
369 	 * Checks if a supported content type can be removed from an application.
370 	 *
371 	 * Return: %TRUE if it is possible to remove supported
372 	 *     content types from a given @appinfo, %FALSE if not.
373 	 */
374 	public bool canRemoveSupportsType()
375 	{
376 		return g_app_info_can_remove_supports_type(getAppInfoStruct()) != 0;
377 	}
378 
379 	/**
380 	 * Tries to delete a #GAppInfo.
381 	 *
382 	 * On some platforms, there may be a difference between user-defined
383 	 * #GAppInfos which can be deleted, and system-wide ones which cannot.
384 	 * See g_app_info_can_delete().
385 	 *
386 	 * Return: %TRUE if @appinfo has been deleted
387 	 *
388 	 * Since: 2.20
389 	 */
390 	public bool delet()
391 	{
392 		return g_app_info_delete(getAppInfoStruct()) != 0;
393 	}
394 
395 	/**
396 	 * Creates a duplicate of a #GAppInfo.
397 	 *
398 	 * Return: a duplicate of @appinfo.
399 	 */
400 	public AppInfoIF dup()
401 	{
402 		auto p = g_app_info_dup(getAppInfoStruct());
403 		
404 		if(p is null)
405 		{
406 			return null;
407 		}
408 		
409 		return ObjectG.getDObject!(AppInfo, AppInfoIF)(cast(GAppInfo*) p);
410 	}
411 
412 	/**
413 	 * Checks if two #GAppInfos are equal.
414 	 *
415 	 * Params:
416 	 *     appinfo2 = the second #GAppInfo.
417 	 *
418 	 * Return: %TRUE if @appinfo1 is equal to @appinfo2. %FALSE otherwise.
419 	 */
420 	public bool equal(AppInfoIF appinfo2)
421 	{
422 		return g_app_info_equal(getAppInfoStruct(), (appinfo2 is null) ? null : appinfo2.getAppInfoStruct()) != 0;
423 	}
424 
425 	/**
426 	 * Gets the commandline with which the application will be
427 	 * started.
428 	 *
429 	 * Return: a string containing the @appinfo's commandline,
430 	 *     or %NULL if this information is not available
431 	 *
432 	 * Since: 2.20
433 	 */
434 	public string getCommandline()
435 	{
436 		return Str.toString(g_app_info_get_commandline(getAppInfoStruct()));
437 	}
438 
439 	/**
440 	 * Gets a human-readable description of an installed application.
441 	 *
442 	 * Return: a string containing a description of the
443 	 *     application @appinfo, or %NULL if none.
444 	 */
445 	public string getDescription()
446 	{
447 		return Str.toString(g_app_info_get_description(getAppInfoStruct()));
448 	}
449 
450 	/**
451 	 * Gets the display name of the application. The display name is often more
452 	 * descriptive to the user than the name itself.
453 	 *
454 	 * Return: the display name of the application for @appinfo, or the name if
455 	 *     no display name is available.
456 	 *
457 	 * Since: 2.24
458 	 */
459 	public string getDisplayName()
460 	{
461 		return Str.toString(g_app_info_get_display_name(getAppInfoStruct()));
462 	}
463 
464 	/**
465 	 * Gets the executable's name for the installed application.
466 	 *
467 	 * Return: a string containing the @appinfo's application
468 	 *     binaries name
469 	 */
470 	public string getExecutable()
471 	{
472 		return Str.toString(g_app_info_get_executable(getAppInfoStruct()));
473 	}
474 
475 	/**
476 	 * Gets the icon for the application.
477 	 *
478 	 * Return: the default #GIcon for @appinfo or %NULL
479 	 *     if there is no default icon.
480 	 */
481 	public IconIF getIcon()
482 	{
483 		auto p = g_app_info_get_icon(getAppInfoStruct());
484 		
485 		if(p is null)
486 		{
487 			return null;
488 		}
489 		
490 		return ObjectG.getDObject!(Icon, IconIF)(cast(GIcon*) p);
491 	}
492 
493 	/**
494 	 * Gets the ID of an application. An id is a string that
495 	 * identifies the application. The exact format of the id is
496 	 * platform dependent. For instance, on Unix this is the
497 	 * desktop file id from the xdg menu specification.
498 	 *
499 	 * Note that the returned ID may be %NULL, depending on how
500 	 * the @appinfo has been constructed.
501 	 *
502 	 * Return: a string containing the application's ID.
503 	 */
504 	public string getId()
505 	{
506 		return Str.toString(g_app_info_get_id(getAppInfoStruct()));
507 	}
508 
509 	/**
510 	 * Gets the installed name of the application.
511 	 *
512 	 * Return: the name of the application for @appinfo.
513 	 */
514 	public string getName()
515 	{
516 		return Str.toString(g_app_info_get_name(getAppInfoStruct()));
517 	}
518 
519 	/**
520 	 * Retrieves the list of content types that @app_info claims to support.
521 	 * If this information is not provided by the environment, this function
522 	 * will return %NULL.
523 	 * This function does not take in consideration associations added with
524 	 * g_app_info_add_supports_type(), but only those exported directly by
525 	 * the application.
526 	 *
527 	 * Return: a list of content types.
528 	 *
529 	 * Since: 2.34
530 	 */
531 	public string[] getSupportedTypes()
532 	{
533 		return Str.toStringArray(g_app_info_get_supported_types(getAppInfoStruct()));
534 	}
535 
536 	/**
537 	 * Launches the application. Passes @files to the launched application
538 	 * as arguments, using the optional @launch_context to get information
539 	 * about the details of the launcher (like what screen it is on).
540 	 * On error, @error will be set accordingly.
541 	 *
542 	 * To launch the application without arguments pass a %NULL @files list.
543 	 *
544 	 * Note that even if the launch is successful the application launched
545 	 * can fail to start if it runs into problems during startup. There is
546 	 * no way to detect this.
547 	 *
548 	 * Some URIs can be changed when passed through a GFile (for instance
549 	 * unsupported URIs with strange formats like mailto:), so if you have
550 	 * a textual URI you want to pass in as argument, consider using
551 	 * g_app_info_launch_uris() instead.
552 	 *
553 	 * The launched application inherits the environment of the launching
554 	 * process, but it can be modified with g_app_launch_context_setenv()
555 	 * and g_app_launch_context_unsetenv().
556 	 *
557 	 * On UNIX, this function sets the `GIO_LAUNCHED_DESKTOP_FILE`
558 	 * environment variable with the path of the launched desktop file and
559 	 * `GIO_LAUNCHED_DESKTOP_FILE_PID` to the process id of the launched
560 	 * process. This can be used to ignore `GIO_LAUNCHED_DESKTOP_FILE`,
561 	 * should it be inherited by further processes. The `DISPLAY` and
562 	 * `DESKTOP_STARTUP_ID` environment variables are also set, based
563 	 * on information provided in @launch_context.
564 	 *
565 	 * Params:
566 	 *     files = a #GList of #GFile objects
567 	 *     launchContext = a #GAppLaunchContext or %NULL
568 	 *
569 	 * Return: %TRUE on successful launch, %FALSE otherwise.
570 	 *
571 	 * Throws: GException on failure.
572 	 */
573 	public bool launch(ListG files, AppLaunchContext launchContext)
574 	{
575 		GError* err = null;
576 		
577 		auto p = g_app_info_launch(getAppInfoStruct(), (files is null) ? null : files.getListGStruct(), (launchContext is null) ? null : launchContext.getAppLaunchContextStruct(), &err) != 0;
578 		
579 		if (err !is null)
580 		{
581 			throw new GException( new ErrorG(err) );
582 		}
583 		
584 		return p;
585 	}
586 
587 	/**
588 	 * Launches the application. This passes the @uris to the launched application
589 	 * as arguments, using the optional @launch_context to get information
590 	 * about the details of the launcher (like what screen it is on).
591 	 * On error, @error will be set accordingly.
592 	 *
593 	 * To launch the application without arguments pass a %NULL @uris list.
594 	 *
595 	 * Note that even if the launch is successful the application launched
596 	 * can fail to start if it runs into problems during startup. There is
597 	 * no way to detect this.
598 	 *
599 	 * Params:
600 	 *     uris = a #GList containing URIs to launch.
601 	 *     launchContext = a #GAppLaunchContext or %NULL
602 	 *
603 	 * Return: %TRUE on successful launch, %FALSE otherwise.
604 	 *
605 	 * Throws: GException on failure.
606 	 */
607 	public bool launchUris(ListG uris, AppLaunchContext launchContext)
608 	{
609 		GError* err = null;
610 		
611 		auto p = g_app_info_launch_uris(getAppInfoStruct(), (uris is null) ? null : uris.getListGStruct(), (launchContext is null) ? null : launchContext.getAppLaunchContextStruct(), &err) != 0;
612 		
613 		if (err !is null)
614 		{
615 			throw new GException( new ErrorG(err) );
616 		}
617 		
618 		return p;
619 	}
620 
621 	/**
622 	 * Removes a supported type from an application, if possible.
623 	 *
624 	 * Params:
625 	 *     contentType = a string.
626 	 *
627 	 * Return: %TRUE on success, %FALSE on error.
628 	 *
629 	 * Throws: GException on failure.
630 	 */
631 	public bool removeSupportsType(string contentType)
632 	{
633 		GError* err = null;
634 		
635 		auto p = g_app_info_remove_supports_type(getAppInfoStruct(), Str.toStringz(contentType), &err) != 0;
636 		
637 		if (err !is null)
638 		{
639 			throw new GException( new ErrorG(err) );
640 		}
641 		
642 		return p;
643 	}
644 
645 	/**
646 	 * Sets the application as the default handler for the given file extension.
647 	 *
648 	 * Params:
649 	 *     extension = a string containing the file extension (without the dot).
650 	 *
651 	 * Return: %TRUE on success, %FALSE on error.
652 	 *
653 	 * Throws: GException on failure.
654 	 */
655 	public bool setAsDefaultForExtension(string extension)
656 	{
657 		GError* err = null;
658 		
659 		auto p = g_app_info_set_as_default_for_extension(getAppInfoStruct(), Str.toStringz(extension), &err) != 0;
660 		
661 		if (err !is null)
662 		{
663 			throw new GException( new ErrorG(err) );
664 		}
665 		
666 		return p;
667 	}
668 
669 	/**
670 	 * Sets the application as the default handler for a given type.
671 	 *
672 	 * Params:
673 	 *     contentType = the content type.
674 	 *
675 	 * Return: %TRUE on success, %FALSE on error.
676 	 *
677 	 * Throws: GException on failure.
678 	 */
679 	public bool setAsDefaultForType(string contentType)
680 	{
681 		GError* err = null;
682 		
683 		auto p = g_app_info_set_as_default_for_type(getAppInfoStruct(), Str.toStringz(contentType), &err) != 0;
684 		
685 		if (err !is null)
686 		{
687 			throw new GException( new ErrorG(err) );
688 		}
689 		
690 		return p;
691 	}
692 
693 	/**
694 	 * Sets the application as the last used application for a given type.
695 	 * This will make the application appear as first in the list returned
696 	 * by g_app_info_get_recommended_for_type(), regardless of the default
697 	 * application for that content type.
698 	 *
699 	 * Params:
700 	 *     contentType = the content type.
701 	 *
702 	 * Return: %TRUE on success, %FALSE on error.
703 	 *
704 	 * Throws: GException on failure.
705 	 */
706 	public bool setAsLastUsedForType(string contentType)
707 	{
708 		GError* err = null;
709 		
710 		auto p = g_app_info_set_as_last_used_for_type(getAppInfoStruct(), Str.toStringz(contentType), &err) != 0;
711 		
712 		if (err !is null)
713 		{
714 			throw new GException( new ErrorG(err) );
715 		}
716 		
717 		return p;
718 	}
719 
720 	/**
721 	 * Checks if the application info should be shown in menus that
722 	 * list available applications.
723 	 *
724 	 * Return: %TRUE if the @appinfo should be shown, %FALSE otherwise.
725 	 */
726 	public bool shouldShow()
727 	{
728 		return g_app_info_should_show(getAppInfoStruct()) != 0;
729 	}
730 
731 	/**
732 	 * Checks if the application accepts files as arguments.
733 	 *
734 	 * Return: %TRUE if the @appinfo supports files.
735 	 */
736 	public bool supportsFiles()
737 	{
738 		return g_app_info_supports_files(getAppInfoStruct()) != 0;
739 	}
740 
741 	/**
742 	 * Checks if the application supports reading files and directories from URIs.
743 	 *
744 	 * Return: %TRUE if the @appinfo supports URIs.
745 	 */
746 	public bool supportsUris()
747 	{
748 		return g_app_info_supports_uris(getAppInfoStruct()) != 0;
749 	}
750 }