Há muito tempo atrás quando mal conhecia o que eram GUI’s, comecei a estudar algo chamado Tk, mas precisamente Tcl/Tk. Comecei a estudar esta linguagem quando vi que o aMSN era todo feito nela. Minha ambição era criar um aMSN ou melhora-lo (hehe), mas infelizmente faculdade rouba nosso tempo, tempo no qual poderia-mos está aprendendo sozinho, mas temos que tirar a nota X pra poder passar, etc. Mas o que raios esse papo tem haver com GTk? Acho que nada, foi só pra introduzir o artigo (hehe), mas espere! Tem sim haver, estamos falando de GUIS, e assim como Tk GTK é uma Biblioteca para criar aplicações gráficas. Ao contrário do que aconteceu com meus estudos em Tcl/Tk, com relação a GTK eu fui adiante e hoje estudo três linguagens diferentes que fazem uso desta mesma biblioteca, dai vem o título deste artigo e também o assunto do mesmo.

Neste artigo pretendo apresentar a todos a biblioteca GTK usada no gnome das distribuições linux. Também pretendo mostrar três linguagens que fazem uso desta biblioteca, e deixar que você escolha a mais poderosa, a mais fácil ou a que você sabe, para que você crie suas aplicações gráficas utilizando GTK.

Antes de falar dessas três linguagens vamos dá uma olhada no histórico da biblioteca GTK.

GTK quer dizer Gnome tool kit, e é usado inteiramente no gnome. Um dos aplicativos gráficos mais famosos do mundo open source, o gimp, possui sua parte gráfica toda feita em GTK. Além de ser fácil de aprender, esta biblioteca é muiltiplataforma, logo você vai poder criar aplicações unix ou win32. Mas como criar tais aplicações e quais as três linguagens que você disse que fazem uso da GTK? São elas PHP-GTK2, C e Python, isso claro sem citar tantas outras que também fazem uso da GTK.

Agora é a hora da verdade, vou mostrar três exemplos de codigos diferentes nestas três linguages e vocês escolhem em qual delas deseja começar a programar usando GTK.

Em C

#include <gtk/gtk.h>

static void destroy( GtkWidget *widget,
                     gpointer   data );

int main( int   argc,
          char *argv[] )
{
    GtkWidget *window ,*label;

    gtk_init (&argc, &argv);
    //Cria a janela e a ponhe no topo
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    //Da um tamanho a janela
    gtk_window_set_default_size(GTK_WINDOW (window),300,200);
    //Da um titulo a janela
    gtk_window_set_title(GTK_WINDOW (window),"Ola mundo");

    //Cria o label com a frase Ola mundo  !
    label = gtk_label_new("Ola Mundo  !");
    //Adiciona o label a janela
    gtk_container_add(GTK_CONTAINER (window), label);
    //Adiciona a funcao destroy para fechar a janela
    g_signal_connect (G_OBJECT (window), "destroy",
		      G_CALLBACK (destroy), NULL);

    //Diz pra mostrar todos os widgets da janela
    gtk_widget_show_all (window);
    //loop do gtk
    gtk_main ();

    return 0;
}
//Funcao pra quando clicar no x da janela ela fechar
static void destroy( GtkWidget *widget,
                     gpointer   data )
{
    gtk_main_quit ();
}

Achou em C complicado? Então que tal em PHP-Gtk2.

PHP-Gtk2

<?php

$wnd = new GtkWindow();
$wnd->set_title('Olá mundo');
$wnd->set_size_request(300,200);
$wnd->connect_simple('destroy', array('gtk', 'main_quit'));

$label_ola= new GtkLabel("Olá Mundo  !'");
$wnd->add($label_ola);

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

Se ainda assim você achou difícil ou não gostou de PHP-Gtk2, então tenta ai no python.

Python

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import pygtk
pygtk.require( '2.0' )
import gtk

def main():
	window = gtk.Window(gtk.WINDOW_TOPLEVEL)
	window.set_title( "Ola Mundo" )
	window.set_size_request(300,200)
	window.connect('destroy',gtk.main_quit)

	label = gtk.Label(' Ola Mundo  !' )
	window.add(label)

	window.show_all()

	gtk.main()

if __name__ == '__main__':
	main()

E ai está os três códigos fazem a mesma coisa, mostram uma janela com um label dizendo “ola mundo”. Agora se você não conhece nenhuma dessas linguagens ou não gosta delas há outras opções para você, eis a lista de linguagens que fazem uso da Gtk:

C++  	gtkmm
C# 	Gtk#
Java 	java-gnome
Python 	PyGTK
Perl 	gtk2-perl
R 	RGtk2
Guile 	guile-gnome
Ruby 	Ruby-GNOME2
PHP 	PHP-GTK
Ada 	GtkAda
OCaml 	LablGTK
Haskell Gtk2Hs
Lua 	lua-gtk
S-Lang 	SLgtk 	      

Viu quantas possibilidades você tem. Até aquela linguagem verborratica e chata que começa com J usa o Gtk. E além disso você pode usar o Glade que é uma ferramenta onde você pode construir sua interface gráfica sem digitar código, apenas fazendo uso do projeto que o Glade gera e utilizando um parser. Mas essa historia fica para uma próxima oportunidade. A quem desejar aprender mais sobre Gtk, dêem uma olhada nas referências ou se liguem aqui no Core Code que em breve vou criar um tutorial de C gtk, pygtk e claro php-gtk2 com o uso do glade e sem o uso do glade.

Referências

http://www.gtk.org/

http://library.gnome.org/devel/gtk-tutorial/stable/c24.html

www.php-gtk.com.br

gtk.php.net

www.kksou.com/

www.pygtk.org/

Há algum tempo venho estudando pygtk e pygame, e recentemente tive a idéia de migrar um jogo, feito por um colega, de C++ para pygame. Como o jogo original possui uma interface gráfica bonitinha, então pensei “tenho que fazer o mesmo com o python, mas como?” Pois até então nunca tinha trabalhado com pygtk e pygame juntos. Resolvi vasculhar na net algo sobre e encontrei uma solução ótima e simples (alias como tudo em python). A solução é criar um gtk.DrawingArea e dentro dele mapear uma superfície SDL, no nosso caso a tela do pygame (pygame.display()). Uma vez que você fez isso é só manipular o seu código pygame no seu display e pronto. Agora eu vou deixar de enrolar e mostrar e explicar o tal código.

CODE

# Proof of concept for PyGTK+Pygame
# Seo Sanghyeon

def callback(widget, *args):

handle = widget.window.xid
size = widget.size_request()
os.environ['SDL_WINDOWID'] = str(handle)
pygame.display.init()
pygame.display.set_mode(size)

widget.connect(‘map-event’, callback)

def fill_random(widget):

screen = pygame.display.get_surface()
r = random.randrange(255)
g = random.randrange(255)
b = random.randrange(255)
screen.fill((r, g, b))
pygame.display.flip()

def main():

win = gtk.Window()
win.connect(‘destroy’,gtk.main_quit)
box = gtk.VBox()
win.add(box)
custom = gtk.DrawingArea()
custom.set_size_request(300,200)
pygame_hack(custom)

box.pack_start(custom)
button = gtk.Button(‘Random fill‘)

button.connect(‘clicked‘,fill_random)

box.pack_start(button)

win.show_all()
gtk.main()

if __name__ == ‘__main__‘:

main()

De todo o código a parte mais importante é a função pygame_hack. É nessa parte do código que pegamos o ID da nossa DrawingArea e copiamos para ser o ID da nossa SDLWINDOW, e é isso que faz com que o display do pygame rode dentro dela.

Neste código abaixo pegamos o XID, ou código do X da nossa janela.

handle = widget.window.xid

Neste outro copiamos o XID da nossa DrawingArea pra dentdo da nossa SDLWINDOW.

os.environ['SDL_WINDOWID'] = str(handle)

Essa pequena applicação mostra uma janela pygtk com um botão que quando acionado preenche o display do pygame dentro do DrawingArea com uma cor que foi selecionada randomicamente. Ver imagem abaixo.

Viu tudo muito simples. Só tem um problema não roda no windows pois ele não consegue pegar o XID, ainda estou procurando um jeito de fazer isso no ruindows, mas no linux roda normal, então tá otimo. O legal desse exemplo é que ele mostra e dá ideias, além de você poder por um display do pygame, você pode por um display do opengl e fazer uma aplicação bem interessante. Afinal com python nem o céu é o limite =].

Como o intuito deste artigo é apenas explicar como por o pygame dentro da janela do gtk não vou explicar todo o código linha a linha, mas se alguém tiver alguma duvida sobre comenta ai que eu respondo.

]]> http://corecode.wordpress.com/2008/05/17/pygtk-pygame/feed/ 0 kirotawa