X-Git-Url: https://git.stderr.nl/gitweb?a=blobdiff_plain;f=src%2Fchimara-glk.c;h=14d1e44801f7b73e0c76c41bdded91eeeb7d0c3f;hb=53fe9495a46d16106fa91cfa589e312e882428dd;hp=fd5d0658976c1e0850ca851f72478fad4812952a;hpb=12101ebc37859ada0a4ad2088ff3ac288acb8274;p=rodin%2Fchimara.git diff --git a/src/chimara-glk.c b/src/chimara-glk.c index fd5d065..14d1e44 100644 --- a/src/chimara-glk.c +++ b/src/chimara-glk.c @@ -27,11 +27,11 @@ * On Linux systems, this is a file with a name like * plugin.so. For portability, you can use libtool and * automake: - * + * |[ * pkglib_LTLIBRARIES = plugin.la * plugin_la_SOURCES = plugin.c foo.c bar.c * plugin_la_LDFLAGS = -module -shared -avoid-version -export-symbols-regex "^glk_main$$" - * + * ]| * This will produce plugin.la which is a text file * containing the correct plugin file to open (see the relevant section of the * fileref_list = NULL; priv->current_stream = NULL; priv->stream_list = NULL; + priv->timer_id = 0; } static void @@ -106,6 +108,9 @@ chimara_glk_set_property(GObject *object, guint prop_id, const GValue *value, GP case PROP_MONOSPACE_FONT_DESCRIPTION: chimara_glk_set_monospace_font_description( glk, (PangoFontDescription *)g_value_get_pointer(value) ); break; + case PROP_SPACING: + chimara_glk_set_spacing( glk, g_value_get_uint(value) ); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); } @@ -130,6 +135,9 @@ chimara_glk_get_property(GObject *object, guint prop_id, GValue *value, GParamSp case PROP_MONOSPACE_FONT_DESCRIPTION: g_value_set_pointer(value, priv->monospace_font_desc); break; + case PROP_SPACING: + g_value_set_uint(value, priv->spacing); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); } @@ -167,14 +175,14 @@ chimara_glk_finalize(GObject *object) /* Internal function: Recursively get the Glk window tree's size request */ static void -request_recurse(winid_t win, GtkRequisition *requisition) +request_recurse(winid_t win, GtkRequisition *requisition, guint spacing) { if(win->type == wintype_Pair) { /* Get children's size requests */ GtkRequisition child1, child2; - request_recurse(win->window_node->children->data, &child1); - request_recurse(win->window_node->children->next->data, &child2); + request_recurse(win->window_node->children->data, &child1, spacing); + request_recurse(win->window_node->children->next->data, &child2, spacing); /* If the split is fixed, get the size of the fixed child */ if((win->split_method & winmethod_DivisionMask) == winmethod_Fixed) @@ -182,16 +190,24 @@ request_recurse(winid_t win, GtkRequisition *requisition) switch(win->split_method & winmethod_DirMask) { case winmethod_Left: - child1.width = win->constraint_size * win->key_window->unit_width; + child1.width = win->key_window? + win->constraint_size * win->key_window->unit_width + : 0; break; case winmethod_Right: - child2.width = win->constraint_size * win->key_window->unit_width; + child2.width = win->key_window? + win->constraint_size * win->key_window->unit_width + : 0; break; case winmethod_Above: - child1.height = win->constraint_size * win->key_window->unit_height; + child1.height = win->key_window? + win->constraint_size * win->key_window->unit_height + : 0; break; case winmethod_Below: - child2.height = win->constraint_size * win->key_window->unit_height; + child2.height = win->key_window? + win->constraint_size * win->key_window->unit_height + : 0; break; } } @@ -201,13 +217,13 @@ request_recurse(winid_t win, GtkRequisition *requisition) { case winmethod_Left: case winmethod_Right: - requisition->width = child1.width + child2.width; + requisition->width = child1.width + child2.width + spacing; requisition->height = MAX(child1.height, child2.height); break; case winmethod_Above: case winmethod_Below: requisition->width = MAX(child1.width, child2.width); - requisition->height = child1.height + child2.height; + requisition->height = child1.height + child2.height + spacing; break; } } @@ -228,17 +244,22 @@ chimara_glk_size_request(GtkWidget *widget, GtkRequisition *requisition) ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(widget); /* For now, just pass the size request on to the root Glk window */ - if(priv->root_window) - request_recurse(priv->root_window->data, requisition); - else { - requisition->width = CHIMARA_GLK_MIN_WIDTH; - requisition->height = CHIMARA_GLK_MIN_HEIGHT; + if(priv->root_window) + { + request_recurse(priv->root_window->data, requisition, priv->spacing); + requisition->width += 2 * GTK_CONTAINER(widget)->border_width; + requisition->height += 2 * GTK_CONTAINER(widget)->border_width; + } + else + { + requisition->width = CHIMARA_GLK_MIN_WIDTH + 2 * GTK_CONTAINER(widget)->border_width; + requisition->height = CHIMARA_GLK_MIN_HEIGHT + 2 * GTK_CONTAINER(widget)->border_width; } } /* Recursively give the Glk windows their allocated space */ static void -allocate_recurse(winid_t win, GtkAllocation *allocation) +allocate_recurse(winid_t win, GtkAllocation *allocation, guint spacing) { if(win->type == wintype_Pair) { @@ -248,45 +269,48 @@ allocate_recurse(winid_t win, GtkAllocation *allocation) if((win->split_method & winmethod_DivisionMask) == winmethod_Fixed) { + /* If the key window has been closed, then default to 0; otherwise + use the key window to determine the size */ switch(win->split_method & winmethod_DirMask) { case winmethod_Left: - child1.width = win->constraint_size * win->key_window->unit_width; - if(child1.width > allocation->width) - child1.width = allocation->width; + child1.width = win->key_window? + CLAMP(win->constraint_size * win->key_window->unit_width, 0, allocation->width - spacing) + : 0; break; case winmethod_Right: - child2.width = win->constraint_size * win->key_window->unit_width; - if(child2.width > allocation->width) - child2.width = allocation->width; + child2.width = win->key_window? + CLAMP(win->constraint_size * win->key_window->unit_width, 0, allocation->width - spacing) + : 0; break; case winmethod_Above: - child1.height = win->constraint_size * win->key_window->unit_height; - if(child1.height > allocation->height) - child1.height = allocation->height; + child1.height = win->key_window? + CLAMP(win->constraint_size * win->key_window->unit_height, 0, allocation->height - spacing) + : 0; break; case winmethod_Below: - child2.height = win->constraint_size * win->key_window->unit_height; - if(child2.height > allocation->height) - child2.height = allocation->height; + child2.height = win->key_window? + CLAMP(win->constraint_size * win->key_window->unit_height, 0, allocation->height - spacing) + : 0; break; } } else /* proportional */ { + gdouble fraction = win->constraint_size / 100.0; switch(win->split_method & winmethod_DirMask) { case winmethod_Left: - child1.width = (glui32)ceil((win->constraint_size / 100.0) * allocation->width); + child1.width = (glui32) ceil( fraction * (allocation->width - spacing) ); break; case winmethod_Right: - child2.width = (glui32)ceil((win->constraint_size / 100.0) * allocation->width); + child2.width = (glui32) ceil( fraction * (allocation->width - spacing) ); break; case winmethod_Above: - child1.height = (glui32)ceil((win->constraint_size / 100.0) * allocation->height); + child1.height = (glui32) ceil( fraction * (allocation->height - spacing) ); break; case winmethod_Below: - child2.height = (glui32)ceil((win->constraint_size / 100.0) * allocation->height); + child2.height = (glui32) ceil( fraction * (allocation->height - spacing) ); break; } } @@ -295,37 +319,103 @@ allocate_recurse(winid_t win, GtkAllocation *allocation) switch(win->split_method & winmethod_DirMask) { case winmethod_Left: - child2.width = allocation->width - child1.width; - child2.x = child1.x + child1.width; + child2.width = allocation->width - spacing - child1.width; + child2.x = child1.x + child1.width + spacing; child2.y = child1.y; child1.height = child2.height = allocation->height; break; case winmethod_Right: - child1.width = allocation->width - child2.width; - child2.x = child1.x + child1.width; + child1.width = allocation->width - spacing - child2.width; + child2.x = child1.x + child1.width + spacing; child2.y = child1.y; child1.height = child2.height = allocation->height; break; case winmethod_Above: - child2.height = allocation->height - child1.height; + child2.height = allocation->height - spacing - child1.height; child2.x = child1.x; - child2.y = child1.y + child1.height; + child2.y = child1.y + child1.height + spacing; child1.width = child2.width = allocation->width; break; case winmethod_Below: - child1.height = allocation->height - child2.height; + child1.height = allocation->height - spacing - child2.height; child2.x = child1.x; - child2.y = child1.y + child1.height; + child2.y = child1.y + child1.height + spacing; child1.width = child2.width = allocation->width; break; } /* Recurse */ - allocate_recurse(win->window_node->children->data, &child1); - allocate_recurse(win->window_node->children->next->data, &child2); + allocate_recurse(win->window_node->children->data, &child1, spacing); + allocate_recurse(win->window_node->children->next->data, &child2, spacing); + } + + else if(win->type == wintype_TextGrid) + { + /* Pass the size allocation on to the framing widget */ + gtk_widget_size_allocate(win->frame, allocation); + /* It says in the spec that when a text grid window is resized smaller, + the bottom or right area is thrown away; when it is resized larger, the + bottom or right area is filled with blanks. */ + glui32 newwidth = (glui32)(win->widget->allocation.width / win->unit_width); + glui32 newheight = (glui32)(win->widget->allocation.height / win->unit_height); + gint line; + GtkTextBuffer *textbuffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) ); + GtkTextIter start, end; + + for(line = 0; line < win->height; line++) + { + gtk_text_buffer_get_iter_at_line(textbuffer, &start, line); + /* If this line is going to fall off the bottom, delete it */ + if(line >= newheight) + { + end = start; + gtk_text_iter_forward_to_line_end(&end); + gtk_text_iter_forward_char(&end); + gtk_text_buffer_delete(textbuffer, &start, &end); + break; + } + /* If this line is not long enough, add spaces on the end */ + if(newwidth > win->width) + { + gchar *spaces = g_strnfill(newwidth - win->width, ' '); + gtk_text_iter_forward_to_line_end(&start); + gtk_text_buffer_insert(textbuffer, &start, spaces, -1); + g_free(spaces); + } + /* But if it's too long, delete characters from the end */ + else if(newwidth < win->width) + { + end = start; + gtk_text_iter_forward_chars(&start, newwidth); + gtk_text_iter_forward_to_line_end(&end); + gtk_text_buffer_delete(textbuffer, &start, &end); + } + /* Note: if the widths are equal, do nothing */ + } + /* Add blank lines if there aren't enough lines to fit the new size */ + if(newheight > win->height) + { + gchar *blanks = g_strnfill(win->width, ' '); + gchar **blanklines = g_new0(gchar *, (newheight - win->height) + 1); + int count; + for(count = 0; count < newheight - win->height; count++) + blanklines[count] = blanks; + blanklines[newheight - win->height] = NULL; + gchar *text = g_strjoinv("\n", blanklines); + g_free(blanklines); /* not g_strfreev() */ + g_free(blanks); + + gtk_text_buffer_get_end_iter(textbuffer, &start); + gtk_text_buffer_insert(textbuffer, &start, "\n", -1); + gtk_text_buffer_insert(textbuffer, &start, text, -1); + g_free(text); + } + + win->width = newwidth; + win->height = newheight; } - /* For non-pair windows, just give them the size */ + /* For non-pair, non-text-grid windows, just give them the size */ else gtk_widget_size_allocate(win->frame, allocation); } @@ -342,8 +432,14 @@ chimara_glk_size_allocate(GtkWidget *widget, GtkAllocation *allocation) widget->allocation = *allocation; - if(priv->root_window) - allocate_recurse(priv->root_window->data, allocation); + if(priv->root_window) { + GtkAllocation child; + child.x = allocation->x + GTK_CONTAINER(widget)->border_width; + child.y = allocation->y + GTK_CONTAINER(widget)->border_width; + child.width = CLAMP(allocation->width - 2 * GTK_CONTAINER(widget)->border_width, 0, allocation->width); + child.height = CLAMP(allocation->height - 2 * GTK_CONTAINER(widget)->border_width, 0, allocation->height); + allocate_recurse(priv->root_window->data, &child, priv->spacing); + } } /* Recursively invoke callback() on the GtkWidget of each non-pair window in the tree */ @@ -440,11 +536,6 @@ chimara_glk_class_init(ChimaraGlkClass *klass) g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); /* Properties */ - GParamSpec *pspec; - pspec = g_param_spec_boolean("interactive", _("Interactive"), - _("Whether user input is expected in the Glk program"), - TRUE, - G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS); /** * ChimaraGlk:interactive: * @@ -455,21 +546,24 @@ chimara_glk_class_init(ChimaraGlkClass *klass) * buffer are also disabled. This is typically used when you wish to control * an interpreter program by feeding it a predefined list of commands. */ - g_object_class_install_property(object_class, PROP_INTERACTIVE, pspec); - pspec = g_param_spec_boolean("protect", _("Protected"), - _("Whether the Glk program is barred from doing file operations"), - FALSE, - G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS); - /** + g_object_class_install_property( object_class, PROP_INTERACTIVE, + g_param_spec_boolean("interactive", _("Interactive"), + _("Whether user input is expected in the Glk program"), + TRUE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS) ); + + /** * ChimaraGlk:protect: * * Sets whether the Glk program is allowed to do file operations. In protect * mode, all file operations will fail. */ - g_object_class_install_property(object_class, PROP_PROTECT, pspec); - pspec = g_param_spec_pointer("default-font-description", _("Default Font"), - _("Font description of the default proportional font"), - G_PARAM_READWRITE | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS); + g_object_class_install_property(object_class, PROP_PROTECT, + g_param_spec_boolean("protect", _("Protected"), + _("Whether the Glk program is barred from doing file operations"), + FALSE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS) ); + /* We can't use G_PARAM_CONSTRUCT on these because then the constructor will initialize them with NULL */ /** @@ -481,10 +575,11 @@ chimara_glk_class_init(ChimaraGlkClass *klass) * Default value: font description created from the string * Sans */ - g_object_class_install_property(object_class, PROP_DEFAULT_FONT_DESCRIPTION, pspec); - pspec = g_param_spec_pointer("monospace-font-description", _("Monospace Font"), - _("Font description of the default monospace font"), - G_PARAM_READWRITE | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS); + g_object_class_install_property(object_class, PROP_DEFAULT_FONT_DESCRIPTION, + g_param_spec_pointer("default-font-description", _("Default Font"), + _("Font description of the default proportional font"), + G_PARAM_READWRITE | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS) ); + /** * ChimaraGlk:monospace-font-description: * @@ -494,7 +589,22 @@ chimara_glk_class_init(ChimaraGlkClass *klass) * Default value: font description created from the string * Monospace */ - g_object_class_install_property(object_class, PROP_MONOSPACE_FONT_DESCRIPTION, pspec); + g_object_class_install_property(object_class, PROP_MONOSPACE_FONT_DESCRIPTION, + g_param_spec_pointer("monospace-font-description", _("Monospace Font"), + _("Font description of the default monospace font"), + G_PARAM_READWRITE | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS) ); + + /** + * ChimaraGlk:spacing: + * + * The amount of space between the Glk windows. + */ + g_object_class_install_property(object_class, PROP_SPACING, + g_param_spec_uint("spacing", _("Spacing"), + _("The amount of space between Glk windows"), + 0, G_MAXUINT, 0, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS) ); + /* Private data */ g_type_class_add_private(klass, sizeof(ChimaraGlkPrivate)); } @@ -644,6 +754,7 @@ chimara_glk_set_default_font_string(ChimaraGlk *glk, const gchar *font) /** * chimara_glk_get_default_font_description: + * @glk: a #ChimaraGlk widget * * Returns @glk's default proportional font. * @@ -710,6 +821,7 @@ chimara_glk_set_monospace_font_string(ChimaraGlk *glk, const gchar *font) /** * chimara_glk_get_monospace_font_description: + * @glk: a #ChimaraGlk widget * * Returns @glk's default monospace font. * @@ -725,6 +837,40 @@ chimara_glk_get_monospace_font_description(ChimaraGlk *glk) return pango_font_description_copy(priv->monospace_font_desc); } +/** + * chimara_glk_set_spacing: + * @glk: a #ChimaraGlk widget + * @spacing: the number of pixels to put between Glk windows + * + * Sets the #ChimaraGlk:spacing property of @glk, which is the border width in + * pixels between Glk windows. + */ +void +chimara_glk_set_spacing(ChimaraGlk *glk, guint spacing) +{ + g_return_if_fail( glk || CHIMARA_IS_GLK(glk) ); + + ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(glk); + priv->spacing = spacing; +} + +/** + * chimara_glk_get_spacing: + * @glk: a #ChimaraGlk widget + * + * Gets the value set by chimara_glk_set_spacing(). + * + * Return value: pixels of spacing between Glk windows + */ +guint +chimara_glk_get_spacing(ChimaraGlk *glk) +{ + g_return_val_if_fail(glk || CHIMARA_IS_GLK(glk), 0); + + ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(glk); + return priv->spacing; +} + /* glk_enter() is the actual function called in the new thread in which glk_main() runs. */ static gpointer glk_enter(gpointer glk_main)