FLTK (pronounced "fulltick") is a cross-platform C++ GUI toolkit for UNIX®/Linux® (X11), Microsoft® Windows®, and MacOS® X. FLTK provides modern GUI functionality without the bloat and supports 3D graphics via OpenGL® and its built-in GLUT emulation. FLTK is designed to be small and modular enough to be statically linked, but works fine as a shared library. FLTK also includes an excellent UI builder called FLUID that can be used to create applications in minutes. FLTK is provided under the terms of the GNU Library Public License, Version 2 with exceptions that allow for static linking. More informations in http://www.fltk.org.

1. 1 de 15
INTRODUÇÃO AO FAST LIGHT TOOLKIT - FLTK
The Fast Light ToolKit
Curso de Verão – Instituto de Computação & CA Computação
Michel Alves dos Santos - UFAL
Bolsista do Centro de Pesquisa em Matemática Computacional
6º Impacto

2. 2 de 15
MODELO DE PROCESSAMENTO DE EVENTOS
Processamento de Eventos
Aplicações FLTK são baseadas em um modelo simples de
processamento de eventos.
Ações de usuário (keystrokes, mouse clicks, etc) causam eventos que
são enviados a janela ativa
Idle, timer e file events são disparados internamente
Aplicações FLTK devem “escutar” ativamente eventos de
processamento oriundos da fila de eventos
Fl::check() - checa se existem eventos na fila
Fl::wait() - espera pelo aparecimento de um evento
Fl::run() - estabelece o processamento de um evento

3. 3 de 15
Processamento de Eventos - Exemplo
UTILIZANDO O RELÓGIO DO SISTEMA PARA EXECUÇÃO DE FUNÇÕES PERIÓDICAS
#include <iostream>
#include <FL/Fl.H>
#include <FL/Fl_Window.H>
/*Declaração de namespace para uso das funções de iostream*/
using namespace std;
/*Contador para número de vezes que passou pelo evento ...*/
int Contador = 0;
void MyCallback(void*)
{
cout << "TICK : " << ++Contador << " " << endl;
Fl::repeat_timeout(1.0, MyCallback);
}
/**
* Função principal do programa.
*/
int main(int argc, char* argv[])
{
Fl_Window win(300,150,"Timer Event ...");
win.show();
Fl::add_timeout(1.0, MyCallback);
return(Fl::run());
}
[Manipulando o timeout de eventos]

4. 4 de 15
FLTK Callbacks e Eventos
COMO RESPONDER A EVENTOS DENTRO DO FLTK – USO DE CALLBACKS
Callbacks ligam funções a eventos.
widget->when(event): determina para qual evento uma
função callback será executada. Exemplos:
• widget->when(FL_WHEN_ENTER_KEY)
• widget->when(FL_WHEN_RELEASE)
widget->callback(mycallback,data): estabelece que
função será chamada e que dados serão passados no
momento em que ocorrer um determinado evento.
• Funções callback devem ser estáticas [ static ]
• Funções callback fornecem um ponteiro Fl_Widget [que
aponta para o widget que foi modificado] e um ponteiro do tipo void

5. 5 de 15
Eventos
TIPOS DE EVENTO DO FLTK
Eventos são passados como argumento para o método
virtual Fl_Widget::handle(int). Exemplos :
• Eventos de Mouse : FL_PUSH, FL_RELEASE, FL_MOVE, …
• Eventos de Foco : FL_FOCUS, FL_LEAVE, ...
• Eventos de Teclado : FL_KEYDOWN, FL_KEYUP, ...
Tipos de evento e conteúdo são avaliados via métodos
Fl::event_*(). Exemplos:
• Fl::event_button()
• Fl::event_x()
• Fl::event_key()

6. 6 de 15
Mouse Events
EVENTOS TIPICAMENTE RELACIONADOS AO MOUSE
FL_PUSH: Quando o botão do mouse está pressionado e o
ponteiro continua sobre o widget;
• FL_DRAG: Quando o mouse é movido, sendo que um de seus
botões continua pressionado [ou em estado FL_PUSH];
• FL_RELEASE: Quando o botão do mouse é liberado;
• FL_MOVE: Quando o ponteiro do mouse é movido sem que
nenhum de seus botões esteja pressionado;
• FL_MOUSEWHEEL: Quando o usuário interage com o botão
“scroller” do mouse.

7. 7 de 15
Focus Events
EVENTOS TIPICAMENTE RELACIONADOS AO GANHO OU PERDA DE FOCO
FL_ENTER: Ocorre quando o mouse é movido para o ponto
ou as coordenadas nas quais se encontra um determinado
widget;
FL_LEAVE: Ocorre quando o mouse é movido para fora de
um determinado widget;
• FL_FOCUS: Indica que um determinado widget possui o foco
de ações advindas do teclado, ou seja, nesse momento o
widget pode receber eventos do tipo FL_KEYDOWN, FL_KEYUP e
FL_UNFOCUS;
• FL_UNFOCUS: Ocorre quando um widget perde o foco para
outro ou quando a janela ativa perde o foco;

8. 8 de 15
Keyboard Events
EVENTOS TIPICAMENTE RELACIONADOS AO TECLADO
• FL_KEYDOWN: Ocorre quando uma tecla é pressionada,
porém o evento se passa realmente quando a tecla está em
estado “DOWN” depois disso, se essa tecla continua
pressionada o evento FL_SHORTCUT é “constantemente
testado”;
• FL_KEYUP: Ocorre quando a tecla que anteriormente estava
em estado FL_KEYDOWN é liberada;
• FL_SHORTCUT: Tenta atender aos pedidos de execução de
atalhos via teclado. Se Fl::focus() retornar zero ou ignorar
eventos do tipo FL_KEYBOARD então o FLTK tentará enviar o
evento para todo o widget que poder, até que um deles retorne
algo diferente de zero;

9. 9 de 15
Widget Events
EVENTOS TIPICAMENTE RELACIONADOS AOS COMPOENTES EM GERAL
FL_DEACTIVATE: Ocorre quando um widget ou o seu
“conteiner” é desativado. Widgets nessa situação não podem
receber o foco;
FL_ACTIVATE: Ocorre quando um widget ou o seu
“conteiner” é ativado;
• FL_HIDE: Ocorre quando um widget é “escondido”, ou seja,
quando não pode ser visualizado;
• FL_SHOW: Ocorre quando um widget está visível ou
novamente ganha visibilidade ou ainda quando sua janela-
mestre é restaurada [ganha novamente visibilidade].

10. 10 de 15
Fl::event_*() methods
FUNÇÕES INLINE PARA TRATAMENTO DE EVENTOS
FLTK mantêm informações sobre eventos recentes em
estruturas e variáveis estáticas [static]. Informações que
são válidas dentro dos métodos handle(int) e callback().
Essas funções são todas inline, portanto pequenas e
muito rápidas:
Fl::event_button [FL_LEFT_MOUSE, FL_MIDDLE_MOUSE e FL_RIGHT_MOUSE]
Fl::event_clicks [verifica a existência de um “double click”]
Fl::event_is_click [verifica se ocorreu mesmo um click]
Fl::event_key [FL_Button + n, FL_Tab e as demais teclas ...]
Fl::event_x [retorna a posição x do mouse]
Fl::event_y [retorna a posição y do mouse]
entre outras ...

11. 11 de 15
MANIPULANDO EVENTOS
Manipulando Eventos
• Mudar o estado de um widget;
• Executar Fl_Widget::redraw() se algum widget precisa ser reexibido;
• Executar Fl_Widget::damage(n) se algum widget precisa ser atualizado;
• Executar Fl_Widget::do_callback() se um callback pode ser gerado;
• Executar Fl_Widget::handle(int) para widgets filhos;
O método virtual int Fl_Widget::handle(int event) é chamado
para manipular cada evento passado a um widget. Como
consequência disso ele pode :
Eventos são identificados por argumentos inteiros
[FL_PUSH, FL_RELEASE, FL_MOVE, FL_FOCUS, FL_LEAVE] e tipos de
evento e conteúdo são avaliados via métodos Fl::event_*().

12. 12 de 15
Exemplo de Manipulação de Eventos
MANIPULANDO EVENTOS - EXEMPLO
Este é um simples exemplo
de manipulação de eventos
através do método virtual int
Fl_Widget::handle(int event).
Podemos notar que os únicos
eventos tratados são : PUSH,
RELEASE e SHORTCUT. Os
demais eventos são
redirecionados ao método
manipulador original.
Nesse exemplo quando a tecla ’x’ é
pressionada o callback padrão
associado ao widget é executado.

13. 13 de 15
DÚVIDAS ?
Dúvidas ?

14. 14 de 15
PENSAMENTO DO DIA !
Henry W. Longfellow (1807-1882), poeta americano.
“Gasta-se menos tempo fazendo a coisa certa,
do que explicando por que a fizemos errado.”

15. 15 de 15
FIM !!!