Tutorial PHP-GTK2

Tutorial de PHP-GTK2

Introdução
Pré-requisitos
Instalando o PHP-GTK2

Instalando no Linux
Instalando no Windows

Conceitos básicos

Widgets e Sinais
Utilizando widgets no PHP-GTK2 para definir formulários
Capturando os sinais

Trabalhando com a interface gráfica (Glade)

Montando o formulário e definindo os sinais
Utilizando os arquivos glade no PHP-GTK2

Trabalhando com tabelas de formulário e banco de dados

Desenhando um formulário que contenha uma tabela
Carregando a tabela a partir de um banco de dados (sqlite)

Considerações finais e referências
Contato

1. Introdução

Este tutorial tem como objetivo dar informações básicas para aqueles que desejam se aventurar com essa ferramenta.

PHP-GTK2 é um conjunto de extensões do PHP que permitem a você criar aplicações Cliente-Servidor. É uma espécie de Visual Basic ou Delphi, só que utilizando a linguagem PHP e a interface gráfica do GTK2.

O GTK (Gimp Tool Kit) foi a princípio desenvolvido para o projeto Gimp e acabou se tornando amplamente utilizado no mundo dos softwares livres. O gerenciador de janelas GNOME, por exemplo, é baseado em GTK. Foram criados diversos "bindinds" para ela, e alguém (Andrei Zmievski) teve a feliz idéia de uní-la com o PHP.

Dentre as principais características do PHP-GTK2, podemos citar:

Portabilidade: Você pode escrever aplicações e executá-la em vários ambientes (Windows, Linux, Mac OS X) sem precisar alterar o código fonte;
Robustez: Você pode usar todo o poder do PHP para desenvolvimento de suas aplicações. O PHP é uma linguagem robusta, bem documentada e suportada. Contém diversas extensões para vários propósitos (Acesso a banco de dados, acesso a File System, impressoras, imagens gráficas, compressão de arquivos e muito mais);
Livre: O PHP-GTK2 é distribuído pela LGPLv2. Você pode baixá-lo gratuitamente no site http://gtk.php.net/.

2. Pré-Requisitos

Para compreender o tutorial, é interessante que você já tenha conhecimento básicos nos tópicos abaixo:

PHP;
Programação cliente-servidor / orientada a eventos;
SQL;

3. Instalando o PHP-GTK2

O PHP-GTK2 pode ser baixado no seguinte endereço: http://gtk.php.net/download.php

Você pode baixar os fontes ou os binários pré-compilados (esses últimos no Windows).

3.1. Instalando do Linux

A maioria das distribuições já vem com o PHP instalado por padrão. Certifique-se apenas de que ela seja no mínimo a versão 5.1 e que tenha suporte ao cli. Você pode conferir isso com o comando abaixo:

php -v

O que você precisa fazer após baixar o PHP-GTK2 (e compilá-lo, caso você tenha baixado os fontes) é adicionar a linha abaixo no seu php.ini
extension=php_gtk2.so

Dependendo da sua distribuição, o PHP-GTK2 estará disponível na ferramenta de download e instalação de pacotes (apt-get, yum, etc). A instalação por essa via é bem mais simples!

A execução das aplicações é feita da seguinte forma:

php nome_arquivo_principal

3.2. Instalando no Windows

No Windows, a instalação dos binários disponíveis no site do PHP-GTK2 (binary pack e binary extensions pack) são suficientes para executar aplicações básicas do PHP-GTK2. Para utilizar as demais extensões do PHP, você deve baixar o instalador do PHP do site oficial do PHP (http://php.net). Você pode seguir o procedimento abaixo (válido para o PHP-GTK2 versão 2.0.1):

Baixe o binary_pack e o extensions_pack do site php-gtk2:
Descompacte os arquivos baixados e coloque-os na pasta c:\php_gtk2 (no nome da pasta e o local ficam a seu critério, é apenas uma sugestão);
Baixe o PHP-5.2.6_non_thread_safe do site do PHP:
Durante a instalação, selecione as extensões de seu interesse, ou escolha todas. Para esse tutorial, é necessário que você tenha as extensões PDO para o Sqlite para poder utilizar os exemplos do item 6;
Ao fim da instalação, vá a pasta onde estão as extensões instaladas do php (por padrão, c:\Arquivos de Programas\php\ext) e copie-as para a pasta das extensões do php-gtk2 (c:\php-gtk2\ext):
Habilite as extensões no arquivo c:\php-gtk2\php-cli.ini. Para o tutorial, as extensões utilizadas as seguintes:

extension = php_pdo.dll

extension = php_pdo_sqlite.dll

Para evitar problemas com charset, altere o parâmetro php-gtk.codepage no arquivo c:\php-gtk2\php-cli.ini:

php-gtk.codepage = CP1252

A execução das aplicações é feita da seguinte forma:

php-win.exe nome_arquivo_principal

4. Conceitos Básicos

4.1. Widgets e Sinais

No mundo do PHP-GTK2 trabalhamos com widgets. Widgets são os elementos gráficos que fazem parte da nossa aplicação.
São exemplos de widgets botões, caixas de texto, formulários, barras de rolagem, entre outros.

figura 01: exemplos de widgets

Existem widgets que podem conter outros widgets. Estes são chamados Widgets Containers. Janelas são exemplos de Containers.
Há Widgets Containers que comportam apenas 1 Widget Filho (formulário, por exemplo) e outros que podem ter vários widgets filhos (Tabelas ou Boxes, por exemplo);

Cada widget possui propriedades que podem ser específicas (cor de texto e comprimento máximo de caracteres em um campo texto, por exemplo) ou comuns a vários widgets (largura e altura do widget).

Os widgets interagem com suas aplicações através de sinais. Eles permitem que você defina o que a sua aplicação irá fazer. Por exemplo, um botão quando clicado gera o sinal clicked. Você pode capturar esse sinal e dizer qual função do seu código será executado.

4.2. Utilizando widgets no PHP-GTK2 para definir formulários

Com base na explicação acima, iremos criar nosso primeiro código em PHP-GTK2. Para escrever seu código, você precisa utilizar um editor de texto puro (bloco de notas, kate, pspad, etc). Existem editores que destacam o código fonte PHP e são uma boa pedida. Eu utilizo o kate.

Para começar, iremos criar um formulário e exibi-lo. Utilizaremos um widget do tipo Window. Digite o código abaixo:

<?php

  $janela = new GtkWindow();

  $janela->set_default_size(320,240);

  $janela->set_title("Formulário PHP-GTK2");

  $janela->show();
  

   $janela->connect_simple('destroy', array('gtk',
'main_quit'));



   Gtk::main();

?>

Salve o código acima como teste.phpw. Em seguida, digite o seguinte comando abaixo para executá-lo:

php teste.phpw (Linux)
ou
php-win.exe teste.phpw (Windows)

será exibido o formulário parecido com o da figura abaixo:

figura 02: Formulário gerado

Vamos entender o código que escrevemos:

$janela = new GtkWindow();
Esse comando nos diz que estamos criando (instanciando) um objeto do tipo GtkWindow. A partir dai, toda interação feita com formulário é feita através da variável $janela.

$janela->set_default_size(320,240);
Com essa função estamos definindo o tamanho padrão do objeto formulário (largura x altura, em pixels)

$janela->set_title("Formulário PHP-GTK2");
Aqui estamos definindo o título do nosso formulário

$janela->show();
A função show torna visível o formulário.

$janela->connect_simple('destroy', array('gtk',
'main_quit'))

;
Aqui estamos capturando o sinal destroy. Esse sinal é lançado quando clicamos no botão fechar do nosso formulário (ícone X).
A função connect_simple nos permite definir qual função deve ser executada quando um sinal é disparado. Nesse caso, associamos a função main_quit da classe gtk. Poderiamos também associar a uma função do nosso próprio código.

Gtk::main();
Aqui é a função principal do programa. Seu papel é manter o programa ativo através de um loop sem fim. Se não colocarmos essa entrada em nosso programa, seriam executados os comandos anteriores e a aplicação terminaria.
Essa função só é interrompida em caso de erro ou quando é executada a função main_quit da classe Gtk .Isso explica porque conectamos o sinal destroy no comando anterior.

Um formulário sem botões, caixas de texto, tabelas e afins não fará muito coisa. Vamos alterar o nosso exemplo incluindo widget do tipo Label:

<?php

  $janela = new GtkWindow();

  $janela->set_default_size(320,240);

  $janela->set_title("Formulário PHP-GTK2 com
elementos");



  // Define um widget do tipo Label

  $Label1 = new GtkLabel("Teste
de formulário");



  // Adiciona o label ao formulário

$janela->add($Label1);



  $janela->show_all();
  

   $janela->connect_simple('destroy', array('gtk',
'main_quit'));



   Gtk::main();

?>

Agora nossa saída se parece com a da figura abaixo:

figura 03: Formulário com elementos

O que alteramos foi incluir um objeto do tipo GtkLabel e vinculá-lo ao nosso formulário com a função add. Perceba também que trocamos a função show pela show_all. Ela faz com que deixemos visível não só o formulário, mas também o label. Se mantivéssemos a função show, apenas o formulário seria exibido.

Um formulário é um Widget do tipo GtkBin, ou seja, pode conter apenas um objeto filho. Um formulário que tenha apenas um botão ou apenas uma caixa de texto não terá muita utilidade, não é mesmo? Como fazemos então para adicionar vários objetos ao nosso formulário?

Existem widgets que permitem que um formulário possa ter mais do que um widget filho, além de posicioná-los uniformemente. Se você conhece HTML, é como se eles fossem uma tag DIV ou uma tag TABLE.
São exemplos de elementos desse tipo:

GtkVBox: Definir divisões verticais no formulário;
GtkHBox: Define divisões horizontais no formulário;
GtkTable: Divide o formulário em células.

Vejamos na prática como isso funciona. Vamos alterar nosso último exemplo para que o fomulário tenha 3 elementos: Um rótulo (GtkLabel), uma caixa de texto (GtkEntry) e um botão (GtkButton). Para isso, utilizaremos um GtkVBox e um GtkHBox:

<?php

  $janela = new GtkWindow();

  $janela->set_default_size(320,240);

  $janela->set_title("Formulário PHP-GTK2 com
elementos");

  $Label = new GtkLabel("Nome");

  $Nome = new GtkEntry();

  $Botao = new GtkButton("_OK",true);



  // Definimos os Boxes horinzontais e verticais.

  // Os parâmetros "false" e "5" indicam que não queremos que
os elementos tenham o

  // mesmo tamanho e qual o espaço entre eles, respectivamente

  $VBox = new GtkVBox(false,5);

  $HBox = new GtkHBox(false,5);



  // Associamos o Label e o Nome ao HBox

$HBox->pack_start($Label);
$HBox->pack_end($Nome

);



  // Associamos o HBOX e o botão ao VBox

  $VBox->pack_start($HBox);

$VBox->pack_end($Botao);



  //Associamos o VBox ao formulário

$janela->add($VBox);



  $janela->show_all();
  

   $janela->connect_simple('destroy', array('gtk',
'main_quit'));



   Gtk::main();

?>

Agora nosso formulário ficou assim:

figura 04: Formulário com vários Widgets

Dividimos nosso formulário em duas linhas (com um GtkVBox) porque adicionamos dois elementos a ele (um GtkHBox e um GtkButton). O GtkHBox por sua vez foi dividido em duas partes por terem sido adicionados dois elementos (um GtkLabel e um GtkEntry).

Quem está acostumado com Visual Basic ou Delphi deve estranhar essa forma de posicionar elementos no formulário, pois não definimos coordenadas para os nossos objetos. No entanto, é possível no PHP-GTK2 fazer da mesma forma. Para isso, temos que utilizar um objeto do tipo GtkFixed. No item 5 entraremos com mais detalhes quando estivermos trabalhando com a interface gráfica.

4.3. Capturando os sinais

Veremos aqui como fazer nossa aplicação interagir com o ambiente através dos sinais.

Cada widget possui um conjundo de sinais que ele dispara em resposta a alguma ação executada pelo usuário ou o ambiente onde está sendo executado. Para capturarmos esses sinais, podemos utilizar a função connect_simple. Através dela, dizemos qual função deve ser executada quando um sinal for disparado.

No nosso último exemplo, definimos um formulário com um label, caixa de texto e um botão. Vamos alterá-lo de forma que quando clicarmos no botão OK seja exibido em uma caixa diálogo o conteúdo digitado na caixa de texto:

<?php

  $janela = new GtkWindow();

  $janela->set_default_size(320,240);

  $janela->set_title("Formulário PHP-GTK2 com
elementos");

  $Label = new GtkLabel("Nome");

  $Nome = new GtkEntry();

  $Botao = new GtkButton("_OK",true);



  $VBox = new GtkVBox(false,5);

  $HBox = new GtkHBox(false,5);

$HBox->pack_start($Label);
$HBox->pack_end($Nome

);



  $VBox->pack_start($HBox);

$VBox->pack_end($Botao);

$janela->add($VBox);



  // Associa o sinal clicked do botão a funcao fExibeTexto

  $Botao->connect_simple('clicked',

'fExibeTexto',$Nome

 );



  $janela->show_all();
  

   $janela->connect_simple('destroy', array('gtk',
'main_quit'));



  // Essa função irá exibir o que foi digitado no objeto do
tipo GtkEntry

 
function

fExibeTexto($campotexto)
{



    $texto =

$campotexto->get_text();

 $dialog = new GtkMessageDialog(null,
Gtk::DIALOG_MODAL,

    Gtk::MESSAGE_WARNING,
Gtk::BUTTONS_OK,


$texto

 );

 
  $dialog->run();

    $dialog->destroy();

}



   Gtk::main();



?>

Execute o código. Digite alguma coisa no campo texto e clique em OK. Sua obterá algo próximo a figura abaixo:

figura 05: Tratamento de sinais

Da maneira parecida como tinhamos feito com o sinal destroy, utiliamos a connect_simple para capturar o sinal clicked do elemento GtkButton:

$Botao->connect_simple('clicked','fExibeTexto',$Nome );

Indicamos que toda vez que esse sinal for disparado deve ser executada a função fExibeTexto. Como essa função recebe um parâmetro (referência do objeto GtkEntry), tivemos que incluir a variável $Nome no terceiro parâmetro da connect_simple. A connect_simple entende que a partir do terceiro parâmetro você está informando os valores que devem passados para a função relacionada.

A função fExibeTexto obtem o valor que foi digitado na caixa de texto referenciada por $Nome e armazena o conteúdo na variável $texto. Esta é usada na criação do objeto do tipo GtkMessageDialog, para que seja exibida pela caixa de diálogo.

5. Trabalhando com a interface gráfica (Glade)

Criar formulários como demonstrado no item anterior é possível mas não é muito produtivo. Dependendo da complexidade do layout, você perde mais tempo desenvolvendo o código para montar o formulário do que na lógica principal da aplicação em si!

Felizmente existem pessoas legais mundo a fora que desenvolveram uma ferramenta para facilitar nossas vidas: Existe uma aplicação chamada Glade para auxiliar nessa tarefa que, na minha opinião, é a parte mais chata de um projeto, porém importante.

O Glade é uma ferramenta WYSIWYG. Você pode desenhar um formulário sem muito esforço, selecionando e o objeto que se deseja adicionar ao formulário.

Seu formulário é salvo com a extensão .glade. Esse arquivo é formatado em xml e pode ser utilizado posteriormente na nossa aplicação. Veremos como utilizá-lo adiante.

O Glade pode ser baixado no endereço http://glade.gnome.org/download.html (o repositório da sua distribuição deve ter disponiblizado também - Sei que no repositório do projeto Fedora existe). Nesse endereço existem versões disponíveis apenas para Linux.

Se você for utilizar no Windows, existe um port que pode ser baixado do endereço http://gladewin32.sourceforge.net/.

Ao abrir o Glade, serão abertas as janelas abaixo:

Imagem Glade

figura 06: Imagem inicial do Glade

Untitled 1 - Glade: Mostra o nome do arquivo aberto e lista todos os widgets que compõem o formulário;
Properties: Permite alterar os atributos e associar funções aos sinais disponíveis do widget selecionado;
Palette: Contém os widgets disponíveis que podem ser adicionados ao projeto.

5.1. Montando o formulário e definindo os sinais

Vamos montar um formulário utilizando o Glade. Tratalharemos com coordenadas fixas, ou seja, diremos em que posiçao dentro do formulário ele deve ficar com precisão de pixels. Para isso, utilizaremos o objeto do tipo Fixed.

Apenas uma observação: Na documentação do PHP-GTK2, é aconselhado que você use o outro método de posicionamento de objetos (através do uso de tabelas, Boxes, etc). A vantagem é que você não precisa se preocupar com redimensionamento de objetos: O GTK2 cuida disso para você. Por outro lado, você tem mais trabalho para montar o formulário. Por não estar habituado com o método novo, optei por usar o Fixed.

Como exemplo, vamos montar uma calculadora rudimentar (para somas somente). Siga os passos abaixo:

Após abrir o Glade, clique no ícone Window da janela Palette: Um formulário será adicionado ao seu formulário.
Clique no ícone Fixed da janela Palette e clique dentro do formulário. Seu formulário ficará como o da figura abaixo:
figura 07: Formulário com GtkFixed
Na lista de widgets do formulário, selecione o objeto window1 e modifique suas propriedades:

Aba "General", propriedade "Name": Substitua por frmPrincipal;
Aba "Common", propriedade "Visible": Altere para Yes;
Aba "Common", propriedade "Width request": Substitua por 320;
Aba "Common", propriedade "Heigth request": Substitua por 240;

Insira 3 objetos do tipo Spin Button no formulário. Da mesma forma que foi feito para o formulário, altere a propriedade "Name" de cada um deles para txtValor1, txtValor2 e txtResultado, respectivamente.
Insira 3 objetos do tipo Label no formulário. Posicione-os na frente dos objetos Spin Button e altere suas propriedades "Label" para Valor1, Valor2 e Resultado, respectivamente.
Insira um objeto do tipo Button no formulário. Altere suas propriedades conforme abaixo:

Aba "General", propriedade "Name": Substitua por btnSomar;
Aba "General", propriedade "Label": Preencha com _Somar
Aba "General", propriedade "Use Underline": Altere para Yes. Nosso botão agora poderá ser acessado pela combinação de teclas ALT+S;
Aba "Signals", sinal "clicked": Abra o combo Box e selecione on_btnSomar_clicked. O Glade compõe um nome de função padrão com:

prefixo "on_" + nome do widget + "_" + nome do sinal

Salve o formulário com o nome de teste_glade.glade.

No fim desses passos, seu formulário deverá estar parecido com o da imagem abaixo:

Visão do formulário

figura 08: Layout do formulário da calculadora

Gravei um vídeo com a montagem desse formulário. Se você quiser pode visualiza-lo abaixo:

5.2. Utilizando os arquivos glade no PHP-GTK2

Utilizar o arquivo .glade gerado na nossa aplicação é simples. O código abaixo demonstra uma das maneiras de fazer isso:

<?php



  // Aqui criamos (instanciamos) um objeto com base nas
definições

  // do arquivo glade. A partir desse objeto, faremos
referência a todos os

  // objetos do formulário

  $glade = new GladeXML(dirname(__FILE__) .
'/teste_glade.glade');

 

  // Estamos obtendo os objetos do formulário ( campos texto,
o botão somar e o

  // o formulário em si ). 

  $frmPrincipal = $glade->get_widget('frmPrincipal');

   $btnSomar =
$glade->get_widget('

btnSomar');
$txtValor1 = $glade->get_widget('txtValor1

');

$txtValor2


= $glade->get_widget('

txtValor2

');

$txtResultado


= $glade->get_widget('

txtResultado');

// Conecta o sinal clicked do botão a função on_btnSomar_clicked

 
$btnSomar->connect_simple('clicked','

on_btnSomar_clicked',$txtValor1,$txtValor2,$txtResultado

);



  $frmPrincipal->connect_simple('destroy',
array('gtk',
'main_quit'));



  // O código da função é executado toda vez que o
botão

  // do formulário emitir o sinal clicked. Faremos a soma dos
valores

  // digitados e imprimiremos no campo resultado

  function on_btnSomar_clicked(

$txtValor1,$txtValor2,$txtResultado

)

  {

    $txtResultado->set_value(


$txtValor1->get_value() +

$txtValor2->get_value()

);

  }



  Gtk::main();

?>

Desconsiderando as linhas de comentário e as tags do php, nosso programa tem apenas 13 linhas de código.
Se não utilizássemos o glade, com certeza ficaria bem maior. Além disso daria muito mais trabalho ajustar o layout.

Abaixo segue uma outra forma de fazer, só que utilizando orientação a objetos. É a forma que adotei por padrão para meus pequenos projetos. Fique a vontade para escolher a forma de programação que lhe deixe mais seguro.

<?php



  class FormCalculadora

  {

    // A função conectada ao
sinal clicked do botão de soma agora

    // acessa os atributos da classe (os objetos do
formulário)

    // ao invés de recebê-los como parâmetro

    function on_btnSomar_clicked(

)

    {

     
$this->txtResultado->set_value(


$this->txtValor1->get_value() +

$this->txtValor2->get_value()

);

    }

    // Instanciamos todos os objetos do
formulário que precisaremos utilizar no construtor

    // (sugestão apenas)

    function __construct()

    {

$this->glade
= new GladeXML(dirname(__FILE__) . '/teste_glade.glade');

$this->

frmPrincipal
= $

this->

glade->get_widget('frmPrincipal');

$this->

btnSomar
= $

this->glade->get_widget('btnSomar');
$this->

txtValor1
= $

this->glade->get_widget('txtValor1

');

$this->txtValor2

= $

this->glade->get_widget('txtValor2

');

$this->txtResultado

= $

this->glade->get_widget('txtResultado');

$this->frmPrincipal->connect_simple('destroy', array('gtk',
'main_quit'));

    }

  }



  // Instanciamos um objeto com base na classe acima

  $objCalculadora = new

FormCalculadora();



  // Aqui apresentamos uma nova forma de conectar sinais
atraves da função

  // signal_autoconnect_instance. Com ela, conectamos de uma
só vez todos os

  // sinais que selecionamos no glade a suas respectivas
funções dentro da classe

$objCalculadora->glade->signal_autoconnect_instance($objCalculadora);



  Gtk::main();

?>

6. Trabalhando com tabelas de formulário e banco de dados

Darei uma breve introdução sobre como inserir tabelas de formulário em nosso formulário e como carrega-las com dados a partir de um banco de dados.

Uma tabela de formulário é de grande utilidade em um sistema. Ela apresenta uma lista de elementos separados por colunas que facilitam a navegação do usuário.
No PHP-GTK2, essas tabelas são representadas pela classe GtkTreeView. Além de permitir exibir dados de forma tabular (linhas x colunas) ela também permite que você expanda os dados em forma de árvore. Vide um exemplo desses formulários (imagem da aplicação de demos do Gtk2):

Fromulário com GtkTreeView

figura 09: GtkTreeView

6.1. Desenhando um formulário que contenha uma tabela

Vamos criar um formulário e inserir uma tabela (GtkTreeView) nele. Vamos utilizar o Glade. Siga os passos abaixo:

Insira um Window e altere as propriedades abaixo:

Aba "General", propriedade "Name": Substitua por frmTesteTabela;
Aba "Common", propriedade "Visible": Altere para Yes;

Insira um Fixed no formulário;
Insira um Scrolled Window no formulário e ajuste para que ocupe boa parte do formulário. Esse objeto permitirá a exibição de barras de rolagem na nossa tabela;
Adicione um TreeView dentro da Scrolled Window e altere a propriedade "Name" para "Tabela01"
Salve o formulário como teste_gtktreeview.glade

A saída deve ser parecida com a abaixo:

Imagem do exemplo do GtkTreeView

figura 10: Formulário com a tabela

6.2. Carregando a tabela a partir de um banco de dados (sqlite3)

Aqui mostrarei como exibir dados na tabela definida acima lendo um banco de dados sqlite3.

Faremos o acesso ao sqlite através de PDO (PHP Data Objects, uma espécie de ODBC nativo do PHP). Algumas extensões devem estar habilitadas no arquivo de configuração do PHP (vide item 3).

Vamos criar uma pequena tabela de banco de dados e vamos carregá-la com algumas informações. Para isso, vamos utilizar o código abaixo:

<?php



  // Fazemos conexão com o banco de dados. Caso o arquivo não
exista, ele é criado

  // automaticamente

  $dbSqlite = new PDO('sqlite:teste_banco.db');



  // Verificamos se não houve nenhum problema na conexão

  if (!$dbSqlite)

  {

    echo("Erro ao abrir o base sqlite\n");

    return false;

  }



  // Vamos criar uma tabela no nosso banco (agenda)

  $dbSqlite->exec("create table agenda (nome varchar,
telefone varchar)");



  // Agora vamos carregá-la com alguns dados

$dbSqlite->exec("insert
into agenda values ('Toby Temple', '(11) 1111-2222')")

;

$dbSqlite->exec("insert
into agenda values ('Mary Ashley', '(33) 4444-5555')")

;

     
$dbSqlite->exec("insert into agenda values ('Tracy Whitney',
'(33) 6666-5555')")

;

  $dbSqlite->exec("insert into agenda
values ('Jill Castle', '(33) 6666-5555')")

;

  $dbSqlite->exec("insert into agenda
values ('Noelle Page', '(33) 6666-5555')")

;

?>

Vamos agora escrever o código para carregar nosso Tree View com dados. Definiremos 2 colunas para ela e listaremos os dados contidos na tabela agenda.

<?php



  class FormTesteTreeView

  {

function

defineColunasTabela()

    {

      

      // Aqui definimos um model. é o objeto
através do qual exibiremos dados na

      // Nossa tabela

      $this->modelTabela = new
GtkListStore(GObject::TYPE_STRING,GObject::TYPE_STRING);

this->Tabela01->set_model($this->modelTabela);



      // Declaramos alguns renderers. Eles
são necessários para definir

      // as propriedades de nossas colunas
(tipo de texto, largura da coluna, etc)

      $rend_nome = new GtkCellRendererText();

     
$rend_telefone = new GtkCellRendererText();

// Vamos definir a largura de nossas colunas
$rend_nome->set_property('width', 300);
$rend_telefone->set_property('width', 50);

// Declaramos as colunas e associamos
// aos respectivos renderers
$col_nome = new GtkTreeViewColumn('Nome', $rend_nome, 'text', 0);
$col_telefone = new GtkTreeViewColumn('Telefone', $rend_telefone, 'text', 1);

// Por fim, adicionamos as colunas a tabela

this->Tabela01->append_column($col_nome);

this->Tabela01->append_column($col_telefone);

    

    function carregaDadosTabela()

    {

      // Conectamos
ao banco criado previamente

      $dbSqlite = new
PDO('sqlite:teste_banco.db');



      // Definimos o comando que será
executado

      $Sql = "select nome, telefone from
agenda";



      // Executamos o comando

$results = $dbSqlite->query($Sql);



      // Percorremos todas as linhas
retornadas no select e atribuimos

      // à variável $row. Essa variável é um
array indexado pelo nome

      // das colunas selecionadas no select

      while ($row =
$results->fetch(PDO::FETCH_ASSOC)) {

        // Adicionamos a linha no
model associado a tabela

       
$this->modelTabela->append($row);

      }



    }

    function __construct()

    {

$this->glade
= new GladeXML(dirname(__FILE__) . '/teste_gtktreeview.glade');

$this->

frmTesteTabela
= $

this->

glade->get_widget('frmTesteTabela');

this->Tabela01

= $

this->glade->get_widget('Tabela01');

$this->frmTesteTabela

->connect_simple('destroy',
array('gtk',
'main_quit'));



      // Aqui chamaremos o método que irá
definir que colunas nossa tabela possui e seus atributos

      $this->defineColunasTabela();



      // O método abaixo irá ler o sqlite e
carregar os dados no nosso GtkTreeView

      $this->carregaDadosTabela();

    }

  }



  $objFormTesteTreeView = new

FormTesteTreeView

();

$objFormTesteTreeView->glade->signal_autoconnect_instance($objFormTesteTreeView);





  Gtk::main();

?>

Definimos as colunas que a nossa tabela deverá conter na função defineColunasTabela. Nela definimos um model para a tabela (objeto que usamos para comunicar com a tabela), alguns renderers (para definir os atributos das colunas) e associamos a nossa tabela.

Na função carregaDadosTabela executamos uma consulta na tabela agenda, e as linhas retornadas foram adicionadas ao model da tabela.

O resultado é visto na imagem abaixo:

Saída do exemplo com o GtkTreeView

figura 11: A saída do nosso exemplo

7. Considerações finais e referências

Espero que com esse tutorial você tenha informações básicas para ir adiante por conta própria.
Talvez alguns pontos possam não ter ficado muito claros, mas com pesquisa a outras fontes e dedicação e você pode ir além.

Há alguns endereços que foram base para esse tutorial e que contém informações e exemplos de aplicações desenvolvidadas em PHP-GTK2.

Site oficial do PHP-GTK ( http://gtk.php.net ): Contém tutoriais, exemplos e uma lista da biblioteca, descrevendo objetos e suas propriedades e métodos;
Site brasileiro do PHP-GTK ( http://www.php-gtk.com.br/ ): Contém manual do PHP-GTK, artigos, aplicativos para download e outros.

Desenvolvi também uma pequena aplicação voltada a controle de vendas e estoque. Pode servir como fonte de estudos. Segue o endereço:
http://sourceforge.net/projects/lwinstok/

8. Contato

Deixo meu e-mail pessoal para contato. Caso você tenha encontrado alguma inconsistência nesse tutorial ou tenha alguma dúvida entre em contato:

pstglia at gmail dot com