X-Git-Url: https://git.stderr.nl/gitweb?a=blobdiff_plain;f=libchimara%2Fchimara-glk.c;h=6669dc6b0f524c8b1497b43e469876e98cab1a11;hb=e4819b66649d4963a0661cba603c2967b02a6b80;hp=00cc8b4c6b11e191957b5277a60b3bcc48aa8542;hpb=6478a4f44526dde5ec7b1090d97b2255ed2879a1;p=rodin%2Fchimara.git diff --git a/libchimara/chimara-glk.c b/libchimara/chimara-glk.c index 00cc8b4..6669dc6 100644 --- a/libchimara/chimara-glk.c +++ b/libchimara/chimara-glk.c @@ -2,16 +2,19 @@ #include #include -#include +#include +#include #include #include #include "chimara-glk.h" #include "chimara-glk-private.h" +#include "chimara-marshallers.h" #include "glk.h" #include "abort.h" #include "window.h" #include "glkstart.h" #include "glkunix.h" +#include "init.h" #define CHIMARA_GLK_MIN_WIDTH 0 #define CHIMARA_GLK_MIN_HEIGHT 0 @@ -56,6 +59,10 @@ enum { enum { STOPPED, STARTED, + WAITING, + CHAR_INPUT, + LINE_INPUT, + TEXT_BUFFER_OUTPUT, LAST_SIGNAL }; @@ -76,16 +83,19 @@ chimara_glk_init(ChimaraGlk *self) priv->protect = FALSE; priv->default_font_desc = pango_font_description_from_string("Sans"); priv->monospace_font_desc = pango_font_description_from_string("Monospace"); + priv->css_file = "style.css"; + priv->default_styles = g_new0(StyleSet,1); + priv->current_styles = g_new0(StyleSet,1); priv->program = NULL; priv->thread = NULL; - priv->event_queue = NULL; - priv->event_lock = NULL; - priv->event_queue_not_empty = NULL; - priv->event_queue_not_full = NULL; - priv->abort_lock = NULL; + priv->event_queue = g_queue_new(); + priv->event_lock = g_mutex_new(); + priv->event_queue_not_empty = g_cond_new(); + priv->event_queue_not_full = g_cond_new(); + priv->abort_lock = g_mutex_new(); priv->abort_signalled = FALSE; - priv->arrange_lock = NULL; - priv->rearranged = NULL; + priv->arrange_lock = g_mutex_new(); + priv->rearranged = g_cond_new(); priv->needs_rearrange = FALSE; priv->ignore_next_arrange_event = FALSE; priv->interrupt_handler = NULL; @@ -186,6 +196,7 @@ chimara_glk_finalize(GObject *object) pango_font_description_free(priv->default_font_desc); pango_font_description_free(priv->monospace_font_desc); g_free(priv->current_dir); + g_hash_table_destroy(priv->default_styles); G_OBJECT_CLASS(chimara_glk_parent_class)->finalize(object); } @@ -200,11 +211,14 @@ request_recurse(winid_t win, GtkRequisition *requisition, guint spacing) GtkRequisition child1, child2; request_recurse(win->window_node->children->data, &child1, spacing); request_recurse(win->window_node->children->next->data, &child2, spacing); + + glui32 division = win->split_method & winmethod_DivisionMask; + glui32 direction = win->split_method & winmethod_DirMask; /* If the split is fixed, get the size of the fixed child */ - if((win->split_method & winmethod_DivisionMask) == winmethod_Fixed) + if(division == winmethod_Fixed) { - switch(win->split_method & winmethod_DirMask) + switch(direction) { case winmethod_Left: child1.width = win->key_window? @@ -230,7 +244,7 @@ request_recurse(winid_t win, GtkRequisition *requisition, guint spacing) } /* Add the children's requests */ - switch(win->split_method & winmethod_DirMask) + switch(direction) { case winmethod_Left: case winmethod_Right: @@ -282,15 +296,24 @@ allocate_recurse(winid_t win, GtkAllocation *allocation, guint spacing) { if(win->type == wintype_Pair) { + glui32 division = win->split_method & winmethod_DivisionMask; + glui32 direction = win->split_method & winmethod_DirMask; + + /* If the space gets too small to honor the spacing property, then just + ignore spacing in this window and below. */ + if( (spacing > allocation->width && (direction == winmethod_Left || direction == winmethod_Right)) + || (spacing > allocation->height && (direction == winmethod_Above || direction == winmethod_Below)) ) + spacing = 0; + GtkAllocation child1, child2; child1.x = allocation->x; child1.y = allocation->y; - if((win->split_method & winmethod_DivisionMask) == winmethod_Fixed) + if(division == 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) + switch(direction) { case winmethod_Left: child1.width = win->key_window? @@ -317,46 +340,46 @@ allocate_recurse(winid_t win, GtkAllocation *allocation, guint spacing) else /* proportional */ { gdouble fraction = win->constraint_size / 100.0; - switch(win->split_method & winmethod_DirMask) + switch(direction) { case winmethod_Left: - child1.width = (glui32) ceil( fraction * (allocation->width - spacing) ); + child1.width = MAX(0, (gint)ceil(fraction * (allocation->width - spacing)) ); break; case winmethod_Right: - child2.width = (glui32) ceil( fraction * (allocation->width - spacing) ); + child2.width = MAX(0, (gint)ceil(fraction * (allocation->width - spacing)) ); break; case winmethod_Above: - child1.height = (glui32) ceil( fraction * (allocation->height - spacing) ); + child1.height = MAX(0, (gint)ceil(fraction * (allocation->height - spacing)) ); break; case winmethod_Below: - child2.height = (glui32) ceil( fraction * (allocation->height - spacing) ); + child2.height = MAX(0, (gint)ceil(fraction * (allocation->height - spacing)) ); break; } } /* Fill in the rest of the size requisitions according to the child specified above */ - switch(win->split_method & winmethod_DirMask) + switch(direction) { case winmethod_Left: - child2.width = allocation->width - spacing - child1.width; + child2.width = MAX(0, 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 - spacing - child2.width; + child1.width = MAX(0, 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 - spacing - child1.height; + child2.height = MAX(0, allocation->height - spacing - child1.height); child2.x = child1.x; child2.y = child1.y + child1.height + spacing; child1.width = child2.width = allocation->width; break; case winmethod_Below: - child1.height = allocation->height - spacing - child2.height; + child1.height = MAX(0, allocation->height - spacing - child2.height); child2.x = child1.x; child2.y = child1.y + child1.height + spacing; child1.width = child2.width = allocation->width; @@ -472,7 +495,7 @@ chimara_glk_size_allocate(GtkWidget *widget, GtkAllocation *allocation) if(!priv->ignore_next_arrange_event) { if(arrange) - event_throw(evtype_Arrange, arrange == priv->root_window->data? NULL : arrange, 0, 0); + event_throw(CHIMARA_GLK(widget), evtype_Arrange, arrange == priv->root_window->data? NULL : arrange, 0, 0); } else priv->ignore_next_arrange_event = FALSE; @@ -525,7 +548,31 @@ chimara_glk_stopped(ChimaraGlk *self) static void chimara_glk_started(ChimaraGlk *self) { - /* TODO: Add default signal handler implementation here */ + /* Default signal handler */ +} + +static void +chimara_glk_waiting(ChimaraGlk *self) +{ + /* Default signal handler */ +} + +static void +chimara_glk_char_input(ChimaraGlk *self, guint window_rock, guint keysym) +{ + /* Default signal handler */ +} + +static void +chimara_glk_line_input(ChimaraGlk *self, guint window_rock, gchar *text) +{ + /* Default signal handler */ +} + +static void +chimara_glk_text_buffer_output(ChimaraGlk *self, guint window_rock, gchar *text) +{ + /* Default signal handler */ } /* G_PARAM_STATIC_STRINGS only appeared in GTK 2.13.0 */ @@ -552,6 +599,10 @@ chimara_glk_class_init(ChimaraGlkClass *klass) /* Signals */ klass->stopped = chimara_glk_stopped; klass->started = chimara_glk_started; + klass->waiting = chimara_glk_waiting; + klass->char_input = chimara_glk_char_input; + klass->line_input = chimara_glk_line_input; + klass->text_buffer_output = chimara_glk_text_buffer_output; /** * ChimaraGlk::stopped: * @glk: The widget that received the signal @@ -561,6 +612,7 @@ chimara_glk_class_init(ChimaraGlkClass *klass) */ chimara_glk_signals[STOPPED] = g_signal_new("stopped", G_OBJECT_CLASS_TYPE(klass), 0, + /* FIXME: Should be G_SIGNAL_RUN_CLEANUP but that segfaults??! */ G_STRUCT_OFFSET(ChimaraGlkClass, stopped), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); /** @@ -571,9 +623,32 @@ chimara_glk_class_init(ChimaraGlkClass *klass) * the widget. */ chimara_glk_signals[STARTED] = g_signal_new ("started", - G_OBJECT_CLASS_TYPE (klass), 0, + G_OBJECT_CLASS_TYPE(klass), 0, G_STRUCT_OFFSET(ChimaraGlkClass, started), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + + chimara_glk_signals[WAITING] = g_signal_new("waiting", + G_OBJECT_CLASS_TYPE(klass), 0, + G_STRUCT_OFFSET(ChimaraGlkClass, waiting), NULL, NULL, + g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + + chimara_glk_signals[CHAR_INPUT] = g_signal_new("char-input", + G_OBJECT_CLASS_TYPE(klass), 0, + G_STRUCT_OFFSET(ChimaraGlkClass, char_input), NULL, NULL, + chimara_marshal_VOID__UINT_UINT, + G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT); + + chimara_glk_signals[LINE_INPUT] = g_signal_new("line-input", + G_OBJECT_CLASS_TYPE(klass), 0, + G_STRUCT_OFFSET(ChimaraGlkClass, line_input), NULL, NULL, + chimara_marshal_VOID__UINT_STRING, + G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_STRING); + + chimara_glk_signals[TEXT_BUFFER_OUTPUT] = g_signal_new("text-buffer-output", + G_OBJECT_CLASS_TYPE(klass), 0, + G_STRUCT_OFFSET(ChimaraGlkClass, text_buffer_output), NULL, NULL, + chimara_marshal_VOID__UINT_STRING, + G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_STRING); /* Properties */ /** @@ -661,18 +736,10 @@ chimara_glk_class_init(ChimaraGlkClass *klass) GtkWidget * chimara_glk_new(void) { - ChimaraGlk *self = CHIMARA_GLK(g_object_new(CHIMARA_TYPE_GLK, NULL)); - ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(self); - - priv->event_queue = g_queue_new(); - priv->event_lock = g_mutex_new(); - priv->event_queue_not_empty = g_cond_new(); - priv->event_queue_not_full = g_cond_new(); - priv->abort_lock = g_mutex_new(); - priv->arrange_lock = g_mutex_new(); - priv->rearranged = g_cond_new(); - - return GTK_WIDGET(self); + /* This is a library entry point; initialize the library */ + chimara_init(); + + return GTK_WIDGET(g_object_new(CHIMARA_TYPE_GLK, NULL)); } /** @@ -913,15 +980,40 @@ chimara_glk_get_spacing(ChimaraGlk *glk) return priv->spacing; } +struct StartupData { + glk_main_t glk_main; + glkunix_startup_code_t glkunix_startup_code; + glkunix_startup_t args; + ChimaraGlkPrivate *glk_data; +}; + /* glk_enter() is the actual function called in the new thread in which glk_main() runs. */ static gpointer -glk_enter(gpointer glk_main) +glk_enter(struct StartupData *startup) { - extern ChimaraGlkPrivate *glk_data; - - g_signal_emit_by_name(glk_data->self, "started"); - ((glk_main_t)glk_main)(); - g_signal_emit_by_name(glk_data->self, "stopped"); + extern GPrivate *glk_data_key; + g_private_set(glk_data_key, startup->glk_data); + + /* Run startup function */ + if(startup->glkunix_startup_code) { + startup->glk_data->in_startup = TRUE; + int result = startup->glkunix_startup_code(&startup->args); + startup->glk_data->in_startup = FALSE; + + int i = 0; + while(i < startup->args.argc) + g_free(startup->args.argv[i++]); + g_free(startup->args.argv); + + if(!result) + return NULL; + } + + /* Run main function */ + g_signal_emit_by_name(startup->glk_data->self, "started"); + (startup->glk_main)(); + g_signal_emit_by_name(startup->glk_data->self, "stopped"); + g_slice_free(struct StartupData, startup); return NULL; } @@ -946,69 +1038,50 @@ glk_enter(gpointer glk_main) * Return value: %TRUE if the Glk program was started successfully. */ gboolean -chimara_glk_run(ChimaraGlk *glk, gchar *plugin, int argc, char *argv[], GError **error) +chimara_glk_run(ChimaraGlk *glk, const gchar *plugin, int argc, char *argv[], GError **error) { g_return_val_if_fail(glk || CHIMARA_IS_GLK(glk), FALSE); g_return_val_if_fail(plugin, FALSE); ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(glk); + struct StartupData *startup = g_slice_new0(struct StartupData); /* Open the module to run */ - glk_main_t glk_main; - glkunix_startup_code_t glkunix_startup_code; g_assert( g_module_supported() ); priv->program = g_module_open(plugin, G_MODULE_BIND_LAZY); if(!priv->program) { g_warning( "Error opening module: %s", g_module_error() ); + /* TODO: set error */ return FALSE; } - if( !g_module_symbol(priv->program, "glk_main", (gpointer *) &glk_main) ) + if( !g_module_symbol(priv->program, "glk_main", (gpointer *) &startup->glk_main) ) { g_warning( "Error finding glk_main(): %s", g_module_error() ); + /* TODO: set error */ return FALSE; } - extern ChimaraGlkPrivate *glk_data; - /* Set the thread's private data */ - /* TODO: Do this with a GPrivate */ - glk_data = priv; - - if( g_module_symbol(priv->program, "glkunix_startup_code", (gpointer *) &glkunix_startup_code) ) + if( g_module_symbol(priv->program, "glkunix_startup_code", (gpointer *) &startup->glkunix_startup_code) ) { - glkunix_startup_t data; glkunix_argumentlist_t *glkunix_arguments; - gboolean startup_succeeded; - if( !(g_module_symbol(priv->program, "glkunix_arguments", (gpointer *) &glkunix_arguments) && parse_command_line(glkunix_arguments, argc, argv, &data)) ) + if( !(g_module_symbol(priv->program, "glkunix_arguments", (gpointer *) &glkunix_arguments) + && parse_command_line(glkunix_arguments, argc, argv, &startup->args)) ) { /* arguments could not be parsed, so create data ourselves */ - data.argc = 1; - data.argv = g_new0(gchar *, 1); + startup->args.argc = 1; + startup->args.argv = g_new0(gchar *, 1); } /* Set the program name */ - data.argv[0] = g_strdup(plugin); - - priv->in_startup = TRUE; - startup_succeeded = glkunix_startup_code(&data); - priv->in_startup = FALSE; - - gchar **ptr = data.argv; - while(*ptr++) - g_free(*ptr); - g_free(data.argv); - - if(!startup_succeeded) - { - chimara_glk_stopped(glk); - return FALSE; - } + startup->args.argv[0] = g_strdup(plugin); } + startup->glk_data = priv; /* Run in a separate thread */ - priv->thread = g_thread_create(glk_enter, glk_main, TRUE, error); + priv->thread = g_thread_create((GThreadFunc)glk_enter, startup, TRUE, error); return !(priv->thread == NULL); } @@ -1026,7 +1099,14 @@ chimara_glk_stop(ChimaraGlk *glk) { g_return_if_fail(glk || CHIMARA_IS_GLK(glk)); /* TODO: check if glk is actually running a program */ - signal_abort(); + ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(glk); + if(priv->abort_lock) { + g_mutex_lock(priv->abort_lock); + priv->abort_signalled = TRUE; + g_mutex_unlock(priv->abort_lock); + /* Stop blocking on the event queue condition */ + event_throw(glk, evtype_Abort, NULL, 0, 0); + } } /**