Phpgtk Mostra

Pablo Dall'Oglio

Novatec

3ª Edição

Criando Aplicações Gráficas com PHP

18

CAPÍTULO 1

Introdução

Quando você tem uma meta, o que era um obstáculopassa a ser uma das etapas do seu plano.

(Gerhard Erich Boehme)

Neste capítulo de introdução, conheceremos as raízes do PHP e do GTK, sua históriae como surgiu o PHP-GTK, assunto principal deste livro.

1.1 O que é o PHP?A linguagem de programação PHP foi criada no outono de 1994 por Rasmus Lerdorf.No início, era formada por um conjunto de scripts voltados à criação de páginas di-nâmicas que Rasmus utilizava para monitorar o acesso ao seu currículo na Internet.À medida que essa ferramenta foi crescendo em funcionalidades, Rasmus teve de escrever uma implementação em C, a qual permitia que as pessoas desenvolvessem,de forma muito simples, suas aplicações para a Web. Chamou essa versão de PHP/FI (Personal Home Pages/Forms Interpreter) e decidiu disponibilizar seu código naWeb em 1995 a fim de compartilhar com outras pessoas, bem como receber ajuda e correção de bugs. A figura 1.1 mostra o logotipo do PHP.

Figura 1.1 – Logo do PHP.

Em novembro de 1997 foi lançada a segunda versão do PHP. Naquele momento,aproximadamente 50 mil domínios ou 1% da Internet já utilizava PHP. No mes-mo ano, Andi Gutmans e Zeev Suraski, dois estudantes que usavam PHP em um projeto acadêmico de comércio eletrônico, resolveram cooperar com Rasmus para

19Capítulo 1 ▪ Introdução

aprimorar o PHP. Para tanto, reescreverem todo o código, com base no PHP/FI 2.Assim nasceu o PHP3, disponibilizado oficialmente em junho de 1998. Dentre as principais características do PHP3 estavam a extensibilidade, a possibilidade de conexão com vários bancos de dados, novos protocolos, uma sintaxe mais consis-tente, suporte à orientação a objetos e uma nova API, que possibilitava a criação de novos módulos e acabou por atrair vários desenvolvedores ao PHP. No final de 1998, o PHP já estava presente em cerca de 10% dos domínios da Internet. Naquela época, o significado da sigla PHP mudou para PHP: Hypertext Preprocessor, a fim de retratar a nova realidade de uma linguagem com propósitos mais amplos.

No inverno de 1998, após o lançamento do PHP 3, Zeev e Andi começaram a trabalhar em uma reescrita do núcleo do PHP, tendo em vista melhorar sua perfor-mance e modularidade em aplicações complexas. Para tal, resolveram chamar esse núcleo de Zend Engine, ou Mecanismo Zend (Zeev + Andi). O PHP4, com base nessemecanismo, foi lançado oficialmente em maio de 2000, trazendo muitas melhorias e recursos novos, como seções, suporte a diversos servidores Web, além da abstraçãode sua API, permitindo inclusive que fosse utilizado como linguagem para shell script. Nesse momento, o PHP já estava presente em cerca de 20% dos domínios da Internet, além de ser usado por milhares de desenvolvedores no mundo inteiro.

Apesar de todos os esforços, o PHP ainda necessitava de maior suporte à orienta-ção a objetos, tal qual existe em linguagens como C++ e Java. Esses recursos foram trazidos pelo PHP 5, após um longo período de desenvolvimento que culminou comsua disponibilização oficial em julho de 2004. Atualmente, na versão 6, o PHP se consolida como uma das linguagens de programação que mais crescem no mundo.

Fonte: PHP Group.

1.2 O que é GTK?O GTK é um conjunto de bibliotecas, desenvolvido originalmente por Peter Mattis,Spencer Kimball e Josh MacDonald, cujo propósito é servir ao desenvolvedor comobase para criar aplicações gráficas.

O GTK (GIMP ToolKit) foi originalmente desenvolvido para o GIMP (GNU Image Manipulation Program), o software de artes gráficas mais conhecido para Linux.Ele tem crescido muito desde o início do projeto e hoje é utilizado como partecentral do Gnome, uma das interfaces gráficas e plataformas de desenvolvimento mais usadas para Linux. O GTK+ também tem sido portado para o BeOS e Win32,fazendo da linguagem a escolha perfeita para o desenvolvimento de aplicaçõesgráficas livres ou comerciais, uma vez que é licenciado sob a GPL (General Public License). Na figura 1.2, você confere o logotipo do GTK.

20 PHP-GTK ▪ Criando Aplicações Gráficas com PHP

Figura 1.2 – Logo do GTK.

O GTK é um conjunto de ferramentas composto de várias partes:

• glib (G Library) – Esta biblioteca contém algumas rotinas de programação em C, provê a estrutura básica de programação, define alguns tipos de dados que são usados pelas camadas superiores.

• gdk (GTK Drawing Kit) – Encapsula o Sistema de Janelas (X ou Windows) sob o GTK. Contém as rotinas para desenho da interface e para responder aos eventos do mouse ou do teclado.

• gtk (Gimp Toolkit) – Contém a biblioteca de componentes, que consiste em uma série de controles, como caixas de edição, listas e botões, dentre outros,organizados em uma estrutura orientada a objetos.

• pango – Biblioteca responsável pelo layout e renderização de texto (caracteresde múltiplos idiomas). Forma o núcleo de manipulação de textos e fontes no GTK2. Utiliza o padrão Unicode e suporta a maioria dos idiomas.

1.3 O que é o PHP-GTK?O PHP-GTK foi criado em março de 2001 por Andrei Zmievski, natural do Usbequis-tão, que atualmente trabalha nos Estados Unidos. Assim como muitos projetos emsoftware livre, este também começou com uma motivação um tanto peculiar: “Fizporque queria ver se era possível”, disse o autor, que se inspirou muito em um pro-jeto já existente, o PyGTK (ligação entre as linguagens entre Python e GTK). AndreiZmievski esteve no Brasil em 2002, durante o III Fórum Internacional de SoftwareLivre, onde fez algumas apresentações, sempre com a presença de grande público.

O PHP-GTK é uma language binding, ou seja, é uma ligação entre duasferramentas já existentes, a linguagem PHP e a biblioteca GTK. Logo, o PHP-GTK é o próprio PHP, com mais recursos, ou seja, com a possibilidade de utilizar a biblioteca GTK para a construção de um ambiente gráfico com janelas. Portanto, o livro abordará primeiro a linguagem de programação PHP para, depois, apresentar exemplos de utilização do PHP com o GTK. O PHP-GTK é a primeira extensão da linguagem PHP que permite escrever aplicações client-side com GUI (Graphical

21Capítulo 1 ▪ Introdução

User Interface). Foi escrita, em parte, para provar que o PHP é uma linguagemcompleta e de propósitos amplos. O casamento do PHP com o GTK é harmonioso,pois ambos são independentes de plataforma. No PHP-GTK temos uma ferramentade desenvolvimento que permite aos desenvolvedores rodarem o mesmo código emambientes Linux,Windows e Mac. Na figura 1.3, você confere o logotipo do PHP-GTK.

Figura 1.3 – Logo do PHP-GTK.

A primeira versão do PHP-GTK, que vigorou de 2001 a 2005, era baseada no PHP4 em conjunto com a biblioteca GTK1.2, justamente a versão coberta pela pri-meira edição deste livro. Logo que as primeiras versões beta do PHP5 começaram a ser lançadas, Andrei iniciou o trabalho de reescrever o PHP-GTK para aproveitar todos os novos recursos relacionados à orientação a objetos que foram surgindo,bem como passar a adotar a biblioteca GTK2, que já estava consolidada e com grande adoção. Assim surge o PHP-GTK2, que é a união da linguagem PHP5 com a biblioteca GTK2, possibilitando o desenvolvimento de aplicações gráficas com-plexas e de grande apelo visual, proporcionadas pelo GTK2, e, ao mesmo tempo, o uso dos avançados recursos de orientação a objetos e conexão a bancos de dados,proporcionados pela linguagem PHP5.

Utilizando PHP-GTK, você poderá criar uma aplicação que possui conectivi-dade com o servidor (banco de dados e acesso a arquivos), como todos os demais programas escritos em PHP. Mas, pelo fato de rodar a aplicação na máquina-cliente,também tem total acesso aos recursos desta, por exemplo, executar aplicações, es-crever arquivos e acessar dispositivos periféricos. Para tal, o PHP-GTK precisa ser instalado em cada máquina-cliente que executará uma aplicação.

Veja na figura 1.4 um gráfico que ilustra bem tudo o que foi descrito até aqui.A linguagem PHP é parte central do desenvolvimento. Todo o código é escrito em PHP, que é a linguagem-mãe. Como resultado visível da aplicação ao usuário final,existem duas possíveis saídas: página HTML, utilizando o PHP da forma tradicional,ou Interface Gráfica, com um ambiente de botões e janelas empregando o GTK.

O PHP é uma linguagem de programação modularizada, composta por um núcleo e cercada por inúmeras extensões da linguagem. Existem extensões para geração de imagens (GD), documentos PDF (FPDF), acesso a servidores Web via Web-Services e FTP, compactação de arquivos (zlib), entre outras. O PHP-GTK surgenesse contexto com a extensão de maior tamanho e complexidade, provendo um


framework completo para a construção de aplicações gráficas para projetos escritosem PHP. Veja na figura 1.5 alguns exemplos de extensões do PHP.

PHP

HTML

GTK

BD

Figura 1.4 – Plataforma de desenvolvimento.

Figura 1.5 – Arquitetura do PHP.

1.4 Instalação em LinuxPara instalar o PHP-GTK, devemos primeiramente instalar o PHP e depois o PHP--GTK.Veja a seguir como fazer isso.Você pode compilar o PHP e o PHP-GTK a partirdas suas fontes ou instalar a versão pré-compilada, simplesmente descompactando-a.

1.4.1 Compilação

Para compilar o PHP-GTK no Linux é necessário ter instaladas as ferramentas GNU(make, libtool, autoconf, automake, gcc etc). Também é necessário ter as versões completas do Gtk (libgtk-2.0, libgtk2.0-dev) e Glib (libglib2.0, libglib2.0-dev). Se você quiser também o suporte ao Glade, é necessário ter instaladas as bibliotecas libglade2, libglade2-dev, libxml2 e libxml2-dev.

• Instale o PHP 5.2.x ou superior. Os parâmetros a seguir são somente uma su-gestão:

25

CAPÍTULO 2

Introdução ao PHP

Você não pode ensinar nada a um homem; você pode apenas ajudá-lo a encontrar a resposta dentro dele mesmo.

(Galileu Galilei)

Este capítulo realiza uma introdução sobre as diversas funções, comandos e estru-turas de controle básicos da linguagem PHP, que são possivelmente utilizados ao longo do livro. Conheceremos as estruturas básicas da linguagem, suas variáveis e seus operadores e também um conjunto de funções para manipulação de arquivos,de arrays, de bancos de dados, dentre outros.

2.1 Um programa PHPNesta seção, serão abordadas as características básicas de um programa PHP.

2.1.1 Extensão de arquivos

A seguir, estão listadas as extensões mais utilizadas para programas em PHP.

Extensão Significado

.php Arquivo PHP contendo um programa PHP.

.class.php Arquivo PHP contendo uma classe PHP.

.inc.php Arquivo PHP a ser incluído, podendo conter constantes ou configurações.

2.1.2 Delimitadores de código

O código de um programa escrito em PHP deve estar contido entre os seguintes delimitadores:

<?php// código;// código;// código;?>

65

CAPÍTULO 3

Objetos e bancos de dados

Nenhuma mente que se abre para uma nova ideia voltará a ter o tamanho original.

(Albert Einstein)

Este capítulo abordará a orientação a objetos por meio de exemplos que incluam conceitos básicos como a visibilidade, a herança, entre outros tópicos importantes para a continuidade da leitura do livro.Além da orientação a objetos, este capítulo examinará também o tratamento de exceções e o acesso a bancos de dados de maneira estruturada e também orientada a objetos, utilizando a biblioteca PDO.

3.1 Orientação a objetosA orientação a objetos é um paradigma de programação que representa uma fi-losofia para a construção de sistemas. No lugar de modelar estruturas de dados e construir um sistema formado por um conjunto de procedimentos, como se fazia em linguagens estruturadas (Cobol, C, Clipper, Pascal), na orientação a objetos modelamos e construímos o sistema utilizando objetos, que são entidades que têm atributos, comportamento, relacionamentos e que representam uma visão de sistema mais próxima do mundo real.

A orientação a objetos é tratada com maior profundidade no livro PHP Progra-mando com Orientação a Objetos, do mesmo autor, Novatec Editora.

3.1.1 Introdução

Ao trabalharmos com a orientação a objetos, é fundamental entender o conceito de classes e objetos. Uma classe é uma estrutura estática que define um tipo de dados. Uma classe pode conter atributos (variáveis) e também funções (métodos) para manipular esses atributos. Neste exemplo, declaramos a classe Produto com quatro atributos. Os atributos são “variáveis” que existem dentro do contexto de

100

CAPÍTULO 4

Introdução ao PHP-GTK

Nunca encontrei uma pessoa tão ignorante que nãopudesse ter aprendido algo com sua ignorância.

(Galileu Galilei)

Para escrever aplicações gráficas é necessário entender alguns termos que sãobastante utilizados, como widgets, contêineres, signals e callbacks, explicados ao longo deste capítulo. Antes de tudo, um pouco da história das interfaces gráficas.

4.1 Interfaces gráficasTodos manipulam interfaces gráficas, ou simplesmente GUI (Graphical User In-terface), ao utilizar o computador. Estamos frequentemente clicando em botões,arrastando o mouse, fechando janelas, selecionando os elementos de uma lista,abrindo menus flutuantes, arrastando barras de ferramentas e de rolagem. O que seria de nós sem todos esses elementos gráficos? Provavelmente o computador não estaria ao alcance de todos. Teríamos em frente uma tela preta com um cursor piscando, aguardando que digitássemos algum comando para que o computador interpretasse e executasse uma ação, como era no princípio, com o Apple 1, Unix,MS-DOS etc. Alguns profissionais da informática com mais tempo de experiência sabem do que estou falando. Naquela época a informática não era tão integrada à nossa realidade como é hoje.

Os primórdios do conceito de Interfaces Gráficas remontam a 1945, quando um cientista visionário chamado Vannevar Bush publicou um artigo que, mais tarde,em 1962, inspiraria outro cientista, Douglas Engelbart, a criar o primeiro mouse,um tanto rudimentar, mas fascinante. Na época, ainda não se considerava a ideia de utilizar o mouse fora do laboratório, mas já se pensava em futuros usos para tal ferramenta dentro de um ambiente de janelas. Em 1963, o estudante Ivan Sutherlandescreveu uma tese com muitos dos fundamentos necessários para a construção de

101Capítulo 4 ▪ Introdução ao PHP-GTK

uma GUI. Toda a ideia baseia-se na psicologia. O cérebro humano interpreta com mais facilidade ícones do que palavras.

Na década de 1970, Alan Kay e outros desenvolvedores criaram o Smaltalk, lin-guagem flexível que permitiu, posteriormente, a criação de uma GUI muito similar à que conhecemos hoje. A primeira interface gráfica (GUI), realmente utilizável,surgiu no Centro de Pesquisa da Xerox em Palo Alto (Xerox Palo Alto Research Center - PARC), em 1974, onde foi desenvolvido o Alto, que permitia criar aplicaçõesgráficas e introduziu os primeiros ícones, mas era grande demais para ser comer-cializado. Mais tarde, em 1981, a Xerox desenvolveria o Xerox Star, uma máquina aperfeiçoada, que provia janelas redimensionáveis, menus e um mouse sofisticado.

Após uma visita aos laboratórios da Xerox em 1979 (devido a um acordo de co-operação), Steve Jobs e seus colegas da Apple Computer começaram a desenvolver um sistema com interface gráfica com base nas mesmas ideias, o Apple Lisa, que foi comercializado em 1983, com várias novidades, como a capacidade de clique e arraste e o menu pop-up. Grande parte dos pesquisadores da Xerox foi contratada pela Apple, que evoluiu muito na área gráfica, culminando na plataforma Macintosh(Figura 4.1), em 1983. De 1981 a 1984 a Apple transferiu muitos de seus conhecimentosa técnicos da Microsoft para que estes desenvolvessem aplicações para a plataformaMac. A Microsoft, por sua vez, passou a desenvolver sua própria interface gráfica,culminando no Windows 1.0, em 1985. Outras interfaces gráficas surgiram naquela época, como o Amiga e o X-Window, a interface gráfica para Unix desenvolvida pelo MIT (Massachusetts Institute of Technology).

Figura 4.1 – Interface gráfica de um Mac.


4.2 Conceitos básicos

4.2.1 Widget

Widget é um termo muito utilizado no mundo das interfaces gráficas. Origina-se do inglês “Windows Gadgets”. O termo gadget é muito abrangente e pode significardispositivo, apetrecho, ferramenta ou utilitário. Dentro do contexto de janelas, um widget pode ser uma caixa de texto, um label, um frame, um painel, uma janela ou qualquer outro componente presente na interface gráfica (GUI), como mostra a figura 4.2.

Uma ótima forma de aprender orientação a objetos em PHP é exatamente utili-zando o PHP-GTK, pois todos os componentes (widgets) do GTK são classes para o PHP. Então, para se utilizar o PHP-GTK, é essencial o aprendizado dos conceitos de orientação a objetos. Todos os widgets do GTK são derivados de uma classe chamada GtkWidget, bem como seus métodos e propriedades.Assim, para se construiruma janela com alguns botões, por exemplo, é necessário que se conheçam quais classes utilizar e quais são os métodos disponibilizados por essas classes.

Figura 4.2 – Widgets diversos.

4.2.2 Contêineres

Um contêiner é um widget que está apto a conter outro widget em seu interior.A maioria dos widgets, como GtkWindow, GtkTable e GtkBox, são também contêineres.Suas propriedades são exatamente as mesmas que as de qualquer outro widget. Os contêineres também podem ser adicionados a outros contêineres. Eles, na verdade,são classes criadas pelo mecanismo de herança a partir de uma classe chamada GtkContainer, que, por sua vez, é derivada da classe GtkWidget.

Alguns dos contêineres (widgets) mais utilizados são as caixas. A GtkVBox (Verti-cal Box), mostrada na figura 4.3, é um contêiner onde os widgets contidos por ela seguem uma disposição vertical (um abaixo do outro). Contêineres como GtkVBoxnão são visíveis, são elementos estruturais, onde se percebe somente seu conteúdo,ordenado verticalmente.

103Capítulo 4 ▪ Introdução ao PHP-GTK

Figura 4.3 – Caixa vertical.

A seguir, na figura 4.4, um exemplo de GtkHBox (Horizontal Box), no qual os ele-mentos adicionados a ela ficam dispostos horizontalmente (um ao lado do outro).

Figura 4.4 – Caixa horizontal.

Existe a possibilidade de fazer várias construções colocando caixas (Box) dentrode caixas, tabelas e frames, ou seja, construir a interface de forma recursiva. Na figura4.5, existe uma grande GtkHBox. Dentro dela há duas outras caixas, uma GtkVBox (com dois elementos, um abaixo do outro) e uma GtkHBox (à direita), que, por sua vez,contém duas outras GtkVBox, cada uma com dois elementos dentro. Assim, percebe--se como é construída a interface gráfica GTK utilizando contêineres e widgets.

Figura 4.5 – Exemplo de contêineres.

Outra forma de construir o visual da aplicação é utilizar o contêiner GtkFixed, oqual permite definir coordenadas fixas (absolutas) para os widgets contidos por ele. Veja na figura 4.6 uma janela contendo um GtkFixed. O aspecto de grade indica a possibilidade de fixar os objetos em qualquer coordenada da janela.


Figura 4.6 – Posições fixas.

4.2.3 Signals

Sinais são mensagens emitidas por widgets em resposta a ações do usuário. Quandose programam interfaces gráficas (GUI), é necessário responder a essas ações, como o clique do mouse em um botão, o ato de selecionar um item de uma lista ou o ato de se fechar uma janela. O GTK faz isso por meio de sinais, que são emitidos para que o programa saiba que aconteceu algo. Quando um sinal é emitido, é possível vincular esse evento à execução de uma função (callback).

4.2.4 Callback

Callbacks são funções registradas pelo programador para reagir a sinais emitidos por widgets.Você especifica qual função será executada “conectando” a função a umsinal emitido por determinado Widget. A seguir, apresentam-se alguns exemplos.

4.3 Ciclo de vida de um objeto

4.3.1 Criação

Como os componentes GTK são disponibilizados para o PHP em forma de classes,para se fazer uso deles basta instanciarmos objetos. Assim, para criar uma janela,instanciamos um objeto da classe GtkWindow. O mesmo vale para outros objetos, comobotões (GtkButton), textos (GtkLabel), menus (GtkMenu) etc.

$janela = new GtkWindow; // cria uma janela$frame = new GtkFrame; // cria um frame$botao = new GtkButton; // cria um botão

121

CAPÍTULO 5

Componentes diversos

A vida é o que acontece enquanto você está ocupado com outros projetos.

(John Lennon)

Neste capítulo serão tratados os mais diversos widgets do GTK, como botões,rótulos de texto, janelas, painéis, caixas para entrada de dados, diálogos, exibição de imagens, combos, menus de ferramentas, notebooks, barras de status, frames,escalas e tabelas, entre outros.

5.1 Componentes básicos

5.1.1 Janela

Neste primeiro exemplo, será demonstrada a criação de uma janela. A Janela é um objeto ($window) que é uma instância da classe GtkWindow. A classe GtkWindow disponibi-liza diversos métodos para manipular uma janela. Definimos dimensões (largura e altura) pelo método set_default_size(), enquanto o título da janela é definido pelo método set_title(). Igualmente definimos o ícone da janela pelo método set_icon() e a sua posição dentro da tela pelo método set_position(). Veja, a seguir, a hierarquia da classe GtkWindow:

GtkObjectGtkWidget

GtkContainerGtkBin

GtkWindow

A seguir, definimos a ação para o sinal destroy, por meio do método connect_simple(). O sinal destroy é emitido sempre que a janela é fechada pelo usuário. Quando emitido, será executada a função onClose(), emitindo uma mensagem no console para o usuário e interrompendo a execução da aplicação pela chamada do método estático Gtk::main_quit(). Veja, na figura 5.1, o resultado deste exemplo.

Figura 5.1 – Exemplo de janela.

� window.php

<?php/* * função onClose * executada quando usuário fecha a janela */function onClose() {

echo "Volte logo !\n";Gtk::main_quit();

}

// cria janela principal$window = new GtkWindow;// define o tamanho$window->set_default_size(200,200);// define o título$window->set_title('Primeira Janela');// define o ícone$window->set_icon(GdkPixbuf::new_from_file('icons/ico_smile.png'));// define a posição na tela$window->set_position(GTK::WIN_POS_CENTER);

// define a ação a ser executada quando// o usuário fecha a janela$window->connect_simple('destroy', 'onClose');

// exibe a janela$window->show_all();Gtk::main();?>

125Capítulo 5 ▪ Componentes diversos

5.1.4 Rótulos de texto

Neste exemplo, demonstramos a criação de um rótulo de texto. Rótulos de texto sãoobjetos derivados da classe GtkLabel. Veja, a seguir, a hierarquia da classe GtkLabel:

GtkObjectGtkWidget

GtkMiscGtkLabel

Definimos o texto contido pelo rótulo de texto no momento de sua criação (new).Em exemplos posteriores estudaremos mais a fundo os métodos oferecidos pela classe GtkLabel. Neste primeiro momento, simplesmente adicionaremos o rótulo de texto na janela e o exibiremos. Veja na figura 5.4 o resultado deste exemplo.

Observação: A janela só comporta um widget por vez, com a utilização do metodo add(), por isso adicionamos somente um rótulo de texto. Mais adiante, veremos como colocar mais widgets na janela com a utilização de contêineres como GtkVBox e GtkHBox.

Figura 5.4 – Rótulos de texto.

� label.php

<?php// cria janela principal$window = new GtkWindow;$window->set_default_size(200,200);$window->set_position(GTK::WIN_POS_CENTER);$window->set_title('Label');

// cria rótulo de texto$label = new GtkLabel('Alô Mundo');

// adiciona rótulo de texto à janela$window->add($label);

135Capítulo 5 ▪ Componentes diversos

5.3.2 Formatação de rótulos

Uma das grandes novidades do GTK2 é a utilização da biblioteca Pango para ren-derização de texto, o que traz uma grande facilidade na exibição e formatação de textos, em virtude da utilização de uma linguagem de marcação muito parecida com o HTML.

Neste exemplo, visto na figura 5.12, utilizaremos uma janela com uma caixa ver-tical que conterá diversos exemplos de rótulos de texto, utilizando as mais diversas formatações de texto, com estilos e cores. Para tal, usaremos o método set_markup()da classe GtkLabel.

Figura 5.12 – Formatação de rótulos.

� label_markup.php

<?php// cria janela principal$window = new GtkWindow;$window->set_position(GTK::WIN_POS_CENTER);$window->set_border_width(4);$window->set_default_size(200,200);

// cria caixa vertical$vbox = new GtkVBox;

// cria rótulo de texto em negrito// e adiciona-o à caixa vertical$label = new GtkLabel;$label->set_markup('texto: negrito');$vbox->pack_start($label);

// cria rótulo de texto em itálico// e adiciona-o à caixa vertical$label = new GtkLabel;$label->set_markup('texto: italico');$vbox->pack_start($label);

5.4.3 Botões com imagens

Anteriormente, vimos como criar um botão com uma imagem a partir do estoque de imagens. Podemos utilizar esse recurso diversas vezes, mas, em muitos casos, a imagem que desejamos utilizar não existe no estoque de imagens.

No exemplo a seguir, na figura 5.15, temos uma janela com uma caixa vertical contendo dois botões. Para cada botão, utilizaremos o método set_image() para lhe atribuir uma imagem (objeto da classe GtkImage). Para ler a imagem a partir do dis-co, utilizamos o método construtor new_from_file() da classe GtkImage. Mais adiante,veremos mais detalhes sobre imagens.

Figura 5.15 – Botões com imagens.

� botao_imagem.php

<?php// cria nova janela$window = new GtkWindow;// define tamanho e espaçamentos$window->set_default_size(120,120);$window->set_border_width(20);$window->set_position(GTK::WIN_POS_CENTER);

// cria caixa vertical$vbox = new GtkVBox;// cria botão$button = new GtkButton;$button->set_label('Configurar');

// cria objeto imagem$imagem = GtkImage::new_from_file('icons/ico_config.png');

// atribui a imagem ao botão$button->set_image($imagem);$vbox->pack_start($button);

// cria botão$button = new GtkButton;$button->set_label('Meus Documentos');

5.6 Imagens

5.6.1 Imagem de arquivo

Neste pequeno exemplo, vemos como se dá a exibição de imagens a partir dearquivo. Para exibir imagens, utilizamos o widget GtkImage, que realiza a leitura da imagem do disco pelo método construtor new_from_file(). Então podemos adicionar esse widget à janela pelo método add().Veja o resultado deste exemplo na figura 5.26.

Veja, a seguir, a hierarquia da classe GtkImage:

GtkObjectGtkWidget

GtkMiscGtkImage

Figura 5.26 – Imagem de arquivo.

� imagem_arquivo.php

<?php// cria janela principal$window = new GtkWindow;$window->set_default_size(200,200);

// cria objeto imagem a partir de imagem PNG$imagem = GtkImage::new_from_file('icons/gnome.png');

// adiciona imagem à janela$window->add($imagem);// exibe janela$window->show_all();gtk::main();?>


5.8.3 Notebook

Notebooks são contêineres muito utilizados, pois dividem as janelas em abas e permitem que cada uma delas contenha vários outros contêineres e widgets. Tra-balhamos com notebooks no dia a dia no editor de textos, no navegador Web etc.Veja, a seguir, a hierarquia da classe GtkNotebook:

GtkObjectGtkWidget

GtkContainerGtkNotebook

No exemplo apresentado na figura 5.34 temos um notebook com as abas lo-calizadas à esquerda, contendo duas páginas. Cada página, além de um rótulo de texto, terá um pequeno ícone identificando-a. Isso porque o notebook permite que utilizemos qualquer widget como título da aba. O método append_page(), responsá-vel pela adição de uma aba, recebe dois parâmetros: o primeiro é o conteúdo e o segundo, o título da aba.

Figura 5.34 – Notebook.

No exemplo a seguir, no método construtor, é criada a janela principal e tambémo objeto da classe GtkNotebook. Então o objeto é inserido dentro da janela. O método set_tab_pos() define a posição das abas (nesse caso, à esquerda).

Os método addPage1() e addPage2() são utilizados aqui para acrescentar o conteúdode cada aba do notebook. Não é necessário dividir o programa em métodos para definirmos o conteúdo de cada aba do notebook. Fizemos isso aqui para organi-zarmos melhor o código do programa.

O método addPage1() acrescenta o conteúdo à primeira aba do notebook. Para tal, cria um frame (GtkFrame) com o conteúdo “Conteudo 1”. O método append_page()é responsável por acrescentar uma aba ao notebook. Ele recebe o conteúdo como primeiro parâmetro e o título da aba como segundo. Nesse caso, no lugar de usar-mos somente uma aba como rótulo do notebook, estamos usando como aba uma caixa vertical contendo uma imagem e um texto e somente por isso o exemplo se tornou mais complexo.

209

CAPÍTULO 6

Textos, listas e árvores

Escolha um trabalho que ame e não teráque trabalhar um único dia em sua vida.

(Confúcio)

Neste capítulo abordaremos três tópicos importantes que merecem ser estudados à parte – exibição de textos, listas e árvores. Esse assunto merece destaque, pois envolve um importante conceito da engenharia de software, o padrão Model,View,Controller, que veremos a seguir.

6.1 Padrão MVCNo desenvolvimento de aplicações, muitas vezes pressionados por fatores externos como o tempo, somos levados a escrever programas que são verdadeiras conchas deretalhos, misturando diversos aspectos, como modelo de dados, fluxos, controles e interface como usuário nomesmo código; esses aspectos poderiam estar separados

para que as futuras manutenções no código fossem mais simples e rápidas.

Essa segmentação dos aspectos de programação é conhecida como MVC (Model,View, Controller) e é apenas uma dentre as várias práticas de programação já conhe-cidas como “design patterns” ou padrões de projeto. O MVC, conforme a figura 6.1,é uma forma de estruturar a aplicação de modo que os aspectos de programação fiquem divididos em três camadas, de acordo com a seguinte arquitetura:

• Model (Modelo)

• Faz abstrações do mundo real.

• Contém os objetos de negócio.

• Contém os dados e os métodos que atuam sobre esses objetos.

• Alerta os objetos “observadores” quando os dados sofrem alterações.


$textbuffer->apply_tag($times, $start, $end);

// cria objeto imagem a partir de imagem PNG$pixbuf = GdkPixbuf::new_from_file('icons/gnome.png');

// inserindo o objeto pixbuf$textbuffer->insert_pixbuf($textbuffer->get_end_iter(), $pixbuf);

// adiciona o TextView à janela de rolagem$scroll->add($textview);

// adiciona a janela de rolagem à janela$window->add($scroll);

// exibe janela$window->show_all(); Gtk::main();?>

6.3 Listas e árvoresA classe GtkTreeView pode ser utilizada para exibir tanto árvores quanto listas. Di-ferentemente do PHP-GTK1, em que existiam as classes GtkCTree (para árvores) e GtkCList (para listas), a classe GtkTreeView provê uma forma única de visualização para ambas as formas de representação, como mostra a figura 6.4.

Figura 6.4 – Exemplo de GtkTreeView.

O conceito mais importante que envolve GtkTreeView é a completa separaçãoentre os dados e a forma pela qual estes são exibidos em tela. Os dados, sejam eles números, textos ou imagens, são armazenados em um modelo, que pode ser GtkListStore (para armazenar listas) e GtkTreeStore (para armazenar árvores). O mode-lo de dados é atribuído a alguma visualização (GtkTreeView). Sempre que o modelo de dados é alterado, automaticamente sua exibição é atualizada em tela, por sua


O modelo de dados é carregado pela leitura de um vetor contendo a localização da imagem da bandeira do país e as demais informações. Quando o usuário clicar com qualquer botão do mouse, o sinal button-release-event é disparado e o método onClick(), executado, exibindo um menu pop-up com as opções “Informação” e “Excluir”.

Caso o usuário escolha a opção “Informação”, o método onShowInfo() é executado,exibindo a quarta coluna do modelo relativa ao iterador (linha clicada), essa coluna(que a princípio não estava sendo exibida) contém justamente o país campeão. Casoo usuário escolha a opção “Excluir”, o método onDeleteIter() é executado, apagando o iterador (linha clicada).Veja o resultado desse exemplo na figura 6.8.

Figura 6.8 – Lista com imagens.

O exemplo inicia assim como o exemplo anterior, com a criação da janelaprincipal e com a criação de uma lista (GtkTreeView). Nesse caso, conectamos o sinal “button-release-event” da lista ao método onClick().Assim, sempre que o usuário cli-car em um botão do mouse sobre um elemento da lista, esse método será executado.

Logo em seguida, são criadas três colunas (GtkTreeViewColumn) e elas são adicionadasà lista por meio do método append_column(). No método construtor da GtkTreeViewColumnpodemos já indicar o título da coluna, o renderizador que irá exibi-la, o atributo e oíndice do modelo que será exibido naquela coluna. Então, é declarada uma matriz contendo os dados que serão inseridos na lista. Esses dados serão percorridos por um foreach e adicionados ao modelo, que possui quatro colunas, a última coluna não é exibida na lista.

Quando o usuário clicar com qualquer botão do mouse sobre a lista, o método onClick() é executado. Esse método testa qual botão do mouse foi clicado. Se for o botão 3 (botão direito), é criado um menu de opções (GtkMenu) e este é apresentado ao usuário por meio do método popup(). Duas opções serão disponibilizadas nesse

237Capítulo 6 ▪ Textos, listas e árvores

Esse exemplo possui mais algumas peculiaridades. Note que existem doisrenderizadores empacotados na mesma coluna. Há somente uma GtkTreeViewColumncontendo um renderizador para imagens (GtkCellRendererPixbuf) e outro para textos (GtkCellRendererText).

Nesse caso, vamos fazer uma analogia com o sistema de arquivos do computador,suas pastas e seus arquivos. Para tanto, o modelo de dados possui três colunas: um objeto (imagem pixbuf) com o ícone do arquivo, um texto com o nome do arquivo e outro com a sua localização. Entretanto, essa terceira coluna do modelo de dados não será exibida por um renderizador.

Sempre que o usuário disparar um duplo clique sobre uma linha da árvore, o método onDoubleClick() será executado e a localização do arquivo (terceira coluna do modelo de dados), exibida na tela em forma de diálogo. Veja o resultado desse exemplo na figura 6.10.

Figura 6.10 – Árvores.

No método construtor do exemplo criamos a janela da aplicação e posterior-mente o objeto GtkTreeView e o objeto GtkTreeStore, que armazenará os dados da árvore.Conectamos o duplo-clique do mouse (representado pelo sinal “row-activated”) ao método onDoubleClick().

Como explicado anteriormente, nesse exemplo teremos dois renderizadores: um de imagem (GtkCellRendererPixbuf) e um de texto (GtkCellRendererText). Os doisrenderizadores serão colocados dentro da mesma coluna ($column1). Posteriormente essa coluna é adicionada à árvore por meio do método append_column(). Em seguida,algumas imagens são lidas e armazenadas em objetos GdkPixbuf.

Os nodos são acrescentados na árvore após várias chamadas do método append(). O primeiro parâmetro do método append() representa o elemento ao qual desejamosinserir um outro como filho. Se esse parâmetro for vazio, estamos adicionando um elemento no topo da árvore.

O método onDoubleClick(), executado quando o usuário clica duplamente sobre um elemento, simplesmente exibe a terceira coluna do modelo de dados, que con-tém a localização do arquivo.

� tree_simples.php

<?php/* * classe ExemploTreeSimples * Todo exemplo está aqui contido */class ExemploTreeSimples {

private $window;private $tree;private $model;

/* * Método Construtor * Cria Janela principal */public function __construct() {

// cria janela principal$this->window = new GtkWindow;$this->window->set_title('Árvores');$this->window->connect_simple('destroy', array('gtk', 'main_quit'));$this->window->set_default_size(320,280);$this->window->set_position(GTK::WIN_POS_CENTER);

// cria janela de rolagem$scroll = new GtkScrolledWindow;$scroll->set_policy(GTK::POLICY_AUTOMATIC, GTK::POLICY_ALWAYS);

// cria árvore e adiciona no scroll$this->tree = new GtkTreeView;$scroll->add($this->tree);

// define a ação para o duplo clique$this->tree->connect('row-activated', array($this, 'onDoubleClick'));

// cria modelo de dados e atribui à árvore$this->model = new GtkTreeStore(GObject::TYPE_OBJECT, GObject::TYPE_STRING,

GObject::TYPE_STRING);$this->tree->set_model($this->model);

241

CAPÍTULO 7

Estendendo o GTK

É impossível para um homem aprender aquilo que ele acha que já sabe.

(Epíteto)

O desenvolvimento de sistemas com base em objetos consiste em criar o sistema sob a óptica do mundo real, criando as entidades (objetos) com comportamentos específicos (atributos/métodos), de modo que interajam uns com os outros. São diversas as vantagens de se utilizar a orientação a objetos no desenvolvimento de aplicações. Desde a similaridade dos objetos com a nossa percepção do mundo real,facilitando o entendimento do sistema e sua provável manutenção; a reusabilidade

proporcionada pela forma de organização do sistema por meio de uma hierarquia;

o encapsulamento, que trata da proteção de acesso às características internas de cada objeto, até a elegância do código, que tende a ficar mais enxuto, organizado e de fácil compreensão.

7.1 HerançaHerança em orientação a objetos é um mecanismo que nos proporciona o com-partilhamento de atributos e métodos entre as classes de uma mesma hierarquia (árvore).As classes inferiores da hierarquia automaticamente herdam todas as pro-priedades e métodos das classes superiores, chamadas de superclasses. Utilizando aherança, em vez de criarmos uma estrutura totalmente nova (uma classe), podemosreaproveitar uma estrutura já existente, que nos forneça uma base abstrata para o desenvolvimento, provendo recursos comuns.

As classes GTK representam bem o conceito de herança, na qual as classes-filha da estrutura de árvore vão refinando o comportamento das suas classes ancestrais (superclasses), adicionando novos métodos. As classes GtkColorButton, GtkFontButton e GtkToggleButton, por exemplo, são todas filhas da classe GtkButton, pois possuem com-portamento semelhante. Assim, todos os métodos e atributos existentes na classe

243Capítulo 7 ▪ Estendendo o GTK

class TMessage extends GtkMessageDialog {/* * método construtor, cria o diálogo * $tipo = 'info' para mensagem de informação * 'error' para mensagem de erro * $frase = mensagem a ser exibida */public function __construct($tipo, $frase) {

// verifica o tipo de mensagem$constante = $tipo == 'info' ? Gtk::MESSAGE_INFO : Gtk::MESSAGE_ERROR;

// chama o método construtor da classe pai// mesmo que "new GtkMessageDialog"parent::__construct(null, Gtk::DIALOG_MODAL, $constante,

Gtk::BUTTONS_OK, $frase);// exibe o diálogoparent::run();parent::destroy();

}}?>

Utilizando a classe

Agora demonstraremos a utilização dessa classe criada, exibindo uma mensagem na tela. Veja o resultado do exemplo na figura 7.1.

Figura 7.1 – Exibindo mensagens.

� TMessage.teste.php

<?php// inclui a classe criadainclude_once 'TMessage.class.php';

// emite mensagem informativanew TMessage('info', 'Warning: Saldo insuficiente !!');

// emite mensagem de erronew TMessage('error', 'Kernel Panic !!');?>

public function get_text() {return $this->input->get_text();

}}?>

Utilizando a classe

Agora demonstraremos a utilização dessa classe criada. No exemplo, solicitaremos ao usuário que digite seu nome. Caso ele clique em OK, o nome será impresso no console. Veja o resultado do exemplo na figura 7.3.

Figura 7.3 – Solicitando valores.

� TInputBox.teste.php

<?php// inclui a classe TInputBoxinclude_once 'TInputBox.class.php';

// instancia TInputBox$dialogo = new TInputBox('título da janela', 'Digite o Nome', '<digite aqui>');

// verifica resposta$resposta = $dialogo->run();

// se resposta for sim...if ($resposta == Gtk::RESPONSE_OK) {

// imprime o conteúdo digitadoecho $dialogo->get_text();

}?>

7.5 Botões com imagemA classe a seguir será criada para simplificar a exibição de botões com imagem.Como o comportamento dessa classe é muito similar ao da GtkButton, a utilizaremoscomo pai para a classe criada. O método construtor dessa classe já irá receber o rótulo do botão, a imagem, a ação e se encarregará de montar o botão internamente.

Utilizando a classe

Agora demonstraremos a utilização dessa classe criada. Para tanto, criaremos uma classe contendo uma janela e três botões, cada qual com uma imagem diferente e uma respectiva ação. Veja o resultado desse exemplo na figura 7.4.

Figura 7.4 – Exibindo botões.

� TImageButton.teste.php

<?php// inclui a classe criadainclude_once 'TImageButton.class.php';/* * Classe ExemploBotao * Demonstra o uso da classe criada */class ExemploBotao {

/* * método construtor * cria a janela com os botões */function __construct() {

$janela = new GtkWindow;$hbox = new GtkHbox; // cria os botões com imagem$botao1 = new TImageButton('Home', 'images/home.png', array($this, 'onHome'));$botao2 = new TImageButton('Config', 'images/config.png', array($this, 'onConfig'));$botao3 = new TImageButton('Imprime','images/print.png', array($this, 'onImprime'));

$hbox->pack_start($botao1);$hbox->pack_start($botao2);$hbox->pack_start($botao3);$janela->add($hbox);$janela->show_all();

}// ação do botão Homefunction onHome() {

echo "Clicou no Home\n";}// ação do botão Configfunction onConfig() {

echo "Clicou no Config\n";}// ação do botão Imprime

Utilizando a classe

Agora será mostrado a utilização dessa classe criada. Para tanto, faremos umformulário de cadastro de pessoas. Quando o usuário clicar no botão “Salvar”, os dados digitados no formulário serão exibidos no console. Veja o resultado desse exemplo na figura 7.6.

Figura 7.6 – Criando formulários.

Neste exemplo, em seu método construtor criamos uma janela e vários objetos ($codigo,

$nome, $endereco), além de um botão $salvar. Logo em seguida utilizamos a classe recém-criada TForm. Para cada objeto, utilizamos o método addField() para adicionar o campo ao formulário, identificando seu nome, seu rótulo de texto, o objeto e o tamanho.Ao final, o formulário é exibido por meio do método show(). Alguns dadosiniciais são definidos para o formulário por meio do método setData().

Sempre que o usuário clicar no botão de ação, o método onSave() será executado.Esse método coleta os dados do formulário por meio do método getData() e exibe esses dados no console.

� TForm.teste.php

<?phpinclude_once 'TForm.class.php';/* * classe ExemploForm * criada para demonstrar a utilização de formulários */class ExemploForm {

private $form; // contém o objeto formulário

/* * método construtor, cria a janela */function __construct() {

$janela = new GtkWindow;$janela->set_size_request(470,200);


// cria alguns campos para o formulário$codigo = new GtkEntry;$nome = new GtkEntry;$endereco = new GtkEntry;$telefone = new GtkEntry;

// cria o botão de ação do formulário$salvar = GtkButton::new_from_stock(Gtk::STOCK_SAVE);$salvar->connect_simple('clicked', array($this, 'onSave'));

// cria o formulario com seus campos$this->form = new TForm;$this->form->addField('codigo', 'Código', $codigo, 140);$this->form->addField('nome', 'Nome', $nome, 240);$this->form->addField('endereco', 'Endereço', $endereco, 240);$this->form->addField('telefone', 'Telefone', $telefone, 240);$this->form->addSeparator('Ação');$this->form->addField('salvar', 'Salvar', $salvar, 100);$this->form->show();

// define alguns dados iniciais$dados_iniciais->codigo = '1';$dados_iniciais->telefone = '(51) XXXX-XXXX';$this->form->setData($dados_iniciais);

// adiciona o form na janela$janela->add($this->form);$janela->show_all();

}

/* * método onSave * simula a ação de salvar os dados do form */function onSave() {

// obtém os dados do formulário$objeto = $this->form->getData();

// exibe os dados no consoleecho "Código: " . $objeto->codigo . "\n";echo "Nome: " . $objeto->nome . "\n";echo "Endereço: " . $objeto->endereco . "\n";echo "Telefone: " . $objeto->telefone. "\n";

// limpa o formulário$this->form->Clear();

}}

// instancia o exemplonew ExemploForm;Gtk::main();?>

276

CAPÍTULO 8

Acessando bancos de dados

É melhor estar preparado para uma oportunidade e não ternenhuma, do que ter uma oportunidade e não estar preparado.

(Whitney Young Jr.)

Neste capítulo serão tratados os aspectos relativos à manipulação de banco de dados,como realizar conexões, consultas, inserir dados e extrair relatórios, dentre outros.O PHP possui suporte nativo à maioria dos bancos de dados utilizados hoje. Você pode utilizar o PHP com o Postgres, Oracle, SqlServer, Firebird, DB2, MySql e outros.Como o interesse de muitos que desenvolvem uma aplicação-cliente em PHP-GTK é a fácil distribuição da aplicação, os exemplos deste capítulo terão como base a utilização do Sqlite, que é um banco de dados simples em formato de arquivos. O Sqlite não precisa de instalação, basta ser compactado junto com a aplicação, o que torna sua distribuição extremamente simples.

8.1 Introdução ao SQLAtualmente, a maioria das aplicações utiliza a linguagem SQL (Structured Query Language) para manipular bancos de dados. A linguagem SQL possui formas de definir a estrutura e a integridade dos dados, permite a inserção, alteração e exclu-são de registros. A seguir será apresentada a sintaxe das instruções SQL utilizadas nos exemplos seguintes.

CREATE TABLE

Permite criar uma nova tabela no banco de dados, identificando-se seu nome e sua estrutura.

CREATE TABLE <tabela> (<nome_coluna><tipo_coluna>, ...)

Parâmetros Descrição

tabela Nome da tabela a ser criada.

279Capítulo 8 ▪ Acessando bancos de dados

8.3 Formulário de cadastroO objetivo deste primeiro exemplo é criar um formulário para cadastro de pessoas no banco de dados. Esse formulário contém campos para código, nome, endereço,idade, telefone e cidade.

8.3.1 Criando a classe para cadastro

Primeiro será criada a classe NovaPessoa. Essa classe irá encapsular todo o formuláriode cadastro e suas funcionalidades. Dentro dessa classe, criamos uma janela que contém uma caixa vertical, onde adicionamos os vários campos do formulário por meio de um laço de repetição FOREACH, para simplificar a escrita e diminuir a quan-tidade de linhas de código. Veja o resultado deste exemplo na figura 8.1.

O formulário terá um botão “Salvar”, que estará conectado ao método onSaveClick(), responsável por coletar os dados do formulário e armazená-los no banco de dados,via método sqlite_query(). Também há um botão para fechar a janela.

Sempre que essa classe for iniciada, ela verificará pela existência do arquivo de dados. Caso este não exista, o próprio programa se encarregará de criá-lo, pelo método criaBanco().

Figura 8.1 – Formulário de cadastro.

No método construtor da classe, criamos a janela principal e uma caixa vertical onde teremos os campos do formulário. Para criar os campos do formulário defi-nimos dois vetores: $this->labels para armazenar os rótulos de texto do formulário e $this->campos para armazenar os campos.

Depois de definir os campos, percorremos estes por meio de um foreach() que criará, para cada campo, uma caixa horizontal e irá acrescentar essa caixa em uma caixa vertical. Por fim, ainda dentro do método construtor criamos dois botões: o primeiro de salvar, que executará o método onSaveClick(), e o segundo de fechar, que

executará o método hide() da janela. Ainda no método construtor executamos o método criaBanco(), que é responsável por criar o banco SQLite caso este não exista.

O método criaBanco() verifica a existência do banco de dados “dados.db”. Caso esse arquivo não exista, ele é criado pela função sqlite_open(). Logo em seguida, umainstrução SQL para criação da tabela de pessoas é executada.

O método onSaveClick() é executado sempre que o usuário clicar no botão de salvar. Esse método coleta os dados digitados pelo usuário no formulário e alimen-ta um objeto chamado $pessoa. Esse objeto é utilizado na formação da string SQLarmazenada na variável $sql e que é executada por meio do método sqlite_query(), inserindo o registro no banco de dados. Ao final, o método Clear() é executado.

O método Clear() é responsável por limpar os campos do formulário e posicionaro cursor da janela no primeiro campo do formulário.

� NovaPessoa.class.php

<?php/** * Classe NovaPessoa * Contém todo formulário de cadastro */class NovaPessoa {

private $window;private $campos;private $labels;

/** * Método construtor * Encapsula a aplicação, cria janela e formulário */public function __construct() {

// cria janela$this->window = new GtkWindow;$this->window->set_title('Incluir');$this->window->connect_simple('destroy', array($this->window, 'hide'));$this->window->set_default_size(540,280);$this->window->set_border_width(10);$this->window->set_position(GTK::WIN_POS_CENTER);

$vbox = new GtkVBox;

// cria um array com os rótulos de texto// e os campos do formulário$this->labels['codigo'] = new GtkLabel(' Código: ');$this->campos['codigo'] = new GtkEntry;$this->campos['codigo']->set_size_request(80,-1);

$this->labels['nome'] = new GtkLabel('Nome: ');$this->campos['nome'] = new GtkEntry;


8.4.1 Criando a classe para a listagem

Essa classe possui uma janela com uma lista (GtkTreeView) que contém quatro colunas(código, nome, endereço e idade).As colunas nome, endereço e idade são editáveis, oque permite ao usuário alterar o seu valor simplesmente clicando duas vezes sobre a célula da listagem. Veja o resultado desse exemplo na figura 8.2.

Observe que durante a conexão do sinal edited dos renderizadores são passadas algumas informações importantes para a função callback (onEdit), como o nome da coluna no banco de dados e sua posição no modelo de dados. O método onEdit() tratará da atualização das informações no banco de dados, via sqlite_query(), en-quanto no modelo de dados será realizado via set().

Abaixo da listagem há dois botões, um para excluir o registro, conectado ao método onDelete(), que irá solicitar uma confirmação ao usuário antes de apagar os dados, e outro para fechar a janela.

Figura 8.2 – Listagem dos dados.

O exemplo inicia no método construtor, onde criamos a janela principal, uma janela de rolagem e adicionamos em seu interior uma lista (GtkTreeView). Essa lista estará vinculada a um modelo (GtkListStore) com quatro colunas do tipo string. Es-sas quatro colunas são objetos GtkTreeViewColumn, como já vimos no capítulo 6. Cada coluna é representada por um renderizador GtkCellRendererText. Quando o usuário editar os dados de alguma coluna,será executado o método onEdit(), o que é definidoquando conectamos o sinal “edited” do renderizador. Para que as colunas possam ser editadas, é necessário habilitar a propriedade “editable” de cada renderizador.

Ainda no método construtor, definimos a largura das colunas, relacionamos quais dados do modelo serão exibidos e adicionamos as colunas à lista pelo métodoappend_column(). Abaixo da lista existirão dois botões: excluir, que estará ligado ao método onDelete(), e fechar, que estará ligado ao método hide() da janela.

Essa classe terá um método Show() que se encarregará de carregar os dados da listagem e exibir a janela. Os dados são carregados pelo método exibeDados(), que abreuma conexão com o banco de dados sqlite por meio do método sqlite_open(), realiza

305

CAPÍTULO 9

Utilizando o Glade

O sábio espera tudo de si mesmo.O homem espera dos outros.

(Confúcio)

Desenvolver aplicações que envolvam muitas interfaces com o usuário pode dar muito trabalho caso tenha de lidar com todos os aspectos no código-fonte, declaran-do objetos, empacotando widgets dentro de contêineres e ajustando os tamanhos manualmente. Podemos criar classes para automatizar a criação de formulários e listagens, mas, mesmo assim, em algum momento, precisaremos criar uma janela com alguns botões de forma rápida e simples. Para tais casos, existe o Glade.

9.1 IntroduçãoO Glade é uma ferramenta cujo objetivo é desenhar interfaces para programas que utilizam a biblioteca GTK. O Glade pode ser utilizado com Python, PHP, C,Ruby, dentre outras linguagens que suportam o GTK. O Glade em si não é um ambiente RAD como é o Delphi ou o Visual Basic, por exemplo. Seu objetivo não é integrar o desenho da aplicação com a escrita de código e execução. Por meio dele, podemos facilmente criar janelas, listas, botões, caixas e organizá-los de uma forma simples. Ao final, este “esquema” da interface é salvo em um arquivo com a extensão “.glade”, que nada mais é do que um arquivo XML contendo a estrutura visual da interface. Esses arquivos salvos pelo Glade podem ser interpretados a partirde nosso código-fonte em PHP, disponibilizando para o sistema todos os widgets e contêineres desenhados por ele. Dessa forma, podemos abstrair os detalhes de construção visual da aplicação e nos concentrar apenas na lógica.

A seguir, na figura 9.1, temos a janela principal do Glade e suas opções básicas (Abrir e Salvar), além das opções do projeto e a lista de cada janela projetada. No menu Editar dispomos das opções como Recortar, Copiar e Colar, enquanto no menu Exibir, há opções para exibir/esconder janelas, dentre outros.


Figura 9.1 – Janela principal.

9.1.1 Onde encontrar

Você pode encontrar a versão do Glade em: http://glade.gnome.org.

9.1.2 Paleta de widgets

Todo projeto no Glade começa com uma janela. O widget que representa uma janelaé o GtkWindow, primeiro componente da paleta do Glade.Após o primeiro clique sobreesse componente, a primeira janela aparecerá na tela e então poderemos começar a usar outros widgets, como GtkHBox (caixa horizontal), GtkVBox (caixa vertical), GtkFixed(que permite posições absolutas para os widgets), GtkLabel (rótulos de texto), GtkEntry(caixas de entrada), GtkRadioButton (botões de rádio), GtkFrame (frames), dentre outros.

Veja, a seguir, na figura 9.2, a paleta de widgets do GTK. É possível utilizar qual-quer um desses elementos para o desenho da aplicação.Alguns elementos adicionaisainda não são implementados pelo PHP-GTK. Lembre-se de que se deve organizar o layout da aplicação dentro de contêineres (GtkWindow, GtkFrame, GtkHBox etc.).

Figura 9.2 – Paleta de widgets.


Figura 9.28 – Campo para digitação da notícia.

Por último, inserimos um botão chamado “Publica” na parte inferior da janela,como mostrado na figura 9.29. O nome dado ao botão na janela de propriedades também será “publica” e o nome, utilizado para posteriormente resgatar o botão no código da aplicação, tal como será feito com todos os componentes já criados.

Figura 9.29 – Criando o botão.

Tendo ainda o botão selecionado, na janela de propriedades temos a guia “sinais”,onde há uma listagem de todos os sinais que poderão ser habilitados para o botão recém-criado. Selecionamos o sinal clicked para, no passo seguinte, registrar uma função que responderá ao sinal, cujo nome será onPublica, como pode ser visto na figura 9.30.

Figura 9.30 – Registrando a função.

Para finalizar, salva-se o projeto no arquivo publica.glade.

325Capítulo 9 ▪ Utilizando o Glade

9.8.2 Construindo o código

Neste ponto, tem-se a interface pronta. O próximo passo é a escrita do código--fonte da aplicação.

A classe criada novamente estende a classe GladeXML. Em seu método construtor conectamos os sinais registrados ao objeto atual. Então capturamos cada um dos objetos contidos no arquivo glade e registramos cada um destes como atributos do objeto corrente (Ex: $this->titulo, $this->autor).

O método onPublica() é executado sempre que o usuário clicar no botão publicar.Nesse caso, obtemos o conteúdo que o usuário digitou em cada um dos campos e,com base nisso, escrevemos um arquivo HTML chamado noticias.html para ao final exibir esse arquivo no navegador (Explorer ou Firefox).

� publica.php

<?php/* classe Publica * Contém todo código que manipulada * o arquivo Glade e interage com o usuário */class Publica extends GladeXML {

/* método construtor * Lê o Glade e disponibiliza * os widgets como propriedades */function __construct($arquivo_glade) {

// carrega o gladeparent::__construct($arquivo_glade);// conecta os seus sinais à métodos desta classeparent::signal_autoconnect_instance($this);

// carrega os widgets$this->titulo = parent::get_widget('titulo');$this->autor = parent::get_widget('autor');$this->email = parent::get_widget('e-mail');$this->data = parent::get_widget('data');$this->fonte = parent::get_widget('fonte');$this->url = parent::get_widget('url');$this->noticia= parent::get_widget('noticia');

}

/* método onPublica * Lê o conteúdo digitado nos widgets * e adiciona em um arquivo HTML */function onPublica() {

// lê os conteúdos digitados$titulo = $this->titulo->get_text();


9.9 Emitindo notas fiscaisNo exemplo a seguir, com o auxílio do Glade, será construído um aplicativo para emitir Notas Fiscais. O usuário digita informações como o número da nota, os da-dos dos clientes, além de uma série de itens da nota (código, descrição, quantidade e valor). A partir daí, a aplicação calcula automaticamente o subtotal, o imposto, o frete e o total. Quando o usuário clicar no botão “Salvar”, a aplicação abrirá uma caixa de diálogo para salvar a nota fiscal em um arquivo PDF. Então, o usuário poderá imprimir a Nota Fiscal a partir do aplicativo utilizado para visualizar esse arquivo, como Acrobat para Windows ou Evince para Linux. Para construir esse exemplo, foi usada a biblioteca FPDF, disponível livremente em www.fpdf.org.

9.9.1 Criando a interface

Em primeiro lugar, será criada uma janela vazia (objeto GtkWindow). Dentro dessa janela, colocaremos um GtkFixed e, a partir de então, colocaremos mais uma série de widgets na janela. Você pode ver a colocação do logotipo na figura 9.33, que é um objeto do tipo GtkImage, a formatação de textos utilizando a linguagem de marcação do pango na figura 9.34. O posicionamento do campo para digitação do número da nota fiscal, na figura 9.35, a criação do campo para digitação do código do produto,na figura 9.36,a criação do objeto do tipo GtkTreeView para listar os produtos,na figura9.37, e a criação do botão “adicionar” usando uma imagem de estoque, na figura 9.38.

Figura 9.33 – Posicionando o logo.

Figura 9.34 – Formatando o texto.

340

CAPÍTULO 10

Extras

A sabedoria da vida não está em fazer aquilo que se gosta,mas gostar daquilo que se faz.

– Leonardo da Vinci

Aqui serão tratados vários assuntos que não foram cobertos pelos capítulos anterio-res.Assim, esperamos atender a uma série de outras necessidades do programador ao desenvolver uma aplicação em PHP-GTK, oferecendo-lhe este capítulo “extra”.

10.1 Tela de loginO exemplo a seguir está todo encapsulado em uma classe. A criação da interface está contida no seu método construtor e a classe é instanciada ao final do código.

Nesse caso, tem-se uma tela de login, representada pela janela criada na classe TableLogin. Ao usuário serão apresentados campos para o preenchimento deUsuário e Senha. Caso ele acerte usuário=”maria”senha=”abacaxi”, a classe Applicationserá instanciada, exibindo a suposta aplicação na tela. Este é um exemplo muito simples de login para uma aplicação, mas que pode ser aperfeiçoado substituindo a verificação de usuário e senha por uma consulta a um banco de dados remoto,por exemplo. Veja o resultado desse exemplo na figura 10.1.

Figura 10.1 – Tela de login.

345Capítulo 10 ▪ Extras

10.3 RelógioNeste exemplo, há um relógio digital formado por um objeto GtkLabel. Essa fun-cionalidade é possível graças ao uso da função date(), que retorna a hora atual já no formato correto, em conjunto com a função Gtk::timeout_add(), a qual agenda a execução de uma função qualquer para daqui a XX milissegundos. Veja o resultado desse exemplo na figura 10.3.

Figura 10.3 – Relógio.

Logo após a definição da função AtualizaClock(), o programa inicia com a criação da janela principal. Logo em seguida criamos um rótulo de texto e o adicionamos à janela. Então programamos para daqui a 1 milissegundo a execução do método AtualizaClock().

O método AtualizaClock() atribui a hora atual ao objeto $label, mediante seumétodo set_markup() e, logo em seguida, agenda uma nova execução para daqui a 1 segundo. Como o método AtualizaClock() agenda sua própria execução, ele fica executando permanentemente enquanto a aplicação está ativa.

� timer.php

<?php/* * função AtualizaClock * Atualiza a hora do relógio */function AtualizaClock() {

global $label;// exibe a hora atual no Label$label->set_markup(''. date("h:i:s") . '');

// Programa nova execução para daqui há 1 segundoGtk::timeout_add(1000, 'AtualizaClock'); // a cada decimo de segundo

}

// cria janela principal$janela = new GtkWindow;$janela->set_position(GTK::WIN_POS_CENTER);$janela->set_default_size(200,100);


// cria rótulo de texto$label = new GtkLabel;

// adiciona rótulo à janela$janela->add($label);

// exibe janela$janela->show_all();

// executa Atualiza Clock em 1 mili-segundoGtk::timeout_add(1, 'AtualizaClock');Gtk::Main();?>

10.4 Movendo objetosNeste exemplo, procuramos demonstrar como é possível mover um objeto dentro de uma área de posições fixas (GtkFixed) com o uso do teclado. Não se trata de um jogo, mas pode ser considerado como a base para a construção de um. Na tela temos dois GIFs animados. Um cão-tubarão no canto inferior direito (parado) e uma raposa ao centro. O usuário poderá movimentar a raposa utilizando as setas do teclado (acima, abaixo, esquerda e direita). Para tanto, a cada evento de tecla pressionada, que gera um sinal key-press-event, monitoramos qual foi a tecla que o usuário pressionou para recalcularmos a linha e a coluna em que a raposa se encontra localizada no GtkFixed e movimentarmos pelo método move() do GtkFixed. Veja o resultado desse exemplo na figura 10.4.

Figura 10.4 – Movimentando objetos.

O exemplo inicia com a criação da janela principal. Conectamos o sinal “key--press-event”, que é emitido sempre que o usuário pressionar qualquer tecla àexecução do método onKeyPress().


// instancia Exemplonew ExemploListaStock;Gtk::Main();?>

10.9 Fechando uma janelaEste exemplo procura mostrar como questionar o usuário antes de fechar uma janela.A classe GtkWindow sempre emite o sinal destroy no momento em que o usuário fecha uma janela. Porém, antes desse sinal, ela emite o sinal delete-event. A função que responder ao sinal delete-event desempenha um papel importante nesse contexto.Caso ela retornar o valor FALSE, o programa seguirá para a emissão do sinal destroy;caso contrário, continuará a execução do programa normalmente.

Para demonstrar esse princípio, faremos com que o programa a seguir, mostradona figura 10.9, exiba uma caixa de diálogo perguntando ao usuário se ele deseja fechar a janela sempre que clicar no botão de fechar.

Figura 10.9 – Fechando a janela.

Nesse exemplo, criamos uma janela e conectamos o seu sinal “delete-event” ao método onClose(). O sinal “delete-event” é emitido quando o usuário clica no botão para fechar a janela.

Quando o usuário clicar no botão para fechar a janela, o método onClose() será executado. Esse método abre uma caixa de diálogo e pergunta ao usuário se ele deseja fechar a janela. Caso sim, o método retorna false e, neste caso, o programa segue a execução para o sinal “destroy”, que por sua vez está conectado com o métodoGtk::main_quit() abortando a aplicação. Caso o usuário escolher não fechar a janela,esse método retorna true e o programa segue sua execução normal.

Em seguida definimos qual será a coluna do modelo que representará a imagemdo ícone por meio do método set_pixbuf_column() e qual representará o texto exibido junto ao ícone por meio do método set_text_column(). Também definimos a largura das colunas do GtkIconView por meio do método set_item_width() e exibimos a janela da aplicação.

Quando o método onSelect() for executado, simplesmente obteremos do modelo de dados o elemento atual selecionado e exibimos este no console por meio da função var_dump(). Para tal, o método onSelect(), que é uma resposta ao evento “item-activated”, recebe como segundo parâmetro o caminho do elemento selecionado ($path), que nos pemite obter o iterador que aponta para o elemento selecionado por meio do método get_iter().

Figura 10.18 – Programa exemplo.

� iconview.php

<?php

// cria a janela$janela = new GtkWindow();$janela->set_title('GtkIconView'); $janela->set_default_size(500, 300);$janela->connect_simple('destroy', array('Gtk', 'main_quit'));

// cria a iconview e o modelo$iconview = new GtkIconView();$model = new GtkListStore(GdkPixbuf::gtype, GObject::TYPE_STRING);$iconview->set_model($model);

// cria janela de rolagem$scroll = new GtkScrolledWindow();$scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

Ao final, inserimos um trecho de código básico PHP (abertura e fechamento de código) por meio do método insert_at_cursor() e exibimos a janela principal.Na figura 10.19, podemos ver o programa em execução (já com algum conteúdo digitado pelo usuário).

Figura 10.19 – Programa exemplo.

� teste-sourceview.php

<?php $janela = new GtkWindow; $scroll = new GtkScrolledWindow; $sourceview = new GtkSourceView;

$janela->set_size_request(700, 400); $janela->set_position(Gtk::WIN_POS_CENTER); $janela->add($scroll); $scroll->add($sourceview);

$buffer = new GtkSourceBuffer; $sourceview->set_buffer($buffer);

$manager = new GtkSourceLanguagesManager; $lang = $manager->get_language_from_mime_type('application/x-php');

$buffer->set_language($lang); $buffer->set_highlight(true); $buffer->set_check_brackets(TRUE);

$sourceview->set_auto_indent(TRUE); $sourceview->set_insert_spaces_instead_of_tabs(TRUE); $sourceview->set_tabs_width(4); $sourceview->set_show_line_numbers(true); $sourceview->set_highlight_current_line(TRUE);

Phpgtk Mostra

Documents

Transcript of Phpgtk Mostra