Now windows can be sized arbitrarily small, but GDK chokes when you try to drag the
[projects/chimara/chimara.git] / src / window.c
index c1a79eeb7d319da6aa4a5a40a5531108d4328f8f..876db66933867406084ab9dfa75081c5b46e2cd1 100644 (file)
@@ -364,22 +364,17 @@ glk_window_open(winid_t split, glui32 method, glui32 size, glui32 wintype,
                
                case wintype_TextGrid:
                {
-                   GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
                    GtkWidget *textview = gtk_text_view_new();
-                   
-                   gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_NEVER );
-                   
+
                    gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(textview), GTK_WRAP_CHAR );
                    gtk_text_view_set_editable( GTK_TEXT_VIEW(textview), FALSE );
-                   
-                   gtk_container_add( GTK_CONTAINER(scrolledwindow), textview );
-                   gtk_widget_show_all(scrolledwindow);
+                       gtk_widget_show(textview);
                                
                        /* Set the window's font */
                        gtk_widget_modify_font(textview, glk_data->monospace_font_desc);
                    
                    win->widget = textview;
-                   win->frame = scrolledwindow;
+                   win->frame = textview;
                        
                        /* Determine the size of a "0" character in pixels */
                        PangoLayout *zero = gtk_widget_create_pango_layout(textview, "0");
@@ -460,6 +455,11 @@ glk_window_open(winid_t split, glui32 method, glui32 size, glui32 wintype,
                        return NULL;
        }
 
+       /* Set the minimum size to "as small as possible" so it doesn't depend on
+        the size of the window contents */
+       gtk_widget_set_size_request(win->widget, 0, 0);
+       gtk_widget_set_size_request(win->frame, 0, 0);
+       
        if(split)
        {
                /* When splitting, construct a new parent window
@@ -480,10 +480,13 @@ glk_window_open(winid_t split, glui32 method, glui32 size, glui32 wintype,
                
                /* Insert the new window into the window tree */
                if(split->window_node->parent == NULL)
-               {
                        glk_data->root_window = pair->window_node;
-               } else {
-                       g_node_append(split->window_node->parent, pair->window_node);
+               else 
+               {
+                       if( split->window_node == g_node_first_sibling(split->window_node) )
+                               g_node_prepend(split->window_node->parent, pair->window_node);
+                       else
+                               g_node_append(split->window_node->parent, pair->window_node);
                        g_node_unlink(split->window_node);
                }
                /* Place the windows in the correct order */
@@ -510,51 +513,47 @@ glk_window_open(winid_t split, glui32 method, glui32 size, glui32 wintype,
        gtk_widget_set_parent(win->frame, GTK_WIDGET(glk_data->self));
        gtk_widget_queue_resize(GTK_WIDGET(glk_data->self));
 
-    /* For text grid windows, wait until GTK draws the window (see note in glk_window_get_size() ), calculate the size and fill the buffer with blanks. */
+       gdk_threads_leave();
+       
+       /* For blank or pair windows, this is almost a no-op. For text grid and
+        text buffer windows, this will wait for GTK to draw the window. Otherwise,
+        opening a window and getting its size immediately will give you the wrong
+        size. */
+       glk_window_get_size(win, NULL, NULL);
+       
+    /* For text grid windows, fill the buffer with blanks. */
     if(wintype == wintype_TextGrid)
     {
-        while(win->widget->allocation.width == 1 && win->widget->allocation.height == 1)
-        {
-            /* Release the GDK lock momentarily */
-            gdk_threads_leave();
-            gdk_threads_enter();
-            while(gtk_events_pending())
-                gtk_main_iteration();
-        }
-        win->width = (glui32)(win->widget->allocation.width / win->unit_width);
-        win->height = (glui32)(win->widget->allocation.height / win->unit_height);
-               
-        /* Mark the cursor position */
+        /* Create the cursor position mark */
+               gdk_threads_enter();
         GtkTextIter begin;
         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
         gtk_text_buffer_get_start_iter(buffer, &begin);
         gtk_text_buffer_create_mark(buffer, "cursor_position", &begin, TRUE);
-        
-        /* Fill the buffer with blanks and move the cursor to the upper left */
         gdk_threads_leave();
+               
+        /* Fill the buffer with blanks and move the cursor to the upper left */
         glk_window_clear(win);
-        gdk_threads_enter();
     }
 
-       gdk_threads_leave();
-
        return win;
 }
 
-/* Internal function: close the window streams of this window and all its children */
-static void
-close_window_streams_below(winid_t win, stream_result_t *result)
+/* Internal function: if node's key window is closing_win or one of its
+ children, set node's key window to NULL. */
+static gboolean 
+remove_key_windows(GNode *node, winid_t closing_win)
 {
-       if(win->type == wintype_Pair) {
-               close_window_streams_below(win->window_node->children->data, NULL);
-               close_window_streams_below(win->window_node->children->next->data, NULL);
-       }
-       stream_close_common(win->window_stream, result);
+       winid_t win = (winid_t)node->data;
+       if(win->key_window && (win->key_window == closing_win || g_node_is_ancestor(closing_win->window_node, win->key_window->window_node)))
+               win->key_window = NULL;
+       return FALSE; /* Don't stop the traversal */
 }
 
-/* Internal function: destroy this window's GTK widgets and those of all its children */
+/* Internal function: destroy this window's GTK widgets, window streams, 
+ and those of all its children */
 static void
-destroy_widgets_below(winid_t win)
+destroy_windows_below(winid_t win, stream_result_t *result)
 {
        switch(win->type)
        {
@@ -573,14 +572,15 @@ destroy_widgets_below(winid_t win)
                        break;
 
                case wintype_Pair:
-                       destroy_widgets_below(win->window_node->children->data);
-                       destroy_widgets_below(win->window_node->children->next->data);
+                       destroy_windows_below(win->window_node->children->data, NULL);
+                       destroy_windows_below(win->window_node->children->next->data, NULL);
                        break;
 
                default:
                        ILLEGAL_PARAM("Unknown window type: %u", win->type);
                        return;
        }
+       stream_close_common(win->window_stream, result);
 }
 
 /* Internal function: free the winid_t structure of this window and those of all its children */
@@ -644,11 +644,13 @@ glk_window_close(winid_t win, stream_result_t *result)
 {
        VALID_WINDOW(win, return);
        
-       /* First close all the window streams before trashing the window tree */
-       close_window_streams_below(win, result);
+       /* If any pair windows have this window or its children as a key window,
+        set their key window to NULL */
+       g_node_traverse(glk_data->root_window, G_IN_ORDER, G_TRAVERSE_NON_LEAVES, -1, (GNodeTraverseFunc)remove_key_windows, win);
        
-       /* Then destroy the widgets of this window and below */
-       destroy_widgets_below(win);
+       /* Close all the window streams and destroy the widgets of this window
+        and below, before trashing the window tree */
+       destroy_windows_below(win, result);
        
        /* Then free the winid_t structures below this node, but not this one itself */
        if(win->type == wintype_Pair) {
@@ -698,6 +700,7 @@ glk_window_close(winid_t win, stream_result_t *result)
        g_free(win);
 
        /* Schedule a redraw */
+       gdk_threads_enter();
        gtk_widget_queue_resize( GTK_WIDGET(glk_data->self) );
        gdk_threads_leave();
 }
@@ -914,7 +917,20 @@ glk_window_get_size(winid_t win, glui32 *widthptr, glui32 *heightptr)
             break;
             
         case wintype_TextGrid:
-            /* The text grid caches its width and height */
+                       gdk_threads_enter();
+                       /* Wait for the window to be drawn, and then cache the width and height */
+                       while(win->widget->allocation.width == 1 && win->widget->allocation.height == 1)
+                   {
+                       /* Release the GDK lock momentarily */
+                       gdk_threads_leave();
+                       gdk_threads_enter();
+                       while(gtk_events_pending())
+                           gtk_main_iteration();
+                   }
+                   win->width = (glui32)(win->widget->allocation.width / win->unit_width);
+                   win->height = (glui32)(win->widget->allocation.height / win->unit_height);
+            gdk_threads_leave();
+                       
             if(widthptr != NULL)
                 *widthptr = win->width;
             if(heightptr != NULL)