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.LoadableIconT; 26 27 public import gio.AsyncResultIF; 28 public import gio.Cancellable; 29 public import gio.InputStream; 30 public import glib.ErrorG; 31 public import glib.GException; 32 public import glib.Str; 33 public import gobject.ObjectG; 34 public import gtkc.gio; 35 public import gtkc.giotypes; 36 37 38 /** 39 * Extends the #GIcon interface and adds the ability to 40 * load icons from streams. 41 */ 42 public template LoadableIconT(TStruct) 43 { 44 /** Get the main Gtk struct */ 45 public GLoadableIcon* getLoadableIconStruct() 46 { 47 return cast(GLoadableIcon*)getStruct(); 48 } 49 50 51 /** 52 * Loads a loadable icon. For the asynchronous version of this function, 53 * see g_loadable_icon_load_async(). 54 * 55 * Params: 56 * size = an integer. 57 * type = a location to store the type of the loaded 58 * icon, %NULL to ignore. 59 * cancellable = optional #GCancellable object, %NULL to 60 * ignore. 61 * 62 * Return: a #GInputStream to read the icon from. 63 * 64 * Throws: GException on failure. 65 */ 66 public InputStream load(int size, out string type, Cancellable cancellable) 67 { 68 char* outtype = null; 69 GError* err = null; 70 71 auto p = g_loadable_icon_load(getLoadableIconStruct(), size, &outtype, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); 72 73 if (err !is null) 74 { 75 throw new GException( new ErrorG(err) ); 76 } 77 78 type = Str.toString(outtype); 79 80 if(p is null) 81 { 82 return null; 83 } 84 85 return ObjectG.getDObject!(InputStream)(cast(GInputStream*) p, true); 86 } 87 88 /** 89 * Loads an icon asynchronously. To finish this function, see 90 * g_loadable_icon_load_finish(). For the synchronous, blocking 91 * version of this function, see g_loadable_icon_load(). 92 * 93 * Params: 94 * size = an integer. 95 * cancellable = optional #GCancellable object, %NULL to ignore. 96 * callback = a #GAsyncReadyCallback to call when the 97 * request is satisfied 98 * userData = the data to pass to callback function 99 */ 100 public void loadAsync(int size, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) 101 { 102 g_loadable_icon_load_async(getLoadableIconStruct(), size, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); 103 } 104 105 /** 106 * Finishes an asynchronous icon load started in g_loadable_icon_load_async(). 107 * 108 * Params: 109 * res = a #GAsyncResult. 110 * type = a location to store the type of the loaded 111 * icon, %NULL to ignore. 112 * 113 * Return: a #GInputStream to read the icon from. 114 * 115 * Throws: GException on failure. 116 */ 117 public InputStream loadFinish(AsyncResultIF res, out string type) 118 { 119 char* outtype = null; 120 GError* err = null; 121 122 auto p = g_loadable_icon_load_finish(getLoadableIconStruct(), (res is null) ? null : res.getAsyncResultStruct(), &outtype, &err); 123 124 if (err !is null) 125 { 126 throw new GException( new ErrorG(err) ); 127 } 128 129 type = Str.toString(outtype); 130 131 if(p is null) 132 { 133 return null; 134 } 135 136 return ObjectG.getDObject!(InputStream)(cast(GInputStream*) p, true); 137 } 138 }