Criando Aplicações Gráficas com PHP

Criando Aplicações Gráficas com PHP 3ª Edição Pablo Dall'Oglio Novatec

capítulo 1 Introdução Quando você tem uma meta, o que era um obstáculo passa 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ória e 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 dinâ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 na Web 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. 18 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 mesmo 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

Capítulo 1 Introdução 19 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 consistente, 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 performance 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 nesse mecanismo, 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ção de 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 com sua 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 como base 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 parte central 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ções grá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 (caracteres de 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 Usbequistão, que atualmente trabalha nos Estados Unidos. Assim como muitos projetos em software livre, este também começou com uma motivação um tanto peculiar: Fiz porque queria ver se era possível, disse o autor, que se inspirou muito em um projeto já existente, o PyGTK (ligação entre as linguagens entre Python e GTK). Andrei Zmievski esteve no Brasil em 2002, durante o III Fórum Internacional de Software Livre, 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 duas ferramentas 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

Capítulo 1 Introdução 21 User Interface). Foi escrita, em parte, para provar que o PHP é uma linguagem completa 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 ferramenta de desenvolvimento que permite aos desenvolvedores rodarem o mesmo código em ambientes 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 primeira 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 complexas 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 conectividade 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, escrever 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 surge nesse contexto com a extensão de maior tamanho e complexidade, provendo um

22 PHP-GTK Criando Aplicações Gráficas com PHP framework completo para a construção de aplicações gráficas para projetos escritos em PHP. Veja na figura 1.5 alguns exemplos de extensões do PHP. HTML BD PHP GTK Figura 1.4 Plataforma de desenvolvimento. Figura 1.5 Arquitetura do PHP. 1.4 Instalação em Linux Para 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 partir das 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 sugestão:

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 estruturas 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 PHP Nesta 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.php.class.php.inc.php Significado Arquivo PHP contendo um programa PHP. Arquivo PHP contendo uma classe 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;?> 25

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 objetos A orientação a objetos é um paradigma de programação que representa uma filosofia 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 Programando 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 65

capítulo 4 Introdução ao PHP-GTK Nunca encontrei uma pessoa tão ignorante que não pudesse ter aprendido algo com sua ignorância. (Galileu Galilei) Para escrever aplicações gráficas é necessário entender alguns termos que são bastante 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áficas Todos manipulam interfaces gráficas, ou simplesmente GUI (Graphical User Interface), 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 Sutherland escreveu uma tese com muitos dos fundamentos necessários para a construção de 100

Capítulo 4 Introdução ao PHP-GTK 101 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, linguagem 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ções gráficas e introduziu os primeiros ícones, mas era grande demais para ser comercializado. 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 cooperaçã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 conhecimentos a técnicos da Microsoft para que estes desenvolvessem aplicações para a plataforma Mac. 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.

102 PHP-GTK Criando Aplicações Gráficas com PHP 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 significar dispositivo, 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 utilizando 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 construir uma 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 (Vertical 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 GtkVBox não são visíveis, são elementos estruturais, onde se percebe somente seu conteúdo, ordenado verticalmente.

Capítulo 4 Introdução ao PHP-GTK 103 Figura 4.3 Caixa vertical. A seguir, na figura 4.4, um exemplo de GtkHBox (Horizontal Box), no qual os elementos 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) dentro de caixas, tabelas e frames, ou seja, construir a interface de forma recursiva. Na figura 4.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, o qual 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.

104 PHP-GTK Criando Aplicações Gráficas com PHP 4.2.3 Signals Figura 4.6 Posições fixas. Sinais são mensagens emitidas por widgets em resposta a ações do usuário. Quando se 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 um sinal 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, como botões (GtkButton), textos (GtkLabel), menus (GtkMenu) etc. $janela = new GtkWindow; $frame = new GtkFrame; $botao = new GtkButton; // cria uma janela // cria um frame // cria um botão

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 disponibiliza 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: GtkObject GtkWidget GtkContainer GtkBin 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. 121

122 PHP-GTK Criando Aplicações Gráficas com PHP window.php <?php /* * função onclose * executada quando usuário fecha a janela */ function onclose() { echo "Volte logo!\n"; Gtk::main_quit(); } Figura 5.1 Exemplo de janela. // 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();?>

Capítulo 5 Componentes diversos 125 5.1.4 Rótulos de texto Neste exemplo, demonstramos a criação de um rótulo de texto. Rótulos de texto são objetos derivados da classe GtkLabel. Veja, a seguir, a hierarquia da classe GtkLabel: GtkObject GtkWidget GtkMisc GtkLabel 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. 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); Figura 5.4 Rótulos de texto.

Capítulo 5 Componentes diversos 135 5.3.2 Formatação de rótulos Uma das grandes novidades do GTK2 é a utilização da biblioteca Pango para renderizaçã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 vertical 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. 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: <b>negrito</b>'); $vbox->pack_start($label); // cria rótulo de texto em itálico // e adiciona-o à caixa vertical $label = new GtkLabel; $label->set_markup('texto: <i>italico</i>'); $vbox->pack_start($label); Figura 5.12 Formatação de rótulos.

140 PHP-GTK Criando Aplicações Gráficas com PHP 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 disco, utilizamos o método construtor new_from_file() da classe GtkImage. Mais adiante, veremos mais detalhes sobre 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'); Figura 5.15 Botões com imagens. // 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');

162 PHP-GTK Criando Aplicações Gráficas com PHP 5.6 Imagens 5.6.1 Imagem de arquivo Neste pequeno exemplo, vemos como se dá a exibição de imagens a partir de arquivo. 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: GtkObject GtkWidget GtkMisc GtkImage imagem_arquivo.php <?php // cria janela principal $window = new GtkWindow; $window->set_default_size(200,200); Figura 5.26 Imagem de arquivo. // 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();?>

176 PHP-GTK Criando Aplicações Gráficas com PHP 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. Trabalhamos com notebooks no dia a dia no editor de textos, no navegador Web etc. Veja, a seguir, a hierarquia da classe GtkNotebook: GtkObject GtkWidget GtkContainer GtkNotebook No exemplo apresentado na figura 5.34 temos um notebook com as abas localizadas à 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ém o 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údo de 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 organizarmos 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 usarmos 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.

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 MVC No desenvolvimento de aplicações, muitas vezes pressionados por fatores externos como o tempo, somos levados a escrever programas que são verdadeiras conchas de retalhos, misturando diversos aspectos, como modelo de dados, fluxos, controles e interface com o usuário no mesmo 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á conhecidas 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. 209

214 PHP-GTK Criando Aplicações Gráficas com PHP $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 árvores A classe GtkTreeView pode ser utilizada para exibir tanto árvores quanto listas. Diferentemente 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ção entre 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 modelo 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

224 PHP-GTK Criando Aplicações Gráficas com PHP 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. Caso o 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 janela principal 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 clicar 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 GtkTreeViewColumn podemos 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

Capítulo 6 Textos, listas e árvores 237 Esse exemplo possui mais algumas peculiaridades. Note que existem dois renderizadores empacotados na mesma coluna. Há somente uma GtkTreeViewColumn contendo 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 posteriormente 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 dois renderizadores 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.

238 PHP-GTK Criando Aplicações Gráficas com PHP 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 desejamos inserir 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 conté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);

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ça Herança em orientação a objetos é um mecanismo que nos proporciona o compartilhamento de atributos e métodos entre as classes de uma mesma hierarquia (árvore). As classes inferiores da hierarquia automaticamente herdam todas as propriedades e métodos das classes superiores, chamadas de superclasses. Utilizando a herança, em vez de criarmos uma estrutura totalmente nova (uma classe), podemos reaproveitar 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 comportamento semelhante. Assim, todos os métodos e atributos existentes na classe 241

Capítulo 7 Estendendo o GTK 243 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álogo parent::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. TMessage.teste.php <?php // inclui a classe criada include_once 'TMessage.class.php'; Figura 7.1 Exibindo mensagens. // emite mensagem informativa new TMessage('info', 'Warning: Saldo insuficiente!!'); // emite mensagem de erro new TMessage('error', 'Kernel Panic!!');?>

Capítulo 7 Estendendo o GTK 247 }?> 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. TInputBox.teste.php <?php // inclui a classe TInputBox include_once 'TInputBox.class.php'; Figura 7.3 Solicitando valores. // 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 digitado echo $dialogo->get_text(); }?> 7.5 Botões com imagem A 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 utilizaremos como 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.

Capítulo 7 Estendendo o GTK 249 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. TImageButton.teste.php Figura 7.4 Exibindo botões. <?php // inclui a classe criada include_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 Home function onhome() { echo "Clicou no Home\n"; } // ação do botão Config function onconfig() { echo "Clicou no Config\n"; } // ação do botão Imprime

Capítulo 7 Estendendo o GTK 257 Utilizando a classe Agora será mostrado a utilização dessa classe criada. Para tanto, faremos um formulá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 dados iniciais 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 <?php include_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);

258 PHP-GTK Criando Aplicações Gráficas com PHP } } // 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 console echo "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 exemplo new ExemploForm; Gtk::main();?>

capítulo 8 Acessando bancos de dados É melhor estar preparado para uma oportunidade e não ter nenhuma, 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 SQL Atualmente, 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 exclusã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 tabela Descrição Nome da tabela a ser criada. 276

Capítulo 8 Acessando bancos de dados 279 8.3 Formulário de cadastro O 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ário de 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 quantidade 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 definimos 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

280 PHP-GTK Criando Aplicações Gráficas com PHP 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, uma instruçã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 alimenta um objeto chamado $pessoa. Esse objeto é utilizado na formação da string SQL armazenada 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 posicionar o 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('<span foreground="red"><b> Código: </b></span>'); $this->campos['codigo'] = new GtkEntry; $this->campos['codigo']->set_size_request(80,-1); $this->labels['nome'] = new GtkLabel('Nome: '); $this->campos['nome'] = new GtkEntry;

284 PHP-GTK Criando Aplicações Gráficas com PHP 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, o que 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(), enquanto 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. Essas 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 é definido quando 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étodo append_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 abre uma conexão com o banco de dados sqlite por meio do método sqlite_open(), realiza

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, declarando 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ção O 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 partir de 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. 305

306 PHP-GTK Criando Aplicações Gráficas com PHP 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 sobre esse 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 qualquer um desses elementos para o desenho da aplicação.alguns elementos adicionais ainda 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.

324 PHP-GTK Criando Aplicações Gráficas com PHP 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.

Capítulo 9 Utilizando o Glade 325 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 glade parent:: construct($arquivo_glade); // conecta os seus sinais à métodos desta classe parent::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();

328 PHP-GTK Criando Aplicações Gráficas com PHP 9.9 Emitindo notas fiscais No 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 dados 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 figura 9.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.

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 anteriores.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 login O 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 de Usuário e Senha. Caso ele acerte usuário= maria senha= abacaxi, a classe Application será 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. 340

Capítulo 10 Extras 345 10.3 Relógio Neste exemplo, há um relógio digital formado por um objeto GtkLabel. Essa funcionalidade é 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 seu mé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('<b>'. date("h:i:s"). '</b>'); } // Programa nova execução para daqui há 1 segundo Gtk::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);

346 PHP-GTK Criando Aplicações Gráficas com PHP // 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-segundo Gtk::timeout_add(1, 'AtualizaClock'); Gtk::Main();?> 10.4 Movendo objetos Neste 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().

Capítulo 10 Extras 359 // instancia Exemplo new ExemploListaStock; Gtk::Main();?> 10.9 Fechando uma janela Este 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, mostrado na 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étodo Gtk::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.

376 PHP-GTK Criando Aplicações Gráficas com PHP Em seguida definimos qual será a coluna do modelo que representará a imagem do í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 itemactivated, 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(). iconview.php <?php Figura 10.18 Programa exemplo. // 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);

Capítulo 10 Extras 379 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). 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); Figura 10.19 Programa exemplo. $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);