X-Git-Url: https://git.stderr.nl/gitweb?p=projects%2Fchimara%2Fchimara.git;a=blobdiff_plain;f=libchimara%2Fwindow.c;h=a4366b4b8ca4c6f11c15da94c38c504f42b53386;hp=5e0ec5015ff95cfded035c18a4b5882d08499a5d;hb=1e0dc5378f314f555e3b923c6d95f5017abd528b;hpb=d2379f1ae607ccb5391f36969d566bf6be0a24cd diff --git a/libchimara/window.c b/libchimara/window.c index 5e0ec50..a4366b4 100644 --- a/libchimara/window.c +++ b/libchimara/window.c @@ -1,8 +1,84 @@ +#include #include "window.h" #include "magic.h" #include "chimara-glk-private.h" +#include "gi_dispa.h" +#include "pager.h" -extern ChimaraGlkPrivate *glk_data; +extern GPrivate glk_data_key; + +static winid_t +window_new_common(glui32 rock) +{ + ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key); + winid_t win = g_new0(struct glk_window_struct, 1); + + win->magic = MAGIC_WINDOW; + win->rock = rock; + if(glk_data->register_obj) + win->disprock = (*glk_data->register_obj)(win, gidisp_Class_Window); + + win->window_node = g_node_new(win); + + /* Every window has a window stream, but printing to it might have no effect */ + win->window_stream = stream_new_common(0); + win->window_stream->file_mode = filemode_Write; + win->window_stream->type = STREAM_TYPE_WINDOW; + win->window_stream->window = win; + win->window_stream->style = "normal"; + win->window_stream->glk_style = "normal"; + + win->echo_stream = NULL; + win->input_request_type = INPUT_REQUEST_NONE; + win->line_input_buffer = NULL; + win->line_input_buffer_unicode = NULL; + win->history = NULL; + win->echo_line_input = TRUE; + win->echo_current_line_input = TRUE; + win->extra_line_terminators = NULL; + win->current_extra_line_terminators = NULL; + + /* Initialise the buffer */ + win->buffer = g_string_sized_new(1024); + + /* Initialise hyperlink table */ + win->hyperlinks = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, g_free); + + return win; +} + +/* Internal function: do all the stuff necessary to close a window. Call only + from Glk thread. */ +static void +window_close_common(winid_t win, gboolean destroy_node) +{ + ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key); + + if(glk_data->unregister_obj) + { + (*glk_data->unregister_obj)(win, gidisp_Class_Window, win->disprock); + win->disprock.ptr = NULL; + } + + if(destroy_node) + g_node_destroy(win->window_node); + + win->magic = MAGIC_FREE; + + g_list_foreach(win->history, (GFunc)g_free, NULL); + g_list_free(win->history); + g_slist_free(win->extra_line_terminators); + g_slist_free(win->current_extra_line_terminators); + + g_string_free(win->buffer, TRUE); + g_hash_table_destroy(win->hyperlinks); + g_free(win->current_hyperlink); + + if(win->backing_store) + cairo_surface_destroy(win->backing_store); + + g_free(win); +} /** * glk_window_iterate: @@ -24,7 +100,8 @@ winid_t glk_window_iterate(winid_t win, glui32 *rockptr) { VALID_WINDOW_OR_NULL(win, return NULL); - + + ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key); GNode *retnode; if(win == NULL) @@ -100,7 +177,11 @@ winid_t glk_window_get_parent(winid_t win) { VALID_WINDOW(win, return NULL); + /* Value will also be NULL if win is the root window */ + if(win->window_node->parent == NULL) + return NULL; + return (winid_t)win->window_node->parent->data; } @@ -121,8 +202,8 @@ glk_window_get_sibling(winid_t win) if(G_NODE_IS_ROOT(win->window_node)) return NULL; if(win->window_node->next) - return (winid_t)win->window_node->next; - return (winid_t)win->window_node->prev; + return (winid_t)win->window_node->next->data; + return (winid_t)win->window_node->prev->data; } /** @@ -135,6 +216,7 @@ glk_window_get_sibling(winid_t win) winid_t glk_window_get_root() { + ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key); if(glk_data->root_window == NULL) return NULL; return (winid_t)glk_data->root_window->data; @@ -147,7 +229,8 @@ glk_window_get_root() * @method: Position of the new window and method of size computation. One of * %winmethod_Above, %winmethod_Below, %winmethod_Left, or %winmethod_Right * OR'ed with %winmethod_Fixed or %winmethod_Proportional. If @wintype is - * %wintype_Blank, then %winmethod_Fixed is not allowed. + * %wintype_Blank, then %winmethod_Fixed is not allowed. May also be OR'ed with + * %winmethod_Border or %winmethod_NoBorder. * @size: Size of the new window, in percentage points if @method is * %winmethod_Proportional, otherwise in characters if @wintype is * %wintype_TextBuffer or %wintype_TextGrid, or pixels if @wintype is @@ -163,9 +246,13 @@ glk_window_get_root() * * If any windows exist, new windows must be created by splitting existing * ones. @split is the window you want to split; this must - * not be zero. @method is a mask of constants to specify the - * direction and the split method (see below). @size is the size of the split. - * @wintype is the type of window you're creating, and @rock is the rock. + * not be zero. @method specifies the direction and the split method + * (see below). @size is the size of the split. @wintype is the type of window + * you're creating, and @rock is the rock. + * + * The method argument must be the logical-or of a direction constant + * (%winmethod_Above, %winmethod_Below, %winmethod_Left, %winmethod_Right) and a + * split-method constant (%winmethod_Fixed, %winmethod_Proportional). * * Remember that it is possible that the library will be unable to create a new * window, in which case glk_window_open() will return %NULL. @@ -211,11 +298,11 @@ glk_window_get_root() * * So to create a text buffer window which takes the top 40% of the original * window's space, you would execute - * |[ newwin = #glk_window_open(win, #winmethod_Above | #winmethod_Proportional, 40, #wintype_TextBuffer, 0); ]| + * |[ newwin = glk_window_open(win, winmethod_Above | winmethod_Proportional, 40, wintype_TextBuffer, 0); ]| * * To create a text grid which is always five lines high, at the bottom of the * original window, you would do - * |[ newwin = #glk_window_open(win, #winmethod_Below | #winmethod_Fixed, 5, #wintype_TextGrid, 0); ]| + * |[ newwin = glk_window_open(win, winmethod_Below | winmethod_Fixed, 5, wintype_TextGrid, 0); ]| * * Note that the meaning of the @size argument depends on the @method argument. * If the method is %winmethod_Fixed, it also depends on the @wintype argument. @@ -260,7 +347,8 @@ glk_window_get_root() * O. C gets two rows; A gets the rest. All done. * * Then the user maliciously starts squeezing the window down, in stages: - * + * + * * * * @@ -328,16 +416,16 @@ glk_window_get_root() * A C * * - * After the first split, the new pair window (O1, which covers the whole - * screen) knows that its first child (A) is above the second, and gets 50% of - * its own area. (A is the key window for this split, but a proportional split - * doesn't care about key windows.) + * The initial window is A. After the first split, the new pair window (O1, + * which covers the whole screen) knows that its new child (B) is below A, and + * gets 50% of its own area. (B is the key window for this split, but a + * proportional split doesn't care about key windows.) * - * After the second split, all this remains true; O1 knows that its first child - * gets 50% of its space, and A is O1's key window. But now O1's first child is - * O2 instead of A. The newer pair window (O2) knows that its first child (C) - * is above the second, and gets a fixed size of two rows. (As measured in C's - * font, because C is O2's key window.) + * After the second split, all this remains true; O1 knows + * that its first child gets 50% of its space, and B is O1's key window. But + * now O1's first child is O2 instead of A. The newer pair window (O2) knows + * that its first child (C) is above the second, and gets a fixed size of two + * rows. (As measured in C's font, because C is O2's key window.) * * If we split C, now, the resulting pair will still be two C-font rows high * — that is, tall enough for two lines of whatever font C displays. For @@ -374,8 +462,11 @@ glk_window_open(winid_t split, glui32 method, glui32 size, glui32 wintype, glui32 rock) { VALID_WINDOW_OR_NULL(split, return NULL); - g_return_val_if_fail(method == (method & (winmethod_DirMask | winmethod_DivisionMask)), NULL); - g_return_val_if_fail(!(((method & winmethod_DivisionMask) == winmethod_Proportional) && size > 100), NULL); + g_return_val_if_fail(!(((method & winmethod_DivisionMask) == winmethod_Proportional) && size > 100), NULL); + if(method != (method & (winmethod_DirMask | winmethod_DivisionMask | winmethod_BorderMask))) + WARNING("Unrecognized bits in method constant"); + + ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key); if(split == NULL && glk_data->root_window != NULL) { @@ -386,11 +477,8 @@ glk_window_open(winid_t split, glui32 method, glui32 size, glui32 wintype, gdk_threads_enter(); /* Create the new window */ - winid_t win = g_new0(struct glk_window_struct, 1); - win->magic = MAGIC_WINDOW; - win->rock = rock; + winid_t win = window_new_common(rock); win->type = wintype; - win->window_node = g_node_new(win); switch(wintype) { @@ -405,53 +493,60 @@ glk_window_open(winid_t split, glui32 method, glui32 size, glui32 wintype, /* A blank window has no size */ win->unit_width = 0; win->unit_height = 0; - /* You can print to a blank window's stream, but it does nothing */ - win->window_stream = window_stream_new(win); - win->echo_stream = NULL; } break; case wintype_TextGrid: { GtkWidget *textview = gtk_text_view_new(); + GtkTextBuffer *textbuffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(textview) ); gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(textview), GTK_WRAP_NONE ); gtk_text_view_set_editable( GTK_TEXT_VIEW(textview), FALSE ); gtk_widget_show(textview); - /* Set the window's font */ - gtk_widget_modify_font(textview, glk_data->monospace_font_desc); + /* Create the styles available to the window stream */ + style_init_textgrid(textbuffer); + gtk_widget_modify_font( textview, get_current_font(wintype) ); win->widget = textview; win->frame = textview; /* Determine the size of a "0" character in pixels */ PangoLayout *zero = gtk_widget_create_pango_layout(textview, "0"); - pango_layout_set_font_description(zero, glk_data->monospace_font_desc); + pango_layout_set_font_description( zero, get_current_font(wintype) ); pango_layout_get_pixel_size(zero, &(win->unit_width), &(win->unit_height)); g_object_unref(zero); - - /* Set the other parameters (width and height are set later) */ - win->window_stream = window_stream_new(win); - win->echo_stream = NULL; - win->input_request_type = INPUT_REQUEST_NONE; - win->line_input_buffer = NULL; - win->line_input_buffer_unicode = NULL; + /* width and height are set later */ /* Connect signal handlers */ - win->keypress_handler = g_signal_connect( G_OBJECT(textview), "key-press-event", G_CALLBACK(on_window_key_press_event), win ); - g_signal_handler_block( G_OBJECT(textview), win->keypress_handler ); + win->char_input_keypress_handler = g_signal_connect(textview, "key-press-event", G_CALLBACK(on_char_input_key_press_event), win); + g_signal_handler_block(textview, win->char_input_keypress_handler); + win->line_input_keypress_handler = g_signal_connect(textview, "key-press-event", G_CALLBACK(on_line_input_key_press_event), win); + g_signal_handler_block(textview, win->line_input_keypress_handler); + win->shutdown_keypress_handler = g_signal_connect(textview, "key-press-event", G_CALLBACK(on_shutdown_key_press_event), win); + g_signal_handler_block(textview, win->shutdown_keypress_handler); + win->button_press_event_handler = g_signal_connect( textview, "button-press-event", G_CALLBACK(on_window_button_press), win ); + g_signal_handler_block(textview, win->button_press_event_handler); } break; case wintype_TextBuffer: { + GtkWidget *overlay = gtk_overlay_new(); GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL); GtkWidget *textview = gtk_text_view_new(); + GtkWidget *pager = gtk_button_new_with_label("More"); + GtkWidget *image = gtk_image_new_from_stock(GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON); GtkTextBuffer *textbuffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(textview) ); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC ); - + + gtk_button_set_image( GTK_BUTTON(pager), image ); + gtk_widget_set_halign(pager, GTK_ALIGN_END); + gtk_widget_set_valign(pager, GTK_ALIGN_END); + gtk_widget_set_no_show_all(pager, TRUE); + gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(textview), GTK_WRAP_WORD_CHAR ); gtk_text_view_set_editable( GTK_TEXT_VIEW(textview), FALSE ); gtk_text_view_set_pixels_inside_wrap( GTK_TEXT_VIEW(textview), 3 ); @@ -459,47 +554,84 @@ glk_window_open(winid_t split, glui32 method, glui32 size, glui32 wintype, gtk_text_view_set_right_margin( GTK_TEXT_VIEW(textview), 20 ); gtk_container_add( GTK_CONTAINER(scrolledwindow), textview ); - gtk_widget_show_all(scrolledwindow); + gtk_container_add( GTK_CONTAINER(overlay), scrolledwindow ); + gtk_overlay_add_overlay( GTK_OVERLAY(overlay), pager ); + gtk_widget_show_all(overlay); - /* Set the window's font */ - gtk_widget_modify_font(textview, glk_data->default_font_desc); - win->widget = textview; - win->frame = scrolledwindow; - + win->scrolledwindow = scrolledwindow; + win->pager = pager; + win->frame = overlay; + + /* Create the styles available to the window stream */ + style_init_textbuffer(textbuffer); + gtk_widget_modify_font( textview, get_current_font(wintype) ); + /* Determine the size of a "0" character in pixels */ PangoLayout *zero = gtk_widget_create_pango_layout(textview, "0"); - pango_layout_set_font_description(zero, glk_data->default_font_desc); + pango_layout_set_font_description( zero, get_current_font(wintype) ); pango_layout_get_pixel_size(zero, &(win->unit_width), &(win->unit_height)); g_object_unref(zero); - - /* Set the other parameters */ - win->window_stream = window_stream_new(win); - win->echo_stream = NULL; - win->input_request_type = INPUT_REQUEST_NONE; - win->line_input_buffer = NULL; - win->line_input_buffer_unicode = NULL; /* Connect signal handlers */ - win->keypress_handler = g_signal_connect( G_OBJECT(textview), "key-press-event", G_CALLBACK(on_window_key_press_event), win ); - g_signal_handler_block( G_OBJECT(textview), win->keypress_handler ); + + /* Pager */ + g_signal_connect_after( textview, "size-allocate", G_CALLBACK(pager_after_size_allocate), win ); + win->pager_keypress_handler = g_signal_connect( textview, "key-press-event", G_CALLBACK(pager_on_key_press_event), win ); + g_signal_handler_block(textview, win->pager_keypress_handler); + GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scrolledwindow)); + win->pager_adjustment_handler = g_signal_connect_after(adj, "value-changed", G_CALLBACK(pager_after_adjustment_changed), win); + g_signal_connect(pager, "clicked", G_CALLBACK(pager_on_clicked), win); - win->insert_text_handler = g_signal_connect_after( G_OBJECT(textbuffer), "insert-text", G_CALLBACK(after_window_insert_text), win ); - g_signal_handler_block( G_OBJECT(textbuffer), win->insert_text_handler ); + /* Char and line input */ + win->char_input_keypress_handler = g_signal_connect( textview, "key-press-event", G_CALLBACK(on_char_input_key_press_event), win ); + g_signal_handler_block(textview, win->char_input_keypress_handler); + win->line_input_keypress_handler = g_signal_connect( textview, "key-press-event", G_CALLBACK(on_line_input_key_press_event), win ); + g_signal_handler_block(textview, win->line_input_keypress_handler); + win->insert_text_handler = g_signal_connect_after( textbuffer, "insert-text", G_CALLBACK(after_window_insert_text), win ); + g_signal_handler_block(textbuffer, win->insert_text_handler); + + /* Shutdown key press */ + win->shutdown_keypress_handler = g_signal_connect( textview, "key-press-event", G_CALLBACK(on_shutdown_key_press_event), win ); + g_signal_handler_block(textview, win->shutdown_keypress_handler); /* Create an editable tag to indicate uneditable parts of the window (for line input) */ gtk_text_buffer_create_tag(textbuffer, "uneditable", "editable", FALSE, "editable-set", TRUE, NULL); - /* Create the default styles available to the window stream */ - style_init_textbuffer(textbuffer); - - /* Mark the position where the user will input text */ + /* Mark the position where the user will input text and the end mark */ GtkTextIter end; gtk_text_buffer_get_end_iter(textbuffer, &end); gtk_text_buffer_create_mark(textbuffer, "input_position", &end, TRUE); + gtk_text_buffer_create_mark(textbuffer, "end_position", &end, FALSE); + + /* Create the pager position mark; it stands for the last character in the buffer + that has been on-screen */ + gtk_text_buffer_create_mark(textbuffer, "pager_position", &end, TRUE); } break; + + case wintype_Graphics: + { + GtkWidget *image = gtk_drawing_area_new(); + gtk_widget_show(image); + + win->unit_width = 1; + win->unit_height = 1; + win->widget = image; + win->frame = image; + win->background_color = 0x00FFFFFF; + win->backing_store = NULL; + + /* Connect signal handlers */ + win->button_press_event_handler = g_signal_connect(image, "button-press-event", G_CALLBACK(on_window_button_press), win); + g_signal_handler_block(image, win->button_press_event_handler); + win->shutdown_keypress_handler = g_signal_connect(image, "key-press-event", G_CALLBACK(on_shutdown_key_press_event), win); + g_signal_handler_block(image, win->shutdown_keypress_handler); + g_signal_connect(image, "configure-event", G_CALLBACK(on_graphics_configure), win); + g_signal_connect(image, "draw", G_CALLBACK(on_graphics_draw), win); + } + break; default: gdk_threads_leave(); @@ -519,14 +651,8 @@ glk_window_open(winid_t split, glui32 method, glui32 size, glui32 wintype, { /* When splitting, construct a new parent window * copying most characteristics from the window that is being split */ - winid_t pair = g_new0(struct glk_window_struct, 1); - pair->magic = MAGIC_WINDOW; - pair->rock = 0; + winid_t pair = window_new_common(0); pair->type = wintype_Pair; - pair->window_node = g_node_new(pair); - /* You can print to a pair window's window stream, but it has no effect */ - pair->window_stream = window_stream_new(pair); - pair->echo_stream = NULL; /* The pair window must know about its children's split method */ pair->key_window = win; @@ -565,10 +691,10 @@ glk_window_open(winid_t split, glui32 method, glui32 size, glui32 wintype, } /* Set the window as a child of the Glk widget, don't trigger an arrange event */ - g_mutex_lock(glk_data->arrange_lock); + g_mutex_lock(&glk_data->arrange_lock); glk_data->needs_rearrange = TRUE; glk_data->ignore_next_arrange_event = TRUE; - g_mutex_unlock(glk_data->arrange_lock); + g_mutex_unlock(&glk_data->arrange_lock); gtk_widget_set_parent(win->frame, GTK_WIDGET(glk_data->self)); gtk_widget_queue_resize(GTK_WIDGET(glk_data->self)); @@ -608,6 +734,7 @@ destroy_windows_below(winid_t win, stream_result_t *result) case wintype_Blank: case wintype_TextGrid: case wintype_TextBuffer: + case wintype_Graphics: gtk_widget_unparent(win->frame); break; @@ -631,8 +758,7 @@ free_winids_below(winid_t win) free_winids_below(win->window_node->children->data); free_winids_below(win->window_node->children->next->data); } - win->magic = MAGIC_FREE; - g_free(win); + window_close_common(win, FALSE); } /** @@ -701,7 +827,9 @@ void glk_window_close(winid_t win, stream_result_t *result) { VALID_WINDOW(win, return); - + + ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key); + gdk_threads_enter(); /* Prevent redraw while we're trashing the window */ /* If any pair windows have this window or its children as a key window, @@ -722,12 +850,16 @@ glk_window_close(winid_t win, stream_result_t *result) /* Parent window changes from a split window into the sibling window */ /* The parent of any window is either a pair window or NULL */ GNode *pair_node = win->window_node->parent; - g_node_destroy(win->window_node); /* If win was not the root window: */ if(pair_node != NULL) { gboolean new_child_on_left = ( pair_node == g_node_first_sibling(pair_node) ); - GNode *sibling_node = pair_node->children; /* only one child left */ + + /* Lookup our sibling */ + GNode *sibling_node = pair_node->children; + if(sibling_node == win->window_node) + sibling_node = sibling_node->next; + GNode *new_parent_node = pair_node->parent; g_node_unlink(pair_node); g_node_unlink(sibling_node); @@ -745,25 +877,21 @@ glk_window_close(winid_t win, stream_result_t *result) g_node_append(new_parent_node, sibling_node); } - winid_t pair = (winid_t) pair_node->data; - g_node_destroy(pair_node); - - pair->magic = MAGIC_FREE; - g_free(pair); + stream_close_common( ((winid_t) pair_node->data)->window_stream, NULL ); + window_close_common( (winid_t) pair_node->data, TRUE); } else /* it was the root window */ { glk_data->root_window = NULL; } - win->magic = MAGIC_FREE; - g_free(win); + window_close_common(win, FALSE); /* Schedule a redraw */ - g_mutex_lock(glk_data->arrange_lock); + g_mutex_lock(&glk_data->arrange_lock); glk_data->needs_rearrange = TRUE; glk_data->ignore_next_arrange_event = TRUE; - g_mutex_unlock(glk_data->arrange_lock); + g_mutex_unlock(&glk_data->arrange_lock); gtk_widget_queue_resize( GTK_WIDGET(glk_data->self) ); gdk_threads_leave(); } @@ -786,15 +914,17 @@ glk_window_close(winid_t win, stream_result_t *result) * * Text grid * - * This will clear the window, filling all positions with blanks. The window - * cursor is moved to the top left corner (position 0,0). + * This will clear the window, filling all positions with blanks (in the + * normal style). The window cursor is moved to the top left corner (position + * 0,0). * * * * Graphics * * Clears the entire window to its current background color. See Graphics Windows. + * linkend="chimara-The-Types-of-Windows#wintype-Graphics">Graphics + * Windows. * * * @@ -810,7 +940,9 @@ glk_window_clear(winid_t win) { VALID_WINDOW(win, return); g_return_if_fail(win->input_request_type != INPUT_REQUEST_LINE && win->input_request_type != INPUT_REQUEST_LINE_UNICODE); - + + ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key); + switch(win->type) { case wintype_Blank: @@ -822,11 +954,11 @@ glk_window_clear(winid_t win) /* fill the buffer with blanks */ { /* Wait for the window's size to be updated */ - g_mutex_lock(glk_data->arrange_lock); + g_mutex_lock(&glk_data->arrange_lock); if(glk_data->needs_rearrange) - g_cond_wait(glk_data->rearranged, glk_data->arrange_lock); - g_mutex_unlock(glk_data->arrange_lock); - + g_cond_wait(&glk_data->rearranged, &glk_data->arrange_lock); + g_mutex_unlock(&glk_data->arrange_lock); + gdk_threads_enter(); /* Manually put newlines at the end of each row of characters in the buffer; manual newlines make resizing the window's grid easier. */ @@ -844,9 +976,12 @@ glk_window_clear(winid_t win) gtk_text_buffer_set_text(textbuffer, text, -1); g_free(text); - GtkTextIter begin; - gtk_text_buffer_get_start_iter(textbuffer, &begin); - gtk_text_buffer_move_mark_by_name(textbuffer, "cursor_position", &begin); + GtkTextIter start, end; + gtk_text_buffer_get_start_iter(textbuffer, &start); + gtk_text_buffer_get_end_iter(textbuffer, &end); + style_apply(win, &start, &end); + + gtk_text_buffer_move_mark_by_name(textbuffer, "cursor_position", &start); gdk_threads_leave(); } @@ -865,6 +1000,24 @@ glk_window_clear(winid_t win) gdk_threads_leave(); } break; + + case wintype_Graphics: + { + GtkAllocation allocation; + + /* Wait for the window's size to be updated */ + g_mutex_lock(&glk_data->arrange_lock); + if(glk_data->needs_rearrange) + g_cond_wait(&glk_data->rearranged, &glk_data->arrange_lock); + g_mutex_unlock(&glk_data->arrange_lock); + + gdk_threads_enter(); + gtk_widget_get_allocation(win->widget, &allocation); + gdk_threads_leave(); + + glk_window_erase_rect(win, 0, 0, allocation.width, allocation.height); + } + break; default: ILLEGAL_PARAM("Unknown window type: %d", win->type); @@ -873,17 +1026,23 @@ glk_window_clear(winid_t win) /** * glk_set_window: - * @win: A window. + * @win: A window, or %NULL. * - * Sets the current stream to @win's window stream. It is exactly equivalent to - * |[ #glk_stream_set_current(#glk_window_get_stream(@win)) ]| + * Sets the current stream to @win's window stream. If @win is %NULL, it is + * equivalent to + * |[ glk_stream_set_current(NULL); ]| + * If @win is not %NULL, it is equivalent to + * |[ glk_stream_set_current(glk_window_get_stream(win)); ]| * See Streams. */ void glk_set_window(winid_t win) { - VALID_WINDOW(win, return); - glk_stream_set_current( glk_window_get_stream(win) ); + VALID_WINDOW_OR_NULL(win, return); + if(win) + glk_stream_set_current( glk_window_get_stream(win) ); + else + glk_stream_set_current(NULL); } /** @@ -976,6 +1135,9 @@ glk_window_get_size(winid_t win, glui32 *widthptr, glui32 *heightptr) { VALID_WINDOW(win, return); + GtkAllocation allocation; + ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key); + switch(win->type) { case wintype_Blank: @@ -988,15 +1150,16 @@ glk_window_get_size(winid_t win, glui32 *widthptr, glui32 *heightptr) case wintype_TextGrid: /* Wait until the window's size is current */ - g_mutex_lock(glk_data->arrange_lock); + g_mutex_lock(&glk_data->arrange_lock); if(glk_data->needs_rearrange) - g_cond_wait(glk_data->rearranged, glk_data->arrange_lock); - g_mutex_unlock(glk_data->arrange_lock); - + g_cond_wait(&glk_data->rearranged, &glk_data->arrange_lock); + g_mutex_unlock(&glk_data->arrange_lock); + gdk_threads_enter(); + gtk_widget_get_allocation(win->widget, &allocation); /* Cache the width and height */ - win->width = (glui32)(win->widget->allocation.width / win->unit_width); - win->height = (glui32)(win->widget->allocation.height / win->unit_height); + win->width = (glui32)(allocation.width / win->unit_width); + win->height = (glui32)(allocation.height / win->unit_height); gdk_threads_leave(); if(widthptr != NULL) @@ -1006,17 +1169,34 @@ glk_window_get_size(winid_t win, glui32 *widthptr, glui32 *heightptr) break; case wintype_TextBuffer: - /* Wait until the window's size is current */ - g_mutex_lock(glk_data->arrange_lock); + /* Wait until the window's size is current */ + g_mutex_lock(&glk_data->arrange_lock); if(glk_data->needs_rearrange) - g_cond_wait(glk_data->rearranged, glk_data->arrange_lock); - g_mutex_unlock(glk_data->arrange_lock); - + g_cond_wait(&glk_data->rearranged, &glk_data->arrange_lock); + g_mutex_unlock(&glk_data->arrange_lock); + + gdk_threads_enter(); + gtk_widget_get_allocation(win->widget, &allocation); + if(widthptr != NULL) + *widthptr = (glui32)(allocation.width / win->unit_width); + if(heightptr != NULL) + *heightptr = (glui32)(allocation.height / win->unit_height); + gdk_threads_leave(); + + break; + + case wintype_Graphics: + g_mutex_lock(&glk_data->arrange_lock); + if(glk_data->needs_rearrange) + g_cond_wait(&glk_data->rearranged, &glk_data->arrange_lock); + g_mutex_unlock(&glk_data->arrange_lock); + gdk_threads_enter(); + gtk_widget_get_allocation(win->widget, &allocation); if(widthptr != NULL) - *widthptr = (glui32)(win->widget->allocation.width / win->unit_width); + *widthptr = (glui32)(allocation.width); if(heightptr != NULL) - *heightptr = (glui32)(win->widget->allocation.height / win->unit_height); + *heightptr = (glui32)(allocation.height); gdk_threads_leave(); break; @@ -1044,15 +1224,15 @@ glk_window_get_size(winid_t win, glui32 *widthptr, glui32 *heightptr) * Consider the example above, where D has collapsed to zero height. Say D was a * text buffer window. You could make a more useful layout by doing * |[ - * #winid_t o2; - * o2 = #glk_window_get_parent(d); - * glk_window_set_arrangement(o2, #winmethod_Above | #winmethod_Fixed, 3, d); + * winid_t o2; + * o2 = glk_window_get_parent(d); + * glk_window_set_arrangement(o2, winmethod_Above | winmethod_Fixed, 3, d); * ]| * That would set D (the upper child of O2) to be O2's key window, and give it a * fixed size of 3 rows. * * If you later wanted to expand D, you could do - * |[ glk_window_set_arrangement(o2, #winmethod_Above | #winmethod_Fixed, 5, NULL); ]| + * |[ glk_window_set_arrangement(o2, winmethod_Above | winmethod_Fixed, 5, NULL); ]| * That expands D to five rows. Note that, since O2's key window is already set * to D, it is not necessary to provide the @keywin argument; you can pass %NULL * to mean leave the key window unchanged. @@ -1062,18 +1242,18 @@ glk_window_get_size(winid_t win, glui32 *widthptr, glui32 *heightptr) * example, you could change O2's key window to be A, but not B. The key window * also cannot be a pair window itself. * - * |[ glk_window_set_arrangement(o2, #winmethod_Below | #winmethod_Fixed, 3, NULL); ]| + * |[ glk_window_set_arrangement(o2, winmethod_Below | winmethod_Fixed, 3, NULL); ]| * This changes the constraint to be on the lower child of * O2, which is A. The key window is still D; so A would then be three rows high * as measured in D's font, and D would get the rest of O2's space. That may not * be what you want. To set A to be three rows high as measured in A's font, you * would do - * |[ glk_window_set_arrangement(o2, #winmethod_Below | #winmethod_Fixed, 3, a); ]| + * |[ glk_window_set_arrangement(o2, winmethod_Below | winmethod_Fixed, 3, a); ]| * * Or you could change O2 to a proportional split: - * |[ glk_window_set_arrangement(o2, #winmethod_Below | #winmethod_Proportional, 30, NULL); ]| + * |[ glk_window_set_arrangement(o2, winmethod_Below | winmethod_Proportional, 30, NULL); ]| * or - * |[ glk_window_set_arrangement(o2, #winmethod_Above | #winmethod_Proportional, 70, NULL); ]| + * |[ glk_window_set_arrangement(o2, winmethod_Above | winmethod_Proportional, 70, NULL); ]| * These do exactly the same thing, since 30% above is the same as * 70% below. You don't need to specify a key window with a proportional * split, so the @keywin argument is %NULL. (You could actually specify either A @@ -1082,9 +1262,9 @@ glk_window_get_size(winid_t win, glui32 *widthptr, glui32 *heightptr) * Whatever constraint you set, glk_window_get_size() will tell you the actual * window size you got. * - * Note that you can resize windows, but you can't flip or rotate them. You - * can't move A above D, or change O2 to a vertical split where A is left or - * right of D. + * Note that you can resize windows, and alter the Border/NoBorder flag. But you + * can't flip or rotate them. You can't move A above D, or change O2 to a + * vertical split where A is left or right of D. * * To get this effect you could close one of the windows, and re-split the * other one with glk_window_open(). @@ -1103,7 +1283,9 @@ glk_window_set_arrangement(winid_t win, glui32 method, glui32 size, winid_t keyw } g_return_if_fail(method == (method & (winmethod_DirMask | winmethod_DivisionMask))); g_return_if_fail(!(((method & winmethod_DivisionMask) == winmethod_Proportional) && size > 100)); - + + ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key); + win->split_method = method; win->constraint_size = size; if(keywin) @@ -1111,10 +1293,10 @@ glk_window_set_arrangement(winid_t win, glui32 method, glui32 size, winid_t keyw /* Tell GTK to rearrange the windows */ gdk_threads_enter(); - g_mutex_lock(glk_data->arrange_lock); + g_mutex_lock(&glk_data->arrange_lock); glk_data->needs_rearrange = TRUE; glk_data->ignore_next_arrange_event = TRUE; - g_mutex_unlock(glk_data->arrange_lock); + g_mutex_unlock(&glk_data->arrange_lock); gtk_widget_queue_resize(GTK_WIDGET(glk_data->self)); gdk_threads_leave(); } @@ -1177,12 +1359,16 @@ glk_window_move_cursor(winid_t win, glui32 xpos, glui32 ypos) { VALID_WINDOW(win, return); g_return_if_fail(win->type == wintype_TextGrid); - + + flush_window_buffer(win); + + ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key); + /* Wait until the window's size is current */ - g_mutex_lock(glk_data->arrange_lock); + g_mutex_lock(&glk_data->arrange_lock); if(glk_data->needs_rearrange) - g_cond_wait(glk_data->rearranged, glk_data->arrange_lock); - g_mutex_unlock(glk_data->arrange_lock); + g_cond_wait(&glk_data->rearranged, &glk_data->arrange_lock); + g_mutex_unlock(&glk_data->arrange_lock); /* Don't do anything if the window is shrunk down to nothing */ if(win->width == 0 || win->height == 0) @@ -1194,6 +1380,7 @@ glk_window_move_cursor(winid_t win, glui32 xpos, glui32 ypos) ypos += xpos / win->width; xpos %= win->width; } + /* Go to the end if the cursor is moved off the bottom edge */ if(ypos >= win->height) { @@ -1211,4 +1398,3 @@ glk_window_move_cursor(winid_t win, glui32 xpos, glui32 ypos) gdk_threads_leave(); } -