another bunch of gui localizations
[asterisk/asterisk.git] / pbx / pbx_gtkconsole.c
old mode 100755 (executable)
new mode 100644 (file)
index 1aefa4c..2cf4665
@@ -1,47 +1,58 @@
 /*
- * Asterisk -- A telephony toolkit for Linux.
+ * Asterisk -- An open source telephony toolkit.
  *
- * GTK Console monitor -- very kludgy right now
- * 
- * Copyright (C) 1999, Mark Spencer
+ * Copyright (C) 1999 - 2005, Digium, Inc.
+ *
+ * Mark Spencer <markster@digium.com>
  *
- * Mark Spencer <markster@linux-support.net>
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
  *
  * This program is free software, distributed under the terms of
- * the GNU General Public License
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
  */
 
-/* 
- * I know this might seem somewhat pointless in its current phase, but one
- * of the most important parts of this module is demonstrate that modules
- * can require other external libraries and still be loaded (in this
- * case, a host of libraries involving gtk), so long as they are properly
- * linked (see the Makefile)
+/*! \file
+ *
+ * \brief GTK Console monitor -- very kludgy right now
+ * 
  */
 
+/*** MODULEINFO
+       <depend>gtk</depend>
+       <defaultenabled>no</defaultenabled>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 
-#include <asterisk/pbx.h>
-#include <asterisk/config.h>
-#include <asterisk/module.h>
-#include <asterisk/logger.h>
-#include <asterisk/options.h>
-#include <stdlib.h>
 #include <fcntl.h>
-#include <unistd.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdarg.h>
+#include <signal.h>
+#include <sys/time.h>
 
 #include <gtk/gtk.h>
 #include <glib.h>
-/* For where to put dynamic tables */
-#include "../asterisk.h"
 
-static pthread_mutex_t verb_lock = PTHREAD_MUTEX_INITIALIZER;
+#include "asterisk/pbx.h"
+#include "asterisk/config.h"
+#include "asterisk/module.h"
+#include "asterisk/logger.h"
+#include "asterisk/cli.h"
+#include "asterisk/utils.h"
+
+AST_MUTEX_DEFINE_STATIC(verb_lock);
 
 static pthread_t console_thread;
 
 static int inuse=0;
+static int clipipe[2];
+static int cleanupid = -1;
+
 static char *dtext = "Asterisk PBX Console (GTK Version)";
 
 static GtkWidget *window;
@@ -50,6 +61,9 @@ static GtkWidget *closew;
 static GtkWidget *verb;
 static GtkWidget *modules;
 static GtkWidget *statusbar;
+static GtkWidget *cli;
+
+static struct timeval last;
 
 static void update_statusbar(char *msg)
 {
@@ -57,7 +71,7 @@ static void update_statusbar(char *msg)
        gtk_statusbar_push(GTK_STATUSBAR(statusbar), 1, msg);
 }
 
-int unload_module(void)
+static int unload_module(void *mod)
 {
        if (inuse) {
                /* Kill off the main thread */
@@ -65,27 +79,102 @@ int unload_module(void)
                gdk_threads_enter();
                gtk_widget_destroy(window);
                gdk_threads_leave();
+               close(clipipe[0]);
+               close(clipipe[1]);
        }
        return 0;
 }
 
+static int cleanup(void *useless)
+{
+       gdk_threads_enter();
+       gtk_clist_thaw(GTK_CLIST(verb));
+       gtk_widget_queue_resize(verb->parent);
+       gtk_clist_moveto(GTK_CLIST(verb), GTK_CLIST(verb)->rows - 1, 0, 0, 0);
+       cleanupid = -1;
+       gdk_threads_leave();
+       return 0;
+}
+
 
-static void verboser(char *stuff, int opos, int replacelast, int complete)
+static void __verboser(const char *stuff, int opos, int replacelast, int complete)
 {
        char *s2[2];
-       pthread_mutex_lock(&verb_lock);
-       s2[0] = stuff;
+       struct timeval tv;
+       int ms;
+       s2[0] = (char *)stuff;
        s2[1] = NULL;
-       gdk_threads_enter();
+       gtk_clist_freeze(GTK_CLIST(verb));
        if (replacelast) 
                gtk_clist_remove(GTK_CLIST(verb), GTK_CLIST(verb)->rows - 1);
        gtk_clist_append(GTK_CLIST(verb), s2);
-       gtk_clist_moveto(GTK_CLIST(verb), GTK_CLIST(verb)->rows - 1, 0, 0, 0);
-       gdk_threads_leave();
-       pthread_mutex_unlock(&verb_lock);
+       if (!ast_tvzero(last)) {
+               gdk_threads_leave();
+               gettimeofday(&tv, NULL);
+               if (cleanupid > -1)
+                       gtk_timeout_remove(cleanupid);
+               ms = ast_tvdiff_ms(tv, last);
+               if (ms < 100) {
+                       /* We just got a message within 100ms, so just schedule an update
+                          in the near future */
+                       cleanupid = gtk_timeout_add(200, cleanup, NULL);
+               } else {
+                       cleanup(&cleanupid);
+               }
+               last = tv;
+       } else {
+               gettimeofday(&last, NULL);
+       }
+}
+
+static void verboser(const char *stuff, int opos, int replacelast, int complete) 
+{
+       ast_mutex_lock(&verb_lock);
+       /* Lock appropriately if we're really being called in verbose mode */
+       __verboser(stuff, opos, replacelast, complete);
+       ast_mutex_unlock(&verb_lock);
+}
+
+static void cliinput(void *data, int source, GdkInputCondition ic)
+{
+       static char buf[256];
+       static int offset = 0;
+       int res;
+       char *c;
+       char *l;
+       char n;
+       /* Read as much stuff is there */
+       res = read(source, buf + offset, sizeof(buf) - 1 - offset);
+       if (res > -1)
+               buf[res + offset] = '\0';
+       /* make sure we've null terminated whatever we have so far */
+       c = buf;
+       l = buf;
+       while(*c) {
+               if (*c == '\n') {
+                       /* Keep the trailing \n */
+                       c++;
+                       n = *c;
+                       *c = '\0';
+                       __verboser(l, 0, 0, 1);
+                       *(c - 1) = '\0';
+                       *c = n;
+                       l = c;
+               } else
+               c++;
+       }
+       if (strlen(l)) {
+               /* We have some left over */
+               memmove(buf, l, strlen(l) + 1);
+               offset = strlen(buf);
+       } else {
+               offset = 0;
+       }
+
 }
 
-static void remove_module()
+
+static void remove_module(void)
 {
        int res;
        char *module;
@@ -104,7 +193,7 @@ static void remove_module()
                }
        }
 }
-static void reload_module()
+static int reload_module(void *mod)
 {
        int res, x;
        char *module;
@@ -140,14 +229,18 @@ static void reload_module()
                        free(module);
                }
        }
+
+       return AST_MODULE_LOAD_SUCCESS;
 }
 
 static void file_ok_sel(GtkWidget *w, GtkFileSelection *fs)
 {
+       char tmp[PATH_MAX];
        char *module = gtk_file_selection_get_filename(fs);
        char buf[256];
-       if (!strncmp(module, AST_MODULE_DIR "/", strlen(AST_MODULE_DIR "/"))) 
-               module += strlen(AST_MODULE_DIR "/");
+       snprintf(tmp, sizeof(tmp), "%s/", ast_config_AST_MODULE_DIR);
+       if (!strncmp(module, (char *)tmp, strlen(tmp))) 
+               module += strlen(tmp);
        gdk_threads_leave();
        if (ast_load_resource(module)) {
                snprintf(buf, sizeof(buf), "Error loading module '%s'.", module);
@@ -160,30 +253,32 @@ static void file_ok_sel(GtkWidget *w, GtkFileSelection *fs)
        gtk_widget_destroy(GTK_WIDGET(fs));
 }
 
-static void add_module()
+static void add_module(void)
 {
+       char tmp[PATH_MAX];
        GtkWidget *filew;
+       snprintf(tmp, sizeof(tmp), "%s/*.so", ast_config_AST_MODULE_DIR);
        filew = gtk_file_selection_new("Load Module");
        gtk_signal_connect(GTK_OBJECT (GTK_FILE_SELECTION(filew)->ok_button),
                                        "clicked", GTK_SIGNAL_FUNC(file_ok_sel), filew);
        gtk_signal_connect_object(GTK_OBJECT (GTK_FILE_SELECTION(filew)->cancel_button),
                                        "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(filew));
-       gtk_file_selection_set_filename(GTK_FILE_SELECTION(filew), AST_MODULE_DIR "/*.so");
+       gtk_file_selection_set_filename(GTK_FILE_SELECTION(filew), (char *)tmp);
        gtk_widget_show(filew);
 }
 
-static int add_mod(char *module, char *description, int usecount)
+static int add_mod(const char *module, const char *description, int usecount, const char *like)
 {
        char use[10];
-       char *pass[4];
+       const char *pass[4];
        int row;
        snprintf(use, sizeof(use), "%d", usecount);
        pass[0] = module;
        pass[1] = description;
        pass[2] = use;
        pass[3] = NULL;
-       row = gtk_clist_append(GTK_CLIST(modules), pass);
-       gtk_clist_set_row_data(GTK_CLIST(modules), row, module);
+       row = gtk_clist_append(GTK_CLIST(modules), (char **) pass);
+       gtk_clist_set_row_data(GTK_CLIST(modules), row, (char *) module);
        return 0;       
 }
 
@@ -194,14 +289,12 @@ static int mod_update(void)
        if (GTK_CLIST(modules)->selection) {
                module= (char *)gtk_clist_get_row_data(GTK_CLIST(modules), (int) GTK_CLIST(modules)->selection->data);
        }
-       gdk_threads_enter();
        gtk_clist_freeze(GTK_CLIST(modules));
        gtk_clist_clear(GTK_CLIST(modules));
-       ast_update_module_list(add_mod);
+       ast_update_module_list(add_mod, NULL);
        if (module)
                gtk_clist_select_row(GTK_CLIST(modules), gtk_clist_find_row_from_data(GTK_CLIST(modules), module), -1);
        gtk_clist_thaw(GTK_CLIST(modules));
-       gdk_threads_leave();
        return 1;
 }
 
@@ -213,15 +306,18 @@ static void exit_now(GtkWidget *widget, gpointer data)
        ast_update_use_count();
        ast_unregister_verbose(verboser);
        ast_unload_resource("pbx_gtkconsole", 0);
-       if (option_verbose > 1)
-               ast_verbose(VERBOSE_PREFIX_2 "GTK Console Monitor Exiting\n");
-               
+       ast_verb(2, "GTK Console Monitor Exiting\n");
+       /* XXX Trying to quit after calling this makes asterisk segfault XXX */
 }
 
 static void exit_completely(GtkWidget *widget, gpointer data)
 {
-       /* This is the wrong way to do this.  We need an ast_clean_exit() routine */
-       exit(0);
+#if 0
+       /* Clever... */
+       ast_cli_command(clipipe[1], "quit");
+#else
+       kill(getpid(), SIGTERM);
+#endif
 }
 
 static void exit_nicely(GtkWidget *widget, gpointer data)
@@ -239,7 +335,18 @@ static void *consolethread(void *data)
        return NULL;
 }
 
-static int show_console()
+static int cli_activate(void)
+{
+       char buf[256] = "";
+       strncpy(buf, gtk_entry_get_text(GTK_ENTRY(cli)), sizeof(buf) - 1);
+       gtk_entry_set_text(GTK_ENTRY(cli), "");
+       if (strlen(buf)) {
+               ast_cli_command(clipipe[1], buf);
+       }
+       return TRUE;
+}
+
+static int show_console(void)
 {
        GtkWidget *hbox;
        GtkWidget *wbox;
@@ -276,7 +383,7 @@ static int show_console()
        gtk_container_add(GTK_CONTAINER(sw), verb);
        gtk_widget_show(verb);
        gtk_widget_show(sw);
-       gtk_widget_set_usize(verb, 600, 400);
+       gtk_widget_set_usize(verb, 640, 400);
        gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sw, gtk_label_new("Verbose Status"));
 
        
@@ -333,55 +440,66 @@ static int show_console()
 
        hbox = gtk_vbox_new(FALSE, 0);
        gtk_widget_show(hbox);
+       
+       /* Command line */
+       cli = gtk_entry_new();
+       gtk_widget_show(cli);
+
+       gtk_signal_connect(GTK_OBJECT(cli), "activate",
+                       GTK_SIGNAL_FUNC (cli_activate), NULL);
 
        gtk_box_pack_start(GTK_BOX(hbox), notebook, TRUE, TRUE, 5);
        gtk_box_pack_start(GTK_BOX(hbox), wbox, FALSE, FALSE, 5);
+       gtk_box_pack_start(GTK_BOX(hbox), cli, FALSE, FALSE, 0);
        gtk_box_pack_start(GTK_BOX(hbox), statusbar, FALSE, FALSE, 0);
-
-
        gtk_container_add(GTK_CONTAINER(window), hbox);
        gtk_window_set_title(GTK_WINDOW(window), "Asterisk Console");
-       pthread_create(&console_thread, NULL, consolethread, NULL);
+       gtk_widget_grab_focus(cli);
+       ast_pthread_create(&console_thread, NULL, consolethread, NULL);
        /* XXX Okay, seriously fix me! XXX */
        usleep(100000);
        ast_register_verbose(verboser);
        gtk_clist_freeze(GTK_CLIST(verb));
        ast_loader_register(mod_update);
        gtk_clist_thaw(GTK_CLIST(verb));
+       gdk_input_add(clipipe[0], GDK_INPUT_READ, cliinput, NULL);
        mod_update();
        update_statusbar("Asterisk Console Ready");
        return 0;
 }
 
 
-int load_module(void)
+static int load_module(void *mod)
 {
+       if (pipe(clipipe)) {
+               ast_log(LOG_WARNING, "Unable to create CLI pipe\n");
+               return AST_MODULE_LOAD_FAILURE;
+       }
        g_thread_init(NULL);
        if (gtk_init_check(NULL, NULL))  {
-               /* XXX Do we need to call this twice? XXX */
-               gtk_init(NULL, NULL);
                if (!show_console()) {
                        inuse++;
                        ast_update_use_count();
-                       if (option_verbose > 1)
-                               ast_verbose( VERBOSE_PREFIX_2 "Launched GTK Console monitor\n");                
+                       ast_verb(2, "Launched GTK Console monitor\n");
                } else
                        ast_log(LOG_WARNING, "Unable to start GTK console\n");
        } else {
                if (option_debug)
                        ast_log(LOG_DEBUG, "Unable to start GTK console monitor -- ignoring\n");
-               else if (option_verbose > 1)
-                       ast_verbose( VERBOSE_PREFIX_2 "GTK is not available -- skipping monitor\n");
+               else
+                       ast_verb(2, "GTK is not available -- skipping monitor\n");
        }
-       return 0;
+       return AST_MODULE_LOAD_SUCCESS;
 }
 
-int usecount(void)
+static const char *description(void)
 {
-       return inuse;
+       return dtext;
 }
 
-char *description(void)
+static const char *key(void)
 {
-       return dtext;
+       return ASTERISK_GPL_KEY;
 }
+
+STD_MOD(MOD_0, reload_module, NULL, NULL);