
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!