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.IconIF;
26 
27 private import gio.IconIF;
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 glib.Variant;
35 private import gobject.ObjectG;
36 public  import gtkc.giotypes;
37 
38 
39 /**
40  * #GIcon is a very minimal interface for icons. It provides functions
41  * for checking the equality of two icons, hashing of icons and
42  * serializing an icon to and from strings.
43  * 
44  * #GIcon does not provide the actual pixmap for the icon as this is out
45  * of GIO's scope, however implementations of #GIcon may contain the name
46  * of an icon (see #GThemedIcon), or the path to an icon (see #GLoadableIcon).
47  * 
48  * To obtain a hash of a #GIcon, see g_icon_hash().
49  * 
50  * To check if two #GIcons are equal, see g_icon_equal().
51  * 
52  * For serializing a #GIcon, use g_icon_serialize() and
53  * g_icon_deserialize().
54  * 
55  * If you want to consume #GIcon (for example, in a toolkit) you must
56  * be prepared to handle at least the three following cases:
57  * #GLoadableIcon, #GThemedIcon and #GEmblemedIcon.  It may also make
58  * sense to have fast-paths for other cases (like handling #GdkPixbuf
59  * directly, for example) but all compliant #GIcon implementations
60  * outside of GIO must implement #GLoadableIcon.
61  * 
62  * If your application or library provides one or more #GIcon
63  * implementations you need to ensure that your new implementation also
64  * implements #GLoadableIcon.  Additionally, you must provide an
65  * implementation of g_icon_serialize() that gives a result that is
66  * understood by g_icon_deserialize(), yielding one of the built-in icon
67  * types.
68  */
69 public interface IconIF{
70 	/** Get the main Gtk struct */
71 	public GIcon* getIconStruct(bool transferOwnership = false);
72 
73 	/** the main Gtk struct as a void* */
74 	protected void* getStruct();
75 
76 
77 	/** */
78 	public static GType getType()
79 	{
80 		return g_icon_get_type();
81 	}
82 
83 	/**
84 	 * Deserializes a #GIcon previously serialized using g_icon_serialize().
85 	 *
86 	 * Params:
87 	 *     value = a #GVariant created with g_icon_serialize()
88 	 *
89 	 * Returns: a #GIcon, or %NULL when deserialization fails.
90 	 *
91 	 * Since: 2.38
92 	 */
93 	public static IconIF deserialize(Variant value)
94 	{
95 		auto p = g_icon_deserialize((value is null) ? null : value.getVariantStruct());
96 
97 		if(p is null)
98 		{
99 			return null;
100 		}
101 
102 		return ObjectG.getDObject!(IconIF)(cast(GIcon*) p, true);
103 	}
104 
105 	/**
106 	 * Gets a hash for an icon.
107 	 *
108 	 * Params:
109 	 *     icon = #gconstpointer to an icon object.
110 	 *
111 	 * Returns: a #guint containing a hash for the @icon, suitable for
112 	 *     use in a #GHashTable or similar data structure.
113 	 */
114 	public static uint hash(void* icon)
115 	{
116 		return g_icon_hash(icon);
117 	}
118 
119 	/**
120 	 * Checks if two icons are equal.
121 	 *
122 	 * Params:
123 	 *     icon2 = pointer to the second #GIcon.
124 	 *
125 	 * Returns: %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
126 	 */
127 	public bool equal(IconIF icon2);
128 
129 	/**
130 	 * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
131 	 * back by calling g_icon_deserialize() on the returned value.
132 	 * As serialization will avoid using raw icon data when possible, it only
133 	 * makes sense to transfer the #GVariant between processes on the same machine,
134 	 * (as opposed to over the network), and within the same file system namespace.
135 	 *
136 	 * Returns: a #GVariant, or %NULL when serialization fails.
137 	 *
138 	 * Since: 2.38
139 	 */
140 	public Variant serialize();
141 
142 	/**
143 	 * Generates a textual representation of @icon that can be used for
144 	 * serialization such as when passing @icon to a different process or
145 	 * saving it to persistent storage. Use g_icon_new_for_string() to
146 	 * get @icon back from the returned string.
147 	 *
148 	 * The encoding of the returned string is proprietary to #GIcon except
149 	 * in the following two cases
150 	 *
151 	 * - If @icon is a #GFileIcon, the returned string is a native path
152 	 * (such as `/path/to/my icon.png`) without escaping
153 	 * if the #GFile for @icon is a native file.  If the file is not
154 	 * native, the returned string is the result of g_file_get_uri()
155 	 * (such as `sftp://path/to/my%20icon.png`).
156 	 *
157 	 * - If @icon is a #GThemedIcon with exactly one name, the encoding is
158 	 * simply the name (such as `network-server`).
159 	 *
160 	 * Returns: An allocated NUL-terminated UTF8 string or
161 	 *     %NULL if @icon can't be serialized. Use g_free() to free.
162 	 *
163 	 * Since: 2.20
164 	 */
165 	public string toString();
166 }