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 gdk.Threads;
26 
27 private import gtkc.gdk;
28 public  import gtkc.gdktypes;
29 
30 
31 /**
32  */
33 
34 /**
35  * A wrapper for the common usage of gdk_threads_add_idle_full()
36  * assigning the default priority, #G_PRIORITY_DEFAULT_IDLE.
37  *
38  * See gdk_threads_add_idle_full().
39  *
40  * Params:
41  *     funct = function to call
42  *     data = data to pass to @function
43  *
44  * Return: the ID (greater than 0) of the event source.
45  *
46  * Since: 2.12
47  */
48 public uint threadsAddIdle(GSourceFunc funct, void* data)
49 {
50 	return gdk_threads_add_idle(funct, data);
51 }
52 
53 /**
54  * Adds a function to be called whenever there are no higher priority
55  * events pending.  If the function returns %FALSE it is automatically
56  * removed from the list of event sources and will not be called again.
57  *
58  * This variant of g_idle_add_full() calls @function with the GDK lock
59  * held. It can be thought of a MT-safe version for GTK+ widgets for the
60  * following use case, where you have to worry about idle_callback()
61  * running in thread A and accessing @self after it has been finalized
62  * in thread B:
63  *
64  * |[<!-- language="C" -->
65  * static gboolean
66  * idle_callback (gpointer data)
67  * {
68  * // gdk_threads_enter(); would be needed for g_idle_add()
69  *
70  * SomeWidget *self = data;
71  * // do stuff with self
72  *
73  * self->idle_id = 0;
74  *
75  * // gdk_threads_leave(); would be needed for g_idle_add()
76  * return FALSE;
77  * }
78  *
79  * static void
80  * some_widget_do_stuff_later (SomeWidget *self)
81  * {
82  * self->idle_id = gdk_threads_add_idle (idle_callback, self)
83  * // using g_idle_add() here would require thread protection in the callback
84  * }
85  *
86  * static void
87  * some_widget_finalize (GObject *object)
88  * {
89  * SomeWidget *self = SOME_WIDGET (object);
90  * if (self->idle_id)
91  * g_source_remove (self->idle_id);
92  * G_OBJECT_CLASS (parent_class)->finalize (object);
93  * }
94  * ]|
95  *
96  * Params:
97  *     priority = the priority of the idle source. Typically this will be in the
98  *         range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE
99  *     funct = function to call
100  *     data = data to pass to @function
101  *     notify = function to call when the idle is removed, or %NULL
102  *
103  * Return: the ID (greater than 0) of the event source.
104  *
105  * Since: 2.12
106  */
107 public uint threadsAddIdleFull(int priority, GSourceFunc funct, void* data, GDestroyNotify notify)
108 {
109 	return gdk_threads_add_idle_full(priority, funct, data, notify);
110 }
111 
112 /**
113  * A wrapper for the common usage of gdk_threads_add_timeout_full()
114  * assigning the default priority, #G_PRIORITY_DEFAULT.
115  *
116  * See gdk_threads_add_timeout_full().
117  *
118  * Params:
119  *     interval = the time between calls to the function, in milliseconds
120  *         (1/1000ths of a second)
121  *     funct = function to call
122  *     data = data to pass to @function
123  *
124  * Return: the ID (greater than 0) of the event source.
125  *
126  * Since: 2.12
127  */
128 public uint threadsAddTimeout(uint interval, GSourceFunc funct, void* data)
129 {
130 	return gdk_threads_add_timeout(interval, funct, data);
131 }
132 
133 /**
134  * Sets a function to be called at regular intervals holding the GDK lock,
135  * with the given priority.  The function is called repeatedly until it
136  * returns %FALSE, at which point the timeout is automatically destroyed
137  * and the function will not be called again.  The @notify function is
138  * called when the timeout is destroyed.  The first call to the
139  * function will be at the end of the first @interval.
140  *
141  * Note that timeout functions may be delayed, due to the processing of other
142  * event sources. Thus they should not be relied on for precise timing.
143  * After each call to the timeout function, the time of the next
144  * timeout is recalculated based on the current time and the given interval
145  * (it does not try to “catch up” time lost in delays).
146  *
147  * This variant of g_timeout_add_full() can be thought of a MT-safe version
148  * for GTK+ widgets for the following use case:
149  *
150  * |[<!-- language="C" -->
151  * static gboolean timeout_callback (gpointer data)
152  * {
153  * SomeWidget *self = data;
154  *
155  * // do stuff with self
156  *
157  * self->timeout_id = 0;
158  *
159  * return G_SOURCE_REMOVE;
160  * }
161  *
162  * static void some_widget_do_stuff_later (SomeWidget *self)
163  * {
164  * self->timeout_id = g_timeout_add (timeout_callback, self)
165  * }
166  *
167  * static void some_widget_finalize (GObject *object)
168  * {
169  * SomeWidget *self = SOME_WIDGET (object);
170  *
171  * if (self->timeout_id)
172  * g_source_remove (self->timeout_id);
173  *
174  * G_OBJECT_CLASS (parent_class)->finalize (object);
175  * }
176  * ]|
177  *
178  * Params:
179  *     priority = the priority of the timeout source. Typically this will be in the
180  *         range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
181  *     interval = the time between calls to the function, in milliseconds
182  *         (1/1000ths of a second)
183  *     funct = function to call
184  *     data = data to pass to @function
185  *     notify = function to call when the timeout is removed, or %NULL
186  *
187  * Return: the ID (greater than 0) of the event source.
188  *
189  * Since: 2.12
190  */
191 public uint threadsAddTimeoutFull(int priority, uint interval, GSourceFunc funct, void* data, GDestroyNotify notify)
192 {
193 	return gdk_threads_add_timeout_full(priority, interval, funct, data, notify);
194 }
195 
196 /**
197  * A wrapper for the common usage of gdk_threads_add_timeout_seconds_full()
198  * assigning the default priority, #G_PRIORITY_DEFAULT.
199  *
200  * For details, see gdk_threads_add_timeout_full().
201  *
202  * Params:
203  *     interval = the time between calls to the function, in seconds
204  *     funct = function to call
205  *     data = data to pass to @function
206  *
207  * Return: the ID (greater than 0) of the event source.
208  *
209  * Since: 2.14
210  */
211 public uint threadsAddTimeoutSeconds(uint interval, GSourceFunc funct, void* data)
212 {
213 	return gdk_threads_add_timeout_seconds(interval, funct, data);
214 }
215 
216 /**
217  * A variant of gdk_threads_add_timeout_full() with second-granularity.
218  * See g_timeout_add_seconds_full() for a discussion of why it is
219  * a good idea to use this function if you don’t need finer granularity.
220  *
221  * Params:
222  *     priority = the priority of the timeout source. Typically this will be in the
223  *         range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
224  *     interval = the time between calls to the function, in seconds
225  *     funct = function to call
226  *     data = data to pass to @function
227  *     notify = function to call when the timeout is removed, or %NULL
228  *
229  * Return: the ID (greater than 0) of the event source.
230  *
231  * Since: 2.14
232  */
233 public uint threadsAddTimeoutSecondsFull(int priority, uint interval, GSourceFunc funct, void* data, GDestroyNotify notify)
234 {
235 	return gdk_threads_add_timeout_seconds_full(priority, interval, funct, data, notify);
236 }
237 
238 /**
239  * This function marks the beginning of a critical section in which
240  * GDK and GTK+ functions can be called safely and without causing race
241  * conditions. Only one thread at a time can be in such a critial
242  * section.
243  *
244  * Deprecated: All GDK and GTK+ calls should be made from the main
245  * thread
246  */
247 public void threadsEnter()
248 {
249 	gdk_threads_enter();
250 }
251 
252 /**
253  * Initializes GDK so that it can be used from multiple threads
254  * in conjunction with gdk_threads_enter() and gdk_threads_leave().
255  *
256  * This call must be made before any use of the main loop from
257  * GTK+; to be safe, call it before gtk_init().
258  *
259  * Deprecated: All GDK and GTK+ calls should be made from the main
260  * thread
261  */
262 public void threadsInit()
263 {
264 	gdk_threads_init();
265 }
266 
267 /**
268  * Leaves a critical region begun with gdk_threads_enter().
269  *
270  * Deprecated: All GDK and GTK+ calls should be made from the main
271  * thread
272  */
273 public void threadsLeave()
274 {
275 	gdk_threads_leave();
276 }
277 
278 /**
279  * Allows the application to replace the standard method that
280  * GDK uses to protect its data structures. Normally, GDK
281  * creates a single #GMutex that is locked by gdk_threads_enter(),
282  * and released by gdk_threads_leave(); using this function an
283  * application provides, instead, a function @enter_fn that is
284  * called by gdk_threads_enter() and a function @leave_fn that is
285  * called by gdk_threads_leave().
286  *
287  * The functions must provide at least same locking functionality
288  * as the default implementation, but can also do extra application
289  * specific processing.
290  *
291  * As an example, consider an application that has its own recursive
292  * lock that when held, holds the GTK+ lock as well. When GTK+ unlocks
293  * the GTK+ lock when entering a recursive main loop, the application
294  * must temporarily release its lock as well.
295  *
296  * Most threaded GTK+ apps won’t need to use this method.
297  *
298  * This method must be called before gdk_threads_init(), and cannot
299  * be called multiple times.
300  *
301  * Deprecated: All GDK and GTK+ calls should be made from the main
302  * thread
303  *
304  * Params:
305  *     enterFn = function called to guard GDK
306  *     leaveFn = function called to release the guard
307  *
308  * Since: 2.4
309  */
310 public void threadsSetLockFunctions(GCallback enterFn, GCallback leaveFn)
311 {
312 	gdk_threads_set_lock_functions(enterFn, leaveFn);
313 }