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 glib.Idle; 26 27 private import glib.Source; 28 private import gtkc.glib; 29 public import gtkc.glibtypes; 30 31 32 /** */ 33 public class Idle 34 { 35 /** Holds all idle delegates */ 36 bool delegate()[] idleListeners; 37 /** our idle ID */ 38 uint idleID; 39 40 /** 41 * Creates a new idle cycle. 42 * Params: 43 * interval = the idle in milieconds 44 * dlg = the delegate to be executed 45 * fireNow = When true the delegate will be executed emmidiatly 46 */ 47 this(bool delegate() dlg, bool fireNow=false) 48 { 49 idleListeners ~= dlg; 50 idleID = g_idle_add(cast(GSourceFunc)&idleCallback, cast(void*)this); 51 if ( fireNow ) 52 { 53 if ( !dlg() ) 54 { 55 idleListeners.length = 0; 56 } 57 } 58 } 59 60 /** 61 * Creates a new idle cycle. 62 * Params: 63 * dlg = the delegate to be executed 64 * priority = Priority for the idle function 65 * fireNow = When true the delegate will be executed emmidiatly 66 */ 67 this(bool delegate() dlg, GPriority priority, bool fireNow=false) 68 { 69 idleListeners ~= dlg; 70 idleID = g_idle_add_full(priority, cast(GSourceFunc)&idleCallback, cast(void*)this, null); 71 if ( fireNow ) 72 { 73 if ( !dlg() ) 74 { 75 idleListeners.length = 0; 76 } 77 } 78 } 79 80 /** */ 81 public void stop() 82 { 83 if ( idleID > 0 ) 84 { 85 g_source_remove(idleID); 86 } 87 idleListeners.length = 0; 88 } 89 90 /** 91 * Removes the idle from gtk 92 */ 93 ~this() 94 { 95 stop(); 96 } 97 98 /** 99 * Adds a new delegate to this idle cycle 100 * Params: 101 * dlg = 102 * fireNow = 103 */ 104 public void addListener(bool delegate() dlg, bool fireNow=false) 105 { 106 idleListeners ~= dlg; 107 if ( fireNow ) 108 { 109 if ( !dlg() ) 110 { 111 idleListeners.length = idleListeners.length - 1; 112 } 113 } 114 } 115 116 /** 117 * The callback execution from glib 118 * Params: 119 * idle = 120 * Returns: 121 */ 122 extern(C) static bool idleCallback(Idle idle) 123 { 124 return idle.callAllListeners(); 125 } 126 127 /** 128 * Executes all delegates on the execution list 129 * Returns: 130 */ 131 private bool callAllListeners() 132 { 133 bool runAgain = false; 134 135 int i = 0; 136 137 while ( i<idleListeners.length ) 138 { 139 if ( !idleListeners[i]() ) 140 { 141 idleListeners = idleListeners[0..i] ~ idleListeners[i+1..idleListeners.length]; 142 } 143 else 144 { 145 runAgain = true; 146 ++i; 147 } 148 } 149 150 // Set idleID to 0 if all delegates are removed 151 if (idleListeners.length == 0) 152 idleID = 0; 153 154 return runAgain; 155 } 156 157 /** 158 */ 159 160 /** 161 * Adds a function to be called whenever there are no higher priority 162 * events pending to the default main loop. The function is given the 163 * default idle priority, #G_PRIORITY_DEFAULT_IDLE. If the function 164 * returns %FALSE it is automatically removed from the list of event 165 * sources and will not be called again. 166 * 167 * See [memory management of sources][mainloop-memory-management] for details 168 * on how to handle the return value and memory management of @data. 169 * 170 * This internally creates a main loop source using g_idle_source_new() 171 * and attaches it to the global #GMainContext using g_source_attach(), so 172 * the callback will be invoked in whichever thread is running that main 173 * context. You can do these steps manually if you need greater control or to 174 * use a custom main context. 175 * 176 * Params: 177 * funct = function to call 178 * data = data to pass to @function. 179 * 180 * Return: the ID (greater than 0) of the event source. 181 */ 182 public static uint add(GSourceFunc funct, void* data) 183 { 184 return g_idle_add(funct, data); 185 } 186 187 /** 188 * Adds a function to be called whenever there are no higher priority 189 * events pending. If the function returns %FALSE it is automatically 190 * removed from the list of event sources and will not be called again. 191 * 192 * See [memory management of sources][mainloop-memory-management] for details 193 * on how to handle the return value and memory management of @data. 194 * 195 * This internally creates a main loop source using g_idle_source_new() 196 * and attaches it to the global #GMainContext using g_source_attach(), so 197 * the callback will be invoked in whichever thread is running that main 198 * context. You can do these steps manually if you need greater control or to 199 * use a custom main context. 200 * 201 * Params: 202 * priority = the priority of the idle source. Typically this will be in the 203 * range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE. 204 * funct = function to call 205 * data = data to pass to @function 206 * notify = function to call when the idle is removed, or %NULL 207 * 208 * Return: the ID (greater than 0) of the event source. 209 */ 210 public static uint addFull(int priority, GSourceFunc funct, void* data, GDestroyNotify notify) 211 { 212 return g_idle_add_full(priority, funct, data, notify); 213 } 214 215 /** 216 * Removes the idle function with the given data. 217 * 218 * Params: 219 * data = the data for the idle source's callback. 220 * 221 * Return: %TRUE if an idle source was found and removed. 222 */ 223 public static bool removeByData(void* data) 224 { 225 return g_idle_remove_by_data(data) != 0; 226 } 227 228 /** 229 * Creates a new idle source. 230 * 231 * The source will not initially be associated with any #GMainContext 232 * and must be added to one with g_source_attach() before it will be 233 * executed. Note that the default priority for idle sources is 234 * %G_PRIORITY_DEFAULT_IDLE, as compared to other sources which 235 * have a default priority of %G_PRIORITY_DEFAULT. 236 * 237 * Return: the newly-created idle source 238 */ 239 public static Source sourceNew() 240 { 241 auto p = g_idle_source_new(); 242 243 if(p is null) 244 { 245 return null; 246 } 247 248 return new Source(cast(GSource*) p, true); 249 } 250 }