X-Git-Url: https://git.stderr.nl/gitweb?a=blobdiff_plain;f=libchimara%2Fchimara-glk.c;h=f62c1bee2b79b372860fc7a61cca8777b6218d08;hb=57ceef742182d6f0d1f7844256863a37c2d80d6a;hp=6669dc6b0f524c8b1497b43e469876e98cab1a11;hpb=e4819b66649d4963a0661cba603c2967b02a6b80;p=rodin%2Fchimara.git

diff --git a/libchimara/chimara-glk.c b/libchimara/chimara-glk.c
index 6669dc6..f62c1be 100644
--- a/libchimara/chimara-glk.c
+++ b/libchimara/chimara-glk.c
@@ -25,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 <function>glk_main()</function>
  * that the Glk library can hook into.
  *
@@ -81,11 +81,12 @@ 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_new0(StyleSet,1);
 	priv->current_styles = g_new0(StyleSet,1);
+	priv->running = FALSE;
     priv->program = NULL;
     priv->thread = NULL;
     priv->event_queue = g_queue_new();
@@ -98,12 +99,16 @@ chimara_glk_init(ChimaraGlk *self)
 	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;
 }
@@ -163,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);
@@ -178,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)
@@ -538,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) )
@@ -548,7 +583,9 @@ chimara_glk_stopped(ChimaraGlk *self)
 static void
 chimara_glk_started(ChimaraGlk *self)
 {
-	/* Default signal handler */
+	CHIMARA_GLK_USE_PRIVATE(self, priv);
+	printf("started signal received\n");
+	priv->running = TRUE;
 }
 
 static void
@@ -607,8 +644,8 @@ chimara_glk_class_init(ChimaraGlkClass *klass)
      * 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, 
@@ -619,31 +656,60 @@ chimara_glk_class_init(ChimaraGlkClass *klass)
 	 * 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_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 <link linkend="chimara-Rocks">Rocks</link>)
+	 * @keysym: The key that was typed, in the form of a key symbol from 
+	 * <filename class="headerfile">gdk/gdkkeysyms.h</filename>
+	 * 
+	 * 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
+	 * <link linkend="chimara-Rocks">Rocks</link>)
+	 * @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 <link
+	 * linkend="chimara-Rocks">Rocks</link>)
+	 * 
+	 * 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,
@@ -726,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 <quote>chimara-error-quark</quote> as a <link 
+ * linkend="GQuark">GQuark</link>.
+ */
+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:
  *
@@ -994,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;
@@ -1011,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;
 }
@@ -1052,14 +1145,12 @@ chimara_glk_run(ChimaraGlk *glk, const gchar *plugin, int argc, char *argv[], GE
     
     if(!priv->program)
     {
-        g_warning( "Error opening module: %s", g_module_error() );
-        /* TODO: set 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() );
-        /* TODO: set error */
+    	g_set_error(error, CHIMARA_ERROR, CHIMARA_NO_GLK_MAIN, _("Error finding glk_main(): %s"), g_module_error());
         return FALSE;
     }
 
@@ -1098,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;
@@ -1120,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 <filename 
+ * class="headerfile">gdk/gdkkeysyms.h</filename>
+ * 
+ * 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);
+}