Tutorial: Janela simples

De posse de um ambiente de desenvolvimento todo configurado, passemos à parte mais interessante: o código.

Neste tutorial, ensinarei a criar uma janela simples, vazia. Essa janela será, naturalmente, a nossa janela principal, e será incrementada a cada tutorial.

Sendo essa janela a principal, ela dever ser derivada da classe FXMainWindow.

Obs.: Toda classe no FOX Toolkit tem o prefixo FX.

FoxTutorialMainWindow.h

 /*
  * FoxTutorialMainWindow.h
  *
  *  Created on: 07/04/2009
  *      Author: edgar
  */

 #ifndef FOXTUTORIALMAINWINDOW_H
 #define FOXTUTORIALMAINWINDOW_H

 #ifndef FXMAINWINDOW_H
 #include <fox-1.6/FXMainWindow.h>
 #endif

 class FoxTutorialMainWindow : public FXMainWindow {
   FXDECLARE(FoxTutorialMainWindow)

 private:
   FoxTutorialMainWindow() {}

 public:
   FoxTutorialMainWindow(FXApp *a);

   virtual void create();

   virtual ~FoxTutorialMainWindow();
 };

 #endif /* FOXTUTORIALMAINWINDOW_H */

Analisando linha por linha:

15: A classe FoxTutorialMainWindow é derivada de FXMainWindow.

16: Macro para declaração de hierarquia. Obrigatório para todas as classes FOX.

19: Construtor default privado sem corpo. Obrigatório também.

22: Construtor público. É o que vamos utilizar. Recebe como parâmetro um ponteiro para FXApp, classe que representa uma aplicação FOX.

24: Todos os componentes FOX têm um método virtual void create(); aqui vamos sobrescrevê-lo.

26: Nosso destrutor.

FoxTutorialMainWindow.cpp

 /*
  * FoxTutorialMainWindow.cpp
  *
  *  Created on: 07/04/2009
  *      Author: edgar
  */

 #include <fox-1.6/fx.h>

 #include "FoxTutorialMainWindow.h"

 FXDEFMAP(FoxTutorialMainWindow) FoxTutorialMainWindowMap[] = {
 };

 FXIMPLEMENT(FoxTutorialMainWindow, FXMainWindow,
     FoxTutorialMainWindowMap,
      ARRAYNUMBER(FoxTutorialMainWindowMap))

 FoxTutorialMainWindow::FoxTutorialMainWindow(FXApp *a)
   : FXMainWindow(a, "Tutorial FOX", NULL, NULL, DECOR_ALL,
        0, 0, 200, 200) {
 }

 void FoxTutorialMainWindow::create() {
   FXMainWindow::create();

   show(PLACEMENT_SCREEN);
 }

 FoxTutorialMainWindow::~FoxTutorialMainWindow() {
 }

Analisando linha por linha:

8: fx.h é um arquivo de fachada que inclui quase todos os arquivos de cabeçalho do FOX Toolkit. Por enquanto, basta saber que ele inclui o suficiente para a interface gráfica de um programa comum.

Outro ponto que merece destaque é que todas as classes FOX estão dentro do namespace FX. O arquivo fx.h automaticamente instrui o compilador a usar esse namespace (using namespace FX;), a menos que a macro FX_NO_GLOBAL_NAMESPACE esteja definida. Mas cá entre nós, quem iria querer definir essa macro e usar FX::FXMainWindow? Detalhe: isso para todas as classes.

12-13: Definição do mapa de mensagens. Aqui é definido o tratamento de eventos, ou seja, a resposta da janela diante das ações do usuário. Como nossa janela não vai tratar nenhum evento por enquanto, ele fica vazio mesmo. Quando falarmos de tratamento de eventos, explicarei o mapa de mensagens com mais detalhes.

15-16: Implementação do mapa de mensagens. Esse é obrigatório. Os parâmetros dessa macro são:

• Nome da classe (FoxTutorialMainWindow)
• Nome da superclasse (FXMainWindow)
• Mapa de mensagens (FoxTutorialMainWindowMap)
• Número de entradas do mapa de mensagens. Para não haver a necessidade de atualizar manualmente esse valor sempre que colocar ou tirar uma entrada do mapa, o FOX provê a macro ARRAYNUMBER, que calcula o número de elementos de um vetor estático.

18-20: Construtor. Como nossa classe é derivada de FXMainWindow, aqui chamamos o construtor da superclasse para a devida inicialização. Mais tarde falarei especificamente da classe FXMainWindow; portanto, apenas saiba que os parâmetros passados são, respectivamente:

• a aplicação que será dona dessa janela
• título da janela
• ícone grande (o ícone que aparece quando se muda de janela com Alt+Tab)
• ícone pequeno (o que fica no canto da janela, na barra de título)
• decorações da janela (borda, barra de título, menu da janela etc.)
• posição X e Y da janela
• largura e altura da janela

Ou seja, estamos criando uma janela com as seguintes propriedades:

• chamada "Tutorial FOX"
• sem ícones (normalmente passa-se NULL para ambos, sendo ajustados dentro do construtor)
• com todas as decorações disponíveis (mais detalhes sobre isso mais tarde, em outro post)
• inicialmente posicionada no canto superior esquerdo da tela (0, 0)
• tamanho inicial de 200x200

22-26: Aqui sobrescrevemos o método create(). Na verdade, apenas o estendemos para que, além de criar a janela, ela possa ser automaticamente exibida. Neste caso, ela será exibida no centro da tela.

28-39: Nosso destrutor. A classe não tem nada de novo, então não há o que destruir explicitamente. Vazio.

main.cpp

É necessário fornecer uma função main() (não WinMain() ou qualquer outra específica de plataforma) para que o programa rode. Normalmente, pode ser implementada da seguinte forma:

 /*
  * main.cpp
  *
  *  Created on: 07/04/2009
  *      Author: edgar
  */

 #include <fox-1.6/fx.h>

 #include "FoxTutorialMainWindow.h"

 int main(int argc, char *argv[]) {
   FXApp app("Tutorial FOX", "Edgar Moraes Diniz");

   app.init(argc, argv);

   new FoxTutorialMainWindow(&app);

   app.create();

   return app.run();
 }

Analisando linha por linha:

12: Por favor, sempre declarem a função main() dessa forma, retornando um inteiro e recebendo dois parâmetros, argc inteiro e argv um vetor de strings. Nada de void main(void). Isso é válido para qualquer aplicativo, mesmo (e principalmente) em linha de comando.

13: Instancia um objeto FXApp, que representa nossa aplicação. Os parâmetros são o nome da aplicação e o fabricante.

15: Inicia o aplicativo, analisando os argumentos de linha de comando. Não adianta tentar burlar a regra da linha 12, passando 0 e NULL. O FOX não deixa.

17: Instancia a nossa janela. Aqui cabe uma discussão interessante sobre o FOX Toolkit.

Percebam que eu não atribuí a nenhum ponteiro. Simplesmente porque não é necessário. O único parâmetro que eu tenho para a janela é a minha aplicação. Essa aplicação vai armazenar o ponteiro para a janela. Quando a aplicação for destruída, ela destrói tudo o que é dela, incluindo essa janela.

Pode parecer estranho no começo (eu levei um certo susto quando vi...), mas com o uso, percebe-se que esse é uma enorme vantagem do FOX. E isso ocorre o tempo inteiro; quando povoarmos nossa janela, isso ficará claro. Resumindo: não preciso ficar me preocupando em destruir um monte de objetos; eles são destruídos por seus donos.

19: Cria a aplicação. Da mesma forma, chamar create() em um objeto FOX faz com que ele chame create() de todos os seus filhos, ou seja, aqui será criada (e, lembrem-se, exibida) nossa janela.

21: Roda a aplicação. É o loop principal do programa, que vai ouvir e tratar eventos.

Resultado

Depois de compilado, basta executar. O resultado:

Lembram do DECOR_ALL? Ele permite que você redimensione, minimize e maximize a janela (entre outros aspectos). Brinquem à vontade com isso. Mais tarde falaremos do poder que o FOX Toolkit oferece com relação a essas três operações.

Obs.: Essa janela não está assim por causa do FOX. O FOX é responsável somente por essa área acinzentada interna. As bordas são de responsabilidade do decorador de janelas (por isso o prefixo DECOR_). Estou usando aqui o Emerald, o decorador de janelas para usar com o Compiz Fusion.

---
Código-fonte para este tutorial.