Gtk-server, tus bash scritps con interfaz gráfica

Gtk-server es un software con el cual podemos crear interfaces gráficas (GTK 1.x o 2.x) en un un montón de shell scripts, desde bash a Perl, pasando por Ruby, Awk o Python (aquí lista completa).

Gtk-server se compila como un binario al que haremos referencias en nuestros shell scripts y que proporciona una especie de API a las librerías GTK, así podremos desde nuestro fichero en texto plano llamar a GTK para dibujar ventanas en el escritorio.

A pensar de lo que se pueda pensar a primera vista, gtk-server no supone una limitación por si misma para programar interfaces gráficas utilizando Gtk, se pueden hacer cosas muy interesantes mediante este software.

A continuación, vamos a ver el famoso Hola Mundo! con bash y gtk-server (una ventana con un botón que pone “Hola Mundo” y si le das se cierra la venta):

#!/bin/bash

### ESTA PRIMERA PARTE ES PARA CREAR LAS FUNCIONES EMBEBIDAS DE GTK PARA BASH (.gtk4bash)
# no es necesario utilizar esto antes, pero te quita trabajo, y es más intuitivo.
###################################################################################################
#
# Create embedded GTK functions for BASH
#
# (c) Peter van Eerten 2006, GPL license
#
# Tested with:
# -BASH 3.0 on Slackware 10 and GTK-server 2.1.4
#
# October 11, 2006: Initial release
# October 12, 2006: Added check to see when created PIPE file is ready
# January 16, 2007: Solved problem of unique filename
# August 20, 2007: Improved for GTK-server 2.1.4
# October 13, 2007: Added mechanism for finding configfile
# May 14, 2008: Added define function, code is even shorter now
# Oct 9, 2008: Added default ‘gtk’ function to use after new definition of calls
#
# Put the first part of this file at the start of each of your BASH scripts and
# you can embed GTK as if you are using the original API.
#————————————————————————————————-

# Set the extending globbing option in BASH
shopt -s extglob

# Pipe filename must be unique for your application
PIPE=”/tmp/gtk.bash.\$$”

# Find GTK-server configfile first
if [[ -f gtk-server.cfg ]]; then
CFG=gtk-server.cfg
elif [[ -f /etc/gtk-server.cfg ]]; then
CFG=/etc/gtk-server.cfg
elif [[ -f /usr/local/etc/gtk-server.cfg ]]; then
CFG=/usr/local/etc/gtk-server.cfg
else
echo “No GTK-server configfile found! Please install GTK-server…”
exit 1
fi

# Now create global functionnames from GTK API
if [[ ! -f $HOME/.gtk4bash || $CFG -nt $HOME/.gtk4bash ]]; then
echo “#!/bin/bash” > $HOME/.gtk4bash
echo “gtk-server -fifo=$PIPE &” >> $HOME/.gtk4bash
echo “while [ ! -p $PIPE ]; do continue; done” >> $HOME/.gtk4bash
while read LINE
do
if [[ $LINE = FUNCTION_NAME* && $LINE = +(*gtk_*|*gdk_*|*g_*|*glade_*) ]]; then
LINE=${LINE#*= }
printf “\nfunction ${LINE%%,*}\n” >> $HOME/.gtk4bash
printf “{\n/bin/echo ${LINE%%,*} \$@ > $PIPE” >> $HOME/.gtk4bash
printf “\nread GTK < $PIPE\n}\n” >> $HOME/.gtk4bash
fi
done < $CFG
printf “\nfunction gtk()\n{\necho \$1 > $PIPE; read GTK < $PIPE;\n}\n” >> $HOME/.gtk4bash
fi

# Declare global variables
declare GTK NULL=”NULL”
unset CFG PIPE LINE

# Assignment function
function define() { $2 $3 $4 $5 $6 $7 $8 $9; eval $1=”$GTK”; }

# Wait for user
read -p “Press  to start hola mundo…” VAR

#————————————————————————————————-
# Aquí empieza el Hola Mundo
#————————————————————————————————-

# Include the generated ‘.gtk4bash’-file in the shellscript to use embedded GTK functions
. $HOME/.gtk4bash

# Definir GUI
gtk_init “NULL NULL”
define WINDOW gtk_window_new 0
gtk_window_set_title $WINDOW “‘Hola Mundo!’”
gtk_window_set_position $WINDOW 1
gtk_window_set_default_size $WINDOW 230 150
define BUTTON gtk_button_new_with_label “‘Hola Mundo’”
gtk_widget_set_size_request $BUTTON 50 25
gtk_container_add $WINDOW $BUTTON

gtk_widget_show_all $WINDOW

# Inicializar variables
EVENT=0

# Mainloop
while [[ $EVENT != $BUTTON && $EVENT != $WINDOW ]]
do
define EVENT gtk_server_callback “wait”
done

# Exit GTK
gtk_server_exit

Este es un pequeño ejemplo de lo que se puede hacer con  gtk-server y bash (u otros lenguajes de script), aquí y aquí se pueden encontrar más ejemplos de lo que se puede hacer, y aquí encontrarás algunas aplicaciones creadas con gtk-server.

Gtk-server no es una aplicación para construir de manera fácil y rápida aplicaciones gráficas (como podría ser Zenity), tienes que conocer GTK, ya que lo único que hace es portar este a los lenguajes de script.

Para empezar a utilizarlo puedes descargarlo desde su web aquí.

Si descargas el source (wget http://downloads.sourceforge.net/gtk-server/gtk-server-2.3.1-sr.tar.gz) lo tienes que descomprimir:

$ tar xzvf gtk-server-2.3.1-sr

$ cd  gtk-server-2.3.1-sr

Y compilarlo e instalarlo:

$ ./configure

$ make

# make install

Y ya puedes empezar a crear tus scrip con interfaz gráfica. Para ello tienes que leer la documentación que puedes encontrar aquí.

Próximamente colgaré un pequeño manual de iniciación para utilizar Gtk-server y Bash.

Diccionario de la RAE en tu terminal GNU/Linux

De vez en cuando se me da por comprar una de esas revistas que hablan de GNU/Linux, sobre todo cuando voy a coger un tren, para entretenerme durante el viaje, y como suelen venir con un CD de las últimas distros que van saliendo pues así de paso las pruebo.

El caso que este fin de semana me compré la “Todo Linux“. Me llamó la atención que en su sección de “Trucos Linux”, el destacado del mes trataba sobre la construcción de un pequeño y simplísimo script para gente nueva en el sistema. El Scritp no lo crearon ellos si no que era una pequeña modificación de un script colgado en TrucoLinux.com y que lo que hacía era mostrar una entrada del diccionario de la RAE en tu terminal.

Como en el artículo comentaban que el script no aceptaba las tildes (ni tampoco las ñ, ni las mayúsculas) pues me dispuse a retocar un poco el mismo para que si aceptara palabras con esos caracteres. Me aburro y lo cuelgo aquí.

El script acepta que le pases la palabra a buscar como parámetro, o se la introduzcas después.

#!/bin/bash 

## Funciones:

function buscar_palabra {
    echo "Se está buscando la palabra \"$aux\" en la RAE, esto"
    echo "puede tardar dependiendo de la velocidad de su conexión"
    echo ''
    #Aquí puedes utilizar lynx o links2 en lugar de links, y si quieres
    #quitarle el "-dump" para visualizar directamente el navegador
    links2 -dump "http://buscon.rae.es/draeI/SrvltGUIBusUsual?LEMA=$palabra&origen=RAE"
    echo ''
}

function adaptar_palabra {
    #Pasar a minúsculas
    palabra=$(echo $palabra | awk '{print tolower($0)}')
    #Para poner la palabra por pantalla
    aux=$palabra
    #Cambiar caracteres especiales
    palabra=$(echo $palabra | sed 's/á/%C3%A1/')
    palabra=$(echo $palabra | sed 's/é/%C3%A9/')
    palabra=$(echo $palabra | sed 's/í/%C3%AD/')
    palabra=$(echo $palabra | sed 's/ó/%C3%B3/')
    palabra=$(echo $palabra | sed 's/ú/%C3%BA/')
    palabra=$(echo $palabra | sed 's/ñ/%C3%B1/')
}

## Parte principal:

if test -z $1
then
	clear
	echo "Diccionario de la RAE"
        echo "Introduce la palabra a buscar:"
	read palabra
	adaptar_palabra
	buscar_palabra
else
	clear
        palabra=$1
	adaptar_palabra
	buscar_palabra
fi

Argordmel propone en los comentarios que sería bueno que el script te diera la oportunidad de volver a buscar una palabra al final. Bien, pues esta podría ser una de las implementaciones ( es solo la parte principal del script):

## Parte principal:
buscar="s"
count="0"
while [ $buscar = 's' ]
do
	if [ $count -eq "0" ]
	then
		if test -z $1
		then
			clear
			echo "Diccionario de la RAE"
		        echo -n "Introduce la palabra a buscar: "
			read palabra
			adaptar_palabra
			buscar_palabra
		else
			clear
		        palabra=$1
			adaptar_palabra
			buscar_palabra
		fi
	else
		echo -n "Otra palabra: "
		read palabra
		adaptar_palabra
		buscar_palabra
	fi

	count=$(($count+1))

	opc=b
	while [ $opc != 'n' ] && [ $opc != 's' ]
	do
		echo -n "¿Buscar otra? [s/n]: "
		read opc
		if [ "$opc" = 'n' ]; then
			exit
		elif [ "$opc" = '' ]; then
			opc='b'
		fi
	done
done

Como bien dice mch en lo comentarios, si modificamos en esta segunda parte principal con el siguiente recorte de código desde la línea 16 (“else”) hasta la 21 (“fi”), podremos pasar como parámetro más de una palabra:

else
	for pal in "$@"; do
		clear
		palabra=$1
		adaptar_palabra
		buscar_palabra
		if [ $# -gt 1 ]; then
			echo "Pulse una tecla para siguiente palabra "
			read -n1
		fi
		shift
	done
fi

Vídeos de Veoh con atajo de teclado

Primero, si no sabes como ver los vídeos de Veoh en GNU/Linux visita: http://linfox.es/14/07/2008/videos-de-veoh-en-gnulinux/ (Sección de VeohProxy)

Por otra parte, si lo has leído y estás utilizando VeohProxy como yo, igual te molesta, igual que a mi, tener que abrir la terminal, ejecutar VeohProxy, copiar el enlace y después abrir una pestaña de firefox (o tu navegador preferido) y copiarlo…

Pues para esto he creado un pequeño script en bash que simplifica la tarea. Puedes descargar el vídeo con un simple atajo de teclado.

El script en cuestión es este:

#!/bin/sh

#Lanzador.  Elige como quieres descargarlo (firefox, opera, wget, otro lanzador a otro navegador)
#Si quieres abrirlo: vlc, mplayer, kaffeine...
NAVEGADOR=firefox

cd ~
python ${HOME}/VeohProxy-1.51/default.py &;
URL=$(xsel -a | cut -d\/ -f5 | cut -d\? -f1)

if [ $NAVEGADOR = "wget" ]; then
	xterm -e wget http://127.0.0.1:64653/$URL
else
	$NAVEGADOR http://127.0.0.1:64653/$URL
fi

¿Cómo se utiliza?

Simplemente buscas el vídeo que quieres ver, lo abres, y una vez ahí selecionas con doble click todo el enlace del vídeo en la barra de direcciones, y depués presionas <Control>F10 (o el atajo de teclado que hayas elegido).

¿Cómo se instala?

Pues primero te descargas el Script. Le das permisos de ejecución:

$ chmod +x veoh.sh

Lo metes por ejemplo en el directorio del VeohProxy. Y ahora solo te queda crear un atajo de teclado que ejecute el script.

NOTA: Para ejecutar el script necesitas el paquete xsel. En Debian y derivados:

# aptitude install xsel

¿Y el atajo de teclado?

Pues en Gnome puedes hacerlo ejecutando gconf-editor (en otros escritorios tendrá un proceso análogo):

Presionas Alt + F2 y escribes gconf-editor. En la ventana que aparece desplegas la pestaña apps -> metacity –> Global_keybindings. En la parte correspondiente a “run_command_1″ eliges tu atajo, yo he puesto “<Control>F10″.

Después vas a la pestaña apps -> metacity –> keybindings_commands y en la parte correspondiente a “command_1″ pones la ruta a al script, yo por ejemplo “/home/aabilio/VeohProxy-1.51/veoh.sh”

Y con esto ya tendías todo hecho. Se acabó todo el proceso de ejecutar VeohProxy, copiar URL, abrir navegador…

A tener en cuenta: El Script presupone que tienes el directorio de VeohProxy con su nombre original y en tu carpeta personal ($HOME) y que vas a seleccionar la URL completa del vídeo (aunque es totalmente editable).

Cambiando la variable NAVEGADOR del principio del script (NAVEGADOR=firefox) puedes elegir con que descargar el vídeo: con un navegador (firefox, opera..), con wget, o incluso abriéndolo directamente (vlc, mplayer, kaffeine…)

enlace | Script veoh.sh

enlace | Vídeos de Veoh en GNU/Linux

IMPORTANTE | Estado VeohProxy a 4 de Marzo de 2009

Comandos Unix (man)

Hoy estreno una nueva sección. En esta nueva sección iré comentando de vez en cuando algún comando de terminal Unix.

La mayoría de los comandos que vaya escribiendo en esta sección se pueden ejecutar en todas las plataformas UNIX (BSD y descendientes de este como Mac, Solaris, etc) aunque para algunas plataformas puede diferir un poco, sobre todo sus argumentos. En principio yo los utilizo bajo GNU/Linux.

Primero para que quede claro la sintaxis general de una orden es:

nombre_de_la_orden arg1 arg2 arg3 …argn

Me estaba preguntando por que orden podía empezar y tras pensarlo un minuto me he decidido por “man” por que para mi es la orden de las ordenes.

Al ejecutar el comando man en una terminal acompañado de otra orden, man te mostrará la página de manual de ese comando. Man siempre es útil, para cuando no sabemos que hace tal comando o no nos acordamos cuales eran los argumentos de aquella orden que hace tiempo que no utilizamos.

Para navegar por las páginas del manual se utilizan las teclas: “Return” (ENTER) para ir a la siguiente línea del manual, “Espacio” para sacar por pantalla la siguiente página y “Q” o “q” para salir de man y volver a la shell.

Las páginas de manual que devuelve man al ser ejecutado suelen estar compuestas de la siguiente forma.

Primero el apartado denominado NAME, en el que como su nombre indica, se especifica el nombre de la orden a la que pertenece el manual junto con una breve línea explicativa.

SYNOPSIS: aquí se presenta la sintaxis de la orden con todos sus argumentos opcionales.

DESCRIPTION: es donde ya se explica mejor qué es la orden, cómo funciona y se describe alguna característica más.

OPTIONS: describe uno a uno los argumentos que se pueden utilizar con la orden, con la información de lo que hace cada uno.

FILES: Muestra las rutas de algunos ficheros que te pueden interesar.

SEE ALSO: Muestra una lista de comandos que están relacionados los cuales te pueden interesar para entender aun mejor la orden que estás buscando.

BUGS: como su nombre indica muestra los bugs conocidos con su descripción.

AUTHOR: Quién escribió la página del manual.

Si bien estas son las partes más comunes, pueden existir más partes en la página de un manual como puede ser EXAMPLES (que muestra algún ejemplo de ejecución de la orden con algún argumento y su acción), HISTORY (muestra la historia de la orden, un pequeño comentario, tampoco nada extenso), o por ejemplo COPYRIGHT (que muestra el copyright del manual, valga la redundancia)

Podría decir bastantes cosas más sobre este maravilloso comando pero tampoco tengo pensado desmenuzar al tope todos las ordenes Unix. Además el que esté empezando por ejemplo en GNU/Linux puede ejecutar en su terminal la orden “man man” y así comprobar todos los argumentos de man.

manual_de_man

Página del manual de la orden “man” sobre la shell bash de GNU/Linux

 

Más info: Wikepedia