X-Git-Url: https://git.stderr.nl/gitweb?a=blobdiff_plain;f=libchimara%2Fchimara-glk.c;h=f62c1bee2b79b372860fc7a61cca8777b6218d08;hb=57ceef742182d6f0d1f7844256863a37c2d80d6a;hp=e0b60592b2e842ff988e35f53c5cb4fd8c70e184;hpb=2ce0ccd78003fce557bb76883c87ca2cb101608d;p=rodin%2Fchimara.git diff --git a/libchimara/chimara-glk.c b/libchimara/chimara-glk.c index e0b6059..f62c1be 100644 --- a/libchimara/chimara-glk.c +++ b/libchimara/chimara-glk.c @@ -8,6 +8,7 @@ #include #include "chimara-glk.h" #include "chimara-glk-private.h" +#include "chimara-marshallers.h" #include "glk.h" #include "abort.h" #include "window.h" @@ -24,7 +25,7 @@ * @stability: Unstable * @include: chimara/chimara-glk.h * - * The ChimaraGlk widget opens and runs a Glk program. The program must be + * The #ChimaraGlk widget opens and runs a Glk program. The program must be * compiled as a plugin module, with a function glk_main() * that the Glk library can hook into. * @@ -58,6 +59,10 @@ enum { enum { STOPPED, STARTED, + WAITING, + CHAR_INPUT, + LINE_INPUT, + TEXT_BUFFER_OUTPUT, LAST_SIGNAL }; @@ -76,28 +81,34 @@ chimara_glk_init(ChimaraGlk *self) priv->self = self; priv->interactive = TRUE; priv->protect = FALSE; - priv->default_font_desc = pango_font_description_from_string("Sans"); + priv->default_font_desc = pango_font_description_from_string("Serif"); priv->monospace_font_desc = pango_font_description_from_string("Monospace"); priv->css_file = "style.css"; - priv->default_styles = g_hash_table_new(g_str_hash, g_str_equal); + priv->default_styles = g_new0(StyleSet,1); + priv->current_styles = g_new0(StyleSet,1); + priv->running = FALSE; 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; + priv->char_input_queue = g_async_queue_new(); + priv->line_input_queue = g_async_queue_new(); + /* Should be g_async_queue_new_full(g_free); but only in GTK >= 2.16 */ + priv->interrupt_handler = NULL; priv->root_window = NULL; priv->fileref_list = NULL; priv->current_stream = NULL; priv->stream_list = NULL; priv->timer_id = 0; + priv->style_initialized = FALSE; priv->in_startup = FALSE; priv->current_dir = NULL; } @@ -157,11 +168,10 @@ chimara_glk_get_property(GObject *object, guint prop_id, GValue *value, GParamSp } static void -chimara_glk_finalize(GObject *object) +chimara_glk_free_private_data(ChimaraGlk *self) { - ChimaraGlk *self = CHIMARA_GLK(object); ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(self); - + /* Free the event queue */ g_mutex_lock(priv->event_lock); g_queue_foreach(priv->event_queue, (GFunc)g_free, NULL); @@ -172,29 +182,58 @@ chimara_glk_finalize(GObject *object) g_mutex_unlock(priv->event_lock); g_mutex_free(priv->event_lock); - /* Free the abort signalling mechanism */ + /* Free the abort signaling mechanism */ g_mutex_lock(priv->abort_lock); /* Make sure no other thread is busy with this */ g_mutex_unlock(priv->abort_lock); g_mutex_free(priv->abort_lock); priv->abort_lock = NULL; - /* Free the window arrangement signalling */ + /* Free the window arrangement signaling */ g_mutex_lock(priv->arrange_lock); g_cond_free(priv->rearranged); g_mutex_unlock(priv->arrange_lock); g_mutex_free(priv->arrange_lock); priv->arrange_lock = NULL; - /* Free private data */ + /* Unref input queues */ + g_async_queue_unref(priv->char_input_queue); + g_async_queue_unref(priv->line_input_queue); + + /* Free styles */ 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_hash_table_destroy(priv->default_styles->text_buffer); + g_hash_table_destroy(priv->default_styles->text_grid); + g_hash_table_destroy(priv->current_styles->text_buffer); + g_hash_table_destroy(priv->current_styles->text_grid); +} +static void +chimara_glk_finalize(GObject *object) +{ + ChimaraGlk *self = CHIMARA_GLK(object); + chimara_glk_free_private_data(self); + G_OBJECT_CLASS(chimara_glk_parent_class)->finalize(object); } +/** + * chimara_glk_reset: + * @self: The ChimaraGLK widget to reset + * + * Resets the widget back to it's origional state. IE: it resets all the private data. + */ +void +chimara_glk_reset(ChimaraGlk *self) +{ + chimara_glk_free_private_data(self); + chimara_glk_init(self); +} + + /* Internal function: Recursively get the Glk window tree's size request */ static void request_recurse(winid_t win, GtkRequisition *requisition, guint spacing) @@ -532,7 +571,9 @@ chimara_glk_forall(GtkContainer *container, gboolean include_internals, GtkCallb static void chimara_glk_stopped(ChimaraGlk *self) { - ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(self); + CHIMARA_GLK_USE_PRIVATE(self, priv); + printf("stopped signal received\n"); + priv->running = FALSE; /* Free the plugin */ if( priv->program && !g_module_close(priv->program) ) @@ -542,7 +583,33 @@ chimara_glk_stopped(ChimaraGlk *self) static void chimara_glk_started(ChimaraGlk *self) { - /* TODO: Add default signal handler implementation here */ + CHIMARA_GLK_USE_PRIVATE(self, priv); + printf("started signal received\n"); + priv->running = TRUE; +} + +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 */ @@ -569,28 +636,85 @@ 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 * - * The ::stopped signal is emitted when the a Glk program finishes - * executing in the widget, whether it ended normally, or was interrupted. + * Emitted when the a Glk program finishes executing in the widget, whether + * it ended normally, or was interrupted. */ 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); /** * ChimaraGlk::started: * @glk: The widget that received the signal * - * The ::started signal is emitted when a Glk program starts executing in - * the widget. + * Emitted when a Glk program starts executing in 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); + /** + * ChimaraGlk::waiting: + * @glk: The widget that received the signal + * + * Emitted when glk_select() is called by the Glk program and the event + * queue is empty, which means that the widget is waiting for input. + */ + 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); + /** + * ChimaraGlk::char-input: + * @glk: The widget that received the signal + * @window_rock: The rock value of the window that received character input + * (see Rocks) + * @keysym: The key that was typed, in the form of a key symbol from + * gdk/gdkkeysyms.h + * + * Emitted when a Glk window receives character input. + */ + 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); + /** + * ChimaraGlk::line-input: + * @glk: The widget that received the signal + * @window_rock: The rock value of the window that received line input (see + * Rocks) + * @text: The text that was typed + * + * Emitted when a Glk window receives line input. + */ + 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); + /** + * ChimaraGlk::text-buffer-output: + * @glk: The widget that received the signal + * @window_rock: The rock value of the window that was printed to (see Rocks) + * + * Emitted when text is printed to a text buffer window. + */ + 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 */ /** @@ -668,6 +792,21 @@ chimara_glk_class_init(ChimaraGlkClass *klass) /* PUBLIC FUNCTIONS */ +/** + * chimara_error_quark: + * + * The error domain for errors from Chimara widgets. + * + * Returns: The string chimara-error-quark as a GQuark. + */ +GQuark +chimara_error_quark(void) +{ + chimara_init(); /* This is a library entry point */ + return g_quark_from_static_string("chimara-error-quark"); +} + /** * chimara_glk_new: * @@ -681,18 +820,7 @@ chimara_glk_new(void) /* This is a library entry point; initialize the library */ chimara_init(); - 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); + return GTK_WIDGET(g_object_new(CHIMARA_TYPE_GLK, NULL)); } /** @@ -947,6 +1075,9 @@ glk_enter(struct StartupData *startup) extern GPrivate *glk_data_key; g_private_set(glk_data_key, startup->glk_data); + g_async_queue_ref(startup->glk_data->char_input_queue); + g_async_queue_ref(startup->glk_data->line_input_queue); + /* Run startup function */ if(startup->glkunix_startup_code) { startup->glk_data->in_startup = TRUE; @@ -964,8 +1095,17 @@ glk_enter(struct StartupData *startup) /* Run main function */ g_signal_emit_by_name(startup->glk_data->self, "started"); + /* FIXME: hack. should be done by the signal above but for some reason + * this doesn't work */ + chimara_glk_started(startup->glk_data->self); + (startup->glk_main)(); + g_signal_emit_by_name(startup->glk_data->self, "stopped"); + /* FIXME: hack. should be done by the signal above but for some reason + * this doesn't work */ + chimara_glk_stopped(startup->glk_data->self); + g_slice_free(struct StartupData, startup); return NULL; } @@ -991,7 +1131,7 @@ glk_enter(struct StartupData *startup) * 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); @@ -1005,12 +1145,12 @@ chimara_glk_run(ChimaraGlk *glk, gchar *plugin, int argc, char *argv[], GError * if(!priv->program) { - g_warning( "Error opening module: %s", g_module_error() ); + g_set_error(error, CHIMARA_ERROR, CHIMARA_LOAD_MODULE_ERROR, _("Error opening module: %s"), g_module_error()); return FALSE; } if( !g_module_symbol(priv->program, "glk_main", (gpointer *) &startup->glk_main) ) { - g_warning( "Error finding glk_main(): %s", g_module_error() ); + g_set_error(error, CHIMARA_ERROR, CHIMARA_NO_GLK_MAIN, _("Error finding glk_main(): %s"), g_module_error()); return FALSE; } @@ -1049,8 +1189,13 @@ void chimara_glk_stop(ChimaraGlk *glk) { g_return_if_fail(glk || CHIMARA_IS_GLK(glk)); - /* TODO: check if glk is actually running a program */ - ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(glk); + CHIMARA_GLK_USE_PRIVATE(glk, priv); + + printf("stopping (%d)...\n", priv->running); + /* Don't do anything if not running a program */ + if(!priv->running) + return; + if(priv->abort_lock) { g_mutex_lock(priv->abort_lock); priv->abort_signalled = TRUE; @@ -1071,7 +1216,70 @@ void chimara_glk_wait(ChimaraGlk *glk) { g_return_if_fail(glk || CHIMARA_IS_GLK(glk)); - - ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(glk); + CHIMARA_GLK_USE_PRIVATE(glk, priv); + /* Don't do anything if not running a program */ + if(!priv->running) + return; g_thread_join(priv->thread); } + +/** + * chimara_glk_get_running: + * @glk: a #ChimaraGlk widget + * + * Use this function to tell whether a program is currently running in the + * widget. + * + * Returns: %TRUE if @glk is executing a Glk program, %FALSE otherwise. + */ +gboolean +chimara_glk_get_running(ChimaraGlk *glk) +{ + g_return_val_if_fail(glk || CHIMARA_IS_GLK(glk), FALSE); + CHIMARA_GLK_USE_PRIVATE(glk, priv); + return priv->running; +} + +/** + * chimara_glk_feed_char_input: + * @glk: a #ChimaraGlk widget + * @keyval: a key symbol as defined in gdk/gdkkeysyms.h + * + * Pretend that a key was pressed in the Glk program as a response to a + * character input request. You can call this function even when no window has + * requested character input, in which case the key will be saved for the + * following window that requests character input. This has the disadvantage + * that if more than one window has requested character input, it is arbitrary + * which one gets the key press. + */ +void +chimara_glk_feed_char_input(ChimaraGlk *glk, guint keyval) +{ + g_return_if_fail(glk || CHIMARA_IS_GLK(glk)); + CHIMARA_GLK_USE_PRIVATE(glk, priv); + g_async_queue_push(priv->char_input_queue, GUINT_TO_POINTER(keyval)); + event_throw(glk, evtype_ForcedCharInput, NULL, 0, 0); +} + +/** + * chimara_glk_feed_line_input: + * @glk: a #ChimaraGlk widget + * @text: text to pass to the next line input request + * + * Pretend that @text was typed in the Glk program as a response to a line input + * request. @text does not need to end with a newline. You can call this + * function even when no window has requested line input, in which case the text + * will be saved for the following window that requests line input. This has the + * disadvantage that if more than one window has requested character input, it + * is arbitrary which one gets the text. + */ +void +chimara_glk_feed_line_input(ChimaraGlk *glk, const gchar *text) +{ + g_return_if_fail(glk || CHIMARA_IS_GLK(glk)); + g_return_if_fail(text); + CHIMARA_GLK_USE_PRIVATE(glk, priv); + g_async_queue_push(priv->line_input_queue, g_strdup(text)); + event_throw(glk, evtype_ForcedLineInput, NULL, 0, 0); +}