Delphi++: Primeiras impressões
Autor: Fabius Lovato | Publicado: 2010-08-06T20:30:00-03:00

Nas últimas semanas tenho lido em foruns alguns post bastante tímidos sobre um tal de Delphi++. Na maioria das vezes&nbsp;contendo o comentário de um ou mais membros classificando-o como fake.
Bom, resolvi ir atrás do tema para entender realmente do que se tratava&nbsp;e, para minha surpresa, encontrei uma nova ferramenta de desenvolvimento com uma proposta no mínimo interessante e que, ao meu entender, tem a intenção de brigar por um lugar ao sol.

Nesse artigo não irei descrever o que é o Delphi++, sua proposta nem todos os recurso que possui, mas sim comentar as primeiras impressões sobre seu IDE comparando-o com o do Delphi.

Instalação
No site oficial ++Technologies&nbsp;é possível fazer o download da versão beta,&nbsp;após registrar-se.
Essa é a primeira versão do IDE e está ainda em estágio beta (v1.0.43.b) mas&nbsp;é simplesmente fantástica, considerando o que ela já oferece.
Ao fazer o download notei que a instalação possua pouco menos de 12&nbsp;MB. Isso fez baixar a expectativa de encontrar um boa ferramenta de desenvolvimento. E se comparar com a instalação do Delphi 2010, 12MB representa pouco mais do que nada.


A instalação é muito tranquila sem nada de diferente. Basta um Next, Next, Nex e pronto.

Inicialização
Logo na tela de abertura já se pode notar um incrível semelhança com o Delphi da Embarcadero.


Na tela de spash nenhuma informação é apresentada que dê ideia do que está sendo realizado durante o start up. E apesar da instalação ser leve, a abertura do IDE passou a impressão de não ser tão leve assim.

IDE
A semelhança com o Delphi não ficou somente somente na tela de spash, todo o IDE é muito familiar. Até mesmo a disposição dos painéis e tools.


Tool Palette
Aqui está um ponto muito interessante.
O Delphi++ conta com&nbsp;muitos dos componentes básicos que são oferecidos pelo Delphi, inclusive componentes para acesso a banco de dados.
O fato de ser utilizado o mesmo ícone para os componentes de mesma proposta facilita bastante sua localização.
Abaixo está a lista de todos os componentes que estão contidos em cada uma das paletas.


Não há muito o que customizar na exibição esse Tool Panel. Na verdade essa é uma característica comum a todas as Tool Panel do IDE. A interface é um tanto rígida e não há quase opções de customização.
Comparando com a Tool Palette do Delphi, o que mais senti falta é da usabilidade do Tool Palette. Enquanto que no Delphi pode-se acrescentar um componente na tela com um duplo-click sobre o componente ou com um arrasta-e-solta, no Delphi++ é requerido que vc necessariamente selecione o componente na Tool Palette e clique no formulário para dropá-lo.

Object Inspector
Na primeiras olhadas para o Object Inspector o que mais chama a atenção é colorido nos nomes das propriedades.
Diferentemente do que é feito nas versões 2009 e 2010 do Delphi, a apresentação das propriedades no Object Inspector não&nbsp;é agrupadas por categoria, elas são apresentadas uma abaixo a outra em ordem alfabética. Infelizmente também não há&nbsp;opções de rearranjamento ou reagrupamento.
Depois de um tempo, olhando com atenção percebe-se que a cor da na qual as propriedades são exibidas dependente do seu tipo. Por exemplo, observe na imagem ao lado. Todas as propriedades da cor verde são do tipo Boolean, assim como as que são do tipo Integer estão em roxo.

Em relação aos tipos de propriedades apresentadas e comparando com&nbsp;as apresentadas no Delphi 2010, notei que há pouquíssimas diferenças, e todas as que identifiquei se tratavam de propriedades que foram acrescentando na versão 2010.
O mesmo ocorre com os tipos de eventos.

Editor
O editor do código fonte&nbsp;trás muitos dos recursos originais do Delphi, inclusive utiliza as mesmas teclas de atalho para tarefas comuns (por exemplo o F12 que alterna entre o modo de design e de edição). No entanto nem tudo funciona 100% e o editor passa uma impressão de não ser muito maleável.
Nas primeiras linhas de código escrito notei que o TAB não identava o código; ainda não há um auto-complete, live-template, code parameters&nbsp;e outras facilidades.
Para que está acostumado com o code-completion (CTRL + Space) certamente irá sentir um pouco de desconforto. Nos release testada o popup só era apresentado&nbsp;após o pressionamento&nbsp;o ponto final (".").
A editor de design do Delphi++ também tem várias limitações. O que notei é que o usuário precisa utilizar constantemente o mouse para ajustar o focus no ponto correto. Isso dificulta muito a alternância entre o formulário e o Object Inspector durante, por exemplo,&nbsp;a tela de criação&nbsp;e design dos formulários.

Mãos a obra
Depois de analisar esses e muitos outros recursos, resolvi colocar a mão na massa e implementar alguma coisa para avaliar a linguaguem propriamente dita.
Comecei dropando alguns componentes no formulário, ajustando algumas propriedades, alinhando os componentes, acrescentei um MainMenu, inclui alguns itens no menu, ...

Quando dei um duplo-click sobre um dos itens do menu com a intenção de implementar o evento OnClick, a duas pequenas diferenças surgiram. Uma é a declaração do evento não incluir o nome da classe (algo como procedure TForm1.menuOpenOnClick ...); a segunda foi ver que em vez de TObject, o parâmetro Sender do evento é do tipo any.

var
&nbsp; gFileName: string;

procedure menuOpen_OnClick(Sender: any);
var
&nbsp; lFStream: TFileStream;
&nbsp; lCharacter: Char;
&nbsp; lBuffer: string;
&nbsp; lSize: Integer;
begin
&nbsp; if self:dlgOpen.Execute then
&nbsp; begin
&nbsp;&nbsp;&nbsp; lFStream := TFileStream.Create(self:dlgOpen.FileName, fmOpenRead);
&nbsp;&nbsp;&nbsp; try
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; lBuffer := '';
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; while lFStream.Read(lCharacter, 1) = 1 do
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; lBuffer := lBuffer + lCharacter;

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; self:memFile.Lines.Text := lBuffer;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; gFileName := self:dlgOpen.FileName;
&nbsp;&nbsp;&nbsp; finally
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; lFStream.Free;
&nbsp;&nbsp;&nbsp; end;
&nbsp; end;
end;
Estava esperando visualizar uma unit com a estrutura de um arquivo pascal padrão (secões: unit, interface, type e&nbsp;implementation), mas tudo que se observa é a declaração dos métodos.
No método acima é a implementação do evento OnClick da opção "Open" do menu "File" que foi acrescentado no formulário.
A simples tarefa de abir um arquivo e importar seu conteúdo para um componente TMemo demandou um tempinho considerável porque a estrutura do arquivo e&nbsp;a bliblioteca de funções não são iguais ao do Delphi.
Inicialmente comecei tentando utilizar as funções FileOpen, FileRead e FileClose para acesso ao arquivo desejado, mas sempre era exibida uma mensagem de erro indicando que tal função não existia. Não há a cláusula "uses", para fazer a importação/referência&nbsp;a units.
Então, depois de um tempo notei que entre&nbsp;as mais&nbsp;de 400 classes oferecidas pelo Delphi++, TFileStream estava incluída.
Outro ponto bastante importante é que a referência para componentes do formulário não é feito digitando o nome do componente diretamente, é necessário incluir "self:".

OBS: Para aqueles que já implementaram ou tiveram algum tipo de contato com o código fonte de macros em aplicativos office, por exemplo, perceberá uma semelhança.

procedure menuNew_OnClick(Sender: any);
begin
&nbsp; self:memFile.Lines.Text := '';
&nbsp; gFileName := '';
end;

procedure menuSave_OnClick(Sender: any);
var
&nbsp; lFStream: TFileStream;
&nbsp; lSize, i: Integer;
&nbsp; lText: string;
begin
&nbsp; if gFileName = '' then
&nbsp;&nbsp;&nbsp; if self:dlgSave.Execute then
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; gFileName := self:dlgSave.FileName;

&nbsp; if gFileName &lt;&gt; '' then
&nbsp; begin
&nbsp;&nbsp;&nbsp; lFStream := TFileStream.Create(gFileName, fmCreate or fmOpenWrite);
&nbsp;&nbsp;&nbsp; lText := self:memFile.Lines.Text;
&nbsp;&nbsp;&nbsp; lSize := Str.Len(lText);

&nbsp;&nbsp;&nbsp; for i := 1 to lSize do
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; lFStream.Write(lText[i], 1);

&nbsp;&nbsp;&nbsp; lFStream.Free;
&nbsp; end;
end;
A implementação do evento OnClick da opção "Save" do menu, também foi um pequeno desafio a parte.
Custou um tempo descobrir que a função "Length" (que retorna o número de caracteres de uma string) não existe e que em vez dela deve-se utilizar "Str.Len".
Na verdade "Str." concentra a maioria das funções de manipulação de strings. Assim como "Date." é o ponto de partida para encontrar funções de manipulação de data.

procedure menuExit_OnClick(Sender: any);
begin
&nbsp; Self.Close;
end;

constructor
begin

end.
Uma divergência com relação a maioria das ferramentas de desenvolvimento é que todo o projeto é armazenado em um único arquivo e na forma binária. Se você abrir o arquivo de projeto com um editor de texto, não irá identificar o código fonte. A visualização e edição fica restrita exclusivamente ao IDE do Delphi++.

Caso deseje visualizar o projeto inteiro, pode&nbsp; fazer o download&nbsp;nesse link.

Conclusões
Ao meu ver o Delphi++ é (me desculpe o termo) uma intenção de cópia do Embarcadero RAD Studio que está em um estágio prematuro, mas que já mostra ser uma alternativa.
O IDE segue a tendência atual das ferramentas de desenvolvimento de não ser exclusivo ao suporte&nbsp;de uma única linguagem de programação, e&nbsp;isso é muito bom. Entretanto, na atual versão (1.0 beta 2) ainda há muito o que ser feito, melhorado, e a ser corrigido,&nbsp;para poder oferecer aos usuários um experiência adequada e um ambiente que proporcione agilidade&nbsp;no desenvolvimento.
A falta de documentação é outro ponto negativo que dificulta bastante os primeiros passos, mas aos que já conhecem a linguagem rapidamente resolve os&nbsp;impasses.
Por outro lado essa é uma conclusão comparada com o RAD Studio 2010, que é uma ferramenta madura e que tem sido constantemente evoluída desde, se não estou enganado, 1995.
Se formos considerar que o Delphi++ ainda está em fase beta, não há como desmerecer esse fabuloso trabalho, ainda mais pelo fato de que já nessa versão beta é oferecido suporte multi-plataforma (recurso previsto somente para a versão 2011 do RAD Studio, e olha lá). 
&nbsp; 
No mínimo eu concluo que vale a pena acompanhar o decorrer dos fatos.