gdi32: Use GetImage to retrieve the brush bits in enhanced metafiles.
[wine/multimedia.git] / server / timer.c
blobb38eae71db1d176cc070dbcc7042719c13d11153
1 /*
2 * Waitable timers management
4 * Copyright (C) 1999 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #include "config.h"
22 #include "wine/port.h"
24 #include <assert.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <sys/time.h>
28 #include <sys/types.h>
29 #include <stdarg.h>
31 #include "ntstatus.h"
32 #define WIN32_NO_STATUS
33 #include "windef.h"
34 #include "winternl.h"
36 #include "file.h"
37 #include "handle.h"
38 #include "request.h"
40 struct timer
42 struct object obj; /* object header */
43 int manual; /* manual reset */
44 int signaled; /* current signaled state */
45 unsigned int period; /* timer period in ms */
46 timeout_t when; /* next expiration */
47 struct timeout_user *timeout; /* timeout user */
48 struct thread *thread; /* thread that set the APC function */
49 client_ptr_t callback; /* callback APC function */
50 client_ptr_t arg; /* callback argument */
53 static void timer_dump( struct object *obj, int verbose );
54 static struct object_type *timer_get_type( struct object *obj );
55 static int timer_signaled( struct object *obj, struct thread *thread );
56 static int timer_satisfied( struct object *obj, struct thread *thread );
57 static unsigned int timer_map_access( struct object *obj, unsigned int access );
58 static void timer_destroy( struct object *obj );
60 static const struct object_ops timer_ops =
62 sizeof(struct timer), /* size */
63 timer_dump, /* dump */
64 timer_get_type, /* get_type */
65 add_queue, /* add_queue */
66 remove_queue, /* remove_queue */
67 timer_signaled, /* signaled */
68 timer_satisfied, /* satisfied */
69 no_signal, /* signal */
70 no_get_fd, /* get_fd */
71 timer_map_access, /* map_access */
72 default_get_sd, /* get_sd */
73 default_set_sd, /* set_sd */
74 no_lookup_name, /* lookup_name */
75 no_open_file, /* open_file */
76 no_close_handle, /* close_handle */
77 timer_destroy /* destroy */
81 /* create a timer object */
82 static struct timer *create_timer( struct directory *root, const struct unicode_str *name,
83 unsigned int attr, int manual )
85 struct timer *timer;
87 if ((timer = create_named_object_dir( root, name, attr, &timer_ops )))
89 if (get_error() != STATUS_OBJECT_NAME_EXISTS)
91 /* initialize it if it didn't already exist */
92 timer->manual = manual;
93 timer->signaled = 0;
94 timer->when = 0;
95 timer->period = 0;
96 timer->timeout = NULL;
97 timer->thread = NULL;
100 return timer;
103 /* callback on timer expiration */
104 static void timer_callback( void *private )
106 struct timer *timer = (struct timer *)private;
108 /* queue an APC */
109 if (timer->thread)
111 apc_call_t data;
113 memset( &data, 0, sizeof(data) );
114 if (timer->callback)
116 data.type = APC_TIMER;
117 data.timer.func = timer->callback;
118 data.timer.time = timer->when;
119 data.timer.arg = timer->arg;
121 else data.type = APC_NONE; /* wake up only */
123 if (!thread_queue_apc( timer->thread, &timer->obj, &data ))
125 release_object( timer->thread );
126 timer->thread = NULL;
130 if (timer->period) /* schedule the next expiration */
132 timer->when += (timeout_t)timer->period * 10000;
133 timer->timeout = add_timeout_user( timer->when, timer_callback, timer );
135 else timer->timeout = NULL;
137 /* wake up waiters */
138 timer->signaled = 1;
139 wake_up( &timer->obj, 0 );
142 /* cancel a running timer */
143 static int cancel_timer( struct timer *timer )
145 int signaled = timer->signaled;
147 if (timer->timeout)
149 remove_timeout_user( timer->timeout );
150 timer->timeout = NULL;
152 if (timer->thread)
154 thread_cancel_apc( timer->thread, &timer->obj, APC_TIMER );
155 release_object( timer->thread );
156 timer->thread = NULL;
158 return signaled;
161 /* set the timer expiration and period */
162 static int set_timer( struct timer *timer, timeout_t expire, unsigned int period,
163 client_ptr_t callback, client_ptr_t arg )
165 int signaled = cancel_timer( timer );
166 if (timer->manual)
168 period = 0; /* period doesn't make any sense for a manual timer */
169 timer->signaled = 0;
171 timer->when = (expire <= 0) ? current_time - expire : max( expire, current_time );
172 timer->period = period;
173 timer->callback = callback;
174 timer->arg = arg;
175 if (callback) timer->thread = (struct thread *)grab_object( current );
176 timer->timeout = add_timeout_user( timer->when, timer_callback, timer );
177 return signaled;
180 static void timer_dump( struct object *obj, int verbose )
182 struct timer *timer = (struct timer *)obj;
183 assert( obj->ops == &timer_ops );
184 fprintf( stderr, "Timer manual=%d when=%s period=%u ",
185 timer->manual, get_timeout_str(timer->when), timer->period );
186 dump_object_name( &timer->obj );
187 fputc( '\n', stderr );
190 static struct object_type *timer_get_type( struct object *obj )
192 static const WCHAR name[] = {'T','i','m','e','r'};
193 static const struct unicode_str str = { name, sizeof(name) };
194 return get_object_type( &str );
197 static int timer_signaled( struct object *obj, struct thread *thread )
199 struct timer *timer = (struct timer *)obj;
200 assert( obj->ops == &timer_ops );
201 return timer->signaled;
204 static int timer_satisfied( struct object *obj, struct thread *thread )
206 struct timer *timer = (struct timer *)obj;
207 assert( obj->ops == &timer_ops );
208 if (!timer->manual) timer->signaled = 0;
209 return 0;
212 static unsigned int timer_map_access( struct object *obj, unsigned int access )
214 if (access & GENERIC_READ) access |= STANDARD_RIGHTS_READ | SYNCHRONIZE | TIMER_QUERY_STATE;
215 if (access & GENERIC_WRITE) access |= STANDARD_RIGHTS_WRITE | TIMER_MODIFY_STATE;
216 if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
217 if (access & GENERIC_ALL) access |= TIMER_ALL_ACCESS;
218 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
221 static void timer_destroy( struct object *obj )
223 struct timer *timer = (struct timer *)obj;
224 assert( obj->ops == &timer_ops );
226 if (timer->timeout) remove_timeout_user( timer->timeout );
227 if (timer->thread) release_object( timer->thread );
230 /* create a timer */
231 DECL_HANDLER(create_timer)
233 struct timer *timer;
234 struct unicode_str name;
235 struct directory *root = NULL;
237 reply->handle = 0;
238 get_req_unicode_str( &name );
239 if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
240 return;
242 if ((timer = create_timer( root, &name, req->attributes, req->manual )))
244 reply->handle = alloc_handle( current->process, timer, req->access, req->attributes );
245 release_object( timer );
248 if (root) release_object( root );
251 /* open a handle to a timer */
252 DECL_HANDLER(open_timer)
254 struct unicode_str name;
255 struct directory *root = NULL;
256 struct timer *timer;
258 get_req_unicode_str( &name );
259 if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
260 return;
262 if ((timer = open_object_dir( root, &name, req->attributes, &timer_ops )))
264 reply->handle = alloc_handle( current->process, &timer->obj, req->access, req->attributes );
265 release_object( timer );
268 if (root) release_object( root );
271 /* set a waitable timer */
272 DECL_HANDLER(set_timer)
274 struct timer *timer;
276 if ((timer = (struct timer *)get_handle_obj( current->process, req->handle,
277 TIMER_MODIFY_STATE, &timer_ops )))
279 reply->signaled = set_timer( timer, req->expire, req->period, req->callback, req->arg );
280 release_object( timer );
284 /* cancel a waitable timer */
285 DECL_HANDLER(cancel_timer)
287 struct timer *timer;
289 if ((timer = (struct timer *)get_handle_obj( current->process, req->handle,
290 TIMER_MODIFY_STATE, &timer_ops )))
292 reply->signaled = cancel_timer( timer );
293 release_object( timer );
297 /* Get information on a waitable timer */
298 DECL_HANDLER(get_timer_info)
300 struct timer *timer;
302 if ((timer = (struct timer *)get_handle_obj( current->process, req->handle,
303 TIMER_QUERY_STATE, &timer_ops )))
305 reply->when = timer->when;
306 reply->signaled = timer->signaled;
307 release_object( timer );