Remove workaround for broken package in Fedora 19
[projects/chimara/chimara.git] / libchimara / event.c
1 #include "event.h"
2 #include "magic.h"
3 #include "glk.h"
4 #include "window.h"
5 #include "input.h"
6 #include <string.h>
7
8 #include "chimara-glk.h"
9 #include "chimara-glk-private.h"
10
11 extern GPrivate glk_data_key;
12
13 #define EVENT_TIMEOUT_MICROSECONDS (3000000)
14
15 /* Internal function: push an event onto the event queue. If the event queue is
16 full, wait for max three seconds and then drop the event. If the event queue is
17 NULL, i.e. freed, then fail silently. */
18 void
19 event_throw(ChimaraGlk *glk, glui32 type, winid_t win, glui32 val1, glui32 val2)
20 {
21         ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(glk);
22         
23         if(!priv->event_queue)
24                 return;
25
26         gint64 timeout = g_get_monotonic_time() + EVENT_TIMEOUT_MICROSECONDS;
27
28         g_mutex_lock(&priv->event_lock);
29
30         /* Wait for room in the event queue */
31         while( g_queue_get_length(priv->event_queue) >= EVENT_QUEUE_MAX_LENGTH )
32                 if( !g_cond_wait_until(&priv->event_queue_not_full, &priv->event_lock, timeout) )
33                 {
34                         /* Drop the event if the event queue is still not emptying */
35                         g_mutex_unlock(&priv->event_lock);
36                         return;
37                 }
38
39         event_t *event = g_new0(event_t, 1);
40         event->type = type;
41         event->win = win;
42         event->val1 = val1;
43         event->val2 = val2;
44         g_queue_push_head(priv->event_queue, event);
45
46         /* Signal that there is an event */
47         g_cond_signal(&priv->event_queue_not_empty);
48
49         g_mutex_unlock(&priv->event_lock);
50 }
51
52 /* Helper function: Wait for an event in the event queue. If it is a forced
53  * input event, but no windows have an input request of that type, then wait
54  * for the next event and put the forced input event back on top of the queue.
55  */
56 static void
57 get_appropriate_event(event_t *event)
58 {
59         ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key);
60
61         g_mutex_lock(&glk_data->event_lock);
62
63         event_t *retrieved_event = NULL;
64
65         /* Wait for an event */
66         if( g_queue_is_empty(glk_data->event_queue) )
67                 g_cond_wait(&glk_data->event_queue_not_empty, &glk_data->event_lock);
68
69         retrieved_event = g_queue_pop_tail(glk_data->event_queue);
70
71         /* Signal that the event queue is no longer full */
72         g_cond_signal(&glk_data->event_queue_not_full);
73
74         g_mutex_unlock(&glk_data->event_lock);
75
76         if(retrieved_event->type == evtype_ForcedCharInput)
77         {
78                 /* Check for forced character input in the queue */
79                 winid_t win;
80                 for(win = glk_window_iterate(NULL, NULL); win; win = glk_window_iterate(win, NULL))
81                         if(win->input_request_type == INPUT_REQUEST_CHARACTER || win->input_request_type == INPUT_REQUEST_CHARACTER_UNICODE)
82                                 break;
83                 if(win)
84                 {
85                         force_char_input_from_queue(win, event);
86                         g_free(retrieved_event);
87                 }
88                 else
89                 {
90                         get_appropriate_event(event);
91                         g_mutex_lock(&glk_data->event_lock);
92                         g_queue_push_tail(glk_data->event_queue, retrieved_event);
93                         g_cond_signal(&glk_data->event_queue_not_empty);
94                         g_mutex_unlock(&glk_data->event_lock);
95                 }
96         }
97         else if(retrieved_event->type == evtype_ForcedLineInput)
98         {
99                 /* Check for forced line input in the queue */
100                 winid_t win;
101                 for(win = glk_window_iterate(NULL, NULL); win; win = glk_window_iterate(win, NULL))
102                         if(win->input_request_type == INPUT_REQUEST_LINE || win->input_request_type == INPUT_REQUEST_LINE_UNICODE)
103                                 break;
104                 if(win)
105                 {
106                         force_line_input_from_queue(win, event);
107                         g_free(retrieved_event);
108                 }
109                 else
110                 {
111                         get_appropriate_event(event);
112                         g_mutex_lock(&glk_data->event_lock);
113                         g_queue_push_tail(glk_data->event_queue, retrieved_event);
114                         g_cond_signal(&glk_data->event_queue_not_empty);
115                         g_mutex_unlock(&glk_data->event_lock);
116                 }
117         }
118         else
119         {
120                 if(retrieved_event == NULL)
121                 {
122                         WARNING("Retrieved NULL event from non-empty event queue");
123                         return;
124                 }
125                 memcpy(event, retrieved_event, sizeof(event_t));
126                 g_free(retrieved_event);
127         }
128 }
129
130 /**
131  * glk_select:
132  * @event: Pointer to an #event_t.
133  *
134  * Causes the program to wait for an event, and then store it in the structure
135  * pointed to by @event. Unlike most Glk functions that take pointers, the
136  * argument of glk_select() may not be %NULL.
137  *
138  * Most of the time, you only get the events that you request. However, there
139  * are some events which can arrive at any time. This is why you must always
140  * call glk_select() in a loop, and continue the loop until you get the event
141  * you really want.
142  */
143 void
144 glk_select(event_t *event)
145 {
146         g_return_if_fail(event != NULL);
147
148         /* Flush all window buffers */
149         winid_t win;
150         for(win = glk_window_iterate(NULL, NULL); win != NULL; win = glk_window_iterate(win, NULL)) {
151                 if(win->type == wintype_TextBuffer || win->type == wintype_TextGrid)
152                         flush_window_buffer(win);
153         }
154
155         ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key);
156
157         get_appropriate_event(event);
158
159         /* Check for interrupt */
160         glk_tick();
161
162         /* If the event was a line input event, the library must release the buffer */
163         if(event->type == evtype_LineInput && glk_data->unregister_arr) 
164         {
165         if(event->win->input_request_type == INPUT_REQUEST_LINE_UNICODE)
166                         (*glk_data->unregister_arr)(event->win->line_input_buffer_unicode, event->win->line_input_buffer_max_len, "&+#!Iu", event->win->buffer_rock);
167                 else
168             (*glk_data->unregister_arr)(event->win->line_input_buffer, event->win->line_input_buffer_max_len, "&+#!Cn", event->win->buffer_rock);
169     }
170         
171         /* If an abort event was generated, the thread should have exited by now */
172         g_assert(event->type != evtype_Abort);
173 }
174
175 /**
176  * glk_select_poll:
177  * @event: Return location for an event.
178  *
179  * You can also inquire if an event is available, without stopping to wait for 
180  * one to occur.
181  * 
182  * This checks if an internally-spawned event is available. If so, it stores it 
183  * in the structure pointed to by @event. If not, it sets
184  * <code>@event->type</code> to %evtype_None. Either way, it returns almost
185  * immediately.
186  * 
187  * The first question you now ask is, what is an internally-spawned event?
188  * glk_select_poll() does not check for or return %evtype_CharInput,
189  * %evtype_LineInput, %evtype_MouseInput, or %evtype_Hyperlink events. It is
190  * intended for you to test conditions which may have occurred while you are
191  * computing, and not interfacing with the player. For example, time may pass
192  * during slow computations; you can use glk_select_poll() to see if a 
193  * %evtype_Timer event has occurred. (See <link 
194  * linkend="chimara-Timer-Events">Timer Events</link>.)
195  * 
196  * At the moment, glk_select_poll() checks for %evtype_Timer, %evtype_Arrange,
197  * %evtype_Redraw and %evtype_SoundNotify events. But see <link 
198  * linkend="chimara-Other-Events">Other Events</link>.
199  * 
200  * The second question is, what does it mean that glk_select_poll() returns 
201  * <quote>almost immediately</quote>? In some Glk libraries, text that you send 
202  * to a window is buffered; it does not actually appear until you request player
203  * input with glk_select(). glk_select_poll() attends to this buffer-flushing 
204  * task in the same way. (Although it does not do the <quote><computeroutput>Hit
205  * any key to scroll down</computeroutput></quote> waiting which may be done in
206  * glk_select(); that's a player-input task.)
207  * 
208  * Similarly, on multitasking platforms, glk_select() may yield time to other
209  * processes; and glk_select_poll() does this as well.
210  * 
211  * The upshot of this is that you should not call glk_select_poll() very often. 
212  * If you are not doing much work between player inputs, you should not need to
213  * call it at all.
214  *
215  * <note><para>
216  *  For example, in a virtual machine interpreter, you should not call
217  *  glk_select_poll() after every opcode.
218  * </para></note>
219  * 
220  * However, if you are doing intense computation, you may wish to call
221  * glk_select_poll() every so often to yield time to other processes. And if you
222  * are printing intermediate results during this computation, you should
223  * glk_select_poll() every so often, so that you can be certain your output will 
224  * be displayed before the next glk_select().
225  * 
226  * <note><para>
227  *  However, you should call glk_tick() often &mdash; once per opcode in a VM
228  *  interpreter. See <link linkend="chimara-The-Tick-Thing">The Tick 
229  *  Thing</link>.
230  * </para></note>
231  */
232 void
233 glk_select_poll(event_t *event)
234 {
235         g_return_if_fail(event != NULL);
236
237         ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key);
238
239         event->type = evtype_None;
240         event->win = NULL;
241         event->val1 = 0;
242         event->val2 = 0;
243
244         g_mutex_lock(&glk_data->event_lock);
245
246         if( !g_queue_is_empty(glk_data->event_queue) )
247         {
248                 GList *link;
249                 int count;
250                 for(count = 0; (link = g_queue_peek_nth_link(glk_data->event_queue, count)) != NULL; count++)
251                 {
252                         glui32 type = ((event_t *)link->data)->type;
253                         if(type != evtype_CharInput && type != evtype_LineInput && type != evtype_MouseInput && type != evtype_Hyperlink)
254                         {
255                                 memcpy(event, link->data, sizeof(event_t));
256                                 g_free(link->data);
257                                 g_queue_delete_link(glk_data->event_queue, link);
258                                 g_cond_signal(&glk_data->event_queue_not_full);
259                                 break;
260                         }
261                 }
262         }
263
264         g_mutex_unlock(&glk_data->event_lock);
265
266         /* Check for interrupt */
267         glk_tick();
268
269         /* If an abort event was generated, the thread should have exited by now */
270         g_assert(event->type != evtype_Abort);
271 }