+2

Entenda o PHP-GTK

criado por Thiago Ribeiro em 09/12/2003 8:58pm
Este artigo trata-se dos princípios iniciais para a aprendizagem de php-gtk, são eles os:
* widgets;
* containers;
* signals;
* callbacks;

Bom, seguindo nesta forma creio que todos passarão a entender claramente do que se trata e como se constrói uma aplicação do tipo. Let's go!

Não sei se porque eu sou um usuário de Linux foi mais fácil de entender sobre o assunto mais acho que não há dificuldades para ninguém não.

Widgets:

Quando se referimos ao termo widget já estamos nos referindo diretamente a uma interface gráfica, ou seja, estamos tratando nada mais ou nada menos do que um programa gráfico, pode ter ele apenas um label, vbox, frame ou simplesmente uma janela vazia; uma GUI (Graphical User Interface) translate: (Interface Gráfica de Usuário). E essas GUIs tem um papel muito importante no desenvolvimento de softwares, pois são de fácil aplicação e nos trazem resultados rápidos e aplicados. Consequentemente temos os toolkits que são praticamente uma caixa de ferramentas para a aplicação das GUIs, e a que estou referindo neste artigo é a classe abstrata GtkWidget. Onde estão todas ferramentas de aplicação Gtk. Gtk na verdade é um software livre do Projeto GNU baseado em três bibliotecas: GLib, Pango e ATK.

Um Widget para melhor explicação passa por uma fase de 5 aplicações que devemos estar conscientes: criação, colocação (container), conexão de sinais (signals), exibição e por fim destruição.

Criação: a criação é uma etapa muito simples e bem clara se observarmos pois nos atribuímos a uma nova Widget, ou seja, como se estivéssemos chamando uma própria classe criada em um programa comum em php, abaixo segue-se uma um exemplo bem simples:

<?php
// Cria uma janela sem nenhum parâmetro e vazia
$janela = &new GtkWindow();  
                                                                                                                                                                         ?>

Colocação (container): a colocação é a fase de montagem da aplicação, ou seja, onde vão se encaixando um objeto ao outro, por ex:

<?php
// Cria uma janela sem nenhum parâmetro e vazia
$janela  = &new GtkWindow(); 
                                                                                                                                                                         
// Cria uma label contendo um texto
$texto = &new GtkLabel("Meu texto vai aqui"); 
                                                                                                                                                                         
// Adiciona o texto a janela
$janela->add($texto); 
                                                                                                                                                                         ?>

Devemos apenas tomar cuidado para não fazermos encaixes dos objetos errados e fazer de mau funcionamento do programa. Vou fazer uma demonstração de um mau exemplo de funcionamento, para usuários iniciantes isso é uma dúvida bem cruel. Segue-se então:

<?php
/* Exemplo incorreto de aplicação PHP-GTK */
                                                                                                                                                                         
// Cria uma janela sem nenhum parâmetro e vazia
$janela  = &new GtkWindow(); 
                                                                                                                                                                         

// Cria uma label contendo um texto
$texto1 = &new GtkLabel("Meu texto 1 vai aqui"); 
// Cria uma label contendo um texto
$texto2 = &new GtkLabel("Meu texto 2 vai aqui"); 

// Adiciona o texto 1 a janela
$janela->add($texto1); 
// Adiciona o texto 2 a janela
$janela->add($texto2); 
                                                                                                                                                                         
/* continuação do programa... */
                                                                                                                                                                         ?>

Rodando nossa aplicação acima teríamos um erro de inserção nula, que será exibida como na mensagem abaixo:

Gtk-CRITICAL **: file gtkbin.c: line 217 (gtk_bin_add): assertion `bin->child == NULL' failed.

Como podemos ver é um erro crítico, como se estivéssemos tentando colocar uma coisa em cima da outra, no mesmo endereço. Quando comecei a encarar o PHP-GTK imaginava que se fizesse isso as aplicações seriam inseridas uma embaixo da outra e me enganei caindo nesse problema, porém uma solução simples para isso seria usar uma ferramenta alternativa que está presente no artigo "Criando uma calculadora simples em php-gtk" e são eles o GtkVBox e GtkHBox, ou melhor os Containers (ver página 2). Segue abaixo o exemplo corrigido:

<?php
/* Exemplo correto */
                                                                                                                                                                         
// Cria uma janela sem nenhum parâmetro e vazia
$janela  = &new GtkWindow(); 
                                                                                                                                                                         
// Cria uma label contendo um texto
$texto1 = &new GtkLabel("Meu texto 1 vai aqui"); 
// Cria uma label contendo um texto
$texto2 = &new GtkLabel("Meu texto 2 vai aqui");
                                                                                                                                                                         
// Cria uma caixa horizontal de 2 colunas onde serão colocados os textos
$caixahorizontal = &new GtkHbox(false,2); 
                                                                                                                                                                         
$caixahorizontal->pack_start($texto1,false,false);
$caixahorizontal->pack_start($texto2,false,false);
                                                                                                                                                                         
$janela->add($caixahorizontal);
                                                                                                                                                                         
/* continuação do programa.... */
                                                                                                                                                                         ?>


Eu usei uma caixa horizontal como poderia ter usado uma vertical também, tanto faz, essa foi apenas uma aplicação para fazer melhor entendimento de como as coisas funcionam. Vou mostrar a sequencia de criação na árvore logo abaixo, mais para melhor entendimento o que vou fazer é criar 3 aplicações que serão inseridas na janela porém vou cascateá-las até que se forme apenas 1 e eu possa inserir na janela principal:

-> Janela
-> Caixa Horizontal (Ferramenta auxiliar, container)
-> Texto1
-> Texto2
-> Janela->Caixa Horizontal

Bom, acho que podemos passar para a etapa de conexão de sinais. :)))

Conexão de sinais (callbacks e signals): esta etapa é basicamente fazer a ligação de eventos com funções de nosso programa. É fazer com que existam ações no programa como por exemplo atribuir a um botão quando clicado exibir uma mensagem, etc.

Exemplo:

<?php
function sair() {
    echo "Saindo....";
    Gtk::main_quit();
}
                                                                                                                                                                         
$janela = &new GtkWindow();
$janela->connect('destroy','sair'); // Conecta o evento de destruição com a função sair
                                                                                                                                                                         
/* continuação do programa... */
                                                                                                                                                                         ?>

Executando a aplicação veremos que ao finalizarmos o programa ele escreverá Saindo... no prompt de comando. Bom você acabou de fazer uma conexão de sinais. Vou dar continuidade neste item porque também é sinonimo de muitas dúvidas.

<?php
$janela->connect('destroy','sair');
                                                                                                                                                                         ?>

Não devemos fazer muita encrenca no uso de conexão de sinais porém devemos conhecer bem os eventos e sinais, basicamente ao pé da letra estamos dizendo para ele: - Por favor conecte minha janela quando for destruída a função sair para que escreva Saindo... ao finalizar-se. Observem que não coloca-se "()" após a função sair, de é uma função que usamos argumentos ou variáveis devemos seguir como no exemplo abaixo:

function sair($msg)
        {
        echo $msg;
        Gtk::main_quit();
        }
                                                                                                                                                                         
   $janela = &new GtkWindow();
   $janela->connect('destroy','sair',"Aqui eu escreve a mensagem para sair...");
                                                                                                                                                                         
   /* continuação do programa... */

Rox. Fácil né?

Uma coisa onde também podemos nos enrolar é quando temos uma classe independente e queremos conectá-la com sinais. Primeiramente agiríamos de uma forma natural, usando-a como no php e faríamos assim:

 class main
        {
        function sair($msg)
                {
                echo $msg;
                Gtk::main_quit();
                }
        }
                                                                                                                                                                         
    $new = new main();
                                                                                                                                                                         
    $janela = &new GtkWindow();
    $janela->connect('destroy','new->sair');
                                                                                                                                                                         
    /* continuação do programa... */

Bom, olhando para o exemplo acima estaríamos cientes de que iria funcionar mais não é bem assim e receberíamos o seguinte erro ao executá-lo:

Warning: Unable to call signal callback 'new->sair' specified in file...

Não tenho nem o que o dizer, basta apenas traduzir e ver que este sinal não pode ser chamado pois não se encontra no arquivo. E você também pode ficar tentando encontrar várias alternativas tentando por exemplo colocar ('destroy',$new'->sair') ou outras alternativas, mais uma bem simples e funcional para que isso seja resolvido é, tchan tchan tchan:

 class main
             {
             var $msg;
             function sair()
                     {
                     echo $this->msg;
                     Gtk::main_quit();
                     }
             }
                                                                                                                                                                         
                                                                                                                                                                         
    $new = new main();
                                                                                                                                                                         
    $janela = &new GtkWindow();
    $janela->connect('destroy',array(&$new,'sair'),$new->msg="Saindo...");
                                                                                                                                                                         
    /* continuação do programa... */

Seguindo como no exemplo acima apenas criei um array para fazer isso. Aí alguém pergunta: - Por que do array? Mais se formos observar o array funciona da seguinte maneira: array teste("oi"=>"hi"); Bom coisa que estamos acostumados a ver em scripts PHP. Falta pouco agora. :))

Exibição: serve apenas para mostrar ou esconder seu widget.

Exemplo 1:
    $janela->show(); // mostra uma janela
                                                                                                                                                                            

Exemplo 2:
    $janela->show_all(); // mostra a janela e tudo que contem nela
    

Exemplo 3:
    $janela->hide(0; // Esconde uma janela
    


Destruição: é ocorrida quando a função Gtk::main_quit é invocada no programa.

Bom, depois desta cansativa parte falando sobre widgets podemos tomar uma cerveja e seguir para a parte de containers. Espero que tenham compreendido tudo, estou explicando o mais claro possível para que se acabem todas as dúvidas. :)))

Comentários:

Mostrando 1 - 9 de 9 comentários
Cara!! Pra o tempo em que isso foi escrito... Tô de boa com a linguagem!! Apesar do aparente desprezo de alguns, php-gtk representa uma potencia da programação de interface gráfica: Alguns dos benefícios são relativos ao custo de desenvolvimento!! E depois que baixei o phpblender... pense num negócio que facilita legal a vida da gente!!
12/10/2005 9:38am (~11 anos atrás)

luish disse:
Pow ontem eu instalei o PHP-GTK e rodeio os arquivos dele numa boa, porém hoje, fui rodar a calculadora em PHP-GTK e outros arquivos dele, não apareceu mais nada... o quê aconteceu?? alguem pode ajudar??
20/01/2004 4:42pm (~13 anos atrás)

galera... quando postei o artigo não tinha notado que estava faltando uma parte.. agora está aí... e respondendo ao marcondes sobre os executáveis acesse o site http://www.priadoblender.com para obter mais informações sobre o próprio...
10/12/2003 12:38pm (~13 anos atrás)

muito boa essa matéria, o GTK eh show msm.soh pra informar a PUC criou uma ferramenta chamada IUP q parece bastante com o GTK, ela explora as características nativas do sistema operacional, soh q por enquanto naum existe para PHP, soh pra C e uma tal de LUA, legal pra quem quer fazer softwares sem ter q "comprar" um delphi ou VB da vida...
10/12/2003 8:29am (~13 anos atrás)

Newton Wagner disse:
Bem, tentando responder a dúvida do marcodes, acho que não cara.. pelo que entendi do PHP-GTK, ele nada mais é que uma extensão do PHP, que é uma linguagem interpretada, e não compilada. Então é necessário instalar o PHP no cliente pra poder rodar aplicações do GTK.

Muito bom artigo mesmo, mas como o marcodes disse, seria ótimo se pudessemos gerar executáveis a partir disso. :).
10/12/2003 8:08am (~13 anos atrás)

Diogo Gomes disse:
Thiago, ótimo seu artigo e facilitou bastante pra quem quer entrar no mundo GTK, verdadeiramente está bem facilitado... Agora criarei coragem para desenvolver algo com o PHP-GTK, detesto começar a trabalhar em algo que eu não saiba, mesmo que por cima, os conceitos básicos... Foi assim com XML, com o próprio PHP e com o Linux.

Parabéns... Vamos entrar nos containers, hehehe
10/12/2003 5:24am (~13 anos atrás)

marco antonio disse:
Sou novo na área de programação e gostaria de saber se há possibilidade de fazer executáveis através dessa linguagem para facilitar a distribuíção de aplicativos feitos em PHP-GTK
09/12/2003 11:02pm (~13 anos atrás)

Bom, como em qualquer projetinho

algumas dicas sao interessantes..
no outro artigo do nosso amigo
haviam algumas funções function pra la function pra cá.. e o que notei num arquivinho GTK que recebi de um amigo esses dias (um editor de texto) ele colocou todas estas funcoes como se faz em php num outro arquivo e faz referencia a elas depois
nos arquivos que precisar.. fica bem mais organizado

Abraços!
09/12/2003 8:59pm (~13 anos atrás)

Sem comentários..
aliás..vai chover bons comentários aqui!

este exemplo do método connect ficou a coisa mais simples do mundo.. mas é isso que a pessoa precisa na hora de estudar, nada de coisas absurdamente complexas, se o que ela precisa entender é o simples..

é tipo estudar ER, quem já estudou o assunto sabe que não é um monstro como algumas parecem ser.

meus sinceros parabéns ficou simples, prático e objetivo o artigo.
09/12/2003 8:54pm (~13 anos atrás)

Novo Comentário:

(Você pode usar tags como <b>, <i> ou <code>. URLs serão convertidas para links automaticamente.)