gtk « WordPress.com Tag Feed

Clipboard Fun

balajirrao — Wed, 02 Jul 2008 20:26:50 +0000

When I was using my GNOME desktop from inside a guest running on top of KVM, suddenly an idea struck me, about a couple of hours ago - "To allow copy and paste between the guest and the host". It would be a very valuable feature to have, I thought.

Deciding to hack a quick solution, I came up with the following in around two hours. It works only one way for the moment. The guest(virtual machine) is the server and the host is the client i.e, you will only be able to copy from the host and paste it into the guest. And it works only with text now.

In the guest, ( please change the IP address appropriately )

[sourcecode language='python']
#!/usr/bin/python
#Run this in the guest
import socket,gtk

clip = gtk.Clipboard(display=gtk.gdk.display_get_default(), selection="CLIPBOARD" )

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.bind(("192.168.1.2", 7070))
serversocket.listen(1)

while (True):
(clientsocket, address) = serversocket.accept()
clip.set_text(clientsocket.recv(100));
clip.store()
clientsocket.close();

serversocket.close()
[/sourcecode]

And in the host,

[sourcecode language='python']
#!/usr/bin/python
import gtk,time,socket

clip = gtk.Clipboard(display=gtk.gdk.display_get_default(), selection="CLIPBOARD" )
while (True):
prev = clip.wait_for_text()
while (prev == (clip.wait_for_text())):
time.sleep(1)

prev = clip.wait_for_text()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("192.168.1.2", 7070))
s.send(prev)
s.close()
s.close()
[/sourcecode]

With this program, I've copy-pasted across two machines in a network! Very powerful isn't it ? Its really surprising too see what around 35 lines of python can do. Though I had studied a bit of python a few years ago, this one small hack has made me fall into love with python again. Its an awesome language. Extremely powerful.

This program uses something called pygtk, which are python extensions for GTK. You can write GTK programs using python.

I wish to develop this further to the extent of copying files, images and other rich content across machine boundaries. Though it probably will be criticised for being bad from a security point of view, it will definitely be useful for users of KVM, XEN and other users of virtual machine monitors.

Happy hacking!

Opensuse 10.3 Japanese Input KDE Follow-up

iamacat — Tue, 01 Jul 2008 16:37:00 +0000

I'm writing this post in konqueror, just for fun. If you managed to get uim and anthy working with the uim-applet in Gnome, KDE apps are almost as easy, and you don't need to run uim-xim or any other p.i.t.a scripts or bridging hacks, as I've described in previous posts. The Konqueror binary I got from the Opensuse repository has uim support built right in. What does that mean? In a text input window, right click, select 'uim:ja,ko,zh:*' and then fire up uim anthy the same old way you would for a gnome app. (As I've said before, the uim-applet set-up options are too diverse to go into here, but I have managed to do it on Debian, Ubuntu, and Opensuse boxen without straying from graphical user interfaces, so don't panic) And voila, 日本語! I suppose this would work in a straight KDE environment in any given KDE application (that's compiled with uim support, of course), although I haven't tried it that way. By the way, there is a KDE taskbar applet to control uim input, and you can use either it or the gnome applet in KDE. And, please, dear readers, let me know how things work out for you. I'm trying to pass on useful information here. Thanks! では、この切りで。

Personalizacion de Linux, Gnome

pol666 — Sat, 28 Jun 2008 20:50:16 +0000

Guia de Personalizacion de Linux (Gnome)

Parte 1: Gnome

Antes que nada Quiero que se Agenden esta direccion, es de suma importacia para la personalizacion de Gnome, aca encuentran, Temas, Skins, Iconos, Wallpapers, etc.

www.gnome-look.org

Bueno comenzare esta guia como post estreno del blog. La guia va abarcar todo lo que trate de personalizacion y embellezimiento de Linux, Tanto en escritorios como GNOME, KDE3, KDE4 y XCFE. Por lo que sera aplicable a la mayoria de las distribuciones como Ubuntu, Suse, Mandriva, Debian, etc. Tambien voy a incluir una guia de Compiz Fusion, incluyendo Emerald, Screenlets y Docks, Por otra parte va a ver capitulos dedicados a la imitacion de escritorios de otros SO como OsX y Vista.

En este capitulo enseñare la personalizacion básica de Gnome, en especial para los usuarios muy novatos.

Wallpaper

Los wallpapers, (fondo de pantalla) son lo primero que cambiamos cuando instalamos un SO. Asi que no pierde importancia.

Aqui nombro algunas webs con Excelentes wallpapers

Recomendados por Mi:

Recomendacion de Clarin.com

http://www.clarin.com/suplementos/informatica/2004/07/28/f-802448.htm

para Cambiar el Wallpaper en Gnome: Hacemos Click Derecho en nuestro Escritorio actual y vamos obviamente a “Cambiar fondo de escritorio” ahi nos saldra una ventana donde podremos cargar nuestra imagen. (dificilisimo ^^)

Panel

Un panel, es la barra que tenemos ubicada en ambas bases del escritorio. Son llamadas Barra de Inicio por los usuarios que vienen de Win2, pero desde ahora se llaman Paneles. Estos pueden ser ubicados en cualquier parte del escritorio con simplemente arrastrarlo con el mouse. Tambien podemos cambiarle el tamaño haciendo click derecho sobre ellos, y luego clikeando en propiedades.

Una ventaja de estos paneles es que podemos aplicarles Texturas, mediante Imagenes, o hacerlos transparentes. O Aplicarles Texturas transparentes mediante imagenes en PNG.

En la pestaña fondo de propiedades del panel, seleccionamos IMAGEN. Y cargamos alguna de estas imagenes (son la mayoria de 27pixeles otras son de 32, acordate que tienen que ser del mismo tamaño de tu panel)

Con esto tenemos unas buenas texturas trasnparentes. Por otra parte los item del panel llamados APPLETS. Pueden ser modificados, movidos, eliminados o agregados. Por ejemplo la clasico menu de Ubuntu lo podemos cambiar por un simple icono, que lo remplaze. Tambien podemos eliminar un panel y dejar uno solo, o agregar 2 mas y tener uno en cada lado de la pantalla.

El Selector de Ventanas tambien es un Applet por lo que puede ser quitado y agregado en cualquier panel. Para modificar applets hacemos click derecho en el panel y clickeamos en “agregar al panel” Lo podemos personalizar a nuestro gusto hasta que quede por ejemplo asi:

Skins, Temas GTK y metacity

Los skins de Gnome, los temas GTK son los que componen las ventanas, los botones, los menues, todo. Los bordes de ventana estan compuestos por otro programa llamado Metacity. Aunque mas adelante les mostrare EMERALD que es un gestor avanzado para bordes de ventana, y depende de compiz y obviamente de acelaracion grafica. (Ya lo nombrare en proximos Post)

Tanto los temas GTK (2.0) y los Metacity se bajan de sus correspondientes pestañas en gnome-look.org.

Para aplicarlos tenemos que ir a sistema/preferencia/apariencia. Y en la pestaña de temas, clickear en instalar alli seleccionamos el paquete en formato tar.gz que bajamos de gnome-look.

Nos dira que instalo correspondientemente el tema y si deseamos aplicarlo. Si no lo aplicó, podemos acerlo, seleccionando un tema cualquier y luego clickeando en “personalizar” ahi, veremos las pestañas con los diferentes temas GTK y Metacity, ademas de los iconos y punteros.

Iconos

Las personalizacion de Iconos de Gnome es fantastica, Podemos cambiarles el tamaño individualmente y ordenarlos en cualquier orden.

Por defecto, Gnome no carga iconos solo los de las unidades montadas, (Usb, Discos Rigidos, Particiones, CD, Floppy, etc)

Podemos arrastrar iconos del menu hacia el Escritorio o tambien podemos crear algunos Accesos directos, o aqui llamados “lanzadores”.

Podemos arrastrar Programas, Carpetas, Archivos. Tambien si no lo desean pueden eliminarlos y optar por un escritorio mas minimalista. Para agrandar los iconos, pueden hacer click derechos sobre ellos y clickear en “estirar icono”

TEMAS DE ICONO: Los Icon Themes, son paquetes que cambian todos los iconos del sistema, dejando el escritorio muy prolijo.

¿De Donde bajar Icon Themes?

Como ya les dije de www.gnome-look.org en la pestaña de Iconos, pueden encontrar varios

Un buen resultado incluyendo los temas GTK y la personalizacion del panel quedaria algo asi:

GDM:

El GDM es la pantalla de Login de Gnome, es muy facil cambiarla, simplemente bajamos una de gnome-look.org en la pestaña GDM. En formato tar.gz

Luego vamos a sistema/administracion/ventana de entrada y ahi en la segunda pestaña, nos da la opcion de seleccionar una existente o examinar por otra. Buscamos la que bajamos y luego la seleccionamos.

Bueno esta es la personalizacion basica de Gnome, El proximo post de esta guia voy a explicar un poco mas de este escritorio, cosas mas complejas y no tan entrenidas como estas.

Saludos

Rank 2 Types

marcotmarcot — Fri, 27 Jun 2008 19:56:13 +0000

I've always seen the forall a types in some GHC messages or in other person's code, but I couldn't get the point of it until I needed to use it myself. I was writing a Gtk2hs application with some windows, and I noticed that for each created window, I was doing the same steps. So I created a function that does what is needed for each function:

basic :: WidgetClass widget => String -> IO (Widget, (GObject -> Widget) -> String -> IO widget)


basic gladeFile =
  do
    (windowGlade :: GladeXML) <- getGlade gladeFile
    let
      windowGet :: Get
      windowGet = xmlGetWidget windowGlade
    (window :: Widget) <- windowGet castToWidget "window"
    (close  :: Button) <- windowGet castToButton "close"
    onClicked close $ widgetDestroy window
    modifyIORef windows (window :)
    return (window, windowGet)

Notice that this code uses GHC extension PatternSignatures, which I like a lot.

The problem was that the returned function, windowGet was not generalized enough, so I couldn't use it with more than one type, even it being very general:

windowGet :: WidgetClass widget => (GObject -> widget) -> String -> IO widget

If I used it with, say, windowGet castToButton "ok" and WindowGet castToSpinButton "value", it would give, in the seconde line, the type error: Couldn't match expected type `Button' against inferred type `SpinButton'.

After asking in #haskell, and reading a little bit of the GHC User's Guide, I got the point. This was only possible with Rank 2 Types. windowGet must be:

windowGet :: forall widget. WidgetClass widget => (GObject -> widget) -> String -> IO widget

So I changed the type signature for basic, and added Rank2Types to the LANGUAGE pragma, and it worked fine.

basic :: String -> IO (Widget, forall widget. WidgetClass widget => (GObject -> Widget) -> String -> IO widget)

Aplicações Desktop com PHP - Parte 1

Fernando Libório — Tue, 24 Jun 2008 23:51:29 +0000

Que o PHP é uma das linguagens de programação mais usadas em ambiente web, todo mundo sabe. Mas pouca gente sabe que também é possível criar aplicações desktop com ela. E é isso que nós iremos fazer. Para tal, iremos utilizar o PHP-GTK.

O que é GTK/GTK+?
O GTK (Gimp Tool Kit) é uma poderosa biblioteca para desenvolvimento de aplicações GUI multi-plataforma, muito utilizada no mundo linux e que vem ganhando seu espaço também no windows.

PHP-GTK
É linguagem binding que permite aos desenvolvedores PHP criarem aplicações gráficas multi-plataforma sem abrir mão dos recursos do PHP.

Vamos então instalar os trecos \o/

Ingredientes

PHP-GTK
Uma caneca com café

Instalação do PHP-GTK no Windows
Baixe aqui http://sourceforge.net/project/downloading.php?groupname=agata&filename=php-gtk2b.exe&use_mirror=ufpr o instalador, execute-o e seja feliz.

Instalação do PHP-GTK no Linux
Baixe aqui http://sourceforge.net/project/downloading.php?groupname=agata&filename=php-gtk2b.tar.gz&use_mirror=ufpr o pacote pré-compilado e siga os passos abaixo:

# tar -xvzf php-gtk2b.tar.gz
# mv php-gtk2 /usr/local/
# ln -sf /usr/local/php-gtk2/bin/php /usr/bin/php-gtk2

1,2,3, testando
Para testar crie um novo arquivo chamdo exemplo.php com o código abaixo:

<?php
if (!class_exists('gtk')) {
die("O módulo php-gtk2 não foi carregado corretamente. Verifique seu php.ini.");
}$wnd = &new GtkWindow();
$wnd->set_title('Exemplo');
$wnd->connect_simple('destroy', array('gtk', 'main_quit'));$label = &new GtkLabel("Perdeu preiboy!'");
$wnd->add($label);

$wnd->show_all();
Gtk::main();
?>

Para executar, vá até a linha de comando e execute:
No Linux

# php-gtk2 exemplo.php

No Windows

C:\php-gtk2\php.exe exemplo.php

É isso ai. No próximo post vamos explorar melhor os recursos do PHP-GTK.

Pra quem quiser saber mais sobre o projeto:
http://www.php-gtk.com.br/
http://gtk.php.net/
Abraços!

Personalización básica de Ubuntu 8.04 Hardy Heron

Aero — Tue, 24 Jun 2008 15:29:11 +0000

Muchas veces, cuando iniciamos Ubuntu por primera vez, nos encontramos con un entorno de escritorio cuya apariencia no es del agrado de todo el mundo. Esto no es problema, ya que una de las cualidades que tiene Ubuntu es que puedes personalizarlo a tu gusto, quizá fue este el gran motivo por el que decidí dar el salto a GNU/Linux. Empecemos con el tutorial:

COMPIZ FUSION

Compiz Fusion es un gestor de ventanas que nos permite realizar una cantidad alucinante de efectos de escritorio. A continuación aprenderemos a instalarlo. Para ello, nos vamos a Synaptic y buscamos los siguientes paquetes: compizconfig-settings-manager y emerald.

Para poder configurar los efectos que nos ofrece Compiz Fusion, nos vamos a Sistema=>Preferencias=>Configuraciíon Avanzada de Efectos del Escritorio.

Si of fijáis en el comando, hemos instalado un paquete llamado "Emerald". Esta aplicación nos permite aplicar un marco a las ventanas alternativo al GTK de GNOME. Podremos encontralo en Sistema=>Preferencias=>Gestor de temas Emerald.

TEMAS DE ESCRITORIO

Bien, en primer lugar nos vamos a una de las siguientes páginas:

Gnome Look

Deviantart

En estas dos páginas podréis encontrar casi cualquier cosa para personalizar vuestro escritorio GNOME. La personalización no puede ser más sencilla. Cuando os descarguéis un tema que os guste, veréis que se trata de un archivo con terminación "tar.gz" no os preocupéis que en la inmensa mayoría de los casos nunca tendréis que compilar ningún código fuente ni nada por el estilo. Bueno, al grano, lo que tendréis que hacer con estos archivos es descomprimirlos y luego arrastrarlos a la siguiente ventana:

Hacéis click derecho en el escritorio y seleccionais "Cambiar fondo de escritorio", se os abrirá una ventana en donde tendréis que seleccionar la pestaña "Tema". En esa ventana arrastráis las carpetas que habíais descomprimido antes. Así de sencillo. Con estos pasos ya habéis terminado.

Para los iconos y los punteros de ratón el procedimiento es exactamente el mismo. Y ¿Qué pasa si quiero cambiar a un tema que ya tenía instalado antes? Muy sencillo, hacemos lo siguiente:

Click derecho en el escritorio; "Cambiar fondo del escritorio"; Seleccionamos la pestaña "Temas"; Click en el botón "Personalizar"; se os abrirá una nueva ventana en donde tendréis infinitas posibilidades de personalización, siempre en función de los temas que tengáis instalados.

Esto es lo básico para personalizar nuestro escritorio GNOME, en posteriores entradas hablaré de cómo modificar el GDM, el GRUB o el splash de carga.

Escritorios en GNU/Linux: GNOME

Aero — Mon, 23 Jun 2008 10:41:13 +0000

Hola de nuevo gente!

Tal y como prometí en anteriores entradas, voy a hablar de los diferentes entornos de escritorio que nos podremos encontrar en GNU/Linux, dado que son muchos los escritorios en GNU/Linux y hay mucha información para barajar, lo mejor será hacer un post con las características y la historia de cada escritorio. En esta ocasión vamos a hablar del entorno de escritorio más usado en las distribuciones Linux: GNOME. Sin más preámbulos, empecemos:

Según el sitio web Alegsa:

"(GNU Network Object Model Environment). GNOME es un proyecto internacional que desarrolla un completo entorno gráfico de usuario para sistemas operativos.

El objetivo de GNOME incluye también un marco de desarrollo de software seleccionando aplicaciones de software para el escritorio, y trabajando sobre programas que administren la ejecución de aplicaciones, manejo de archivos y administración de ventajas y tareas.

GNOME es parte del Proyecto GNU, y es utililzado en múltiples sistemas operativos basados en UNIX.

Objetivos de GNOME

GNOME tiene dos objetivos principales:

El entorno de escritorio GNOME , un intuitivo y atractivo escritorio para sus usuarios.

La plataforma de desarrollo de GNOME, una gran plataforma para la creación de aplicaciones que se integren en el escritorio..

El proyecto GNOME pone énfasis en la simplicidad y usabilidad, apoyándose en estas premisas:

Crear un entorno de escritorio que siempre tenga el código fuente disponible para ser reusado bajo licencia de software libre.

Asegurarse que el escritorio peuda ser usado por cualquiera, sin importar habilidades técnicas o discapacidades físicas.

Crear un proyecto disponible en múltiples idiomas (actualmente posee más de 100 versiones en diferentes idiomas).

Facilitar la creación de software que se integre cómodamente con el escritorio permitiendo también a los programadores elegir el lenguaje de programación.

Historia de GNOME

GNOME fue anunciado por el proyecto GNU en agosto de 1997, en respuesta a las inquietudes generadas por las licencias usadas en KDE, otro entorno de escritorio gratuito. Esas licencias podían no garantizar la libre realización de software. KDE empleaba la herramienta Qt para desarrollarse, pero Qt no era libre y de código abierto (recién esto último se lograría en el año 2000, pero el proyecto GNOME ya estaba en pleno desarrollo).

Por las inquietudes generadas por las licencias, se iniciaron dos proyectos: Harmony y GNOME. Se eligión GTK+ como base del escritorio GNOME.

Los iniciadores del proyecto GNOME fueron los mexicanos Miguel de Icaza y Federico Mena.

El nombre GNOME fue propuesto como un acrónimo de GNU Network Object Model Environment por Elliot Lee. Este nombre hace referencia a la intención original de GNOME, de crear un marco similar al OLE de Microsoft. Este nombre no refleja más que la visión central del proyecto GNOME y, por lo tanto, el nombre completo es ahora considerado obsoleto

Plataformas

GNOME fue originariamente diseñado para Linux, pero actualmente corre en la mayoría de los sistemas basados en UNIX, y ha sido adoptado por Sun Microsystems como parte del Java Desktop Environment de su plataforma Solaris.

GNOME es el entorno de escritorio por defecto enla mayoría de las distribuciones de Linux actuales como Debian, Fedora y Ubuntu.

La interfaz GNOME

GNOME es similar a la mayoría de entornos de escritorios tradicionales. Maneja ventanas, aplicacoines y archivos como en la mayoría de los sistemas operativos actuales.

En su configuración por defecto, el escritorio posee un menú lanzador para aceso rápido a los programas instalados y a la localización de archivos; las ventanas abiertas pueden ser accedidas por una barra de tareas alojada en el inferior de la pantalla, y en la esquina superior derecha está el área de notificación, para que los programas muestren información mientras se ejecutan de fondo. De todas maneras, estas características pueden ser movidas o reemplazadas según los deseos del usuario.

La apariencia de GNOME puede ser cambiada con el uso de tremas, siendo los temas por defecto Bluecurve y Clearlooks."

Personalizar Gnome Ligeramente

psyfurius — Sun, 22 Jun 2008 20:22:45 +0000

Algunas personas no pueden personalizar el tema de las ventanas de Gnome con CompizFusion o Emerald porque sus PC tienen el RAM suficiente para poder procesar datos en el incio. Estas personas tienen la Opcion de personalizar sus ventanas utilizando temas para GTK+. Mucho de estos temas los puedes encontrar en http://www.gnome-look.org.

Estos tipos de temas para las ventanas funcionan igual de ligero como los temas por defecto de Gnome. Para poder instalar un tema GTK en Gnome sigue estos pasos:

1. Descarga un tema GTK. Para este tuto utilizare uno llamado "Crystal dlb". Puedes descargarlo haciendo click AQUI.

*No extraigas el archivo

2. Para instalar el tema vamos a Sistema/Preferencias/Apariencia o tambien haciendo click derecho sobre el escritorio, seleccionas "Cambiar el Fondo del Escritorio" y dirigete a "Tema". Click en "Instalar", busca el archivo descargado en tu PC y agregalo, listo.

Aqui les dejo 5 temas en un solo paquete para descargar...

*Si este "HowTo" te ayudo, agradece...

Gnome

psyfurius — Fri, 20 Jun 2008 15:00:19 +0000

Que es Gnome?

- GNOME es un entorno de escritorio para sistemas operativos de tipo Unix bajo tecnología X Window. Forma parte oficial del proyecto GNU. Nació como una alternativa a KDE. Se encuentra disponible actualmente en 48 idiomas en su última versión.

Para quien es Gnome?

- Gnome es para personas que tengan una PC con al menos 256+ MB Ram.

Que "Distro" viene con Gnome por defecto?

- Si, muchas vienen con Gnome por defecto. Por ejemplo tenemos a Ubuntu y Fedora. Otras distribuciones como OpenSuse y Mandriva no vienen por defecto con Gnome pero "si" tienen la opcion para instalar con Gnome.

Cual es la ultima version de Gnome?

- Hoy 20 de Junio de 2008, la ultima version reportada es la v2.22.

Web: http://www.gnome.org/

libwnck package for sid

marcotmarcot — Fri, 20 Jun 2008 05:40:48 +0000

I've done a package for the correction of the libwnck bug to sid. It's available at Debian Mentors and at my Home Page.

lexadrez - programa exemplo com pygtk

medeubranco — Wed, 18 Jun 2008 01:26:21 +0000

Para quem acompanhou os tutoriais de PyGTK deste blog e queria ver um programa mais completo usando drawingArea e outras graças do GTK, eu posso oferecer o programa que escrevi um tempo atrás para rever as partidas de xadrez que eu jogava no yahoo!.

Enquanto escrevia, resolvi que o software poderia ser também uma ferramenta para estudar aberturas, e preparei ele para isso.

Coloquei o programa no codigolivre :
lexadrez.codigolivre.org.br

Como o codigolivre vira e mexe está inacessível, passo o link para baixar direto o código:
lexadrez-0.001.tar.gz

O programa exibindo a Ruy Lopes:

O código foi todo orientado a objetos. As classes estão mais ou menos documentadas, experimente usar o pydoc pelo terminal, no diretório do programa.

Acho que poderia ter sido melhor escrito em vários aspectos: o parser para leitura do jogo está muito POG, as classes são muito dependentes umas das outras, entre outras coisas. Não coloquei o recurso de gravar as aberturas diretamente no programa; se alguém quiser fazê-lo, não está difícil.

Recursos funcionando:

exibe jogos e aberturas no formato do yahoo!
permite movimentar as peças de acordo com as regras do xadrez
edita e salva comentários nas partidas e aberturas

Se você tem mais experiência em OOP, gostaria saber quais "regras" da boa programação eu violei, e de que forma o código poderia ter sido melhor escrito. Juro que não fico chateado. Use e abuse dos comentários.

Xandros 4.1 and Firefox 3 Don't Play Well Together

Dan Seto — Wed, 18 Jun 2008 00:23:25 +0000

For those of you running Xandros Linux Desktop Professional 4.1, you may want to pause and reflect before installing the new Firefox 3 browser.

I downloaded the new Firefox this afternoon and began the install. However, the install ran until it halted with an error saying GTK+ 2.1 was required but only an earlier version was installed. After searching the Xandros support forums, it appears you have to install and compile the source code for GTK+ 2.1 because Xandros does not have an update for it. But, now wait for it, you first have to overcome dependencies by installing and compiling several other files. But, now wait for it, well, you know the drill. You are in dependency hell with no way out. Even if you get GTK+ 2.1 installed, you run the chance of breaking other applications. If that occurs, you are pretty much on your own, up that certain creek without a paddle.

What's even worse is that the install program killed my existing version of firefox (2.0.0.14). I don't know what the install did but my old version refused to run and I couldn't find a download to re-install for this version. What I ended up doing was I uninstalled the Xandros Firefox (2.0.0.6), an old version I had long ago abandoned by downloading newer versions directly from Firefox, and then re-installing that from Xandros Networks. Once that was done, both 2.0.0.6 and 2.0.0.14 started working again.

I don't know why that worked, but it did. For me, anyway. YMMV. Insert disclaimer here.

In any case, unless someone creates a binary for Xandros, backports GTK+ 2.1, or another solution is found, you should probably avoid Firefox 3 on Xandros Desktop Professional 4.1.

Aloha!

libwnck

marcotmarcot — Tue, 17 Jun 2008 00:09:45 +0000

When XMonad was used with GNOME, through EwmhDesktops and the last window was destroyed, it would not be deleted from the window list and from the workspace switcher. This bug report explains the situation. To correct it, I've made a patch to libwnck's screen.c, which was applied in the SVN version of this file. I've done a package for Ubuntu Hardy Heron and other for Debian Etch with a corrected version of this library.

Google Gadgets

balajirrao — Sun, 15 Jun 2008 10:32:18 +0000

Just now I read from lwn.net about the release of Google Gadgets for Linux and Google Desktop for linux. I decided to check it out and obtained the source. Once small problem is, it does not have installer packages for various distros. Installing from source was pretty easy. I had no dependency problem at all. Everything was smooth. It builds separately for Qt and Gtk, although I tried only the GTK one as I no longer use KDE.

There are a lot of gadgets to choose from. The gadget chooser looks like this.

Some of them don't work. But some of them throw a scary warning like this when you tried to add it. Being afraid, I just say No. :)

Here's a screenshot of my desktop decorated with a few cool gadgets and firefox showing Google Desktop for linux. Grab your copy and try it out. Enjoy madi!!

DrawingArea - Desenhando na tela com PyGTK

medeubranco — Sun, 15 Jun 2008 05:35:14 +0000

Nos artigos anteriores sobre PyGTK, eu apresentei quatro widgets básicos:

gtk.Window - uma janela
gtk.VBox - um container para acomodar os widgets
gtk.Button - botão
gtk.Label - uma etiqueta para texto

Muitos outros widgets básicos não foram nem mencionados, como o gtk.Entry (caixa de texto), gtk.TreeView (lista em árvore), gtk.Toolbar (barra de ferramentas), entre outros.

Acontece que não vou mostrar nenhum deles aqui ainda.

Vamos falar de um componente que é menos usado nas aplicações em geral mas é muito útil. É o gtk.DrawingArea, Uma simples janela X onde podemos desenhar qualquer coisa, inclusive quadrados verdes com borda preta, de 50x50 pixels. E é exatamente isso que vamos fazer aqui.
Vamos construir, passo a passo, uma janela que contem uma área de desenho (DrawingArea) e um botão. Vamos chamar a área de desenho de tela.
A cada clique de mouse na tela, um quadrado verde é desenhado, tendo como centro o ponto clicado.

O botão vai limpar a tela.

Se você ainda não sabe como criar uma janela em PyGTK, leia primeiro esses dois pequenos artigos:

Criando uma simples janela com pygtk
Criando uma simples janela em pygtk - parte II

O grande astro da noite é a gtk.DrawingArea. Então vamos criar nossa tela:

[sourcecode language='python']
tela=gtk.DrawingArea()
[/sourcecode]

Como deveríamos saber, interfaces gráficas trabalham com eventos, como cliques em um botão, cliques e movimentos de mouse, teclas pressionadas, janelas arrastadas, minimizadas, escondidas por outras, etc. O usuário simplesmente dispara os eventos, o programador cuida de criar respostas a eles. Para uma DrawingArea um evento importante é o expose-event, disparado quando a tela é reexibida. Se a tela estava oculta, quando ela volta a aparecer precisa ser redesenhada, então vamos conectar o expose-event à função que vai desenhar os nossos preciosos quadrados verdes:

[sourcecode language='python']
tela.connect('expose-event',desenha)
[/sourcecode]

Outro evento importante para o nosso programa é o button-press-event, disparado quando você clica na tela com o mouse; mas este evento não está configurado, então vamos adicioná-lo à nossa tela, e então fazer a conexão com a função que vai criar nossos imprescindíveis quadrados verdes:

[sourcecode language='python']
tela.add_events( gtk.gdk.BUTTON_PRESS_MASK )
tela.connect('button-press-event',cria_quadrado)
[/sourcecode]

Não nos esqueçamos do objetivo deste programa: criar quadrados verdes. Os quadrados serão armazenados em uma lista. Listas são um tipo de dados que o Python nos provê. Criaremos a lista de quadrados:

[sourcecode language='python']
quadrados=[]
[/sourcecode]

Agora a coisa começa a ficar mais interessante. Dê uma olhada na função criar_quadrado(), que será executada a cada clique na tela:

[sourcecode language='python']
def cria_quadrado(tela,evento):
    global quadrados
    coor=evento.get_coords()
    x=coor[0]
    y=coor[1]
    novo_quadrado=[ x-25 , y-25 , 50 , 50 ]
    quadrados.append(novo_quadrado)
    desenha(tela,None)

[/sourcecode]

A função recebe dois parâmetros: a tela onde ocorreu o evento, e o evento propriamente dito.

A segunda linha da função declara como global a lista de quadrados, ou seja, um objeto criado fora da função pode ser acessado de dentro dela sem ter sido passado como parâmetro.

A terceira linha pega as coordenadas do evento. O ponto exato onde ocorreu o clique. O método get_coords() retorna uma tupla com as coordenadas X e Y. Assim: (X,Y).

A quarta e quinta linhas criam duas variáveis para conter os valores da tupla.

A sexta linha finalmente cria o nosso quadrado (não desenha, só cria) e a sétima o adiciona à lista de quadrados. O quadrado, então, nada mais é que uma outra lista contendo as coordenadas de inicio, a largura e a altura.

Vamos analisar melhor o quadrado criado:

x-25 : é o primeiro item da lista. Indica a coordenada X do canto superior esquerdo do quadrado.

y-25: é o segundo item da lista e indica a coordenada Y do canto superior esquerdo do quadrado.
Os valores x e y vieram do evento de mouse. Subtraímos 25 (alguém reparou que 25 é metade de 50?) de cada para que o ponto clicado fosse o centro do quadrado.

Em uma DrawingArea, as coordenadas são orientadas de cima para baixo e da esquerda para a direita.

50: terceiro e quarto itens da lista; respectivamente altura e largura do quadrado.
A oitava linha da função 'cria_quadrado' chama a função 'desenha'. A tela é passada como parâmetro. None é o segundo parâmetro, e só está aí porque a função pede um segundo parâmetro (ela também é disparada quando ocorre o expose-event).

Já sabemos como criar os quadrados na memória. O próximo passo é desenhá-los na tela:

[sourcecode language='python']

def desenha( tela , evento ):
    global quadrados
    gc=tela.get_style().fg_gc[gtk.STATE_NORMAL]

    verde=gtk.gdk.Color(0,48255,0,0)
    preto=gtk.gdk.Color(0,0,0,0)
    fundo=gtk.gdk.Color(65535,65535,65535,0)

    #pintando o fundo da nossa tela
    gc.set_rgb_fg_color(fundo)
    tela.window.draw_rectangle(gc,True,0,0,800,600 )

    for q in quadrados:
        gc.set_rgb_fg_color(verde)
        tela.window.draw_rectangle(gc,True,q[0],q[1],q[2],q[3])
        gc.set_rgb_fg_color(preto)
        tela.window.draw_rectangle(gc,False,q[0],q[1],q[2],q[3])

[/sourcecode]

Dissecando a função:

Aqui vamos usar a lista de quadrados, que foi criada fora do contexto desta função e é modificada por outra função. Por isso o global quadrados.
Precisamos também criar um graphics context (gc):

[sourcecode language='python']
    gc=tela.get_style().fg_gc[gtk.STATE_NORMAL]
[/sourcecode]

Um graphics context armazena informações como cor de fundo, de primeiro plano e espessura da linha de desenho.

Precisamos de algumas cores para fazer nossa arte:

[sourcecode language='python']
    verde=gtk.gdk.Color(0,48255,0,0)
    preto=gtk.gdk.Color(0,0,0,0)
    fundo=gtk.gdk.Color(65535,65535,65535,0)
[/sourcecode]

Vamos dar um fundo branco para a nossa tela:

[sourcecode language='python']
    gc.set_rgb_fg_color(fundo)
    tela.window.draw_rectangle(gc,True,0,0,800,600 )
[/sourcecode]

Os dois comandos acima serão usados novamente agora, pois vamos percorrer a lista de quadrados e desenhar cada um deles. Se a lista estiver vazia, nenhum quadrado será desenhado:

[sourcecode language='python']
    for q in quadrados:
        # desenhando um quadrado preenchido de verde
        gc.set_rgb_fg_color(verde)
        tela.window.draw_rectangle(gc,True,q[0],q[1],q[2],q[3])
    #desenhando a borda preta do quadrado
        gc.set_rgb_fg_color(preto)
        tela.window.draw_rectangle(gc,False,q[0],q[1],q[2],q[3])

[/sourcecode]

Em gc.set_rgb_fg_color( cor ) definimos a cor a ser usada ao desenhar.

O método draw_rectangle precisa ser compreendido. Vejamos os parâmetros usados:

gc : o graphics context criado lá em cima.

False ou True : indica se o quadrado será preenchido.

q[0] até q[3]: são os quatro valores do quadrado criado lá em cima.

Faltou o botão para apagar a tela. Ele está presente no código completo mais abaixo. Por enquanto basta dizer que apaga-se a tela simplesmente limpando a lista de quadrados e disparando novamente a função 'desenha()'.

Vamos ver como ficou o nosso programa:

[sourcecode language='python']
#!/usr/bin/env python
import pygtk
import gtk

#declarando a lista de quadrados
quadrados=[]

def cria_quadrado(tela,evento):
    global quadrados

    #obtendo as coordenadas do clique de mouse
    coor=evento.get_coords()
    x=coor[0]
    y=coor[1]

    #criando um novo quadrado e incluindo ele na lista
    novo_quadrado=[x-25,y-25,50,50]
    quadrados.append(novo_quadrado)

    # disparando a funcao 'desenha()'
    # para incluir o nosso novo quadrado
    desenha(tela,None)

# a funcao desenha() deve ser chamada sempre que
# quisermos redesenhar a tela
# ou quando a tela precisar ser redesenhada
# por ter sido encoberta por outra janele, por
# exemplo
def desenha(tela,evento ):
    global quadrados
    #criando um "graphics context"
    gc=tela.get_style().fg_gc[gtk.STATE_NORMAL]

    #definindo as cores
    verde=gtk.gdk.Color(0,48255,0,0)
    preto=gtk.gdk.Color(0,0,0,0)
    fundo=gtk.gdk.Color(65535,65535,65535,0)

    #pintando o fundo da nossa tela
    gc.set_rgb_fg_color(fundo)
    tela.window.draw_rectangle(gc,True,0,0,800,600 )

    # desenhando cada um dos quadrados
    for q in quadrados:

        #desenhando o quadrado preenchido
        gc.set_rgb_fg_color(verde)
        tela.window.draw_rectangle(gc,True,q[0],q[1],q[2],q[3])

        #desenhando a borda do quadrado
        gc.set_rgb_fg_color(preto)
        tela.window.draw_rectangle(gc,False,q[0],q[1],q[2],q[3])

def limpar(botao):
    global quadrados
    global tela
    #limpando a lista de quadrados
    quadrados=[]

    #disparando novamente a funcao "desenha()"
    #para desenhar a tela branca sem nenhum quadrado
    desenha(tela, None)

win=gtk.Window()
win.set_title( "medeubranco.wordpress.com - Desenhando na tela com PyGTK" )
win.set_size_request(800,600)
win.connect('destroy',gtk.main_quit)

box=gtk.VBox()

#aqui a nossa tela sendo criada
tela=gtk.DrawingArea()

tela.connect('expose-event',desenha)
tela.add_events( gtk.gdk.BUTTON_PRESS_MASK )
tela.connect('button-press-event',cria_quadrado)

botao=gtk.Button( "limpar" )

botao.connect("clicked",limpar)

win.add(box)
box.set_border_width(10)

box.pack_start(tela)
box.pack_start(botao,False)
win.show_all()
gtk.main()

[/sourcecode]

Olha o resultado:

Na tentativa de manter este artigo o menos complexo possível, muita coisa foi omitida aqui. Há outros métodos de desenho além do draw_rectangle, e há outras formas de lidar com uma DrawingArea.

Para se aprofundar, você pode começar por aqui:

http://www.pygtk.org/pygtk2tutorial/sec-DrawingAreaWidgetAndDrawing.html
Espero que este tutorial tenha sido útil a você e que você encontre formas criativas de usar uma DrawingArea.

Até o próximo artigo deste blog.

Las comparaciones NO son odiosas.

jmgv — Fri, 13 Jun 2008 14:50:21 +0000

Tengo la costumbre de participar en debates estériles simplemente porque me divierten. Aunque, ahora que me doy cuente, que si me divierten, ya no son tan estériles. He leido cientos de hilos en listas de correo con los típicas comparaciones. Kde vs Gnome, C++ vs C, C++ vs Java, Gtk+ vs Qt, Linux vs Windows...

A día de hoy, o mejor dicho, a día de hace una semana, estaba totalmente convencido que el C++ era mejor que C. Sin embargo ahora no empiezo a tenerlo claro. Y es que, tengo un grave problema, cuanta más experiencia tengo, cuanto más tecnologías diferentes analizo, menos claras tengo las cosas cuando supuestamente debería ser lo contrario.

El caso, es que en estos momentos tengo un proyecto entre manos, para el que necesito crear algún tipo de interfaz gráfico para el usuario. Tenía que elegir unas librerías que me permitieran hacer esto. Mi elección de manera natural estaba clara, elegiría Qt porque es una librería probada sobradamente (KDE la usa en su escritorio) y que además tiene una magnifica documentación. Pero sobre todo, mi inclinación por usar Qt era porque estaban programadas en C++. Sin embargo, mientras he ido madurando la aplicación, he empezado a tener menos claro si debo poner mi aplicación con licencia GPL o no, y aunque no lo tengo decidido aún, con Qt no tengo elección, debe ser GPL. Es cierto que existe otra licencia comercial de Qt que no me obliga a ello, pero los costes no son asumibles por mí en este momento.

Buscando una alternativa, llegué de nuevo a Gtk+. Ya conocía Gtk+ pero la mantenía un poco en la distancia porque estaban realizadas en C, sin embargo tenía una gran ventaja para mi, su licencia era LGPL. Esta licencia me permite hacer con mi código lo que me venga en gana. Es decir, me dar libertad verdadera.

Sé que el tipo de licencia no debería ser un factor a tener muy en cuenta para decidir la tecnología que vas a utilizar para el desarrollo de una aplicación, sin embargo, en esta ocasión decidí echarle un vistazo. Para los que no lo sepan, Gtk+ es a Gnome, lo que Qt es a KDE. Por lo tanto, ni que decir tiene que Gtk+ también es una librería madura.

Gtk no pertenece a ninguna empresa. Qt en realidad, en su versión GPL tampoco, pero sí pertenece a medias entre Trolltech (recientemente adquirido por Nokia) y la Foundación KDE. Sea como sea, y aunque no dudo sobre las buenas intenciones de la Fundación KDE, Qt tiene dueños. Sin embargo Gtk+ no pertenece a nadie. Este es otro factor que me hizo pensar que merecía la pena echarle un ojo.

Sinceramente, aún estoy frotándome los ojos cuando miré el código por dentro. Es un código diseñado con un gusto exquisito, y con una filosofía orientada a objetos, que me gustaría ver en muchos de los programas desarrollados en C++. Ya sabéis la programación orientada a objetos no es una cuestión del lenguaje si no de diseño. Esto queda reflejado de forma patente en el código de las GTK+

Ahora bien, si está pensado con OOP en la cabeza, porqué no usar un lenguaje orientado a objetos. Según algunos de los desarrolladores de Gtk+ y según se puede leer en numerosos sitios de internet a poco que busques por internet, la mayoria de la gente que decide usar C sobre C++ es porque piensan que C++ te obliga a meter una serie de sobrecargas que no son necesarias, y que lleva a la gente que usa el lenguaje a hacer malos diseños. Tampoco les suele gustar mucho el uso de las STL o de las Boosts.

Está claro que, del mal diseño de una aplicación no tiene la culpa el lenguaje si no el que lo diseña. Pero... un lenguaje está claro que te condiciona la forma en la que enfocas un problema. Es más complicado hacer un buen programa en Perl que en Java.

En un hilo de discusión muy famoso, Linus dijo que había elegido C para el desarrollo de Git porque le parece mucha mejor opción. Y dijo también "si elegir C sirve para mantener apartado del proyecto a los programadores de C++, ya es una buena opcion". Otra de las perlas que soltó fue, que "a cualquier persona que eliga C++ en vez de C para un proyecto, no la quería tener en su proyecto". Sin duda alguna estas no son maneras de expresarse, pero más allá de esa questión, yo me pregunto ¿tendrá razón?.

Generalizar es un pecado mortal en estos contextos, pero, debido a la naturaleza del lenguaje, quien pensáis que por regla general conoce mejor el funcionamiento de los ordenadores, ¿un programador de C o uno de Java? y ¿entre uno de C y otro de C++?. A pesar de tirarme piedras sobre mi propio tejado, yo creo que por regla general el de C. Y aunque no estoy de acuerdo con Linus en las formas como lo dijo, empiezo a estar de acuerdo en el fondo de lo que dijo.

La gente suele decir, que con C++ se pueden abordar projectos más grandes que con C. Bueno, eso depende. Probablemente ninguna de estas personas haya trabajado en proyectos tan grande como pueden ser Gnome, Evolution o GiMP por poner algunos ejemplos. Sin embargo todos ellos están desarrollados en C. Lo que si te obliga C es a llevar una disciplina que sólo los buenos conocedores de como funciona el software son capaces de llevar a cabo. En C no hay recolección automática de basura, eso lo tiene que hacer el programador, en C++ ocurre lo mismo, pero... en C si te creas un polimorfismo sabes exactamente lo que estás haciendo porque lo hace el propio programador, mientras que en C++ muchos de los paradigmas de la programación orientada a objetos están ocultas en la sintaxis del programa, como debe ser en un lenguaje pensado para el desarrollo orientado a objetos. Lo mismo ocurre con el uso de strings, que en determindas ocasiones cuando son utilizadas en C++ para concatenar, requiere de muchos recursos para hacerlo y es extremadamente lento. Sin embargo, al estar todo oculto, es complicado de que un programador pueda detectarlo.

En definitiva, creo que, en los proyectos donde tan sólo se permite C, la probabilidad de que haya un mal programador es más baja, que en los proyectos donde se desarrolla en C++.

Estoy convencido de que, entre los programadores de las Gtk+ hay muy pocos programadores malos a la vista del código y del diseño. Queda patente una gran formación en la ingeniería del software y unas ideas muy claras de como hacer las cosas bien.

Cuando me hice cargo del mantenimiento del paquete de software libre DDD. Pensé en ponerle un mejor entorno gráfico, ya que actualmente usa Motif que ya no se mantienen a buen ritmo, y pensé en reescribir algunas de las parte en C++. Sin embargo, ahora lo que vamos a hacer es dejar el C, no reescribir nada en C++ y meter Gtk en vez de Qt como tenía pensado. Ya veremos cual es la experiencia.

De hecho, después de ver como está hecho Gtk+, y como está organizado la plataforma de desarrollo de Gnome, me estoy replanteando muchas cosas que hasta hace una semana daba por hecho.

Un ejemplo de Ruby/Ruby-gnome2

lonecat — Fri, 13 Jun 2008 01:18:53 +0000

Cuando busco ejemplos en internet, intento reproducirlos para luego analizarlos en detalle y comprender el codigo. Sin embargo, hay muchas veces que encuentro ejemplos que muchas veces son muy faciles y no me aportan mucho. Otras veces encuentro ejemplos que son muy dificiles y presentan multiples conceptos que me confunden. Por eso siempre que aprendo un nuevo lenguaje de programacion intento aplicar los conocimientos en ejemplos practicos que uso dia a dia.
El siguiente es un pequeño ejemplo que muestra una pequeña ventana que calcula el tiempo aproximado que tardará una descarga.

El resultado:

El codigo (descargas.rb):
1 #!/usr/bin/env ruby 2 ######################################################################### 3 # 4 # Calculadora de descargas, por Jose Felix Gomez 5 # 05/2008 6 # 7 # 8 # 9 require 'gtk2' 10 11 class Descarga 12 def initialize 13 window = Gtk::Window.new('Descargas') 14 window.set_border_width(5) 15 window.set_size_request(300,200) 16 window.resizable=false 17 table = Gtk::Table.new(4,2,true) 18 window.add(table) 19 boton_calcular = Gtk::Button.new('Calcular') 20 boton_salir = Gtk::Button.new('Salir') 21 label_tamano = Gtk::Label.new('Tamaño') 22 label_velocidad = Gtk::Label.new('Velocidad') 23 label_resultado = Gtk::Label.new('Ingresa los valores y presiona \'Enter\'') 24 entry_tamano = Gtk::Entry.new 25 entry_tamano.text = '100m' 26 entry_velocidad = Gtk::Entry.new 27 entry_velocidad.text = '512' 28 table.attach_defaults(label_velocidad,0,1,1,2) 29 table.attach_defaults(label_tamano,0,1,0,1) 30 table.attach_defaults(entry_tamano,1,2,0,1) 31 table.attach_defaults(entry_velocidad,1,2,1,2) 32 table.attach_defaults(boton_calcular,0,1,3,4) 33 table.attach_defaults(boton_salir,1,2,3,4) 34 table.attach_defaults(label_resultado,0,2,2,3) 35 36 boton_salir.signal_connect('clicked'){Gtk.main_quit} 37 38 boton_calcular.signal_connect('clicked') do 39 label_resultado.label = calcular(entry_velocidad.text.to_i, entry_tamano.text) 40 entry_velocidad.select = true 41 end 42 43 entry_velocidad.signal_connect('activate') do 44 label_resultado.label = calcular(entry_velocidad.text.to_i, entry_tamano.text) 45 end 46 47 entry_velocidad.signal_connect('activate') do 48 label_resultado.label = calcular(entry_velocidad.text.to_i, entry_tamano.text) 49 end 50 51 entry_tamano.signal_connect('changed') do 52 label_resultado.label = calcular(entry_velocidad.text.to_i, entry_tamano.text) unless /[a-zA-Z]/.match(entry_tamano.text) == nil 53 end 54 55 entry_velocidad.signal_connect('changed') do 56 label_resultado.label = calcular(entry_velocidad.text.to_i, entry_tamano.text) unless /[a-zA-Z]/.match(entry_tamano.text) == nil 57 end 58 59 window.signal_connect('delete_event'){Gtk.main_quit} 60 window.signal_connect('destroy_event'){Gtk.main_quit} 61 window.show_all 62 end 63 64 def calcular(velocidad, tamano) 65 sufijo = /[a-zA-Z]/.match(tamano)[0].downcase 66 unless ( velocidad < 10 && sufijo == 'k' ) || velocidad < 10 67 velocidad /= 10 68 multiplicador = case 69 when sufijo == 'm':1024 70 when sufijo == 'g':1024**2 71 when sufijo == 'k':1 72 else 1 73 end 74 tamano = /[0-9]*/.match(tamano)[0].to_f * multiplicador 75 segundos = tamano / velocidad 76 horas = (segundos / 3600).to_i 77 minutos = (segundos / 60) % 60 78 segundos = segundos % 60 79 return "#{horas.to_i}:#{minutos.to_i}:#{segundos.to_i}" 80 else 81 return "Infinito" 82 end 83 end 84 end 85 app = Descarga.new 86 Gtk.main

Criando uma simples janela em pygtk - Parte II

medeubranco — Wed, 11 Jun 2008 00:02:05 +0000

No nosso primeiro artigo sobre este assunto, criamos uma janela sem conteúdo algum. Desta vez vamos adicionar alguma funcionalidade a esta janela. Baixe o código fonte abaixo, salve como gtk_window.py e execute-o:

[sourcecode language='python']
#!/usr/bin/env python

import pygtk
import gtk

def clicada( botao , label ):
if label.get_text() == "" :
label.set_text( "obrigado" )
else:
label.set_text( "" )

win=gtk.Window( )
win.set_title( 'Titulo da Janela' )

win.set_size_request(200,50)
win.connect( "destroy" , gtk.main_quit )

box=gtk.VBox( )
win.add( box )

label=gtk.Label( "" )
box.pack_start( label )

botao=gtk.Button( "clique-me" )
box.pack_start( botao )
botao.connect( "clicked" , clicada , label )

win.show_all()
gtk.main()
[/sourcecode]

A primeira diferença deste código para o anterior é que agora usamos uma função:

[sourcecode language='python']
def clicada( botao , label ):
if label.get_text() == "" :
label.set_text( "obrigado" )
else:
label.set_text( "" )
[/sourcecode]

Esta função, que denominamos "clicada", está aí para ser uma função de callback para o botão que será criado mais à frente no código. Ela recebe dois parâmetros: um gtk.button e um gtk.Label.

Uma outra novidade é a gtk.VBox criada na linha 18. A VBox (Caixa Vertical) é um container; serve para "acondicionar" os widgets (botões, caixas de texto, rótulos, etc) na janela. Existem outros tipos de container e você pode aprender mais sobre eles em outro lugar.

Na linha 19 ( win.add( box ) ), a gtk.VBox é adicionada a Janela.

Um novo widget é criado na linha 21 [ label=gtk.Label( "" ) ], uma "etiqueta" com rótulo em branco. Esta "etiqueta" é adicionada à gtk.VBox na linha 22 [ box.pack_start( label ) ].

Nas linha 24 e 25 repetimos o procedimento, desta vez com um gtk.Button, um botão.

Agora atenção, pois na linha 26 é que nós dizemos o que vai acontecer quando o botão for clicado:

[sourcecode language='python']botao.connect( "clicked" , clicada , label )[/sourcecode]

Esta linha conecta o sinal "clicked" à função 'clicada' ( linhas 6 a 10 ), passando como parâmetro o objeto label. O próprio botão é passado como parâmetro aqui de forma implícita.

Na linha 28 determinamos a exibição da Janela e todos os seus componentes, e na linha 29 chamamos o loop principal.

Copie o código, salve e execute.

Il dilemma MSN...

Flycaster — Tue, 10 Jun 2008 14:24:01 +0000

Uno dei più blasonati quesiti che si pone un utente qualunque che passa da Microsoft Windows ad una qualsiasi distribuzione GNU/Linux, è: ora come faccio a comunicare coi miei amici "appasionati" di Windows Live Messenger? Ebbene, lo si voglia o meno, abbiamo sempre una schiera abbastanza grande di amici che usano questo client come preferito per comunicare. Di conseguenza ci troveremo in situazioni spiacevoli quando magari una nostra cara amica ci invia una "simpatica" animoticon aspettandosi una nostra gradita reazione... mentre invece stiamo usando Pidgin e nemmeno ci accorgiamo di nulla -.-'. L'idea di convincere questa enorme schiera a fare a meno di questo tipo di "sciccherie" è quanto meno da scartare a priori e da non prendere nemmeno lontanamente in considerazione. Sarebbe come strappar via bruscamente ad una teenager i poster di Brad Pitt dalla sua stanzetta. Immaginatene le conseguenze... quindi che soluzione predere? Beh, di soluzioni ce ne sono tantissime, bisogna solo scegliere... però sappiate, qualsiasi sia la scelta che farete, non avrete mai al 100% le funzioni del programma originale di casa Microsoft®.

Mi va di citare tra le tante, solo 2 soluzioni che ritengo degne di nota: eMeSeNe ed aMSN (o anche Alvaro's Messenger). Ce ne sarebbe anche una terza, già presente di default nella distribuzione Ubuntu, e cioè Pidgin, che a mio parere però, può essere si idoneo per arrangiarsi (svolge benissimo le funzioni basilari, è di gran lunga il più fluido ed essenziale, anzi si parla anche di una futura implementazione audio/video), ma è da scartare per chi vuole a disposizione tutti i "gingillini" della controparte closed source. Fosse per me, mi farei bastare questo, ha tutto il necessario per comunicare decentemente. Ma qui stiamo parlando di utenti con esose esigenze.

Ecco Pidgin nel suo più spartano splendore.

Per averlo non dovete fare assolutamente niente. Lo troverete installato già all'ultima versione disponibile su Ubuntu 8.04, basta solo inserire il proprio account, la password ed un'immagine da visualizzare ed eccoci in linea pronti a comunicare con gli amici.

Se cerchiamo qualcosa di più accattivante, passiamo subito allora ad eMeSeNe. Un giovanissimo clone di grande spessore e perfettamente integrato in GNOME. Supporta l'invio e ricezione di files (niente cartelle condivise), trilli, emoticons personalizzabili, niente conversazione audio, niente webcam, niente animoticons. Da segnalare però una funzione che non c'è nemmeno in WLM: quando carichiamo un'immagine personale, abbiamo la possibilità di selezionare un'area a nostro piacimento da visualizzare come avatar (per esempio visualizzare solo il viso in una foto a mezzo busto). Per averlo basta dare da terminale:

sudo apt-get install emesene

dato che è entrato a far parte dei repository ufficiali di Ubuntu, avviarlo, connetterci e scoprire il resto delle funzionalità attivando i plugins presenti.

Ecco come si presenta la schermata principale di eMeSeNe.

Se abbiamo bisogno di qualcosa di ancor più messenger-affine, allora è il caso di passare ad installare aMSN. Di suo non ha quasi niente in più rispetto al più giovane amico eMeSeNe, ma ha il pregio di poter essere facilmente espandibile tramite aggiunta di plugins scaricabili un pò ovunque e raccolti in questa sezione del sito ufficiale. Il client di Alvaro supporta quasi tutto, compresi i nick colorati che in eMeSeNe sono stati volutamente non inclusi a causa di un utilizzo eccessivo delle risorse della CPU (dato che evidentemente è mosso da una filosofia differente, cioè rimanere quanto più leggero e funzionale possibile). Per avere la versione "pulita" possiamo installarlo direttamente da terminale:

sudo apt-get install amsn

e poi espanderlo e migliorarlo a piacimento scaricando plugins dal link di prima, o anche nuove skins reperibili ovunque sulla rete o sempre nella sezione apposita del sito ufficiale (ricordo che sia i plugins che le skins vanno messi nelle rispettive sottocartelle presenti nella cartella nascosta .amsn nella nostra home). Se invece siamo così pigri oppure così presi da non voler perdere assolutamente altro tempo ed avere subito tutto bello e pronto, possiamo usare uno script che fa tutto da solo, aggiungendo anche automaticamente diverse features. Apriamo un terminale e mettiamoci al lavoro.

sudo apt-get install buil-essential
wget http://flycaster.altervista.org/uploads/fixamsn.sh
bash fixamsn.sh clean
sudo apt-get install amsn
bash fixamsn.sh cvs

Ci sarà un processo alquanto lungo, ma varrà la pena di aspettare. Al termine riavviamo il pc ed avremo tutto pronto... o quasi. Molto probabilmente al primo avvio di aMSN visualizzeremo questo errore:

Cooooosa! Dovrei compilare qualcosa adesso!!! :|

No no state tranquilli :D si tratta solo di un insignificante errore risolvibile in questo modo (sempre dal nostro carissimo terminale ;)):

sudo gedit /usr/bin/amsn

Apparirà una finestra nella quale dobbiamo modificare la prima riga, cioè questa:

exec wish8.5 $0 $@

in questa:

exec /usr/local/bin/wish8.6 $0 $@

salvare e chiudere il file. Provate ad avviare ora aMSN :D.

Finalmente pronto all'uso!

Inoltre se vogliamo abilitare anche il Drag'n'Drop (inviare un file semplicemente trascinandolo nella finestra della conversazione), scaricate questo piccolo file (tasto destro, salva con nome), cliccateci sopra col tasto destro e entrate nelle Proprietà. Passate alla scheda Permessi e spuntate la voce Consenti l'esecuzione del file come programma, click su chiudi. Ora basta cliccare due volte sul file "dnd" e su Esegui nel terminale, alla prima richiesta di password non inserite niente e schiacciate invio, alla seconda richiesta invece (se ci sarà una seconda richiesta), mettete la vosta. Riavviate aMSN e provate ad inviare comodamente trascinandolo, un file. ;)

Leotard

Hund — Sun, 08 Jun 2008 21:03:26 +0000

Ladda ner @ dA

Inagurando sección: Temas de Escritorio

ZardoZ the TechnoMage — Sun, 08 Jun 2008 16:58:04 +0000

Podeis leerlo en el nuevo blog : http://zardoz-technomage.es/blog/webs/blogs/180/

Lkmonitor.org

bargarux — Sun, 08 Jun 2008 13:13:44 +0000

Linux Kernel Monitor ya tiene dominio propio desde hace unos días gracias a nuestro webmaster James Wheeler, a partir de ahora sólo será necesario teclear http://lkmonitor.org/ para acceder a la página del proyecto. Una gran ventaja sin duda, sobretodo a efectos memorísticos.

Criando uma simples janela com pygtk

medeubranco — Sat, 07 Jun 2008 22:39:49 +0000

É duro querer ou precisar fazer alguma coisa e não saber nem como começar; quando a gente não faz nem idéia de como a coisa pode ser feita.

Neste artigo nós vamos fazer uma simples janela vazia com pygtk para ultrapassar essa barreira do "não tenho nem idéia de como é".

Uma janela em gtk é criada instanciando a classe gtk.Window():
janela=gtk.Window()

A janela tem que ser exibida com o método Show():
janela.Show()

Vamos ver então um código exemplo. Salve o código abaixo com um nome sugestivo, algo como janela_gtk.py, e execute com python janela_gtk.py :

#!/usr/bin/env python

import pygtk import gtk

win=gtk.Window() win.set_title('Titulo da Janela')

win.set_size_request(400,400) win.connect("destroy",gtk.main_quit)

win.show() gtk.main()

As linhas
import pygtk import gtk
simplesmente importam os módulos para que seu programa python possa utilizar as classes gtk.

Nas linhas
win=gtk.Window() win.set_title('Titulo da Janela')
uma janela gtk é criada, e um título é atribuído a ela.

Em win.set_size_request(400,400) definimos o tamanho(altura, largura) da janela.

Agora vem uma coisa interessante. Na linha abaixo conectamos um determinado sinal a uma funçao:
win.connect("destroy",gtk.main_quit)
Sinais são coisas que você vai muito usar ao trabalhar com pygtk. Aqui o sinal "destroy" é conectado ao método main_quit do gtk. Grosso modo, significa que, quando você fechar a janela, o método será chamado e o loop (veja abaixo) que mantém o programa em funcionamento será encerrado.

A linha abaixo é um mistério:
win.show()
Dou um pirulito a quem descobrir para que serve.

Finalmente,
gtk.main()
chama o loop principal, que vai fazer o gtk ficar esperando por eventos (os sinais) que fazem a mágica de um programa com interface gráfica.

Instalasi Glib dari tarball

juztboy — Sat, 07 Jun 2008 15:48:25 +0000

Malam ini gw pengen nginstall Glib. Setelah download selama beberapa menit, dapet sudah Glib terbaru. Versi 2.17 yg notabene tidak ditujukan untuk pengguna secara umum. Hal ini dapat dilihat dari nomor versi minor ganjil. Dengan kata lain, ini merupakan versi unstable.

Dari beberapa pengalaman, versi unstable yg ada dapat berjalan dengan baik. Rata-rata yang sering mengalami error pada versi unstable adalah aplikasi end user. Sedangkan Glib ini bukan aplikasi, tetapi hanya kumpulan library untuk bahasa C.

Glib ini sering diperlukan saat menginstall beberapa aplikasi. Salah satunya adalah GTK yang merupakan engine GUI untuk aplikasi-aplikasi lain seperti pidgin, xmms, GIMP, dll.

Apa sih yang istimewa dari instalasi Glib ini?????

Sebenarnya seh gak ada yang istimewa, karena tahapan instalasi dari tarball secara umum dapat diterapkan pada instalasi Glib. Trus tahapan itu apa aja??? Bagi yang biasa menggunakan distro slackware dan turunannya pasti tau. Bagi pengguna distro lain, pasti juga tau bila sering melakukan instalasi aplikasi dari tarball. Tahapan-tahapan tersebut adalah:

1. ekstrak dengan perintah tar -xvf namafile.tar.gz
2. Masuk k direktori hasil ekstraksi dengan perintah cd namadirektori
3. konfigurasi dengan perintah .configure
4. compile dengan perintah make
5. instalasi dengan perintah make install

Kelima tahapan diatas dapat diterapkan pada hampir semua instalasi aplikasi melalui tarball.

Instalasi Glib pada Kubuntu 8.04 tidak mengalami masalah saat masuk tahapan pertama dan kedua. masalah baru dihadapi saat melakukan konfigurasi. Masalah disini adalah kurangnya library. Hal ini dapat diatasi dengan instalasi modul-modul berikut ini :

linux-libc-dev
libc6-dev
pkg-config
gettext

Instalasi modul tersebut dapat dilakukan dengan cara berikut ini:

$sudo apt-get install linux-libc-dev libc6-dev pkg-config gettext

Setelah instalasi modul yang kurang selesai, instalasi Glib dapat dilanjutkan. sampai tahap akhir tanpa masalah.

Good Luck ;)

Google Gadgets per Linux

Alessandro — Fri, 06 Jun 2008 11:18:43 +0000

Salve gente :D suppongo abbiate mai visto i gadgets per il desktop windows e per quello mac che offre la nostra amata home page Google.
Bene, da oggi sono finalmente disponibili i Gadgets per il nostro amato Linux! :D
Sono scritti in GTK+ e in QT, la versione GTK+ offre anche una barra laterale simile a quella di Google Desktop per Windows.

Un altro progetto che mi fa molta gola e che vorrei avere su linux è SketchUp, un ottimo "programma google" -disponibile solo per windows e mac- per la semplice ma allo stesso tempo professionale creazione di oggetti 3D.

Comunque altre informazioni e guide per l'installazione di questi gadgets sono disponibili sulla home page del progetto.