Scripts en Cinnamon

Un script básico es un archivo creado con un editor de texto, que contiene uno o varios comandos ,y que puede ser ejecutado sin tener que escribir el comando en la terminal cada vez que queramos que se ejecute.Como crear un script básico
Además de estos scripts con una sintaxis muy sencilla de entender y de crear, también los hay muy complicados tanto de entender como de crear ( se puede consultar el Manual de programación Bash Shell en formato .pdf: http://thales.cica.es/rd/glinex/practicas-glinex05/manuales/bash/practica.pdf ) ; también los hay que se ejecutan sin que aparezca ninguna interfaz gráfica, y otros en los que aparece una o varias ventanas durante su ejecución, éstos suelen/pueden estar hechos usando Zenity
Si eres aficionado a crear/coleccionar/usar  scripts/comandos, te interesa saber donde conviene tenerlos guardados para tenerlos siempre bien accesibles para su fácil uso.

1- Nemo scripts:
Una forma de añadir acciones al menú contextual de Nemo es por medio de los scripts para Nautilus (*), como por ejemplo los que se pueden añadir desde las páginas siguientes:
http://g-scripts.sourceforge.net/
http://nautilus-scripts.javielinux.com/index.php
http://gnome-look.org/index.php?xsortmode=high&page=0&xcontentmode=188

(*)Los scripts para Nautilus sirven igualmente para Nemo, y en este caso se deben guardar en el directorio: /home/usuario/.gnome2/nemo-scripts.


2- Nemo actions:
En Nemo aparecen por defecto en el menú contextual una serie de opciones que realizan una serie de acciones predeterminadas; podemos añadir nuevas acciones al menú contextual de Nemo, las cuales se guardan en el directorio: /home/usuario/.local/share/nemo/actions. Ver como Añadir acciones al menú contextual de Nemo
y ejemplos de algunas de ellas que he añadido a mi sistema:Nuevas acciones en el menú contextual de Nemo

Tanto los scripts como las acciones de Nemo se usan desde el menú contextual del administrador de archivos, y sirven para ejecutar scripts/comandos que hacen referencia a archivos y/o directorios del administrador de archivos, e interactuan con ellos.

3- Applet scripts menu:
Instalando el applet ( ver instalar Applets y extensiones en Cinnamon) Scripts Menu http://cinnamon-spices.linuxmint.com/applets/view/185  nos aparece un icono en el panel de Cinnamon desde el cual podemos ejecutar los scripts que guardemos en el directorio /home/usuario/.scripts-applet 
En este directorio podemos guardar scripts que no necesiten que elijamos previamente archivos y/o directorios del administrador de archivos..
Como se puede ver en la imagen de configuración del applet, podemos cambiar la dirección en donde guardar los scripts, por otra que nos guste mas.

Ahí tengo guardado por ejemplo un script en Zenity para hibernar el sistema tras x segundos, o el script de TVenLinux para ver y grabar canales de televisión.

4- Archivo oculto /home/usuario/.bashrc:
El archivo de configuración de la terminal /home/usuario/.bashrc es un archivo oculto en nuestro directorio de usuario, que puede ser muy útil para crear en él nuestra propia lista de comandos complejos útiles.

Esto se hace, abriendo este archivo y añadiendo al final una lista de comandos complejos que usemos a menudo, pero que no recordemos fácilmente, creando un "alias" o nombre fácil de acordarnos para un comando complejo; esto se hace precisamente usando en este archivo el comando alias, el cual se usa con la sintaxis siguiente:  
alias nombre-del-alias='comando con argumentos a ejecutar'

Por ejemplo:
# desinstalar paquetes con apt-get
alias desinstalar='sudo apt-get remove --purge'
# instalar paquetes con apt-get
alias instalar='sudo apt-get install'
# actualizar synaptic
alias update='sudo apt-get update'
# desinstalar paquetes con aptitude
alias des='sudo aptitude remove'
#desinstalar paquetes y sus archivos de configuración
alias purge='sudo aptitude remove --purge'
# instalar paquetes con aptitude
alias ins='sudo aptitude install'

Con ello, por ejemplo, para desinstalar cairo-dock ( y los paquetes asociados, que se instalaron con él ) y sus archivos de configuración, solo tengo que escribir en la terminal un alias, en este caso, purge: 
purge cairo-dock , y tras dar a la tecla intro se me pide la contraseña de root, la pongo y ya el comando me desinstala todo lo que le he pedido con dicho alias.

Ver más detalles en Crear nuestra propia lista de comandos

5- Carpeta /home/usuario/scripts: 
Si no sabes muy bien donde guardar los scripts que tu mismo vayas haciendo, o recopilando, es una buena idea tenerlos todos guardados en una carpeta especifica de tu directorio de usuario, por ejemplo /home/usuario/scripts: en este caso lo mejor es que en el propio script se indique desde que carpeta se tiene que ejecutar, bien con una dirección relativa o con una absoluta: Viajando por los directorios con la terminal

--------------------------
1-Si es un script que necesita ser usado desde el menú contextual del administrador de archivos, y sirve para ejecutar scripts/comandos que hacen referencia a archivos y/o directorios del administrador de archivos, e interactuan con ellos, guárdalo en /home/usuario/.gnome2/nemo-scripts

2-Si es un script que además de lo anterior sirve para añadir una nueva Acción al menú contextual de Nemo, guárdalo en /home/usuario/.local/share/nemo/actions
  
3-Si es un script que no necesita que elijamos previamente archivos y/o directorios del administrador de archivos, puedes guardarlo en /home/usuario/.scripts-applet 

4-Si es un alias de un comando, debe de estar en el archivo oculto /home/usuario/.bashrc

5-Si no pertenece a ninguna de las categorías anteriores, se puede guardar en el directorio /home/usuario/scripts
 

Hacer que se ejecute un script durante el proceso: salida de la sesión gráfica->pantalla de acceso->retorno a la sesión gráfica

No siempre queremos que un script se ejecute de forma manual, sino que aveces queremos que se ejecute a) en un determinado tiempo, día/s y hora/s,  o b) en un determinado momento durante el proceso del inicio del sistema o c) durante el proceso: salida de la sesión gráfica->pantalla de acceso->retorno a la sesión gráfica.

a) En el índice del blog, en la sección Tareas hay varios temas que explican como hacer que un script se ejecute de forma repetitiva o no, en un dia/s y hora/s determinadas

b)En el tema Hacer que se ejecute un script en el inicio del sistema se explica como conseguir que un script se inicie al iniciarse el sistema y/o entrar en la sesión gráfica.

c) Ahora de lo que se trata es hacer que un script que tenemos guardado en algún lugar del disco duro se ejecute cuando salimos de la sesión gráfica de cualquier usuario, volvemos a la pantalla de acceso y volvemos a entrar en la sesión gráfica del mismo u otro usuario. Para ello modificamos ligeramente un archivo de configuración del programa Gestor de la Pantalla de Acceso ( en inglés Display Manager ) . El archivo a modificar varia ligeramente en función del display manager que se use.

En MDM - Mint Display Manager ( es el que viene por defecto con Mint Cinnamon):

Se edita con sudo gedit /etc/mdm/PostSession/Default dicho archivo /etc/mdm/PostSession/Default, añadiendo una línea que indica la dirección donde esta guardado el script ( por ejemplo en /home/usuario/Scripts/script.sh ) que queremos que se ejecute al salir de la sesión de cualquier usuario, de forma que ahora está así:

#!/bin/sh
#dirección del script que queremos que se autoejecute al salir de la pantalla de acceso
/home/usuario/Scripts/script.sh
exit 0

Se guardan los cambios realizados en dicho archivo. Ahora cada vez que se sale de la pantalla de acceso, para entrar en la sesión gráfica de un usuario, se ejecuta el script.sh

¿ Y para que sirve esto ? Bueno, eso es cuestión de la imaginación de cada cual...yo le he encontrado una utilidad: Crear un usuario "invitado" en Mint-Cinnamon

En GDM - Gnome Display Manager ( Es el que viene por defecto con Gnome-shell):

En Mint 15 Cinnamon con gdm como administrador de la pantalla de acceso (  ya que al instalar Gnome-shell junto a Cinnamon me obliga a sustituir mdm por gdm )  se hace de forma similar, editando el archivo /etc/gdm/PostSession/Default

En Lightdm - Ligero Display Manager  ( Es el que viene por defecto con Ubuntu ):

No uso esta distro, y no he probado como hacerlo con lightdm, pero en esta dirección http://ubuntuforums.org/showthread.php?t=1918649&p=11656736#post11656736   parece que explican como llevarlo a cabo, y parecer ser muy similar a como se hace en gdm o mdm: editando el archivo /etc/lightdm/lightdm.conf

————————————-

Hacer que se ejecute un script en el inicio del sistema

En este tema se explican varios  procedimientos para hacer que se pueda ejecutar un script en el inicio del sistema. Según si queremos que el script se ejecute en las sesiones de todos los usuarios, o solo en la sesión de uno de ellos, si queremos que se ejecute con o sin permisos de root, debemos elegir uno u otro procedimiento.

1-- Sistema-Preferencias-Aplicaciones al inicio: "Añadir programa al inicio":  en "Comando" se pone la dirección en donde esta el script que previamente hemos creado y guardado en algún lugar del disco duro. Este es el procedimiento que recomiendo si el script que queremos que se inicie al inicio del sistema solamente para una determinada sesión de usuario, pero no para otras sesiones de otros usuarios del sistema.

Si tenemos configurado el sistema para que se puedan abrir varias sesiones de varios usuarios: De esta forma podemos hacer que en la sesión de un usuario se ejecute un script y en la sesión de otro usuario no se ejecute ese script, o que en una sesión se ejecute un script, y en otra sesión de otro usuario se ejecute otro script.

Es un método para usar script con un usuario en concreto.

2-- Gnome-schedule: instalamos el paquete gnome-schedule y lo ejecutamos con o sin permisos de root según necesitemos que el script se ejecute con o sin permisos de root.  Configuramos el programa: en Hora y Fecha: Básico -> "Al Reiniciar"  , para que el script se autoinicie al inicio del sistema.  Mas información sobre este programa en Programar tareas repetitivas con Gnome-schedule

Con este procedimiento podemos crear una tarea programada distinta, que ejecute un script al inicio,  para cada usuario si ejecutamos el programa sin permisos de root, o crear una tarea programada que se ejecute en las sesiones de todos los usuarios si ejecutamos el programa con permisos de root



3-- Iniciar el script desde el directorio /etc/init.d

-- El primer paso es crear el script ( mi-script.sh  , este archivo script  puede tener cualquier nombre   ) en el directorio /etc/init.d
-- Después de esto tenemos que darle permisos al archivo para que se pueda ejecutar sin problemas, esto lo hacemos con el siguiente comando: chmod +x mi-script.sh
-- Podemos ejecutar el script, para comprobar que funciona bien, de la siguiente manera: ./mi-script.sh
-- Para agregar este comando para que sea ejecutado en el momento que el sistema arranque, lo hacemos con el siguiente comando: update-rc.d mi-script.sh defaults 80
-- Ahora el script se va a ejecutar cada vez que el sistema arranque.

El primer paso se hace desde el Nautilus ejecutado en modo root, iniciado desde la terminal con: sudo nautilus los demás comandos se ejecutan desde la terminal de root y desde el directorio /etc/init.d

Con este procedimiento creamos un script que se iniciara en las sesiones de todos los usuarios, o que necesitamos que se inicie antes de que se entre en la sesión gráfica de usuario.

------------------

Añadido: gracias a un comentario de Guadafan, en el foro de Guadalinex.org

4-- También se puede lanzar el/los scripts desde el archivo /etc/rc.local
Dicho archivo tiene este contenido (traducido):

Este script se ejecuta al final de cada nivel de ejecución multiusuario.

# Asegúrese de que el script "exit 0" en caso de éxito o de cualquier otro
# Valor en caso de error.
#
# Con el fin de habilitar o deshabilitar este script sólo cambia la ejecución
Número de bits.
#
# Por defecto este script no hace nada
exit 0

Es decir el/los script/s han de ponerse en la línea anterior a: exit 0 ; se ejecutarán para todos los usuarios del sistema.

——————————-

No siempre queremos que un script se ejecute de forma manual, sino que aveces queremos que se ejecute a) en un determinado tiempo, día/s y hora/s,  o b) en un determinado momento durante el proceso del inicio del sistema o c) durante el proceso: salida de la sesión gráfica->pantalla de acceso->retorno a la sesión gráfica.

a) En el índice del blog, en la sección Tareas hay varios temas que explican como hacer que un script se ejecute de forma repetitiva o no, en un día/s y hora/s determinadas.

b) Este caso es el que se explica en este tema.

c) Este caso se explica en hacer que se ejecute un script durante el proceso: salida de la sesión gráfica -> pantalla de acceso -> retorno a la sesión gráfica.

---------------------------------

Script para que el sistema haga copias de seguridad automáticas,conservando solo las mas modernas.

Tenía interés en  hacer un script que no fuera muy complicado, y que ejecutándolo con Gnome-Schedule ( automatizar tareas repetitivas con Gnome-schedule ) con permisos de root*  1 vez por semana fuera: a) creando copias de seguridad de varias cosas ( programas, correos, archivos de configuración etc ), con la fecha en la que se van creando los archivos en sus respectivos nombres,  pero que al mismo tiempo b)  fuera borrando las copias de seguridad con mas de, por ejemplo, 30 días, para que no se fueran acumulando copias de seguridad demasiado viejas y que ocupan un espacio innecesario en el disco duro.  Por supuesto también se puede ejecutar este script con crontab.

La solución a la parte a) ya la sabia de otras lecturas en blogs, foros, etc , y de leer lo que sale al teclear en la terminal: man tar

La solución a la parte b) me la dio el amigo Guadafan, de Gualdalinex: http://hostinglandia.com/viewtopic.php?f=32&t=19 ,y tras leer lo que sale en la terminal al teclear:  man find
-mtime n : Los  datos  del  fichero  fueron modificados por última vez hace n×24 horas.
-exec orden ; Ejecuta  orden;  verdad  si  se  devuelve el status 0. Todos los argumentos que siguen a find se toman como de la orden hasta que se encuentre uno consistente en `;'. La cadena `{}' se reemplaza por el nombre del fichero que se está procesando;  en  cualquier sitio de los argumentos de la orden, no sólo en argumentos donde esté sola, como en algunas otras versiones de find.  Ambas  construcciones  pueden necesitar `escaparse' (con una `\') o entrecomillarse, para protegerlas de la expansión que  efectuaría  el shell. La orden se ejecuta en el directorio de comienzo.

Al final lo he conseguido: La "sintaxis básica" del script seria algo así:

1 #!/bin/bash
2 #echo Script para crear backups fecha.tar en el directorio /media/mi-disco/backups
3 #echo
4 cd /media/mi-disco/backups
5 #echo  crear archivos comprimidos .tar backups de lo que queramos
6 tar zcvf nombre_del_backup_`date +%d%B%Y-%H-hora-%M-minutos`.tar  dirección de los archivos y/o directorios a copiar
7 #echo eliminar los archivos .tar mas "viejos" de 30 dias
8 sudo find /media/mi-disco/backups/*.tar* -mtime +30 -exec rm {} \;
9 exit

Los números no forman parte del script, solo los he puesto para identificar mejor lo que es cada línea.

-----------------------------------

Un ejemplo de este scirpt con comandos mas "reales" seria:

1 #!/bin/bash
2 #echo Script para crear backups fecha.tar en el directorio /media/mi-disco/backups
3 #echo
4 cd  /media/mi-disco/backups
5 #echo
6 tar zcvf backup-firefox_`date +%d%B%Y-%H-hora-%M-minutos`.tar /home/usuario/.mozilla
7 tar zcvf backup-sylpheed_`date +%d%B%Y-%H-hora-%M-minutos`.tar /home/usuario/.sylpheed-2.0
8 tar zcvf backup-mail_`date +%d%B%Y-%H-hora-%M-minutos`.tar /home/usuario/Mail
9 tar zcvf grub2_`date +%d-%B-%Y-%H-hora-%M-minutos`.tar /etc/default/grub /etc/grub.d/  /boot/grub/grub.cfg
10 sudo tar zcvf apt_`date +%d-%B-%Y-%H-hora-%M-minutos`.tar /etc/apt/ /var/lib/apt/ /var/cache/apt/
11 sudo find /media/mi-disco/backups/*.tar* -mtime +30 -exec rm {} \;
12 exit

Los números no forman parte del script, solo los he puesto para identificar mejor lo que es cada línea.

Se le pueden añadir mas lineas del tipo tar zcvf.... para crear copias de seguridad en forma de archivos comprimidos .tar de mas directorios y/o archivos.

Con él , ejecutándolo 1 vez por semana ( con Gnome-Schedule en modo root*  ) mantendríamos copias de seguridad  de Firefox, Sylpheed ( programa de correos ) y de los correos, del Grub2, y de Synaptic,  de los últimos 30 días, borrándose las copias mas antiguas.

* Sobre el uso del comando sudo en este script:

Si los archivos/directorios que queremos copiar tienen permisos de usuario, la línea tar zcvf ....no necesita llevar delante el comando sudo, y el archivo .tar que se creará tendrá también permisos de usuario.
Si los archivos/directorios que queremos copiar tienen permisos de root, la línea tar zcvf ... necesita llevar delante el comando sudo, y el archivo .tar que se creará tendrá también permisos de root.
Si hay una o mas líneas tar zcvf...con el comando sudo delante, la línea find también tendrá que llevar delante el comando sudo, para que al borrar los archivos .tar con permisos de root no nos pida confirmación ni contraseña para borrar cada uno de ellos.
Si en todo el script no hay ninguna línea que comience por el comando sudo ( ni delante de tar zcvf ni de find ), se podrá ejecutar con Gnome-Schedule con permisos de usuario.
Si en el script hay alguna línea que comience por el comando sudo, se debe ejecutar con Gnome-Schedule con permisos de root.
Lo mas sencillo es ponel el script  para ser ejecutado por Gnome-Schedule con permisos de root, ya que así podrá ser ejecutado tanto si hay o no líneas con el comando sudo delante, de forma que si lo modificamos (añadiendo una línea con sudo  ) no tengamos que modificar también como ejecutarlo.

------------------------------------------------------------------------------------

En resumen: Si ejecutamos un  script de este tipo con Gnome-Schedule ejecutado con permisos de root, podremos hacer que el sistema trabaje por nosotros y haga de forma automática copias de seguridad de lo que queramos ( según las líneas tar zcvf ... que pongamos), en el directorio que hayamos puesto en el script, cada un cierto tiempo que nosotros elegimos (en el Gnome-Schedule) , y conservar solo las copias mas modernas del tiempo que queramos (según el número que pongamos tras -mtime+ ) ; vamos, que me parece un chollo de script.

-------------------------------------------------------------------------------------

Deshabilitar/Habilitar el touchpad con scripts

En un tema anterior ( Configurar , habilitar o  deshabilitar el touchpad con aplicaciones gráficas ) se explicó como configurar las opciones del touchpad mediante aplicaciones gráficas, en este tema vamos a ver como deshabilitar/habilitar el touchpad, con scripts, sin aplicaciones gráficas.

1ª Opción: Desde http://sites.google.com/site/trucosubuntu/controladores/touchpad se puede obtener un script touchpad.sh (o el texto del script en formato pdf:  touchpad ) que una vez ejecutado ( durante su ejecución nos pide varias veces la contraseña de root para instalar y modificar varias opciones en el sistema ) nos añade a Sistema-Preferencias-Aplicaciones al inicio-Programas al inicio, una entrada nueva: Autodeshabilitar touchpad, con el comando: touchpad-auto, que detecta si existe un ratón, y si es así, deshabilita el touchpad. De esta forma se deshabilita o habilita de forma automática el touchpad en función de que se detecte que hay, o no, conectado un ratón. Una vez instalado este script, también se puede habilitar o deshabilitar el touchpad de forma manual con la combinación de teclas: Alt+t

Así mismo, este script añade una entrada nueva en el programa Gconf-Editor ; teclear Alt+f2 y luego gconf-editor, para que se abra dicho programa, y luego ir a: Desktop-Gnome-Peripherals-Touchpad:  touchpad autodisable. Si esta opción esta habilitada hace que si esta conectado el ratón, se auto deshabilite la otra opción: touchpad enabled. Y si deshabilitamos touchpad autodisable, y habilitamos touchpad enabled, entonces este script no funciona, y no se deshabilita el touchpad tengamos o no conectado el ratón.

Si después de haber ejecutado el script queremos que no surta efecto, y que siga habilitado el touchpad aunque tengamos conectado el ratón:
-- des-seleccionar la entrada "Autodeshabilitar touchpad" en Sistema-Preferencia-Aplicaciones al inicio-Programas al inicio, con lo cual en el próximo inicio del sistema no se ejecutará el script y/o
-- debemos en el programa Gconf-Editor des-seleccionar la opción "touchpad autodisable", y seleccionar la opción "touchpad enabled".

--------------------------------------

2ª Opción: Ejecutando en la terminal: xinput -list nos aparece una lista similar a:

usuario@mint ~ $ xinput -list
⎡ Virtual core pointer                        id=2    [master pointer  (3)]
⎜   ↳ Virtual core XTEST pointer                  id=4    [slave  pointer  (2)]
⎜   ↳ Macintosh mouse button emulation            id=14    [slave  pointer  (2)]
⎜   ↳ Logitech USB Receiver                       id=10    [slave  pointer  (2)]
⎜   ↳ Logitech USB Receiver                       id=11    [slave  pointer  (2)]
⎜   ↳ ETPS/2 Elantech Touchpad id=13    [slave  pointer  (2)]
⎣ Virtual core keyboard                       id=3    [master keyboard (2)]
↳ Virtual core XTEST keyboard                 id=5    [slave  keyboard (3)]
↳ Power Button                                id=6    [slave  keyboard (3)]
↳ Video Bus                                   id=7    [slave  keyboard (3)]
↳ Power Button                                id=8    [slave  keyboard (3)]
↳ USB 2.0 Camera                              id=9    [slave  keyboard (3)]
↳ AT Translated Set 2 keyboard                id=12    [slave  keyboard (3)]

Elegimos la que hace referencia al touchpad, en mi caso: ETPS/2 Elantech Touchpad, y creamos dos scripts:

Script A) para DesHabilitar el Touchpad :

#!/bin/bash
echo Script para deshabilitar touchpad
echo xinput -list
echo elegir el touchpad y ponerlo en el siguiente comando
xinput set-int-prop "ETPS/2 Elantech Touchpad" "Device Enabled" 8 0

, y el otro Script B) para Habilitar el Touchpad:

#!/bin/bash
echo Script para habilitar touchpad
echo xinput -list
echo elegir el touchpad y ponerlo en el siguiente comando
xinput set-int-prop "ETPS/2 Elantech Touchpad" "Device Enabled" 8 1

Una vez hemos creado estos dos scripts podemos añadir al panel un "lanzador de aplicaciones personalizado" que nos añada un icono al panel desde el cual con un clik habilitar el touchpad, y otro lanzador que nos añada otro icono al panel desde el cual con un clik deshabilitar el touchpad.

También podemos a través de Sistema-Preferencias-Combinaciones de Teclas: adjudicar una nueva combinación de teclas a cada uno de esos comandos para que se pueda habilitar o deshabilitar el touchpad con una combinación de teclas en vez de con un click del ratón.

Con respecto a los comandos para activar o desactivar el touchpad:  no es "tan" necesario el uso de un script que detecte el ratón para que al encender el ordenador, se desconecte el touchpad, (script de la opción 1  ) porque la configuración que se haya adoptado con estos comandos se conserva, es decir, si con el script A  desconectamos el touchpad y apagamos el ordenador, cuando lo volvemos a encender, el touchpad sigue desconectado.

----------------------------------------------——————————————

Mejorando un script con Zenity

El paquete Zenity viene incluido en los repositorios de las distros principales; permite mostrar cuadros de diálogo a partir de scripts de terminal.

Como creo que la manera más fácil de ver cómo se usa algo es a través de unos ejemplos, aquí hay algunos: En las siguientes páginas (en ingles) hay una recopilación de todos los posibles diálogos en zenity:
http://linux.byexamples.com/archives/259/a-complete-zenity-dialog-examples-1/
http://linux.byexamples.com/archives/259/a-complete-zenity-dialog-examples-2/

Tienen capturas usando cada una de las opciones y el comando correspondiente. Además, el siguiente extracto, con el comando zenity --help lista todas las posibilidades.

zenity --calendar Mostrar el diálogo del calendario
zenity --entry Mostrar el diálogo de entrada de texto
zenity --error Mostrar el diálogo de error
zenity --info Mostrar el diálogo de información
zenity --file-selection Mostrar el diálogo de selección de archivo
zenity --list Mostrar el diálogo de lista
zenity --notification Mostrar notificación
zenity --progress Mostrar el diálogo de indicación de progreso
zenity --question Mostrar el diálogo de pregunta: ¿Está seguro de que desea continuar?
zenity --warning Mostrar el diálogo de advertencia: ¿Está seguro de que desea continuar?
zenity --scale Mostrar el diálogo de escala: ajustar el valor de la escala
zenity --text-info Mostrar el diálogo de texto de información

Aplicaciones: Como podéis suponer, las aplicaciones son múltiples. Creo que prácticamente cualquier script que requiera algo de interactividad con el usuario puede mejorarse con esta herramienta para pedirle (o mostrarle) los datos a la persona que está enfrente de la pantalla. Creo que son dos las situaciones donde más útil puede ser conocer esta herramienta:

* Para preparar scripts para gente que le asuste la consola. Con un poco de esfuerzo se puede montar un script con apariencia de programa "muy trabajado" y con la misma funcionalidad (invocando por debajo a los programas oportunos, claro está).
* Para hacer que un script que corra a través del "demonio cron" ( "tareas programadas" - programa gnome-schedule ) se comunique con el usuario (mostrando mensajes de error o de estado).

El "demonio cron" es un proceso en segundo plano que ejecuta uno o varios programas en particular, en determinados momentos (por ejemplo, cada minuto, día, semana o mes); el usuario normal o el administrador del sistema, con permisos de root,  puede crear procesos de este tipo con el programa "tareas programadas" ( gnome-schedule).

Si lo usáis a través de cron (o, en general con gnome-schedule en modo root) es probable que necesitéis usar algo como lo siguiente:

su "nombre del usuario" -c 'DISPLAY=:0 zenity --info --text="vuestrotexto"'

( su = comando para que lo siguiente se use como root; sustituir: zenity --info --text="vuestrotexto"' , por la opción de zenity que se requiera ).

------------------------

Comparto con vosotros, como ejemplo de lo que se puede hacer con Zenity,  este "Script para apagar el pc de forma programada, con una barra deslizante de tiempo" que nos indica el tiempo que queda hasta que se apaga el pc.
Nos puede servir, por ejemplo para dejar encendido el pc por la noche durante un cierto tiempo y que luego se apague el solo. De todas formas una vez lanzado si a mitad del tiempo que falta para que se ejecute la orden de apagado, te arrepientes puedes darle a cancelar.
Información extraída desde: http://blog.deigote.com/2009/04/17/programmed-shutdown-pequeno-script-para-apagar-la-maquina/ o desde: http://deigote.com/scripts/x-programmed-shutdown

El script es:

#!/bin/bash
# Ask for time in minutes to sleep and after that poweroff the computer
# needs - zenity

minutes=`zenity --entry --title "Apagar el ordenador" --text "¿Dentro de cuántos minutos?" --entry-text "120" 2>&1` || exit
seconds=`expr $minutes "*" 60`

if [ $seconds != "" ] ; then
for i in `seq 1 $seconds` ; do
percentage=`expr $i "*" 100`
percentage=`expr $percentage "/" $seconds`
echo $percentage
sleep 1
done | zenity --title="Apagar el ordenador" --text="Esperando $minutes minutos" --progress --auto-close --auto-kill
sudo /sbin/poweroff
fi

-----------------
Para ejecutarlo, basta guardarlo en un directorio  y darle permisos de ejecución. Hay que tener permiso de root para ejecutar el mandato poweroff. En mi caso, tengo en el panel un lanzador precedido de gksudo, de tal manera que el script se lanza pidiendo primero la contraseña de root.

Otra solución es editar el archivo /etc/sudoers y añadir la linea:  usuario ALL=NOPASSWD: /sbin/poweroff al final del archivo /etc/sudoers para que el usuario "usuario" pueda ejecutar el comando poweroff sin que se le pida la contraseña de root.  De esta forma se puede ejecutar el script sin que pida la contraseña de root.

El archivo /etc/sudoers se puede editar:
--- Con el editor nano: con la siguiente linea en la terminal:
sudo nano /etc/sudoers
Una vez añadida la linea que se indica mas arriba se guardan los cambios en nano con: tecla F3, luego la tecla intro, y despues se cierra el editor nano con la tecla F2 .

--- Con gedit: para esto hay que seguir los siguientes pasos:
1- abrir Nautilus con permisos de root:  alt+f2      gksu nautilus
2- seleccionar el archivo /etc/sudoers y cambiar los permisos para que sean de lectura y escritura para root ( seleccionar el archivo->propiedades->permisos )
3- abrir con Gedit el archivo /etc/sudoers  y añadirle la línea indicada arriba
4- guardar los cambios  y cerrar el archivo
5- volver a cambiar los permisos del archivo para que sean de solo lectura para el usuario root y para el grupo root, y ninguno para otros.
6- cerrar Nautilus

-----------------------
El manual de Zenity ( en español ) se puede consultar aquí: http://library.gnome.org/users/zenity/stable/index.html.es

Copiar o mover un archivo a cualquier directorio con un script

Para copiar o mover un archivo, de forma gráfica,  desde /home/usuario a un directorio del sistema ( directorio / y sus subdirectorios ) hay que hacerlo ejecutando un Nautilus con permisos de root, con la orden: gksu nautilus. Esto es así porque los directorios del sistema no tienen permisos de escritura para un usuario que no sea el root.

Los pendrives y/o discos duros externos o particiones adicionales creadas en formato fat32 o ntfs, o incluso en ext3 o ext4 para almacenar datos si que suelen tener permisos de escritura para el usuario normal, pero si solo  tuvieran permisos de escritura para el usuario root, podríamos copiar o mover a ellos archivos desde /home/usuario con los scripts de este tema.

Para copiar ( o mover ) un archivo en un directorio cualquiera, distinto de /home/usuario,  sin necesidad de entrar en un Nautilus con permisos de root: desde    http://gnome-look.org/content/show.php/Nautilus+Scripts+Pack?content=90330 he bajado un paquete de scripts de nautilus, entre los que esta Copy to y Move to; Con estos scripts puedo copiar/mover respectivamente en cualquier directorio:
Si es en uno que se necesite permisos de root me pide la contraseña antes de hacerlo, y luego lo hace, y si es en uno que no necesita permisos de root no pide la contraseña, y lo copia o mueve.

Estos scripts para Nautilus se instalan en la carpeta /home/usuario/.gnome2/nautilus-scripts, y se tiene acceso a ellos en Nautilus >botón secundario >menú Scripts

Es decir,  una vez tenemos el script en esa dirección elegimos el archivo que queremos copiar ( o mover ), damos al botón derecho del ratón y vamos al menú contextual Scripts , en el que se verán todos los scripts que tengamos en esa carpeta (/home/usuario/.gnome2/nautilus-scripts ).elegimos el script Copy to o el Movy to según si lo queremos copiar o mover. Una vez hecho esto  se abre un pequeño administrador de archivos en el que elegimos el directorio al que queremos copiar o mover el archivo, y nos pide la contraseña si es necesario ( si lo queremos copiar o mover a un directorio del sistema que sea distinto al /home/usuario ).

Os dejo estos dos scripts porque creo que son muy útiles para copiar o mover archivos a directorios del sistema, sin el peligro de abrir un Nautilus con permisos de root.

El texto del script Copy to es tal que así:

#!/bin/bash
#########################################################
#                     #
# This are NScripts v3.4            #
#                     #
# Licensed under the GNU GENERAL PUBLIC LICENSE 3   #
#                     #
# Copyright 2007 - 2008 Christopher Bratusek      #
#                     #
#########################################################

if [[ -x /usr/bin/gksu || -x /opt/gnome/bin/gksu ]]; then
sudotool="gksu -u root"
elif [[ -x /usr/bin/gnomesu || -x /opt/gnome/bin/gnomesu ]]; then
sudotool=gnomesu
fi

destination=$(zenity --file-selection --directory --title "Where to copy files?")

echo $NAUTILUS_SCRIPT_SELECTED_URIS > ~/.gnome2/temp_copy_list

for file in $(cat ~/.gnome2/temp_copy_list); do \

file_name=$(echo $file | sed -e 's/file:\/\///g' -e 's/\%20/\ /g')
short_file_name=$(echo $file | sed -e 's#.*/##g' -e 's/\%20/\ /g')

if [[ -w $destination && -a $destination/$short_file_name ]]; then \
confirm=$(zenity zenity --question --text "Overwrite File $destination/$short_file_name?"; echo $?)
if [[ $confirm == 0 ]]; then
cp -r "$file_name" $destination
if (( $? != 0 )); then
zenity --info --text "Something went wrong" --title "Failure"
fi
fi
elif [[ -w $destination ]]; then \
cp -r "$file_name" $destination
if (( $? != 0 )); then
zenity --info --text "Something went wrong" --title "Failure"
fi
elif [[ -a $destination && $sudotool != "" ]]; then
$sudotool "cp -r '$file_name' $destination"
else   zenity --info --title "Failure" --text "$destination does either not\nexist or is not writable"
fi; \
done

rm -f ~/.gnome2/temp_copy_list
--------------
El texto del script Move to es así:

#!/bin/bash
#########################################################
#                     #
# This are NScripts v3.4            #
#                     #
# Licensed under the GNU GENERAL PUBLIC LICENSE 3   #
#                     #
# Copyright 2007 - 2008 Christopher Bratusek      #
#                     #
#########################################################

if [[ -x /usr/bin/gksu || -x /opt/gnome/bin/gksu ]]; then
sudotool="gksu -u root"
elif [[ -x /usr/bin/gnomesu || -x /opt/gnome/bin/gnomesu ]]; then
sudotool=gnomesu
fi

destination=$(zenity --file-selection --directory --title "Where to move files?")

echo $NAUTILUS_SCRIPT_SELECTED_URIS > ~/.gnome2/temp_move_list

for file in $(cat ~/.gnome2/temp_move_list); do \

file_name=$(echo $file | sed -e 's/file:\/\///g' -e 's/\%20/\ /g')
short_file_name=$(echo $file | sed -e 's#.*/##g' -e 's/\%20/\ /g')

if [[ -w $destination && -a $destination/$short_file_name ]]; then \
confirm=$(zenity zenity --question --text "Overwrite File $destination/$short_file_name?"; echo $?)
if [[ $confirm == 0 ]]; then
mv "$file_name" $destination
if (( $? != 0 )); then
zenity --info --text "Something went wrong" --title "Failure"
fi
fi
elif [[ -w $destination ]]; then \
mv "$file_name" $destination
if (( $? != 0 )); then
zenity --info --text "Something went wrong" --title "Failure"
fi
elif [[ -a $destination && $sudotool != "" ]]; then
$sudotool "mv '$file_name' $destination"
else   zenity --info --title "Failure" --text "$destination does either not\nexist or is not writable"
fi; \
done

rm -f ~/.gnome2/temp_move_list

------------------------

Para, con el texto de los scripts, crear un script : Como crear un script básico
------------------------

Como tener los scripts y/o comandos a mano

Si eres aficionado a coleccionar/usar  scripts/comandos, tanto los conseguidos desde algunas de las páginas en las que es mas fácil de conseguirlos ( ver al final del tema ), como los hechos por ti mismo, te interesa saber donde conviene tenerlos guardados para tenerlos siempre bien accesibles para su fácil uso.

1--- En el directorio /home/usuario: es un buen lugar para tener los scripts que tu mismo vayas haciendo, salvo que hayas hecho muchos en cuyo caso mejor tenerlos en una carpeta especifica de tu carpeta de usuario, por ejemplo /home/usuario/scripts: en este caso lo mejor es que en el propio script se indique desde que carpeta se tiene que ejecutar.

2--- En el archivo /home/usuario/.bashrc es un buen lugar para tener comandos complejos que no ocupen mas de una línea, usados con el comando alias, tal como se indica en el tema Comando alias

No se deben guardar aquí los comandos o lineas de comandos que se usan seleccionando previamente un archivo o directorio sobre el que se quiere que actúe el comando o linea de comandos, sino los que se ejecutan automáticamente sin seleccionar nada previamente.

3--- En el directorio /home/usuario/.gnome2/nautilus-scripts es un buen lugar para tener tus propios scripts ( si son del tipo que se indica a continuación ) , o los scripts que se pueden bajar desde las páginas indicadas mas abajo.

Aquí deben estar los scripts que se usan seleccionando previamente un archivo o directorio sobre el que se quiere que actúe el script: por ejemplo seleccionar una imagen y aplicarle un script para girarla.

------------------------------

Se pueden obtener scripts muy útiles desde:

http://g-scripts.sourceforge.net/

http://nautilus-scripts.javielinux.com/index.php

http://gnome-look.org/index.php?xsortmode=high&page=0&xcontentmode=188

------------------------------

4----En Internet hay muchas páginas en las que explican el uso de comandos; en el foro de Linux Mint Comunidad Hispana ( Fran y Uleti ) me han dado estas direcciones:

http://www.esdebian.org/wiki/lista-comandos-gnulinux-1

http://www.esdebian.org/wiki/lista-comandos-gnulinux-2

http://www.esdebian.org/wiki/lista-comandos-gnulinux-3

http://comandostux.awardspace.com

---------------------------------------------------------

Script para guardar una captura/imagen del escritorio

Explico como crear/usar un script que permite tomar y guardar una imagen de captura de un espacio limitado de la pantalla del escritorio, o de toda la pantalla. Una vez se ejecuta el script se transforma el cursor en una cruz y permite seleccionar sólo la región deseada ( que si se quiere puede ser toda la pantalla ) y no necesariamente la pantalla completa ni una ventana, hace la captura y luego pregunta donde guardarla y con que nombre.

Para que funcione se necesita tener instalado el paquete imagemagick. Se puede guardar ( "guardar_captura_escritorio"), para tenerlo fácilmente a mano, en /home/usuario/.gnome2/nautilus-scripts; y se debe crear como se indica aquí.

El script es:

#!/bin/bash

import /tmp/captmp.jpg
captura=$(zenity --title "Guardar como..." --file-selection --save --separator " " || exit )

mv /tmp/captmp.jpg  "$captura.jpg"
display "$captura.jpg"

--------------------------

Como usarlo:

1- Con el botón derecho del ratón->Script->guardar_captura_escritorio. Dado que este sistema no sirve cuando queremos guardar una captura de Firefox. podemos en este caso usar el otro sistema...

2-Con una Combinación de Teclas:Para asignar una combinación de teclas a este script: Sistema-Preferencias-Combinaciones de teclas-Combinación personalizada-añadir: añadir nombre y dirección donde esta guardado el comando ( /home/usuario/.gnome2/nautilus-scripts/guardar captura escritorio ), y asignar combinación de teclas, por ejemplo Alt+P. Con ello al teclear Alt+P se inicia el script y se toma una imagen de una zona elegida del escritorio, y se guarda con el nombre que queramos en la carpeta que elijamos.

En ambos casos: una vez se ejecuta el script se transforma el cursor en una cruz y permite seleccionar sólo la región deseada ( que si se quiere puede ser toda la pantalla ) y no necesariamente la pantalla completa ni una ventana, hace la captura y luego pregunta donde guardarla y con que nombre. Es una forma sencilla de obtener una imagen de alguna zona de nuestro escritorio y poderla compartir con los amigos.

--------------------------

Script para oir emisoras de radio

Aquí tenéis un ejemplo de script sencillo para oir emisoras de radio: Para que funcione se necesita tener previamente instalado el programa mplayer ( reproductor multimedia ) y conocer la dirección correspondiente a la emisora que queremos oir y que tenemos que poner como "playlist". Para ello tendremos que conectarnos con el navegador web a la dirección principal de la emisora que queramos poner en el script, y desde allí averiguarlo: tened en cuenta que las direcciones van cambiando.

Para averiguar la dirección que queremos poner en el script: vamos a la página web donde podemos escuchar la emisora, y miramos su código fuente:  click derecho del ratón y en el menú contextual-->"Ver código fuente de la página"; se abre otra ventana o pestaña, en la que tecleando Ctrl+F encontraremos un enlace a un fichero asx:copiamos esa dirección y la guardamos en un archivo de texto, para de esta misma forma ir guardando varias direcciones de radios, que podemos después copiar en el script.

¿ Que ventaja tiene esta forma de oir una emisora de radio ?: por ejemplo sirve para estar oyendo una radio de internet sin tener que tener un navegador abierto, o una pestaña/ventana del navegador abierta, y sin tener que instalar paquetes especiales para oir música de internet.

Desde esta página: http://www.espana.fm/ podéis conectaros a un montón de radios españolas en internet, y en esta otra http://www.accuradio.com/ a un montón de radios intenacionales, y a partir de ahí averiguar mas direcciones que añadir a las que pongo como ejemplo en el script. Seguro que hay mas páginas similares a las dos anteriores desde las que podéis ir averiguando direcciones para añadir al script, haciendo uno a vuestro gusto.

-------------------------------------------

#!/bin/bash
echo "Script para seleccionar qué radio quieres escuchar"
echo""
echo " 1 -> Kiss FM"
echo " 2 -> RNE clásica"
echo " S -> Salir"
echo ""
echo "Seleccione una de las radios "
read radio
if [ "$radio" = "1" ]; then
mplayer -playlist http://pointers.audiovideoweb.com/asxfiles-live/ny60winlive7001.asx
elif [ "$radio" = "2" ]; then
mplayer -playlist http://www.rtve.es/rne/audio/RNEclasica.asx
elif [ "$radio" = "S" ]; then
exit
fi
#FIN

--------------------------------------

Podéis añadir de forma similar mas emisoras de radio, o modificar las que he puesto como ejemplo ( en rojo), y una vez tengáis escrito el script totalmente a vuestro gusto podéis hacer que se pueda ejecutar como indico en el tema "como crear un script básico".

Lo podéis guardar en la carpeta de scripts para nautilus: /home/usuario/.gnome2/nautilus-scripts, para tenerlo a mano desde nautilus, o crear un enlace desde el escritorio o desde el menú de aplicaciones, o desde el panel.

-------------------------------------------------------

Cómo crear un Script Básico

A- Definición de script básico: Un script básico es un archivo creado con un editor de texto, que contiene un comando ( se puede hacer de forma similar con mas de un comando) ,y que puede ser ejecutado sin tener que escribir el comando en la terminal cada vez que queramos que se ejecute.

B- como crear un script básico de un solo comando:

1- Abrir el editor simple de textos (gedit), y copiar en él las siguientes lineas:

#!/bin/bash
echo descripción
echo ..dentro de 4 seg se inicia el script,o cierra la terminal
sleep 4s
cd /home/usuario
comando

2- guardar como: script-básico, en el directorio Templates
Ahora podremos acceder a este archivo en : Nautilus > botón secundario> Crear un documento. Nos creara una copia en el directorio del Usuario. Esto nos sirve para siempre que queramos crear un script, acceder a este archivo, y modificarlo a nuestro gusto.

3- Abrimos la copia que se nos ha creado en nuestro directorio de Usuario, y lo modificamos a nuestro gusto:
podemos modificar las siguientes lineas:
- Linea #!/bin/bash : no modificarla, esta línea es la que indica que lo siguiente es un script para ser ejecutado en una terminal
- Linea "echo descripción" : cambiamos la palabra descripción, por un mensaje descriptivo de lo que va a hacer el comando ( no quitar la palabra echo, que indica que lo que viene a continuación, en la misma linea, no es un comando )
- Linea "echo ..dentro de 4 seg se inicia el script,o cierra la terminal" nos informa de que en 4 segundos se iniciara el comando descrito en la linea anterior, y nos da la oportunidad de dejar que se ejecute, o de cerrar la terminal.
- Linea "sleep 4s": podemos modificar el tiempo que queramos que tarde en ejecutarse el comando
- Linea "cd /home/usuario": cambiamos usuario por el nombre de nuestro usuario
- Linea "comando": lo cambiamos por el comando que queramos que se ejecute.
( Para aprender sobre comandos ver las paginas que se indican mas abajo)
Guardamos las modificaciones del archivo, guardándolo como: ponemos un nombre descriptivo a nuestro script básico recién creado.

4- Lo seleccionamos, y en Propiedades:
- abrir con: añadimos abrir con terminal, por defecto (conservando la opción de abrir con el editor de textos, para poderlo modificar mas adelante si queremos)
- permisos: señalamos: permitir ejecutar el archivo como un programa ( o seleccionamos permisos de ejecución ) .
En Nautilus > Editar > Preferencias > Comportamiento > "archivos de textos ejecutables" > "preguntar cada vez".
Ahora al abrir nuestro archivo script, en la ventana que aparece seleccionamos: ejecutar en una terminal, y se abrirá la terminal, nos mostrara el mensaje descriptivo, esperara 4 segundos, y se ejecutara el comando que hayamos puesto.

C- Algunos ejemplos de scripts básicos:
(Todos los comandos básicos que he ido creando los he ido guardando en una carpeta del tipo:
/home/usuario/scripts )
------------------------------
#!/bin/bash
echo unir dos películas .avi
echo ,que deben estar ambas en el directorio home/usuario,
echo cuyo nombre son pelicula1.avi y pelicula2.avi
echo se creara un archivo película.avi en el mismo directorio
echo ..dentro de 4 seg se inicia el script,o ciérralo
sleep 4s
cd /home/usuario
avimerge -i pelicula1.avi pelicula2.avi -o película.avi

------------------------------
#!/bin/bash
echo crear una imagen .iso de un cdrom
echo ..dentro de 4 seg se inicia el script,o ciérralo
sleep 4s
sudo umount /dev/cdrom
cd /home/usuario
dd -if=/dev/cdrom of=micd.iso bs=1024

------------------------------
#!/bin/bash
echo unir 2 archivos de video .asf
echo ..dentro de 4 seg se inicia el script,o ciérralo
sleep 4s
cd /home/usuario
mencoder pelicula1.asf pelicula2.asf -ovc copy -oac copy -o película.asf
sleep 4s
echo pasar a formato avi
mencoder película.asf -ovc lavc lavcopts pass=2 -oac mp3lame -o película.avi
sleep 4s
echo pasar a formato mpg
ffmpeg -i película.avi -target pal-vcd película.mpg

------------------------------
D- paginas de información sobre comandos:
http://www.google.es/search?hl=es&client=firefox-a&rls=com.ubuntu%3Aes-ES%3Aofficial&hs=IwP&q=comandos+linux&btnG=Buscar&meta=lr%3Dlang_es

http://www.linuxguide.it/commands_list.php?Choose_Language:Spanish

En estas paginas aparece mucha información sobre los comandos que se usan en linux, que puede servirnos para, con la ayuda de nuestra imaginación, crear nuestros propios scripts básicos
=====

E- Páginas desde las que se pueden bajar scripts mucho mas sofisticados, que nos pueden ser de gran utilidad:

http://g-scripts.sourceforge.net/

http://nautilus-scripts.javielinux.com/index.php

http://gnome-look.org/index.php?xsortmode=high&page=0&xcontentmode=188

se instalan en la carpeta /home/usuario/.gnome2/nautilus-scripts
se tiene acceso a ellos en Nautilus >botón secundario >menú Scripts
Estos scripts son mucho mas "sofisticados" que los que podemos crear con este mini manual de creación de scripts básicos.

Manual de programación Bash Shell en .pdf: http://thales.cica.es/rd/glinex/practicas-glinex05/manuales/bash/practica.pdf
------------------------------------