Cómo hacer nuestro propio emulador de terminal

Pues eso, que me apetecía escribir algo distinto a Linux From Scratch y, de paso, que fuera sencillo, interesante y que tuviera que ver con la programación, así que vamos a hacernos nuestro propio emulador de terminal en lenguaje C. No va a ser una superterminal, mas bien una nanoterminal, pero el que quiera puede seguir ampliándola hasta dónde quiera llegar.

Cómo lo vamos a hacer

La forma más fácil de hacer un emulador de terminal en C es usando VTE. VTE es un widget para GTK que prácticamente nos hace todo el trabajo importante. Sólo hay que crear una ventana, añadirle un control vte, lanzar un shell en él, mostrar la ventana y llamar a la función main de GTK.

Evidentemente, haciendo esto no vamos a tener un emulador de terminal repleto de características, pero ya va a poder lanzar cualquier programa, va a permitir desplazar la pantalla para ver el scrollbuffer y hasta va a poder copiar y pegar de una forma muy básica.

El código fuente

Probablemente sea el programa más corto que hayáis visto para GTK escrito en C y que haga algo útil. Aquí está todo el código fuente. Guardadlo en un fichero con extensión .c llamado, por ejemplo nanoterm.c.

#include

void main(int argc, char *argv[])
{
    gtk_init(&argc, &argv);
    GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    GtkWidget *terminal = vte_terminal_new();
    gtk_container_add(GTK_CONTAINER(window), terminal);
    g_signal_connect(window, "delete-event", gtk_main_quit, NULL);
    vte_terminal_fork_command(VTE_TERMINAL(terminal), NULL, NULL, NULL, NULL, TRUE, TRUE, TRUE);
    gtk_widget_show_all(window);
    gtk_main();
}

Ahora tenemos que compilarlo y ejecutarlo. Para ello, lo primero es instalar los paquetes necesarios para programar en C si es que no los tenéis ya. En ArchLinux basta con instalar el grupo de paquetes base-devel. En debian y ubuntu creo que es build-essential. En otras distros, tendréis que investigar. Hay que tener instalado también pkg-config, puesto que es la manera más sencilla de pasarle todas las opciones necesarias al compilador. Si estáis de compilar cosas ya tendréis instalado todo esto.

Compilamos y probamos

Una vez instaladas las herramientas necesarias, el comando para compilar es este:

gcc -Wall `pkg-config --cflags --libs vte` nanoterm.c -o nanoterm

Da un par de warnings que vamos a ignorar, pero si todo va bien habrá generado un binario llamado nanoterm que podremos ejecutar. Ahora ya podemos probarlo lanzando “nanoterm“.

nanoterm en acción

También podemos hacer un Makefile si queremos, aunque el comando de compilación es tan sencillo que casi no merece la pena.

Características

La forma de usarlo es muy sencilla. Con sólo ejecutarlo ya tenemos un shell y podemos lanzar comandos y programas de consola de todo tipo. Cuando hayamos lanzado suficientes comandos como para que la pantalla se desplace hacia arriba, con las teclas Shift+PgUp y Shift+PgDown podemos desplazar la pantalla para ver las lineas anteriores.

También podemos seleccionar una parte del texto arrastrando con el botón izquierdo y pegarlo donde queramos haciendo click con el botón central. Para salir, lo mejor es cerrar la ventana. Si usamos “exit” el shell termina, pero la ventana no se cierra. Aunque esto tiene fácil solución.

Cómo funciona

Voy a explicar todo el código fuente linea a linea. No me llevará mucho dado lo pequeño que es.

La linea 1 incluye las definiciones necesarias para usar las funciones del widget VTE. Indirectamente, esto incluye también las de GTK, así que con este include tenemos todo lo que el compilador necesita para encontrar todos los símbolos que vamos a usar en el programa.

La linea 3 es la declaración de la función main. No me voy a poner a explicarla ya que cualquiera con nociones de C sabe lo que es. Podría haber declarado la función de tipo int, que sería más correcto, pero la he hecho void para ahorrarme el return. Hoy estoy un poco vago. 🙂

La linea 5 inicializa la librería GTK a partir de los argumentos de la linea de comandos del programa. Procesa los parámetros estándar de todas las aplicaciones GTK y los demás los deja tal cual.

La linea 6 crea la ventana en la que vamos a colocar el widget y la 7 crear el widget en sí. Luego, la 8 añade el widget a la ventana.

La linea 9 es para permitir que el programa se termine cuando el usuario cierre la ventana. Si no ponemos esta linea, la ventana se cierra, pero el proceso sigue en ejecución para nada, lo cual es un poco marrano. 🙂 El parámetro “delete-event” es el nombre del evento que se lanza cuando se cierra la ventana, y gtk_main_quit es la función que termina la llamada a gtk_main que ponemos en la linea 12.

La linea 10 lanza el shell del usuario en el emulador de terminal. Está función está obsoleta, pero es la forma más sencilla de hacerlo. Tiene varios argumentos para especificar el programa a lanzar y sus parámetros. Si ponemos NULL lanzará el shell que tenga configurado el usuario actual con los parámetros y las variables de entorno por defecto. También se puede especificar si queremos que se logee la sesión. Poniendo TRUE le indicamos que sí.

La linea 11 muestra la ventana que hemos creado con su widget VTE incluido.

Por último, la linea 12 llama a la función gtk_main, que es la que mantiene la aplicación funcionando hasta que alguien llame a gtk_main_quit, que gracias a la linea 9, es lo que ocurre cuando cerramos la ventana.

Y esto es todo. Ahora podéis añadirle cosas y hacer lo que queráis con él.

Enlaces

EOF

Anuncios

2 pensamientos en “Cómo hacer nuestro propio emulador de terminal

  1. demianx864

    O= muy bueno yo no uso mucho C y me dio errores al compilar ya que no tengo muchas librerias de C instaladas, tendré que investigar que necesito instalar en gentoo para que no haya problemas 🙂

    Pero muy buena la entrada igual que las de Linux From Scratch, yo hice una Terminal en Perl pero para Gnome2 ya que no hay Vte para Gnome3 Perl 😦

    Que window manager es el de la captura?

Los comentarios están cerrados.