Code opschonen, toevoegen documentatie
[projects/chimara/chimara.git] / src / window.c
1 #include "window.h"
2
3 /* Global tree of all windows */
4 static GNode *root_window = NULL;
5
6 /**
7  * glk_window_iterate:
8  * @win: A window, or %NULL.
9  * @rockptr: Return location for the next window's rock, or %NULL.
10  *
11  * Iterates over the list of windows; if @win is %NULL, it returns the first
12  * window, otherwise the next window after @win. If there are no more, it
13  * returns #NULL. The window's rock is stored in @rockptr. If you don't want
14  * the rocks to be returned, you may set @rockptr to %NULL.
15  *
16  * The order in which windows are returned is arbitrary. The root window is
17  * not necessarily first, nor is it necessarily last. The order may change
18  * every time you create or destroy a window, invalidating the iteration.
19  *
20  * Returns: the next window, or %NULL if there are no more.
21  */
22 winid_t
23 glk_window_iterate(winid_t win, glui32 *rockptr)
24 {
25         GNode *retnode;
26         
27         if(win == NULL)
28                 retnode = root_window;
29         else
30         {
31                 GNode *node = win->window_node;
32                 if( G_NODE_IS_LEAF(node) )
33                 {
34                         while(node && node->next == NULL)
35                                 node = node->parent;
36                         if(node)
37                                 retnode = node->next;
38                         else
39                                 retnode = NULL;
40                 }
41                 else
42                         retnode = g_node_first_child(node);
43         }
44         winid_t retval = retnode? (winid_t)retnode->data : NULL;
45                 
46         /* Store the window's rock in rockptr */
47         if(retval && rockptr)
48                 *rockptr = glk_window_get_rock(retval);
49                 
50         return retval;
51 }
52
53 /**
54  * glk_window_get_rock:
55  * @win: A window.
56  * 
57  * Returns @win's rock value. Pair windows always have rock 0; all other windows
58  * have the rock value you created them with.
59  *
60  * Returns: A rock value.
61  */
62 glui32
63 glk_window_get_rock(winid_t win)
64 {
65         g_return_val_if_fail(win != NULL, 0);
66         return win->rock;
67 }
68
69 /**
70  * glk_window_get_type:
71  * @win: A window.
72  *
73  * Returns @win's type, one of #wintype_Blank, #wintype_Pair,
74  * #wintype_TextBuffer, #wintype_TextGrid, or #wintype_Graphics.
75  *
76  * Returns: The window's type.
77  */
78 glui32
79 glk_window_get_type(winid_t win)
80 {
81         g_return_val_if_fail(win != NULL, 0);
82         return win->type;
83 }
84
85 /**
86  * glk_window_get_parent:
87  * @win: A window.
88  *
89  * Returns the window @win's parent window. If @win is the root window, this
90  * returns %NULL, since the root window has no parent. Remember that the parent
91  * of every window is a pair window; other window types are always childless.
92  *
93  * Returns: A window.
94  */
95 winid_t
96 glk_window_get_parent(winid_t win)
97 {
98         g_return_val_if_fail(win != NULL, NULL);
99         /* Value will also be NULL if win is the root window */
100         return (winid_t)win->window_node->parent->data;
101 }
102
103 /**
104  * glk_window_get_sibling:
105  * @win: A window.
106  *
107  * Returns the other child of the window @win's parent. If @win is the
108  * root window, this returns %NULL.
109  *
110  * Returns: A window, or %NULL.
111  */
112 winid_t
113 glk_window_get_sibling(winid_t win)
114 {
115         g_return_val_if_fail(win != NULL, NULL);
116         
117         if(G_NODE_IS_ROOT(win->window_node))
118                 return NULL;
119         if(win->window_node->next)
120                 return (winid_t)win->window_node->next;
121         return (winid_t)win->window_node->prev;
122 }
123
124 /**
125  * glk_window_get_root:
126  * 
127  * Returns the root window. If there are no windows, this returns #NULL.
128  *
129  * Returns: A window, or #NULL.
130  */
131 winid_t
132 glk_window_get_root()
133 {
134         if(root_window == NULL)
135                 return NULL;
136         return (winid_t)root_window->data;
137 }
138
139 /**
140  * glk_window_open:
141  * @split: The window to split to create the new window. Must be 0 if there
142  * are no windows yet.
143  * @method: Position of the new window and method of size computation. One of
144  * #winmethod_Above, #winmethod_Below, #winmethod_Left, or #winmethod_Right
145  * OR'ed with #winmethod_Fixed or #winmethod_Proportional. If @wintype is
146  * #wintype_Blank, then #winmethod_Fixed is not allowed.
147  * @size: Size of the new window, in percentage points if @method is
148  * #winmethod_Proportional, otherwise in characters if @wintype is 
149  * #wintype_TextBuffer or #wintype_TextGrid, or pixels if @wintype is
150  * #wintype_Graphics.
151  * @wintype: Type of the new window. One of #wintype_Blank, #wintype_TextGrid,
152  * #wintype_TextBuffer, or #wintype_Graphics.
153  * @rock: The new window's rock value.
154  *
155  * If there are no windows, create a new root window. @split must be 0, and
156  * @method and @size are ignored. Otherwise, split window @split into two, with
157  * position, size, and type specified by @method, @size, and @wintype. See the
158  * Glk documentation for the window placement algorithm.
159  *
160  * Returns: the new window.
161  */
162 winid_t
163 glk_window_open(winid_t split, glui32 method, glui32 size, glui32 wintype, 
164                 glui32 rock)
165 {
166         extern GtkBuilder *builder;
167
168         if(split)
169         {
170                 g_warning("glk_window_open: splitting of windows not implemented");
171                 return NULL;
172         }
173
174         if(root_window != NULL)
175         {
176                 g_warning("glk_window_open: there is already a window");
177                 return NULL;
178         }
179         /* We only create one window and don't support any more than that */
180         winid_t win = g_new0(struct glk_window_struct, 1);
181         root_window = g_node_new(win);
182
183         win->rock = rock;
184         win->type = wintype;
185
186         gdk_threads_enter();
187
188         GtkBox *vbox = GTK_BOX( gtk_builder_get_object(builder, "vbox") );                      
189         if(vbox == NULL)
190         {
191                 error_dialog(NULL, NULL, "Could not find vbox");
192                 gdk_threads_leave();
193                 return NULL;
194         }
195
196         switch(wintype)
197         {
198                 case wintype_Blank:
199                 {
200                         /* A blank window will be a label without any text */
201                         GtkWidget *label = gtk_label_new("");
202                         gtk_box_pack_end(vbox, label, TRUE, TRUE, 0);
203                         gtk_widget_show(label);
204                         
205                         win->widget = label;
206                         /* You can print to a blank window's stream, but it does nothing */
207                         win->window_stream = window_stream_new(win);
208                         win->echo_stream = NULL;
209                 }
210                         break;
211                         
212                 case wintype_TextBuffer:
213                 {
214                         GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
215                         GtkWidget *textview = gtk_text_view_new();
216                         GtkTextBuffer *textbuffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(textview) );
217
218                         gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(textview), GTK_WRAP_WORD_CHAR );
219                         gtk_text_view_set_editable( GTK_TEXT_VIEW(textview), FALSE );
220
221                         gtk_container_add( GTK_CONTAINER(scrolledwindow), textview );
222                         gtk_box_pack_end(vbox, scrolledwindow, TRUE, TRUE, 0);
223                         gtk_widget_show_all(scrolledwindow);
224
225                         win->widget = textview;
226                         win->window_stream = window_stream_new(win);
227                         win->echo_stream = NULL;
228                         win->input_request_type = INPUT_REQUEST_NONE;
229                         win->line_input_buffer = NULL;
230                         win->line_input_buffer_unicode = NULL;
231
232                         /* Connect signal handlers */
233                         win->keypress_handler = g_signal_connect( G_OBJECT(textview), "key-press-event", G_CALLBACK(on_window_key_press_event), win );
234                         g_signal_handler_block( G_OBJECT(textview), win->keypress_handler );
235
236                         win->insert_text_handler = g_signal_connect_after( G_OBJECT(textbuffer), "insert-text", G_CALLBACK(after_window_insert_text), win );
237                         g_signal_handler_block( G_OBJECT(textbuffer), win->insert_text_handler );
238
239                         /* Create an editable tag to indicate uneditable parts of the window
240                         (for line input) */
241                         gtk_text_buffer_create_tag(textbuffer, "uneditable", "editable", FALSE, "editable-set", TRUE, NULL);
242
243                         /* Mark the position where the user will input text */
244                         GtkTextIter end;
245                         gtk_text_buffer_get_end_iter(textbuffer, &end);
246                         gtk_text_buffer_create_mark(textbuffer, "input_position", &end, TRUE);
247                 }
248                         break;
249                         
250                 default:
251                         g_warning("%s: unsupported window type", __func__);
252                         g_free(win);
253                         gdk_threads_leave();
254                         return NULL;
255         }
256
257         win->window_node = root_window;
258
259         gdk_threads_leave();
260
261         return win;
262 }
263
264 /**
265  * glk_window_close:
266  * @win: Window to close.
267  * @result: Pointer to a #stream_result_t in which to store the write count.
268  *
269  * Closes @win, which is pretty much exactly the opposite of opening a window.
270  * It is legal to close all your windows, or to close the root window (which is
271  * the same thing.) 
272  *
273  * The @result argument is filled with the output character count of the window
274  * stream.
275  */
276 void
277 glk_window_close(winid_t win, stream_result_t *result)
278 {
279         g_return_if_fail(win != NULL);
280
281         switch(win->type)
282         {
283                 case wintype_TextBuffer:
284                         gtk_widget_destroy( gtk_widget_get_parent(win->widget) );
285                         /* TODO: Cancel all input requests */
286                         break;
287
288                 case wintype_Blank:
289                         gtk_widget_destroy(win->widget);
290                         break;
291         }
292
293         stream_close_common(win->window_stream, result);
294
295         g_node_destroy(win->window_node);
296         /* TODO: iterate over child windows, closing them */
297
298         g_free(win);
299 }
300
301 /**
302  * glk_window_clear:
303  * @win: A window.
304  *
305  * Erases the window @win. The meaning of this depends on the window type.
306  *
307  * <itemizedlist>
308  *  <listitem><para>
309  *   Text buffer: This may do any number of things, such as delete all text in 
310  *   the window, or print enough blank lines to scroll all text beyond 
311  *   visibility, or insert a page-break marker which is treated specially by the
312  *   display part of the library.
313  *  </para></listitem>
314  *  <listitem><para>
315  *   Text grid: This will clear the window, filling all positions with blanks.
316  *   The window cursor is moved to the top left corner (position 0,0).
317  *  </para></listitem>
318  *  <listitem><para>
319  *   Graphics: Clears the entire window to its current background color.
320  *  </para></listitem>
321  *  <listitem><para>
322  *   Other window types: No effect. 
323  *  </para></listitem>
324  * </itemizedlist>
325  *
326  * It is illegal to erase a window which has line input pending. 
327  */
328 void
329 glk_window_clear(winid_t win)
330 {
331         g_return_if_fail(win != NULL);
332         g_return_if_fail(win->input_request_type != INPUT_REQUEST_LINE && win->input_request_type != INPUT_REQUEST_LINE_UNICODE);
333         
334         switch(win->type)
335         {
336                 case wintype_Blank:
337                         /* do nothing */
338                         break;
339                         
340                 case wintype_TextBuffer:
341                         /* delete all text in the window */
342                 {
343                         gdk_threads_enter();
344
345                         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
346                         GtkTextIter start, end;
347                         gtk_text_buffer_get_bounds(buffer, &start, &end);
348                         gtk_text_buffer_delete(buffer, &start, &end);
349
350                         gdk_threads_leave();
351                 }
352                         break;
353                         
354                 default:
355                         g_warning("glk_window_clear: unsupported window type");
356         }
357 }
358
359 /**
360  * glk_set_window:
361  * @win: A window.
362  *
363  * Sets the current stream to @win's window stream. It is exactly equivalent to
364  * <informalexample><programlisting>
365  *  glk_stream_set_current(glk_window_get_stream(win))
366  * </programlisting></informalexample>
367  */
368 void
369 glk_set_window(winid_t win)
370 {
371         glk_stream_set_current( glk_window_get_stream(win) );
372 }
373
374 /**
375  * glk_window_get_stream:
376  * @win: A window.
377  *
378  * Returns the stream which is associated with @win. Every window has a stream
379  * which can be printed to, but this may not be useful, depending on the window
380  * type. (For example, printing to a blank window's stream has no effect.)
381  *
382  * Returns: The window stream.
383  */
384 strid_t glk_window_get_stream(winid_t win)
385 {
386         g_return_val_if_fail(win != NULL, NULL);
387         return win->window_stream;
388 }
389
390 /**
391  * glk_window_set_echo_stream:
392  * @win: A window.
393  * @str: A stream to attach to the window, or %NULL.
394  *
395  * Attaches the stream @str to @win as a second stream. Any text printed to the
396  * window is also echoed to this second stream, which is called the window's
397  * "echo stream."
398  *
399  * Effectively, any call to glk_put_char() (or the other output commands) which
400  * is directed to @win's window stream, is replicated to @win's echo stream.
401  * This also goes for the style commands such as glk_set_style().
402  *
403  * Note that the echoing is one-way. You can still print text directly to the
404  * echo stream, and it will go wherever the stream is bound, but it does not
405  * back up and appear in the window.
406  *
407  * It is illegal to set a window's echo stream to be its own window stream,
408  * which would create an infinite loop. It is similarly illegal to create a
409  * longer loop (two or more windows echoing to each other.)
410  *
411  * You can reset a window to stop echoing by setting @str to %NULL.
412  */
413 void
414 glk_window_set_echo_stream(winid_t win, strid_t str)
415 {
416         g_return_if_fail(win != NULL);
417         
418         /* Test for an infinite loop */
419         strid_t next = str;
420         for(; next && next->type == STREAM_TYPE_WINDOW; next = next->window->echo_stream)
421         {
422                 if(next == win->window_stream)
423                 {
424                         g_warning("%s: Infinite loop detected", __func__);
425                         win->echo_stream = NULL;
426                         return;
427                 }
428         }
429         
430         win->echo_stream = str;
431 }
432
433 /**
434  * glk_window_get_echo_stream:
435  * @win: A window.
436  *
437  * Returns the echo stream of window @win. If the window has no echo stream (as
438  * is initially the case) then this returns %NULL.
439  *
440  * Returns: A stream, or %NULL.
441  */
442 strid_t
443 glk_window_get_echo_stream(winid_t win)
444 {
445         g_return_val_if_fail(win != NULL, NULL);
446         return win->echo_stream;
447 }
448
449 /**
450  * glk_window_get_size:
451  * @win: A window.
452  * @widthptr: Pointer to a location to store the window's width, or %NULL.
453  * @heightptr: Pointer to a location to store the window's height, or %NULL.
454  *
455  * Simply returns the actual size of the window, in its measurement system.
456  * Either @widthptr or @heightptr can be %NULL, if you only want one 
457  * measurement. (Or, in fact, both, if you want to waste time.)
458  */
459 void
460 glk_window_get_size(winid_t win, glui32 *widthptr, glui32 *heightptr)
461 {
462         g_return_if_fail(win != NULL);
463
464         /* TODO: Write this function */
465         /* For a text buffer window: Return the number of rows and columns which
466         would be available _if_ the window was filled with "0" (zero) characters in
467         the "normal" font. */
468         if(widthptr != NULL) {
469                 *widthptr = 0;
470         }
471
472         if(heightptr != NULL) {
473                 *heightptr = 0;
474         }
475 }
476
477 /**
478  * glk_window_move_cursor:
479  * @win: A text grid window.
480  * @xpos: Horizontal cursor position.
481  * @ypos: Vertical cursor position.
482  * 
483  * Sets the cursor position. If you move the cursor right past the end of a 
484  * line, it wraps; the next character which is printed will appear at the
485  * beginning of the next line.
486  * 
487  * If you move the cursor below the last line, or when the cursor reaches the
488  * end of the last line, it goes "off the screen" and further output has no
489  * effect. You must call glk_window_move_cursor() or glk_window_clear() to move
490  * the cursor back into the visible region.
491  * 
492  * <note><para>
493  *  Note that the arguments of glk_window_move_cursor() are <type>unsigned 
494  *  int</type>s. This is okay, since there are no negative positions. If you try
495  *  to pass a negative value, Glk will interpret it as a huge positive value,
496  *  and it will wrap or go off the last line.
497  * </para></note>
498  *
499  * <note><para>
500  *  Also note that the output cursor is not necessarily visible. In particular,
501  *  when you are requesting line or character input in a grid window, you cannot
502  *  rely on the cursor position to prompt the player where input is indicated.
503  *  You should print some character prompt at that spot -- a ">" character, for
504  *  example.
505  * </para></note>
506  */
507 void
508 glk_window_move_cursor(winid_t win, glui32 xpos, glui32 ypos)
509 {
510         g_return_if_fail(win != NULL);
511         g_return_if_fail(win->type == wintype_TextGrid);
512         /* TODO: write this function */
513 }