Desenvolvendo aplicações GNUstep

Sempre fui fascinado pelo NeXTSTEP e gostaria muito tivesse dado certo. Por mais que a Apple negue, seu Mac OS X não é muito mais do que uma versão nova de um NeXTSTEP portado para equipamentos MacIntosh.

Mas não só o OS X herdou os recursos do NeXTSTEP. No começo da década de 1990, em colaboração com a SUN Microsystems a NeXT lançou o OpenStep, uma especificação aberta que define a API para o NeXTSTEP.

Assim ambientes baseados em NeXTSTEP podem rodar em quaisquer sistemas operacionais e aplicações portáteis podem ser criadas.

A Free Software Foundation lançou um projeto de implementação da API OpenStep para sistemas GNU, o GNUstep.

Mais do que uma API de programação, GNUstep é todo um ambiente, desde a API até aplicações e ambiente operacional.

Inicialmente o ambiente gráfico / geranciador de janelas era o AfterStep. Certo dia, na lista de discussão para definir os rumos da versão 2 do AfterStep, um brasileiro chamado Alfredo Kojima sugeriu a reescrita do código do zero.

Enquanto o grupo continuava debadendo, Kojima decidiu iniciar o desenvolvimento da versão 2 do AfterStep, codinome WindowMaker, por conta própria e depois apresentou-o à comunidade. O Window Maker então substituiu o AfterStep como gerenciador de janelas do projeto GNUstep e o AfterStep continuou seu desenvolvimento a parte.

Diversas versões do Window Maker foram lançadas, apesar de nunca ter chegado a uma versão 1.0, um eterno beta – atualmente se encontra na versão 0.92. Porém seu desenvolvimento esfriou gradativamente.

Ano passado o projeto voltou a esquentar e promessas de novas versões estão no ar, o que me inspirou a escrever este artigo.

Consulte o blog do Bardo.

GNUstep

Mas este artigo não é sobre Window Maker, e sim sobre GNUstep.

Para desenvolver aplicações GNUstep, você precisa baixar seu core antes. Acesse a página de recursos, vá ao tópico GNUstep Core e baixe as versões estáveis de cada pacote. Descompacte, compile e instale na ordem em que os pacotes aparecem na tabela (startup, make, base, gui e backend). O core do GNUstep deverá ser instalado em /usr/GNUstep/.

Você precisa acrescentar /usr/GNUstep/System/Tools a seu path de executáveis, /usr/GNUstep/System/Library/Libraries a sua lista de diretórios de bibliotecas – em ambiente GNU/Linux, acrescente esse path ao arquivo /etc/ld.so.conf e execute ldconfig – e crie uma variável de ambiente GNUSTEP_MAKEFILES com o valor /usr/GNUstep/System/Library/Makefiles e outra GNUSTEP_INSTALLATION_DOMAIN com o valor SYSTEM.

Tendo o GNUstep instalado, podemos partir para as ferramentas de desenvolvimento, Gorm e Project Center. Você também encontrará apontadores para as versões estáveis na mesma máquina de recursos, no tópico GNUstep Development Tools.

Criando um projeto

Vamos criar nosso primeiro projeto GNUstep!

Primeiro abrimos o Project Center com o comando:

bash$ openapp ProjectCenter

Vá em Project → New... (ou pressione M-n), vai abrir uma janela de diálogo pedindo o nome do projeto. Selecione o tipo Application e forneça o nome Temperature e clique Ok.

Por enquanto nossa brincadeira com Project Center acaba por aqui. Pode salvar – Project → Save ou M-s – e sair – Quit ou M-q.

Criando uma aplicação

Agora vamos trabalhar no Gorm, execute:

bash$ openapp Gorm

Um segredinho: nas versões anteriores você mandava abrir o Temperature.gorm a partir do Project Center e ele já abria o Gorm para a aplicação atual. Na versão que experimentei – Gorm 1.2.6 e Project Center 0.5.0 – há um bug. O truque é abrir o Gorm a parte e criar uma nova aplicação.

Se quiser testar se está funcionando – em algumas lugares que testei funcionou – para abrir o Gorm, na janela principal do Project Center clique em Interfaces e duplo clique em Temperature.gorm.

No Gorm, crie uma janela e marque como Visible at launch time.

No Gorm então acesse Document → New Application, depois vá em Document → Save As.... Na janela de diálogo encontre seu projeto Temperature, dentro dele Resources e, dentro desse, salve como Temperature.gorm – confirme o Replace.

Vão abrir três janelas: Main Menu, My Window e Temperature.gorm. Se as janelas Palettes e Inspector não estiverem abertas, encontre-as no menu Tools.

Selecione a janela My Window – ela representa a janela principal da aplicação – e veja em Inspector o campo Title contendo My Window – se não estiver vendo, mude o seletor para Attributes. Mude o título para Temperature Converter – repare que o título da janela My Window também mudou.

Repare que na janela Palettes tem alguns widgets. Para acrescentar um widget à janela é só segurar e arrastar (drag'n'drop). Vamos acrescentar três tipos de widget: Text, System Bold e Button. Adicione componentes até ficar mais ou menos com a cara deste corte:


Para mudar o texto de um widget, use o duplo clique. Você também pode mudar a borda no Inspector. Altere os widgets até ficarem mais ou menos assim:


Agora é hora de criar a classe para gerenciar essa janela! Hora de codar? Ainda não…

Na janela Temperature.gorm, na barra principal clique em Classes e selecione NSObject – futuca um pouco que você acha. No menu Operations selecione SubClass. Na lista da direita vai aparecer NewClass e o Inspector vai selecioná-lo – veja a caixa Class com NewClass. Mude o nome da classe para ConverterManager. Apenas confirme na janela Modifying Class.

Podemos agora criar os atributos (outlets) e métodos da classe (actions).

Vamos criar um atributo para cada caixa de texto que criamos – incluside a de Kelvin.

Na janela Inspector há a aba Outlets (0) com o botão Add. Clique nesse botão e teremos NewOutlet com um duplo clique você será capaz de mudar seu nome para degreeC.

Crie mais dois atributos: degreeF e kelvin.

Para criar o primeiro método acesse a aba Actions (0) e siga o mesmo procedimento anterior. Os métodos serão chamados convertC2F: e convertF2C:.

E a classe já está pronta!

Instanciando a classe

Mantendo a classe ConverterManager, no menu principal do Gorm selecione Classes → Instantiate. Na janela Temperature.gorm aparecerá um objeto ConverterManager: é agora que vem parte da mágica…

Precisamos inicialmente ligar o atributo degreeC dessa instância à primeira caixa de texto da janela (ao lado do rótulo °C).

Segure a tecla Ctrl, clique sobre a instância, segure e arraste, solte sobre a caixa de diálogo – vai aparecer um T na caixa –, então, na janela Inspector selecione degreeC e clique no botão Connect. Vai aparecer um S sobre a instância e, na janela Inspector, em Connections, vai aparecer: degreeC (TextField(0)).

Faça o mesmo para as outras caixas ligando cada caixa a um atributo.

Agora precisamos fazer com que os botões acionem métodos da instância, para isso o procedimento é o inverso: segurando a tecla Ctrl clique sobre o botão Celsius to Fahrenheit, segure, arraste e solte sobre a instância de ConverterManager na janela Temperature.gorm.

Na janela Inspector clique em target → convertC2F: e então clique no botão Connect.

Faça o mesmo para conectar o outro botão ao outro método. Agora todas as ações estão conectadas!

Salvando tudo

Na janela Temperature.gorm, selecione Classes e encontre a classe ConverterManager. Selecione-a, então, no menu principal do Gorm clique em Classes → Create Class Files. Apenas confirme as duas janelas de diálogo. Isso criará os dois arquivos ConverterManager.m e ConverterManager.h dentro de Resources.

Agora clique em Document → Save All e Quit.

De volta ao Project Center

Volte ao Project Center e clique em Project → Open... e abra o arquivo PC.project do projeto Temperature.

Na janela principal do projeto dê um duplo clique em Classes e depois em ConverterManager.m, isso adicionará o código ao projeto do Project Center.

Finalmente o código!

Precisamos finalmente editar o conteúdo dos métodos. Duplo clique sobre ConverterManager.m na janela principal e vai abrir a janela do editor:

/* All Rights reserved */

#include <AppKit/AppKit.h>
#include "ConverterManager.h"

@implementation ConverterManager


- (void) convertC2F: (id)sender
{
  /* insert your code here */
}


- (void) convertF2C: (id)sender
{
  /* insert your code here */
}

@end

O código é Objective C, um variante orientado a objetos de C que lembra um pouco Smalltalk.

O método covertC2F deve obter o valor do atributo degreeC – que está ligado à caixa de diálogo com o valor em graus Celsius –, calcular e ajustar os valores em Fahrenreit e Kelvin:

- (void) convertC2F: (id)sender
{
  float celsius = [degreeC floatValue];
  float fahrenreit = (9.0f * celsius / 5.0f) + 32.0f;

  [degreeF setStringValue: [NSString stringWithFormat: @"%1.2f",
    fahrenreit]];

  [kelvin setStringValue: [NSString stringWithFormat: @"%1.2fK",
    (celsius + 273.15f)]];
}

O método convertF2C deve fazer o contrário:

- (void) convertF2C: (id)sender
{
  float fahrenreit = [degreeF floatValue];
  float celsius = 5.0f * (fahrenreit - 32.0f) / 9.0f;

  [degreeC setStringValue: [NSString stringWithFormat: @"%1.2f",
    celsius]];

  [kelvin setStringValue: [NSString stringWithFormat: @"%1.2fK",
    (celsius + 273.15f)]];
}

Salve agora (M-s) e feche o editor. Clique no ícone com a chave de fenda para compilar:


Na janela de build há outro ícone igual, clique nele para compilar. Se tudo correr bem você verá uma bela mensagem:

=== Build succeeded! ===

Se falhar, volte e veja o que está errado.

Clique então no ícone do foguete para rodar:


Na janela Launch clique no mesmo ícone e a janela irá abrir. Faça alguns testes para ver se funciona bem.

Para sair clique com o botão direito e escolha Quit.

Se tudo funcionar bem, seu programa está pronto! Salve tudo em Project → Save.

Instalando a aplicação

Para instalar, abra um terminal:

bash$ cd Temperature/
bash$ make
bash$ sudo make install

Assim sua aplicação estará instalada em /usr/GNUstep/System/Applications/Temperature.app – ou /usr/GNUstep/Local/Applications/Temperature.app, se você se esqueceu de ajustar o conteúdo da variável de ambiente GNUSTEP_INSTALLATION_DOMAIN – e você executá-la com o comando:

bash$ openapp Temperature

Conclusão

Espero que com este artigo algumas pessoas se interessem pelo desenvolvimento de aplicações para ambiente GNUstep, que aliás roda sobre Mac OS X também – em plataforma OS X, o WINGs (toolkit de widgets para Window Maker) e o GNUstep são abstrações do Cocoa, toolkit de widgets do OS X.

A facilidade de desenvolvimento de aplicações gráficas para GNUstep com Project Center e Gorm é incrível, apesar de seu jeitão esquisito e do uso da tremendamente estranha linguagem de programação Objective C.

[]'s
Cacilhas

PS: Eu já estava morrendo de sono quando escrevi este artigo, portanto alguns erros de português podem ocorrer. Por favor me avisem!