O documento é uma introdução ao Fast Light Toolkit (FLTK), abordando a criação e extensão de widgets através de herança e subclassing. Ele detalha métodos comuns e manipulação de eventos nos widgets, além de recursos de desenho e composição de widgets. Exemplos de código ilustram a construção de classes e a utilização de métodos para a criação de interfaces gráficas com o FLTK.

1. 1 de 15INTRODUÇÃ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
5º Impacto

2. 2 de 15ADICIONANDO E EXTENDENDO WIDGETS
Compondo e
Extendendo Widgets
[Exemplo de hierarquia de classes do pacote FLTK]

3. 3 de 15
Novos widgets são criados através de herança ou
subclassing de widgets já existentes no FLTK.
Tipicamente usasse a classe Fl_Widget para controles
simples e Fl_Group para widgets compostos.
Subclassing
[Exemplo de alguns widgets simples e compostos pertencentes ao pacote fltk]
SUBCLASSING

4. 4 de 15
Widget Methods
MÉTODOS COMUNS A MAIORIA DOS WIDGETS DO FLTK
Cada classe de widget dentro do FLTK provê um conjunto
de métodos que manipula o estado/valor das propriedades
dos objetos derivados dessas classes.
– widget->position(x, y)
– widget->resize(x, y, width, height)
– widget->size(width, height)
– widget->color(color) (ex: FL_BLUE)
– widget->labelcolor(color)
– widget->when(event)
– widget->callback(static_function, data)

5. 5 de 15CONSTRUINDO UMA SUBCLASSE DE FL_WIDGET
Subclasses de Fl_Widget
Nossas classes podem descender diretamente de Fl_Widget
ou de qualquer classe derivada [subclasse] da mesma.
Fl_Widget possui 4 métodos virtuais que podem ser
sobrepostos se necessário [draw, handle, resize e ~Fl_Widget].
MyClass(int x, int y, int w, int h, const char *label = 0);
Construtor padrão :
MyClass::MyClass(int x, int y, int w, int h, const char *label)
: Fl_Widget(x, y, w, h, label)
{
// do initialization stuff...
};
Invocando o construtor da classe base :

6. 6 de 15MÉTODOS PROTEGIDOS DE FL_WIDGET
Métodos Protegidos
São providos os seguintes métodos para uso em
subclasses.
– Fl_Widget::clear_visible
– Fl_Widget::damage
– Fl_Widget::draw_box
– Fl_Widget::draw_focus
– Fl_Widget::draw_label
– Fl_Widget::set_flag
– Fl_Widget::set_visible
– Fl_Widget::test_shortcut
– Fl_Widget::type

7. 7 de 15MANIPULANDO 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_*().

8. 8 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.

9. 9 de 15
Drawing – Desenhando Widgets
UTILIZAÇÃO DAS PRIMITIVAS DE DESENHO DO FLTK
O desenho em widgets no FLTK é ativado/executado
através da chamada ao método virtual Fl_Widget::draw().
São fornecidas várias rotinas de desenho pelo FLTK:
• Pontos fl_point(x, y)
• Linhas fl_line(x, y, x1, y1)
• Polígonos fl_polygon(x, y, x1, y1, x2, y2)
• Elipses fl_arc(x, y, w, h, a1, a2)
• Textos fl_draw(text, x, y)
• Caixas fl_draw_box(Fl_Boxtype,x,y,w,h,Fl_Color)
• Imagens fl_draw_image(uchar *, X, Y, W, H, D, LD)
• Overlays fl_overlay_rect(x, y, w, h)

10. 10 de 15
Drawing – Exemplo
UTILIZAÇÃO DAS PRIMITIVAS DE DESENHO DO FLTK - EXEMPLO
#include <FL/Fl.H>
#include <FL/Fl_Window.H>
#include <FL/fl_draw.H>
class Drawing : public Fl_Widget
{
void draw()
{
fl_color(FL_WHITE);
fl_arc(140,140,70,0,-360);
fl_end_line();
}
public:
Drawing(int X,int Y,int W,int H)
: Fl_Widget(X,Y,W,H) {}
};
int main(int argc, char** argv)
{
Fl_Window window(300,300);
Drawing drawing(10,10,280,280);
window.end();
window.show(argc,argv);
return Fl::run();
}
[Exemplo “Drawing” ]

11. 11 de 15
Composição
CONSTRUINDO WIDGETS POR COMPOSIÇÃO
Um widget construído por composição possui um ou mais
widgets “filhos”. Para construir um widget por
composição devemos “herdar” de Fl_Group.
class MyClass : public Fl_Group
{
Fl_Button the_button;
Fl_Slider the_slider;
//...
};
Exemplo de construção por composição :
MyClass::MyClass(int x, int y, int w, int h) : Fl_Group(x, y, w, h),
the_button(x + 5, y + 5, 100, 20), the_slider(x, y + 50, w, 20)
{
//...(you could add dynamically created child widgets here)...
end(); // don't forget to do this!
}

12. 12 de 15CONSTRUINDO UMA SUBCLASSE DE FL_WINDOW
Subclasses de Fl_Window
Exemplo de criação de widget através
de composição. Notem que usamos
um Fl_Window, pois o mesmo herda
de Fl_Group.

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

14. 14 de 15PENSAMENTO DO DIA !
Provérbio Japonês
“No centro de toda ação está oculta a
tranquilidade ...”

15. 15 de 15FIM !!!