Problema bordes de ventana en metacity 2.26.0-2

Si tienes Debian GNU/Linux testing y actualizas en estos días probablemente te encuentres que las ventanas maximizadas no muestran la decoración (los bordes de ventana).
Esto se debe a un problema con la nueva versión del paquete de metacity, el bug está reportado.

Para ir tirando, el problema lo puedes solucionar con un simple:

[bash light="true"]$ metacity –replace &[/bash]

EDITADO (27/07/2009):
El bug ha sido corregido con el lanzamiento de la versión 2.26.0-3 en testing (ya había sido lanzada hace unos días en unstable)
Las ventanas no perdían la decoración, sino que ignoraban las barras del panel y se escondían detrás de estas.
Actualiza a la nueva versión para solucionar el problema.

Script VideoFondo.sh: Coloca vídeos de wallpaper gráficamente

Hace unos días navegando por el blog de catrip me encontré con un pequeño scritp diseñado para manejar de forma fácil xwinwrap (programilla para colocar como fundo de escritorio imágenes animadas, vídeos o incluso tu propia webcam).

El script hace uso de Zenity para manejar de forma gráfica y mediante opciones la forma en la que se presentará el fondo de pantalla de tu ordenador.

Ese día no tenía mucho que hacer así que lo retoqué un poco y se lo envíe, a el le pareció correcto colgarlo en su web como una mejora y ahora yo lo cuelgo aquí por si alguno de los pocos visitantes de este blog les sirve para algo :)

EDITADO (01/02/2010): Ahora acepta seleccionar varios vídeos para para poner en cola al reproducir.

[bash]
#!/bin/bash

#########################################################
# #
# VideoFondo.sh #
# #
# Realizado inicialmente por Catrip <alktrip@gmail.com> #
# y retocado por aabilio <aabilio@gmail.com> #
# WTFPL <http://en.wikipedia.org/wiki/WTFPL> #
#########################################################

### OPCIONES ###

PARAM="-fs -sp -ni -nf -st -s -b -o"

dato1="Colocar un o varios vídeos como Wallpaper"
dato2="Colocar Screen Saver como Wallpaper"
dato3="Finalizar la reproducción"
dato4="Colocar webcam como Wallpaper"
dato5="Finalizar el programa"

con_sonido="Colocar vídeo con sonido"
sin_sonido="Colocar vídeo sin sonido"
BACK="Volver"

### FUNCIONES ###

function fun_opacidad {
opacidad=$(zenity –list –width="60" –height="415" –text "Selecciona una opción" –title "Nivel de Opacidad" –column "Opacidad" `for (( c=1; c<=9; c++ )); do echo -n "0.$c "; done` 1)
}

function fun_check {
if pidof xwinwrap > /dev/null ; then
killall xwinwrap
fi
}

function fun_typeson {
typeson=$(zenity –list –width="315" –height="260" –text "Opciones del vídeo" –title "Opciones" –column "Opción" "$con_sonido" "$sin_sonido" "$BACK")
if [ "$typeson" = "$sin_sonido" ]; then
SON=" -nosound"
fi
if [ "$typeson" = "$con_sonido" ]; then
unset SON
fi
if [ "$typeson" = "$BACK" ]; then
main
fi
}

### MAIN ###

function main
{
type=$(zenity –list –width="415" –height="260" –text "Indique la operación a realizar" –title "ScreenSaver, Vídeo o WebCam como Wallpaper" –column "Opción" "$dato1" "$dato2" "$dato4" "$dato3" "$dato5")

if [ "$type" = "$dato1" ]; then
fun_typeson

FILES=`zenity –file-selection \
–title="Selecciona el vídeo a colocar como Wallpaper" –multiple –separator=" "`

fun_opacidad
fun_check

exec xwinwrap $PARAM "$opacidad" — mplayer -quiet -noconsolecontrols -loop 0$SON -wid WID $FILES
fi

if [ "$type" = "$dato2" ]; then
screen=$(ls /usr/lib/xscreensaver/ | zenity –list –width="60" –height="415" –text "Selecciona un ScreenSaver" –title "ScreenSavers" –column "ScreenSaver")
fun_opacidad
fun_check
exec xwinwrap -argb $PARAM "$opacidad" — /usr/lib/xscreensaver/"$screen" -window-id WID
fi

if [ "$type" = "$dato3" ]; then
fun_check
fi

if [ "$type" = "$dato4" ]; then
fun_opacidad
fun_check
exec xwinwrap $PARAM "$opacidad" — mplayer -wid WID -quiet -fps 30 tv:// -vf mirror
fi

if [ "$type" = "$dato5" ]; then
fun_check
exit;
fi

#Incluimos a main en un bucle infinito hasta que el USER cierre
main

}

#Llamamos a que se ejecute la function main:
main
[/bash]

Enlace | Descarga el script (VideoFondo.sh) junto con un xwinwrap compilado para amd64.

Enlace | Descargar un .deb con Xwinwrap para 32 bits.

Enlace | Para todo lo demás (requisitos del script, vídeo de funcionamiento, enlaces…) visitar la web de Catrip.

Mobling pinta muy bien

¿Ya has probado Mobling en tu netbook?

Puedes probar en modo live bajando la imagen desde aquí.

Lo puedes grabar en pen (al menos 1 GiB) de la siguiente manera con el comando dd:

# dd bs=4096 if= of=

o con el script de python image-writer que puedes encontrar aquí, y ejecutarlo de la siguiente manera:

# ./image-writer 

Antes de nada le tendrías que haber dado permisos de ejecución al script de image-writer:

# chmod a+x ./image-writer

De momento el proyecto está en fase temprana y tiene barios bugs y muchas opciones no disponibles, pero se lanzan versiones a un ritmo bastante bueno.

Yo si lo he probado y puedo decir que pinta bastante bien y su interfaz de manejo es espectacular.

Enlace | Web de Mobling

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.

Opera Unite, de momento, no reinventa nada

Bien, pues ya salió a la luz el gran secreto de Opera que iba a revolucionar la Web. Gran cantidad de blogs y páginas web nos anunciaban que Opera nos estaba preparando algo que iba a reinventar la Web en sí. Sinceramente, para mí, lo único que han reinventado, y mal hecho, ha sido el concepto de navegador. Un concepto en el que este deja de ser un simple navegador, y se convierte en servidor web mediante el cual podemos compartir desde imágenes hasta música, pasando por crear una web o dejarnos notas en una chorrada de nevera. Opera Unite se llama todo esta parafernalia. Todo lo que de momento puedes hacer con Unite, se puede hacer desde hace años. Quizá “lo nuevo” de todo esto es que tienes configurado todo con a penas un par de clicks ( Tools > Opera Unite Server).

Creas una cuenta (si ya tienes una cuenta de My Opera simplemente utilizas esta), aceptas la licencia y a correr.

Tendrás a tu disposición  un panel lateral donde puedes ir “instalando” el servidor web, el servidor de archivos y de fotos, el Media Player para compartir tu música, todo esto seleccionando los directorios que quieres compartir.

Si, se puede decir que si esto lo quieres hacer “de otra manera” (crear un servidor web), utilizando recursos que ya existen desde hace tiempo, tardarás un ratito más, sobre todo, si lo configuras todo para una gran seguridad. Pero, precisamente de eso quería hablar también, ¿qué problemas de seguridad nos puede acarrear esta “nueva tecnología” de Opera?

Opera es cerrado, no nos muestra los niveles de seguridad que implementan, como se van a tratar nuestros datos, de qué manera funcionará su proxy, por que recordemos que aunque en última instancia las conexiones se realicen punto a punto todo tendrá que estar centralizado sobre sus servidores aunque nada más sea para el uso de sus DNS y la asignación de nuestros dominios.

Bien es cierto que un usuario poco o medianamente experimentado no logrará conseguir un nivel de seguridad férreo tanto para su servidor web o ftp, pero la posibilidad de ser controlado por uno mismo existe. A parte, dejando atrás la configuración, estos servicios ya tienen cabida en la actual Internet: Webs sociales para comunicarse, para compartir fotos, para compartir notas, entre otros. Lo bueno de Unite, dirán algunos, es que no tienes que subir las cosas que quieras compartir a un servidor.Pero para mi precisamente esto, la esencia misma de Unite, es en lo que falla, por lo menos en España (y en general en todo el mundo con la tecnología ADSL). Las capacidades de subida que nos ofrecen son pésimas, un par de usuarios descargando contenidos de nuestro servidor puede colapsarnos nuestra red (esto tanto en Unite como en un servidor local cualquiera, aunque por ejemplo en Apache puedes controlar más estos aspectos: cantidad de información que se puede descargar, que rango de IPs lo pueden descargar,…).

Lo que está claro que para un usuario más experimentado Unite no puede ser una opción, este no tendría el control total de su servidor, necesitaría de más recursos para compartir datos (recordemos que para que todo esto rule tenemos que tener el navegador abierto, para tener un navegador tenemos que disponer de un entorno gráfico, un entorno gráfico consume y necesita más recursos…).

Sobre la facilidad de uso, también hay que decir que existen servidores que se instalan con un solo click, o aquellos destinados solo a compartir en un momento puntual un archivo o un conjunto de archivos como BaShare. Puede que sean poco conocidos, pero Opera tampoco tiene un gran mercado tampoco.

Considero de Unite que no es más que la unión de unos pocos servicios propios de la Web 2.0 con la salvedad de que no se utilizan grandes servidores centrales, si no que todo se comparte desde nuestro ordenador, como si de una red P2P se tratara.

Pero recordemos que esto solo es el principio y si bien, para mi, el principio es nefasto (sobre todo después de la expectación que creó), puede que acabe siendo algo innovador, o más bien puede que cree una moda (al más puro estilo Fotolog). Y aunque por la definición en sí del propio Unite yo esté en contra del mismo (considero que un navegador es un navegador y un servidor es un servidor), puede que se hagan cosas interesante utilizando esta nueva idea. Opera proporciona una API para crear nuevos servicios a partir de Unite y esto si que me parece interesante, y no por que crea que de momento se puede crear algo innovador, si no porque aquí si se le permite al usuario crear sus propias aplicaciones (por ejemplo aquí se muestra como crear tu propio sistema de blog, cutre y para nada necesario e innovador) y quién sabe, quizá con el tiempo Opera consiga por fin, que reinventó la web gracias a estas aplicaciones de terceros (aunque creo que para que esto se de tiene que cambiar un poco el sistema base, como implementar operaciones con URIs propias o acceso casi totalmente directo de punto a punto, por poner unos ejemplos) .

Es cuestión de tiempo ver si esto triunfa, o se queda simplemente donde está (Opera ya tiene algo parecido con sus blogs y su “My Opera”), o realmente se produce algo parecido a reinventarse la web. Yo me atrevería a apostar que no llegará muy lejos, pero quien sabe.

Resumiendo, desde mi punto de vista, Opera Unite no me parece una mala idea, puede ayudar a aquellos usuarios menos experimentados o simplemente a aquellos con menos ganas de “cacharrear” (o simplemente por que encuentras que realmente es la manera más fácil de compartir un fichero específico en un momento determinado), pero, al menos de momento, no reinventa nada, no innova nada, solo pone un par de conceptos de la Web 2.0 y las redes P2P juntos y a correr.

Y si después de todo esto piensas: “No me he enterado de nada, ¿qué es todo esto?”; Pues descúbrelo tu mismo:

Opera Unite es parte de la nueva versión de Opera (10 BETA) que puedes descargar desde aquí para GNU/Linux.

Simplemente hay que instalarla y correr Unite desde Tools > Opera Unite Server y descubrir todo lo que te ofrece este servicio (intuitivo y fácil de administrar).

P.D.: Que conste que no tengo nada contra Opera, me parece un navegador excelente, seguramente sería mi navegador predeterminado si fuera libre.

Me-Tv, Visor de TV perfectamente integrado en Gnome

Me-tv es un programa con el que podrás ver la televisión digital en tu escritorio Gnome. Tiene soporte para las tarjetas DVB-T, DVB-C, DVB-S y ATSC soportadas por el kernel.

Me-tv puede gravar lo que estás viendo en el momento pero también puede programar una grabación, además también podrás hacer Broadcast a través de Internet.

Puedes encontrarlo aquí y descargarlo de aquí, aunque si lo quieres en paquete .deb solo tendrás para i386, así que he empaquetado uno para amd64 que lo puedes descargar de aquí.

Próximamente subiré una traducción del programa en Gallego.