Balaio Tecnológico

Trabalhando com Ações em Delphi e C++ Builder

2012-01-23T15:32:00.001-02:00

As operações que um usuário pode executar em programas com interface visual podem estar disponíveis de diversas maneiras. As formas mais óbvias e mais utilizadas são os menus, barras de ferramentas, menus de contexto, botões espalhados pela interface e, mais recentemente, os ribbons introduzidos pela interface do Microsoft Office. Com essa variedade de formas de se acessar uma operação, é bastante comum que esse acesso esteja disponível em mais de um lugar.

Do ponto de vista do programador surge então uma questão: qual a melhor maneira de se gerenciar as operações em uma aplicação, notadamente aquelas que estarão acessíveis por mais de uma via ? A solução para quem desenvolve com Delphi ou C++ Builder é um componente que já existe há um bom tempo nesses ambientes, chamado TActionManager.

Como diz o nome, o objetivo do TActionManager é gerenciar as operações que estarão disponíveis para o usuário em uma aplicação, centralizando a configuração básica de cada operação. O componente permite organizar as operações por afinidade (relativas a arquivo, edição, visualizar ou ajuda, por exemplo); informar textos e imagens descritivos da operação a fim de manter a uniformidade visual independente da forma de acesso escolhida; sinalizar se a operação está ativa ou mesmo visível.

E como é que isso tudo se conecta ? Alimentar o TActionManager com operações faz com que o IDE crie instâncias de um outro objeto, o TAction. Cada TAction corresponde a uma operação - ou ação - isolada, independente da interação necessária para ativá-la. Essa ação pode então ser associada à propriedade Action existente em diversos componentes - itens de menu, botões, itens em barras de ferramenta, etc.

Entretanto, certos componentes - como o TActionMainMenuBar e o TRibbon - são configurados diretamente com uma instância do ActionManager e não com ações individuais.

Para dar manutenção nas ações gerenciadas pelo ActionManager, dê um duplo clique nele. Será exibida uma caixa de diálogo como a reproduzida abaixo, onde é possível criar novas ações, excluí-las e rearranjá-las. Selecionar uma ação fará com que o Object Inspector apresente as propriedades relativas a ela.

Há umas poucas propriedades no ActionManager e elas não são obrigatórias; destaco abaixo aquelas que são mais utilizadas:

Images e DisabledImages são TImageList contendo, respectivamente, a imagem que deve ser vinculada a uma ação quando ela está ativa e quando está desabilitada. Em ambos os casos, as imagens devem ser pequenas - 16 x 16 pixels. Uma das propriedades de uma ação é o índice da imagem a ser usada; como só há um índice, a imagem correspondente à ação deve estar exatamente na mesma posição em todas as listas de imagens configuradas.
LargeImages e LargeDisabledImages são os TImageList que contem imagens grandes - 32 por 32 pixels - para as ações configuradas nesse gerenciador. A primeira lista vincula imagens a ações ativas enquanto a segunda traz as imagens grandes para ações desabilitadas. Lembre-se que as imagens relativas a uma ação devem estar na mesma posição, conforme dito no tópico anterior.
State: Permite desativar todas as ações de um única vez, impedindo-as de serem disparadas.
Use a propriedade ActionBars para criar barras de ferramentas associadas ao gerenciador.
FileName indica o caminho completo para um arquivo que armazernará a configuração dinâmica feita pelo usuário final em tempo de execução.

Como se depreende do exposto acima, o gerenciador de ações pode ser usado em conjunto com o TCustomizeDlg para permitir ao usuário final reorganizar as barras de ferramentas.

Uma vez que o gerenciador está preparado, podemos acrescentar-lhe as ações e configurá-las. A lista abaixo mostra as principais propriedades do TAction:

Use Caption para informar o texto padrão para a ação. É esse texto que será usado num item de menu ou como texto de um botão onde a ação for vinculada.
Use Category para organizar as ações, agrupando-as por afinidade, o que facilita a manuntenção de ações tanto para o programador quanto para o usuário final - caso a funcionalidade de configuração seja disponibilizada a ele.
ImageIndex é a posição das imagens a serem usadas para representar a ação em diversos contextos. Cada ação terá à sua disposição o mesmo índice em cada uma das 4 listas existentes no gerenciador de ações.
Uma combinação de teclas pode ser atribuída em Shortcut. Essa combinação é um método alternativo para executar a ação associada a ela.
O evento OnExecute é usado para centralizar a execução da ação. Assim, não é preciso acrescentar código em nenhum outro ponto do programa nem responder a outros eventos; basta configurar a propriedade Action existente no componente que desejar disparar a ação - menus e botões, por exemplo.
Enabled permite habilitar ou desabilitar uma ação individual de forma centralizada. Isto é, altere essa propriedade para que todas as possibilidades de se executar a ação sejam afetadas de uma só vez.
Modifique a propriedade Visible para esconder ou mostrar uma ação de uma só vez em todos os contextos nos quais ela estiver disponível.

Mais Informações
Documentação do TActionManager, Classe TAction

Preparando a execução de um programa em desktop remoto

2011-12-30T10:22:00.001-02:00

A adoção maciça da internet e os benefícios associados a ela têm levado as empresas a optar cada vez com mais frequência por programas que possam ser executados nessa infraestrutura. O principal benefício aqui está relacionado aos custos já que os desktops não precisam ser tão potentes - basta que tenham acesso à internet para executarem esses programas remotos - e a manutenção dos equipamentos passa ser centralizada.

Por outro lado, nem todos os programas em uso pelas empresas operam nativamente na internet. Seja por que são programas legados ou por que o fabricamente ainda não os preparou para o ambiente web ou simplesmente porque há muitos programas e não houve tempo hábil para uma conversão em massa. Por isso, programas como o RDS (Remote Desktop Services) da Microsoft e as soluções da Citrix para virtualização de desktops têm sido bastante adotados.

Essas soluções permitem que um usuário execute remotamente os programas que necessita, através de um desktop virtual acessível via rede local ou internet. Com isso, o hardware mais robusto fica centralizado num servidor e pode ser compartilhado por diversos usuários simultâneos.

Nesse ambiente, diversos usuários podem estar executando sua aplicação no mesmo computador remoto, compartilhando recursos como a pasta de trabalho, memória mapeada, disco, etc. Desse modo, as diferentes execuções simultâneas do programa podem conflitar entre si. Decisões baseadas no nome do computador, seu endereço IP ou outra informação de hardware também podem causar problemas já que todos os usuários remotos lerão os mesmos valores. A ABC71, por exemplo, usa o nome do computador onde nosso ERP está em execução como parte do controle de licenças.

Em Windows, normalmente as soluções de desktop virtual se baseiam nos serviços de Remote Desktop (antes chamado de Terminal Services), razão pela qual podemos usar a Remote Desktop Services API para preparar nossas aplicações para que rodem nesse ambiente. Essa API permite resgatar e modificar informações sobre um usuário específico, além de executar tarefas relativas à administração do serviço.

Para começar, temos que determinar se o programa está executando num desktop convencional ou num virtual. Isso pode ser conseguido com uma chamada à função GetSystemMetrics. Saber que estou numa sessão remota me permite, por exemplo, ajustar uma pasta de trabalho coerente para cada execução distinta do meu programa.

function TForm1.IsRemoteSession : boolean;

var res : integer;

begin

  res := GetSystemMetrics (SM_REMOTESESSION);

  Result := (res <> 0);

end;

A função GetSystemMetrics é um curinga da API do Windows; com ela é possível recuperar uma porção de parâmetros do ambiente operacional. Chamada com SM_REMOTESESSION, ela retorna um valor diferente de zero se o programa estiver num desktop virtual.

Muitas informações valiosas sobre a sessão remota em andamento podem ser obtidas através da função WTSQuerySessionInformation. No exemplo abaixo, eu a utilizo para recuperar o nome do computador que está acessando o desktop remoto:

procedure TForm1.GetSessionInfo;

var lSessionId: DWORD;

    lBuffer : PChar;

    lBytesReturned : DWORD;

    lStationName : String;

begin

  lSessionId := 0;

  { Descobre a identificação da sessão do usuário com base na identificação do programa no Windows }

  if not ProcessIdToSessionId (GetCurrentProcessId (), DWORD(@lSessionId)) then

    raise Exception.Create ('Não foi possível obter Remote SessoinId');

  lBuffer := Nil;

  lBytesReturned := 0;

  lStationName := '';

  { Obtem nome da máquina Client }

  if (WTSQuerySessionInformation (WTS_CURRENT_SERVER_HANDLE,

                                   lSessionId,

                                   WTSClientName,

                                   lBuffer,

                                   lBytesReturned))

  then

    lStationName := String(lBuffer)

  else

    raise Exception.Create ('Não foi possível obter o nome da estação');

  { Libera a memória alocada automaticamente }

  WTSFreeMemory (lBuffer);

  { ... }

end;

Vamos por partes. Para recuperar as informações de uma sessão remota, primeiro temos que identificar essa sessão. A função ProcessIdToSessionId da API do Windows nos fornece isso, mapeando o Process ID de nosso programa para a correspondente identificação da sessão remota onde ele está executando.

O passo seguinte é chamar a função WTSQuerySessionInformation para levantar as informações desejadas. Essa função recebe 5 parâmetros. O primeiro é um handle para o servidor da sessão remota. No exemplo, passei a constante WTS_CURRENT_SERVER_HANDLE para indicar que quero informações sobre o servidor atual. Poderia ter usado WTSOpenServer para abrir outro servidor remoto.

O segundo parâmetro é a identificação da sessão que obtivemos no primeiro passo. O parâmetro seguinte é o que determina qual informação será recuperada. Os valores permitidos são os listados no enumerado WTS_INFO_CLASS. No exemplo, usei WTSClientName para obter o nome do computador do usuário que diparou o acesso remoto; a lista de informações recuperáveis inclui o endereço IP desse mesmo computador, a pasta de trabalho remota (no servidor), o nome do usuário e informações sobre o uso da sessão e sobre a Client, dentre outras.

Os dois últimos parâmetros são, respectivamente, um ponteiro para a área que receberá a informação solicitada e a quantidade de bytes que essa informação está ocupando. Como ambos são calculados pela função WTSQuerySessionInformation, não é preciso alocar previamente a memória para eles. No entanto, é nossa responsabilidade liberar a memória alocada usando a função WTSFreeMemory, como mostra o passo final do código do exemplo.

Se tivesse usado GetComputerName, eu obteria o nome do computador remoto, isto é, o servidor onde o programa está efetivamente sendo executado. A questão é que o mesmo nome seria retornado para qualquer usuário que acesse um desktop remoto nesse servidor ...

A lista de funções da Remote Desktop Services API inclui ainda formas de administrar o RDS tais como iniciar e encerrar sessões, inventariar as sessões ativas, modificar configurações de uma sessão, etc.

Mais Informações
Remote Desktop Services API Functions, Função GetSystemMetrics, Função ProcessIdToSessionId, Função WTSFreeMemory

Design Patterns com Delphi: Template - Parte II

2011-12-21T17:07:00.000-02:00

No meu último post, introduzi o conceito do Design Pattern comportamental Template. Em resumo, esse padrão estabelece uma sequência de passos para a execução de uma determinada tarefa, permitindo que sejam criadas heranças que implementem suas próprias versões de um ou mais dos passos, de acordo com a necessidade.

Neste post, eu sugiro uma implementação em Delphi do exemplo envolvendo criação de infraestruturas que usei para apresentar o Template no outro post. Para facilitar o entendimento, reproduzo novamente abaixo o diagrama UML que modela a infraestrutura da transações de negócio usada como exemplo:

Como dá para intuir a partir da simplicidade do diagrama, a codificação também não é complexa. A primeira providência é criar a classe que define o formato geral do algorítimo, os passos que o comporão, em qual ordem esses passos devem ser chamados para completar a tarefa e quais deles poderão ser particularizados em heranças do algorítimo. Esta classe - chamada de Abstract Class - servirá, portanto, de base para as demais implementações do mesmo algorítimo. No nosso exemplo, é a classe TWTransacao que tem essa responsabilidade:

TWTransacao=class

protected

    _Erros: TWErros; { Lista de erros da transação }

    procedure BeginTrans;

    procedure CommitTrans;

    procedure RollbackTrans;

    function ConsisteDados : boolean;virtual;

    function GravaDados : integer;virtual;

public

    function ExecutarTransacao : integer;

end;

{ ... }

function TWTransacao.ConsisteDados : boolean;

begin

  Result := true;

end;

function TWTransacao.GravaDados : integer;

begin

  Result := 0;

end;

function TWTransacao.ExecutarTransacao : integer;

begin

  Result := -99;

  Try

    _Erros.Clear;

    { Inicia uma transação com o banco de dados }

    BeginTrans;

    { Se estiver tudo OK com os dados, gravá-los no banco }

    if (ConsisteDados) then

      Result := GravaDados;

    { Efetiva a transação }

    CommitTrans;

  Except

    { Se houve algum erro, aborta a transação com o banco de dados}

    RollbackTrans;

    Result := -100;

  end;

end;

Observe que há apenas uma função pública : ExecutarTransacao. As partes do programa que desejarem executar uma transação de negócio precisam ter acesso apenas a ela, não importando quais ou quantos são os passos necessários para executá-la.

Em contraste, tanto os passos do algorítimo que poderão ser estendidos pelas heranças quanto os métodos internos auxiliares foram colocados na área protegida, escondendo os detalhes para códigos externos. Aqui, as funções ConsisteDados e GravaDados poderiam ter sido declaradas como abstratas, o que forçaria as heranças a fornecer-lhes uma implementação. No entanto, não é mandatório que elas tenham essa característica, de modo que o exemplo ilustra como a classe base do Template pode providenciar uma versão padrão dos passos do algorítimo, mesmo que sejam versões bem simples. Elas poderiam, por exemplo, registrar um log da execução.

As funções relativas a transações com o banco de dados (BeginTrans, CommitTrans e RollbackTrans) apenas repassam suas respectivas chamadas diretamente ao banco; por isso, suas implementações foram omitidas no quadro acima.

Já temos a classe base, podemos então codificar as heranças previstas para transações de produtos, pedidos de venda e notas fiscais:

TWTrnProduto = class(TWTransacao)

private

    _prod : TWProduto;

protected

    function ConsisteDados : boolean;override;

    function GravaDados : integer;override;

{ ... }

end;

TWTrnPedidoVenda = class(TWTransacao)

private

    _Pedido : TWPedidoVenda;

protected

    function ConsisteDados : boolean;override;

    function GravaDados : integer;override;

{ ... }

end;

TWTrnNotaFiscal = class(TWTransacao)

private

    _Nota : TWNotaFiscal;

protected

    function ConsisteDados : boolean;override;

    function GravaDados : integer;override;

{ ... }

end;

{ ... }

function TWTrnProduto.ConsisteDados : boolean;

begin

  Result := inherited ConsisteDados;

  if (TWProduto.ExisteProd (_Prod) ) then

  begin

    Result := false;

    _Erros.Add ('Produto já existe');

  end;

end;

function TWTrnProduto.GravaDados : integer;

begin

  inherited GravaDados;

  _Produto.Insert();

end;

function TWTrnPedidoVenda.ConsisteDados : boolean;

begin

  Result := inherited ConsisteDados;

  if (TWPedidoVenda.ExistePedido (_Pedido) ) then

  begin

    Result := false;

    _Erros.Add ('Já existe pedido com esse número.');

  end;

  if (not _Pedido.VerifSaldoProdutos) then

    Result := false;

  if (not _Pedido.VerifDadosComerciais) then

    Result := false;

   { Se detectou algum erro, reporta para a transação }

  _Erros.Add(_Pedido.Erros);

end;

function TWTrnPedidoVenda.GravaDados : integer;

begin

  inherited GravaDados;

  { Insere o pedido, atualiza saldo dos produtos e faz outros ajustes }

  _Pedido.Insert ();

end;

Vemos no quadro anterior que as transações reais são heranças da classe de transação básica e que elas fornecem suas próprias versões de passos do algorítimo base. Com isso, elas garantem que suas próprias regras de negócio sejam respeitadas, enquanto são mantidas a ordem de chamada dos passos e outras regras estipuladas pela classe TWTransacao. A transação de nota fiscal foi omitida no quadro mas a ideia dela é bastante similar à de pedidos de venda.

Para completar o exemplo, falta a classe Client, isto é, aquela parte do código que utilizará o nosso template.

TWTela = class

protected

    _Trn : TWTransacao;

public

{ ... }

    procedure ExecutarTransacao();
end;

{ ... }

procedure TWTela.ExecutarTransacao();

begin

  _Trn := ObtemTransacao ();

  _Trn.ExecutarTransacao;

end;

Como mostra o quadro, o código da classe TWTela acaba ficando extremamente simples. Aqui, o maior problema talvez seja decidir o melhor meio de obter uma instância da transação correta. Dependendo das circunstâncias, podemos optar pelo método Factory ou organizar as telas usando o padrão Mediator - o que permitiria cada tela instanciar diretamente a transação adequada.

Mais Informações
Design Patterns com Delphi: Template - Parte I, Posts sobre Design Patterns

Design Patterns com Delphi: Template - Parte I

2011-12-13T17:00:00.000-02:00

Criar uma infraestrutura de software é padronizar a forma como as coisas acontececerão dentro de um programa, estabelecendo regras e ditando as mensagens que cada parte do código está preparada para receber. Por exemplo, uma infraestrutura para realizar transações de negócio dentro do sistema pode ser descrita simplificadamente em poucos passos : abertura de transação com o banco de dados; consistência das informações contidas no(s) objeto(s) de negócio envolvido(s); persistência das informações nas respectivas tabelas; encerramento da transação. Todo objeto com capacidade de realizar uma transação terá necessariamente que implementar esses passos.

Se cada Caso de Uso implementar uma versão independente dos passos, mudanças nessa sequência teriam que ser replicadas em todas as implementações. O alvo do Design Pattern comportamental Template é justamente situações como esta, onde um algorítimo é definido de modo centralizado, moldando a forma de trabalho a ser seguida por todas as classes de objeto que desejarem implementá-lo. Um ou mais passos podem ser sobrepostos pelas heranças, permitindo que elas implementem comportamentos diferenciados quando for necessário.

Essa idéia é similar à do Pattern Strategy. A diferença mais importante entre ambos é que o Template permite que heranças alterem partes de um algorítimo enquanto no Strategy temos que optar por uma das versões de um algorítimo bem conhecido e executar todo o trabalho com esse algorítimo.

O quadro a seguir traz um diagrama UML mostrando as relações esperadas entre as classes participantes da solução para o Template. O cenário abordado é o da transação de negócio citado no primeiro parágrafo deste post:

Neste exemplo, nem todos os métodos são virtuais. São declarados como virtuais apenas aqueles que poderão (ou deverão) ter uma implementação distinta nas classes herdadas. Como podemos ver, o algorítimo é decomposto em métodos mais granulares que podem ser sobrepostos quando ncessários. Neste contexto, tais métodos são chamados de operações primitivas.

No exemplo, o método ExecutarTransacao é responsável por chamar cada operação primitiva no tempo correto, moldando efetivamente o algorítimo que deve ser executado por cada classe da hierarquia. Este método é chamado de Template (modelo).

Formalmente, as classes participantes de uma solução para o pattern Template recebem os seguintes nomes:

É denominada Abstract Class a classe base que define as operações primitivas que estarão disponíveis para o algorítimo. Ela também define o esqueleto do algorítimo ao implementar o método Template, chamando cada operação primitiva na ordem correta. No diagrama acima, este é o papel da classe TWTransacao. É importante ressaltar que, apesar do nome, essa classe não precisa ser obrigatoriamente abstrata; se for adequado, a Abstract Class pode prover versões básicas de todas as operações primitivas.

As classes que provêm versões particulares de uma ou mais das operações primitivas são chamadas Concrete Class. Isso permite-lhes realizar ações específicas dentro dos passos básicos que formam o algorítimo determinado pela classe base. No exemplo, as classes TWTrnProduto, TWTrnNotaFiscal e TWTrnPedidoVenda são desse tipo. Elas fornecem suas próprias versões dos métodos que consistem e gravam os dados relativos, respectivamente, às transações para inserir um novo produto, criar uma nota fiscal e criar um pedido de venda.

O Client é qualquer parte do sistema que esteja apta a disparar o algorítimo definido na classe base. A classe TWTela do diagrama de exemplo detem esse papel.

No próximo post, eu apresento uma sugestão de como implementar o exemplo proposto usando Delphi.

Mais Informações
Posts sobre Design Patterns

HTML5 criará novos desafios para os profissionais de Segurança em TI

2011-12-08T17:36:00.002-02:00

Agora parece que a Adobe se rendeu em definitivo ao avanço do HTML5, que nasceu com a missão de flexibilizar o desenvolvimento para aplicações Web, eliminando a necessidade de instalação de plugins de terceiros - como o próprio Flash da Adobe. Em post recente no blog do Flex, a empresa recomenda que se opte pelo HTML5 pois essa tecnologia prevalecerá no longo prazo.

Eles também anunciaram que não desenvolverão o plugin do Flash para versões futuras dos navegadores de dispositivos móveis. É claro que não pretendem deixar de criar ferramentas e estão usando o know-how que têm e a base fiel de clientes conquistados para se manterem relevantes. Ao que parece, a ideia é criar novas ferramentas mantendo a essência da filosofia de desenvolvimento das ferramentas atuais - só que produzindo HTML5 e Javascript ao invés do código próprietário do Flahs. Veja aqui o comunicado publicado no site da empresa, revelando os planos para o futuro do Flash.

Com isso, a euforia com o HTML5 já começa a assentar, dando lugar ao pragmatismo. Os especialistas começam a fazer avaliações mais realistas sobre a nova tecnologia e levantam questões até aqui deixadas em segundo plano. A expectativa de adoção dela vem suscitando, por exemplo, questões relativas à segurança, conforme mostra o artigo abaixo, cujo original (em inglês) foi publicado pela InfoWorld:

A adoção do HTML5 abrirá espaço para a criação de uma vasta gama de novas aplicações Web, mas poderá também introduzir novos desafios para os profissionais de segurança nas empresas, de acordo com a firma de segurança Sophos.

Em suas previsões sobre segurança para 2012, a Sophos identifica como principais riscos as novas tecnologias para Web e redes - incluindo HTML5. Enquanto essas tecnologias introduzem novos recursos impressionantes para desenvolvimento de aplicações Web ricas, elas também introduzem novas formas de ataque, explicou a companhia.

O HTML4 supriu conteúdo na Web por muitos anos, mas é uma linguagem de programação muito básica, de modo que os desenvolvedores tiveram que complementá-lo com add-ons como o JavaScript, Flash e Google Gears. Estes add-ons têm frequentemente muitas vulnerabilidades, tornando o sistema inseguro como um todo.

HTML5 remove a necessidade da maioria dos add-ons, porque é uma linguagem mais sofisticada e vem com um banco de dados completo, permitindo que os usuários armazenem gigas de informação. Então, por exemplo, você pode criar uma animação completa, realidade virtual em 3D ou guardar aplicações completas dentro do navegador.

De acordo com James Lyne, tecnólogo sênior na Sophos, isso chega muito perto da visão in-client originalmente associada à computação na nuvem. No entanto, armazenar dados dentro do navegador torna o navegador em si um alvo para os cyber criminosos.

"Tradicionalmente, o navegador é um meio para que cyber criminosos obtenham acesso ao seu PC. Agora, eles tentarão atacar o próprio navegador para roubar seus dados", diz Lyne.

A execução em sandbox do HTML5 também aumenta os riscos de "clickjacking" (induzir um usuário Web a revelar informações confidentiais ou tomar o controle do computador desse usuário quando ele clica num link aparentemente inócuo) já que as páginas Web não são mais capazes de identificar de onde os comandos estão vindo.

"Todo aquele código escrito pelos desenvolvedores para prevenir que aplicações Web sejam capturadas por alguém não autorizado ou sofram clickjacking agora não funcionará", diz Lyne. "Implementaram um recurso para aumentar a segurança mas inadivertidamente desativaram um outro mais importante."

Além disso, HTML levanta novas questões sobre cookies, que poderão tornar redundantes as recomendações para remoção deles após um determinado período.

"O HTML5 poderia até ter novos super-cookies," diz Lyne. "Se um site não for codificado de forma apropriada, os caras maus poderão compilar uma enorme base de dados com as URLs por onde você navegou e rastrear as informações que você eventualmente tenha fornecido nelas. Eles poderão capturar uma grande quantidade de dados."

Apesar desses problemas pontenciais, Lyne diz que adotar o HTML5 trará muitos benefícios para a segurança. Haverá redução nos riscos relacionados aos add-ons, bem como mais segurançã ao facilitar validação de dados no lado client das aplicações. Também haverão bibliotecas capazes de lidar com questões como SQL injection.

"Ao longo do tempo, o HTML5 vai resolver muitos dos problemas que temos, mas, como qualquer nova tencologia, há uma tendência a uma regressão num primeiro momemto," diz ele. "De maneira geral, deveríamos acelerar na direção do HTML5 porque Flash tem sido traumático e as novas aplicações Web estão muito legais - só temos que nos certificar de não estarmos adotando um pesadelo."

Mais Informações
HTML5 to create new challenges for security pros in 2012, Your Questions about Flex

Trabalhando com emails em uma caixa postal usando IMAP4 em Delphi

2011-11-04T14:12:00.001-02:00

Mostrei num outro post aqui no blog como ter acesso aos emails numa caixa postal através do protocolo POP3 no Delphi. O POP3 é um protocolo amplamente adotado para permitir o acesso remoto aos emails de uma caixa postal mas ele é bastante limitado. Seus recursos estão restritos basicamente à manipulação das mensagens existentes na caixa postal, permitindo lê-las, apagá-las ou arquivá-las.

Se precisar de recursos mais avançados - tais como gerenciar pastas, localizar uma mensagem pesquisando o texto dela, compartilhar caixas postais com um grupo de trabalho, entre outras - temos que apelar para o IMAP4, um protocolo mais completo.

O primeiro passo para trabalhar com o IMAP4, assim como acontece com os outros protocolos baseados no TCP/IP, é estabelecer uma conexão com o servidor. Aqui também isso exige que alguns parâmetros sejam informados, tais como o endereço do servidor, a porta onde ele estará aguardando requisições e um usuário com permissão de acesso ao serviço, bem como sua respectiva senha:

var iMap TIdIMAP4;

begin

iMap := TIdIMAP4.Create (Nil);

{ Atribui os dados fornecidos pelo usuário e tenta se conectar }

iMap.Host := _ServerIMAP; { Endereço do servidor }

iMap.Port := _PortaIMAP; { Porta que o servidor está ouvindo }

iMap.Username := _UserIMAP;

iMap.Password := _SenhaIMAP;

iMap.Connect(100000);

 {  Realiza aqui algumas tarefas com o IMAP conectado}

{ Descarta a conexão e outros recursos qdo não forem mais necessários }

iMap.Disconnect();

iMap.Free ();

end;

Uma grande diferença em relação ao funcionamento do POP3 é que o IMAP4 pode gerenciar várias caixas postais numa única conexão. Do ponto de vista do usuário, cada caixa postal é normalmente encarada como uma pasta. Como os comandos do IMAP4 são direcionados a uma caixa postal, isso nos obriga a selecionar uma antes de submeter os comandos.

Ao menos a caixa chamada INBOX (caixa de entrada) deve existir mas você pode levantar uma lista completa com todos os nomes das caixas que existem na conta usando a função ListMailBoxes. Um usuário pode, então, ser apresentado a essa lista para que escolha a caixa mais apropriada para as necessidades dele. Considerando o iMap criado e conectado no quadro anterior, fazer o levantamento é bem simples:

var lMaixBoxes : TStringList;

lCaixaSel : String;

begin

{ ... }

lMaixBoxes := TStringList.Create();

iMap.ListMailBoxes(lMaixBoxes);

{ Carrega a lista na tela para o usuário escolher uma delas. }

lCaixaSel := SelecionaCaixaPostal (lMaixBoxes);

lMailBoxes.Free();

if (not iMap.SelectMailBox (lCaixaSel) ) then

raise Exception.Create('Erro na seleção da caixa postal');

{ ... }

end;

Uma vez que a caixa foi escolhida, precisamos repassá-la ao iMap para que possamos operar com a caixa específica. É o que faz a chamada à função SelectMailBox no código acima. Essa chamada faz com que o TidIMAP4 alimente sua propriedade MailBox com um resumo do estado atual da caixa selecionada, disponibilizando informações como a quantidade total de mensagens e quantas dessas permanecem não lidas, entre outras informações.

Com uma caixa selecionada, podemos realizar operações como pesquisar os emails contidos nela. Nesse quesito, o IMAP4 é muito mais flexível que o POP3 já que nos fornece uma opção para filtrar as mensagens desejadas usando a estrutura TIdIMAP4SearchRec. O principal recurso dessa estrutura é o campo SearchKey. É esse campo que determina quais critérios devem ser respeitados na consulta e, portanto, quais dos outros campos da estrutura serão considerados quando a consulta for submetida pela função SearchMailBox. O exemplo abaixo usa o iMap conectado para procurar todas as mensagens que ainda não foram lidas na caixa postal atual e varre a lista encontrada, recuperando cada uma delas.

var rec : array of TIdIMAP4SearchRec;

TheMsg : TIdMessage;

contMsg, i, idMsg : Integer;

begin

{ Procura por emails do tipo skUnseen - ou seja, somente os "não lidos" }

rec[0].SearchKey := skUnseen;

if not iMap.SearchMailBox (rec)  then

raise Exception.Create('Erro na pesquisa da caixa postal');

      { Quantas mensagens foram encontradas ? }

      contMsg := iMap.MailBox.SearchResult.Length;

for  i := 0 to contMsg - 1 do begin

        TheMsg := TIdMessage.Create(Nil);

         { Obtem a identificação da mensagem ... }

         idMsg := iMap.MailBox.SearchResult[i];

          { ... e a usa para recuperar o email completo }

          iMap.Retrieve (idMsg, TheMsg);

{ Analisa anexos e outros procedimentos }

end;

end;

Veja que a a função de pesquisa aceita um array de filtros como parâmetro. Isso significa que podemos construir uma combinação de filtros para que uma lista mais refinada seja retornada. Outras possibilidades de filtros para pesquisar a caixa incluem o texto contido nas mensagens ou seus cabeçalhos, a data de recepção delas ou até mesmo seu tamanho.

Um outro ponto importante a destacar é que o resultado da pesquisa é armazenado na propriedade SearchResult do MailBox. O resultado fica acessível como uma lista de identificadores das mensagens que atenderam o critério estipulado para a busca. Esses identificadores são números inteiros que podem ser usados em diversas funções da caixa postal, como a que recupera o conteúdo da mensagem ou que permite excluí-la.

Uma vez que uma mensagem foi recuperada com sucesso, a instância da classe TIdMessage nos dá acesso a todas as informações pertinentes a ela, incluindo os anexos, caso ela possua algum. O trecho que trata os anexos foi removido pra não poluir muito o quadro. Como a recuperação de anexos funciona exatamente igual ao do POP3, o processo descrito no post Recuperando emails de uma caixa postal com Delphi pode ser usado para realizar esse trabalho.

Um outro recurso do IMAP4 é que você pode copiar mensagens da caixa atualmente selecionada pra uma outra caixa usando a função CopyMsgs. Ela aceita 2 parâmetros : um array com os identificadores das mensagens a serem copiadas e o nome da caixa postal que receberá as mensagens. Caso precise mover as mensagens, use essa função combinada com a DeleteMsgs, que exclui uma lista de mensagens da caixa atual.

O IMAP4 ainda disponibiliza funções para gerenciar as caixas postais. É possível criar uma caixa nova, renomer uma caixa e excluir caixas existentes. Os nomes das funções com esses objetivos são bastante intuitivos : CreateMailBox, DeleteMailBox e RenameMailBox.

Mais Informações
Recuperando emails de uma caixa postal com POP3 em Delphi, IMAP4

Trabalhando com a tag Canvas do HTML5 - parte IV

2011-10-21T11:55:00.002-02:00

Até agora , nos posts que escrevi sobre o uso do canvas do HTML5, quando precisei me referir a uma cor nos scripts de exemplo, eu sempre usei a representação tradicional para cores estabelecida pelo CSS (Cascading Style Sheet). Isto é, as cores sempre foram especificadas como uma mistura da intensidade de vermelho, verde e azul (o código RGB) que resultasse na cor desejada. Neste post, mostro que o Canvas permite aplicar um grau de transparência às cores e também trabalhar com gradientes de cores.

As regras para cores no canvas são as mesmas definidas para o CSS. Portanto, podemos usar aqui também a função rgba(), que introduz um quarto parâmetro para controlar o nível de transparência de cores. Os 3 primeiros parâmetros são os conhecidos níveis de intensidade do vermelho, verde e azul (representados por números de 0 a 255). O último valor – chamado de alpha – corresponde ao grau de transparência a ser aplicado aos desenhos subsequentes. Ele pode assumir valores entre 0 (completamente transparente) e 1 (desenha a imagem opaca, sobrepondo totalmente o fundo, sendo esse o efeito padrão obtido até aqui).

  var myCanvas = document.getElementById("cnvCores2");

var ctx = myCanvas.getContext("2d");

var incrY = myCanvas.height / 10;

var grausFin = 360;

var radFin = (Math.PI/180)* grausFin;

var meioCompr = myCanvas.width / 2;

ctx.font = "11px Arial";

/* Primeiro, preenche com cor do fundo opaca */

ctx.fillStyle = 'rgb(20,230,20)';

ctx.fillRect(0, 0, meioCompr, myCanvas.height / 2);

ctx.fillRect(meioCompr, myCanvas.height / 2, meioCompr, myCanvas.height / 2);

for (var i = 0; i < 10;i++) {
/* agora, pinta por cima usando branco mas variando a transparência */

ctx.fillStyle = 'rgba(255,255,255,' + (1.0 - (i / 10.0)) + ')';

ctx.fillRect(0, i*incrY, meioCompr, incrY);

ctx.fillStyle = "navy";

ctx.fillText (Math.ceil (10.0 - i) / 10.0, 8, (i+1)*incrY - 4);

}

/* preenche no centro um círculo marrom com alto grau de transparência */

ctx.beginPath();

ctx.fillStyle = 'rgba(128,0,0,0.4)';

ctx.arc(meioCompr, myCanvas.height / 4, meioCompr, 0, radFin, false);

ctx.fill();

ctx.closePath();

/* Como seria sem o parâmetro de transparência */

ctx.beginPath();

ctx.fillStyle = 'rgb(128,0,0)';

ctx.arc(meioCompr, 3 * myCanvas.height / 4, meioCompr, 0, radFin, false);

ctx.fill();   

ctx.closePath(); 
 Seu navegador (ou leitor de RSS) não suporta canvas ...

Parte do código é dedicada a escrever o grau de transparência de cada uma das faixas horizontais. Como o desenho de texto também é afetado pelo valor de fillStyle - incluindo a transparência configurada nele -, eu atribuo a ela uma outra cor sólida para que o texto esteja plenamente visível, sem qualquer interferência do fundo previamente desenhado.

Há uma propriedade do contexto de pintura chamada globalAlpha que permite mudar o grau de transparência dos desenhos, influenciando preenchimentos e contornos num único comando. Essa característica tem sua utilidade, mas é menos flexível do que controlar separadamente pelo tipo de desenho.

Uma outra forma de trabalhar com cores prevista no canvas do HTML5 é o preenchimento de áreas com um gradiente, isto é, a pintura é iniciada com uma cor e vai gradualmente se aproximando de uma segunda cor, que é finalmente usada para concluir a pintura. Estão previstos dois tipos de gradiente : um linear e outro radial. Para usar um deles, basta criar o tipo desejado, alimentar as cores que comporão o gradiente e então associá-lo à propriedade fillStyle do contexto do Canvas, exatamente como fizemos com cores e transparências.

O tipo linear é instanciado através da função createLinearGradient enquanto para o gradiente radial usamos createRadialGradient. Ambos os métodos criam objetos que respeitam a especificação da interface CanvasGradient, atualmente composta por apenas uma função cujo objetivo é adicionar pontos de parada para as cores no gradiente. Ou seja, essa função define quantas cores básicas haverão no gradiente resultante e quanto espaço cada uma ocupará nele. As cores intermediárias são calculadas automaticamente de modo a preencher toda a área definida pela função de criação.

/* Gradiente linear simples com 2 cores: uma vai do
início do retângulo até o meio e a outra do meio até o fim */

var lineargradient = ctx.createLinearGradient(0,0,120,120);

lineargradient.addColorStop (0, 'navy');

lineargradient.addColorStop (0.5, 'rgb(50,50,180)');

lineargradient.addColorStop (1, 'rgb(120,120,220)');

/* Preenche o retângulo real com o padrão gradiente criado acima */

ctx.fillStyle = lineargradient 

ctx.fillRect (0,0,180,180);

/* Outro gradiente, agora com mais cores ... */

lineargradient = ctx.createLinearGradient(0,200,180,280);

lineargradient.addColorStop (0, 'navy');

lineargradient.addColorStop (0.2, 'red');

lineargradient.addColorStop (0.8, 'rgb(50,50,180)');

lineargradient.addColorStop (1, 'green');

ctx.fillStyle = lineargradient 

ctx.fillRect (0,200,180, 280);

Seu navegador (ou leitor de RSS) não suporta canvas ...

A função createLinearGradient cria uma área retangular - definida por pontos que indicam o canto superior esquerdo e o inferior direito. O gradiente é criado nesse retângulo virtual e ele então é usado para preencher o retângulo real no canvas. Como o retângulo real pode ter tamanho diferente daquele usado para criar o gradiente, o canvas faz alguns ajustes para que caiba. Se o retângulo real for maior, a última cor de parada é usada para preencher o resto da área.

Veja que para adicionarmos uma cor de parada temos que informar um valor entre 0 e 1. Esse valor é chamado de offset e indica a que distância do início do retângulo a nova cor deve começar a aparecer. Uma cor prevalece até que a próxima cor de parada seja encontrada. Então, o tanto de espaço ocupado por cada uma é definido pelo offset da parada seguinte.

Para o gradiente radial, a principal diferença é que, ao invés do efeito ser aplicado num retângulo, ele é aplicado numa área delimitada por dois círculos Os círculos são definidos na criação do gradiente, sendo que os 3 primeiros parâmetros correspondem ao ponto central e raio do círculo inicial e os 3 parâmetros seguintes correspondem ao ponto central e raio do círculo final. A área fora dos círculos é mantida com a cor original da área preenchida.

/* Círculo com gradiente */
  var radgrad = ctx.createRadialGradient (105, 115, 20, 112, 130, 50);

  radgrad.addColorStop(0, '#FF5F98');

  radgrad.addColorStop(0.75, '#FF0188');

  radgrad.addColorStop(1, 'rgba(255,1,136,0)');

/* Ao preencher retângulo, somente a área com o gradiente circular é considerada !*/

  ctx.fillStyle = radgrad;

  ctx.fillRect(0,0,250,500);

/* Outro círculo com gradiente */

  radgrad = ctx.createRadialGradient(95,35,15,102,40,40);

  radgrad.addColorStop(0, '#00C9FF');

  radgrad.addColorStop(0.8, '#00B5E2');

  radgrad.addColorStop(1, 'rgba(0,201,255,0)');

  ctx.fillStyle = radgrad;

  ctx.fillRect(0,0,250,500);

/* Aqui , a área circular resultante é maior que o retângulo; então, o retângulo todo é preenchido */

radgrad = ctx.createRadialGradient (200, 350, 65, 200, 350, 140);

radgrad.addColorStop (0, 'navy');

radgrad.addColorStop (0.5, 'rgb(50,50,180)');

radgrad.addColorStop (1, 'rgb(120,120,220)');

ctx.fillStyle = radgrad 

ctx.fillRect (50,200,150,150);

Seu navegador (ou leitor de RSS) não suporta canvas ...

Parte do exemplo acima foi retirada do tutorial de canvas da Fundação Mozilla. Veja que a criação do gradiente aceita a função rgba(), significando que podemos aplicar transparência neste momento também.

Mais Informações
Trabalhando com a tag Canvas do HTML5 - parte I, parte II e parte III, Tutorial de Canvas na Fundação Mozilla

Design Patterns com Delphi: Strategy - Parte II

2011-10-06T15:11:00.000-03:00

No último post, eu apresentei o conceito e a aplicabilidade do Design Pattern comportamental Strategy. Aqui, vou mostrar como implementar em Delphi o exemplo prático utilizado naquele post, relacionado a pagamento de títulos. Para facilitar o entendimento, reproduzo abaixo o diagrama UML com a sugestão de modelagem proposta:

A implementação das relações expostas no diagrama não é especialmente complexa. Ela envolve apenas conceitos comuns da programação orientada a objetos, como herança e polimorfismo.

O primeiro passo é declarar uma classe abstrata (ou interface, se preferir), definindo nela as linhas mestras que deverão ser respeitadas por todos as implementações reais do algoritmo em questão. Isto é, essa classe introduz funções que determinam a estratégia para execução da tarefa, impondo-a a todas as classes que queiram atuar como um algoritmo alternativo para a tarefa - daí o nome do padrão ser Strategy:

TWTitulo = class;

TWPagamento=class

    public

      function efetuaPgto (ATitulo: TWTitulo) : integer;virtual;abstract;

end;

Nesse exemplo, há uma única função abstrata que obrigatoriamente terá que existir em cada nova implementação do algoritmo. Essa função aceita como parâmetro uma instância da classe Context da solução, papel encarnado aqui pelo título a pagar (TWTitulo). Com isso, qualquer algoritmo que adote a estratégia definida tem acesso às informações relevantes do título, bem como a suas operações. Permitir essa comunicação é imprescindível para que a tarefa (o pagamento do título) possa ser concretizada.

Agora que temos a interface estabelecida, podemos adicionar os diferentes algoritmos previstos no diagrama, criando cada um deles como uma herança simples que forneça código para a função abstrata da interface:

TWContaBancaria = class;

  TWPgtoBoleto=class(TWPagamento)

    { ... }

    public

      function efetuaPgto (ATitulo: TWTitulo) : integer;override;

end;

  TWPgtoDebitoAuto=class(TWPagamento)

    { ... }

      _Conta : TWContaBancaria;

    public

      constructor Create (AConta: TWContaBancaria);

      function efetuaPgto (ATitulo: TWTitulo) : integer;override;

end;

  TWPgtoInternet=class(TWPagamento)

    { ... }

    public

      function efetuaPgto (ATitulo: TWTitulo) : integer;override;

end;

implementation

{ ... }

constructor TWPgtoDebitoAuto.Create (AConta: TWContaBancaria);

begin

    _Conta := AConta;

{ ... }

end;

function TWPgtoDebitoAuto.efetuaPgto (ATitulo: TWTitulo) : integer;

begin

  _Conta.Conecta;

  _Conta.DebitaValor(ATitulo.ObtemValor);

  ATitulo.RegistraPagto;  

{ ... }  

end;

A implementação da TWPgtoDebitoAuto no quadro acima mostra que podem ser necessárias outras informações para que a tarefa seja executada num determinado algorítmo. A função que executa a tarefa, no entanto, foi fixada na classe base (a interface) e não deve ser alterada já que isso implicaria que todas as outras heranças teriam que respeitar os novos parâmetros, o que nem sempre é desejável. Então, uma solução é passar as informações extras no construtor da própria classe.

Esse detalhe tem que ser levado em conta pela Factory responsável pela criação de instâncias da classe de pagamento. De acordo com o conceito de Factory, devemos criar uma função que centraliza a instanciação de uma família de classes:

TWTipoPagto = (tpBoleto, tpDebitoAuto, tpInternet);

function CriaNovoPagto (ATipo: TWTipoPagto; AContaDebito : TWContaBancaria) : TWPagamento;

begin

    Result := Nil;

  case (ATipo) of

  tpBoleto: 

    Result :=  TWPgtoBoleto.Create;

  tpDebitoAuto: 

    Result := TWPgtoDebitoAuto.Create (AContaDebito);

  tpInternet: 

    Result := TWPgtoInternet.Create;

  end;

end;

O último aspecto que falta abordar é com relação às características da classe de contexto TWTitulo. Além de propriedades inerentes a títulos - como seu valor, data de vencimento, código de barras, identificação do beneficiário, etc. - essa classe terá que manter uma instância da classe base de estratégia (o pagamento) para poder trocar mensagens com ela.

TWTitulo=class

    protected

      _Id : String;

      _DataVencto : TDateTime;

      _Valor : Double;

      _Pagto : TWPagamento;

      _FoiPago : Boolean;

      procedure RegistraPagto;

{ ... }  

    public

      function ObtemValor : Double;

      function Pagar (AMeioPgto: TWTipoPagto): integer;

{ ... }  

end;

{ ... }  

function TWTitulo.Pagar (AMeioPgto: TWTipoPagto): integer;

begin

  if (_Pagto = Nil) then

    _Pagto := CriaNovoPagto (AMeioPgto, _Sessao.ObtemContaBancaria);

  _Pagto.efetuaPgto (Self);

end;

Com isso, temos a classe de contexto armazenando internamente uma instância do pagamento (a estratégia) e controlando seu ciclo de vida. A instância fica disponível para que o contexto possa utilizá-la sempre que for necessário executar a tarefa embutida nela.

Note que a solução fica aberta para receber facilmente novos algoritmos, preservando o fraco acoplamento entre as classes já previstas e implementadas. Assim, poucos pontos têm que ser alterados para se introduzir uma nova forma de realizar a tarefa: basta codificar a nova classe e prever a criação de suas instâncias na função factory.

Mais Informações Design Patterns com Delphi: Strategy - Parte I, Posts sobre Design Patterns

Design Patterns com Delphi: Strategy - Parte I

2011-09-29T11:22:00.000-03:00

Certas tarefas em um sistema computacional podem ser implementadas de diferentes maneiras sem que isso afete o resultado final esperado. Isto é, partindo de um determinado contexto, podemos selecionar um algoritmo entre vários possíveis e atingir o mesmo objetivo com qualquer um deles. Por exemplo, dada uma lista que precisa ser ordenada, há diversos algoritmos de ordenação que podem realizar a tarefa, como o método da bolha, quick sort ou busca binária. Independentemente do algoritmo escolhido, ao final do processo teremos a lista classificada. É claro que há diferenças de performance de um método pra outro mas isso é parte do processo de escolha daquele que melhor se adapta a uma situação. Cada situação encontrada pode levar a uma escolha distinta, sem que uma seja necessariamente preferida em relação às outras.

O programa pode, então, ter que intercambiar dinamicamente o algoritmo, seja por opção explícita do usuário ou por causa de outras questões circunstanciais encontradas durante a execução. Em projetos orientados a objetos, podemos desenhar uma solução para esse tipo de cenário usando o Design Pattern comportamental Strategy.

O objetivo do Strategy é permitir que o programa utilize de forma transparente qualquer algoritmo capaz de realizar uma determinada tarefa, construindo para isso uma estrutura de classes com baixo acoplamento. Com isso, fica fácil adicionar novos algoritmos, enquanto os códigos que os utilizarão continuam independentes da escolha feita.

Num sistema real, essa solução pode ser aplicada, por exemplo, no pagamento de títulos. Considere que um título pode ser pago levando o respectivo boleto ao banco, cadastrando a conta como débito automático ou registrando o pagamento no Internet Banking. Qualquer que seja a forma selecionada, o resultado é o título pago. O diagrama UML abaixo mostra as classes e suas relações para o Strategy aplicado a este cenário:

A nomenclatura formal para as classes que participam da solução com o pattern Strategy é a seguinte:

A classe Strategy é uma interface onde é definido o comportamento comum a ser respeitado por todos os algoritmos. Em outras palavras, devemos incluir nesta classe funções virtuais (e provavelmente abstratas) que fixarão a forma com que a tarefa estará acessível às outras partes do programa. A classe TWPagamento do diagrama acima exerce esse papel, definindo que pagamentos deverão ser feitos através da função efetuaPgto.

São chamadas de Concrete Strategy as classes que atendem a definição introduzida no Strategy e que, portanto, implementam um algoritmo que efetivamente realize a tarefa proposta. No diagrama, esse papel cabe a três classes distintas : TWPgtoBoleto, TWPgtoDebitoAuto e TWPgtoInternete. Cada uma delas executará a tarefa a sua maneira, providenciando uma versão própria da função efetuaPgto.

O Context é a classe que usará o comportamento definido pela Strategy, invocando as funções disponibilizadas por ela. Portanto, o Context deverá armazenar internamente uma referência ao Strategy. Em geral, ele também terá que expor formas de interagir com o Strategy, publicando propriedade e funções. No nosso exemplo, o Context é a classe TWTitulo; a interação com o Strategy é conseguida passando-se para a tarefa uma instância do próprio título a ser pago.

Um Client é qualquer parte do sistema que solicite uma operação à classe Context. Esse tipo de classe foi omitido do diagrama.

No próximo post, mostro uma sugestão de como implementar na prática essa solução usando o Delphi.

Mais Informações
Posts sobre Design Patterns

Trabalhando com a tag Canvas do HTML5 - parte III

2011-09-23T16:03:00.000-03:00

Dando continuidade aos posts sobre uso da tag Canvas (veja parte I e parte II), falo aqui sobre o uso de textos no canvas e a manipulação de imagens.

As propriedades básicas disponíveis para formatarmos a exibição de textos no Canvas são o tipo de fonte e a cor para o desenho. O tipo do fonte pode ser modificado através da propriedade font. Como a interpretação do valor contido nessa propriedade é idêntica ao de folhas de estilo CSS, podemos configurar com ela a família do fonte (Arial, Tahoma, Courier, etc.), o tamanho das letras e estilos especiais (negrito, itálico, etc.).

Quando trabalhamos com figuras geométricas no outro post, vimos que há duas formas de comandar um desenho : traçando apenas a borda ou preenchendo também o interior da figura, sendo que as cores para um ou outro são configuradas em propriedades separadas. O mesmo vale para o desenho de textos.

Assim, a propriedade fillStyle conterá a cor para preencher o texto quando este for desenhado usando a função fillText. Por outro lado, a propriedade strokeStyle define a cor das bordas do texto vazado a ser desenhado usando a função strokeText. Ambas as propriedades aceitam valores que estejam em conformidade com as regras de definição de cores estabelecidas pelo padrão CSS. Veja um exemplo :

 var myCanvas = document.getElementById("cnvText2");

var ctx = myCanvas.getContext("2d");

ctx.fillText ("Fonte e cores padrões", 5, 20);

ctx.font = "bold 16px Verdana";

ctx.fillStyle = "blue";

ctx.fillText ("Verdana 16px negrito", 5, 40);

ctx.font = "20px Courier";

ctx.strokeStyle = "#0FAF0F";

ctx.strokeText ("Courier 20px stroke", 5, 65);

ctx.font = "36px Arial";

ctx.strokeStyle = "maroon";

ctx.strokeText ("Arial 36px stroke", 5, 100);      Seu navegador (ou leitor de RSS) não suporta canvas ...

Usando fontes pequenas, o efeito de desenhar somente a borda acaba diluído, dando a impressão que o texto está todo preenchido. Portanto, ele funciona melhor com fontes maiores.

Conforme vemos no quadro anterior, as funções de desenho de texto aceitam 3 parâmetros : o próprio texto que será escrito e as coordenadas da posição no canvas onde ele deve ser renderizado. Normalmente, a posição indica o canto superior esquerdo de um retângulo virtual que conterá o texto. O significado dessa posição, no entanto, pode variar de acordo com o valor das propriedades textAlign e textBaseline. A primeira altera a interpretação do posicionamento horizontal do texto enquanto a segunda controla a coordenada vertical. Não é muito comum ter que alterar esses valores pois, no geral, os valores originais dão conta do recado.

Poderíamos ainda ter passado como 4o parâmetro o comprimento máximo que o texto deve ocupar - caso o tamanho real exceda esse valor, o tamanho do fonte é alterado automaticamente para que o texto caiba.

Um outro aspecto para incrementar a renderização de textos é a criação do efeito de sombra. Essa característica é controlada pelas propriedades shadowColor - que corresponde à cor da sombra - e o par shadowOffsetX e shadowOffsetY - respectivamente, o deslocamento horizontal e vertical da sombra a ser projetada em relação ao texto. É possível também esfumaçar a sombra, deixando o efeito mais sutil. Consegue-se isso usando a propriedade shadowBlur, cujo valor indica o quão borrada deve ser a sombra projetada. Seguem alguns exemplos:

  ctx.font = "18pt Arial";

ctx.fillStyle = "#0F0FA0";

ctx.shadowColor = "gray";

ctx.shadowOffsetX = 3;

ctx.shadowOffsetY = 3;

ctx.fillText ("Texto com sombra comum", 5, 40);

ctx.fillStyle = "#7F0FA0";

ctx.shadowColor = "black";

ctx.shadowOffsetX = 2;

ctx.shadowOffsetY = 2;

ctx.shadowBlur = 2;

ctx.fillText ("Texto com sombra borrada", 5, 70);

ctx.fillStyle = "green";

ctx.shadowColor = "black";

ctx.shadowOffsetX = 2;

ctx.shadowOffsetY = 2;

ctx.shadowBlur = 8;

ctx.fillText ("Sombra muito borrada", 5, 100);

      Seu navegador (ou leitor de RSS) não suporta canvas ...

De acordo com a padronização da W3C, para desenharmos uma imagem no canvas devemos usar a função drawImage. Com ela, podemos transferir para o canvas uma imagem inteira ou uma parte retangular dela. Também podemos modificar a proporção da imagem renderizada no canvas, indicando se ela é cópia exata da imagem original ou se será ajustada para um novo comprimento e altura. Neste link publicado pela W3C há uma explicação e um gráfico que ilustram o funcionamento dos parâmetros envolvidos na cópia da imagem original para o Canvas.

Em sua versão mais simples, o drawImage aceita como parâmetros a imagem em si e a coordenada do canto superior esquerdo no canvas a partir de onde a imagem será renderizada. Neste contexto, uma imagem pode ser tanto uma tag IMG quanto um outro canvas ou até mesmo a tag VIDEO, introduzida no HTML5. No caso da IMG, podemos recuperar uma referência à imagem usando a função getElementById do documento HTML (se a imagem já estiver embutida na página HTML) ou criar uma nova referência do zero, instanciando o objeto Image:

  var img = new Image();

img.onload = function () {

ctx.drawImage (img, 10, 10);

ctx.drawImage (img, 110, 10, 70, 110);

ctx.drawImage (img, 10, 15, 45, 60, 220, 20, 45, 60);

}

img.src = '40anos.gif';

ctx.font = "10pt Tahoma";

ctx.fillText ("Normal", 30, 130);

ctx.fillText ("Novo tamanho", 110, 130);

ctx.fillText ("Cópia parcial",210, 130);       Seu navegador (ou leitor de RSS) não suporta canvas ...

É importante ressaltar que a carga da imagem é disparada de modo assíncrono, logo após a URL para a imagem ter sido informada. Isto significa que o script continua a executar enquanto o navegador localiza e carrega a imagem. Por isso, no script acima a imagem é desenhada no canvas dentro do evento onload da tag da imagem. Ou seja, o desenho só é feito quando efetivamente a imagem está disponível.

As propriedades para sombreamento de texto discutidas neste post também são aplicáveis ao desenho de imagens. Assim, podemos incrementar o resultado adicionando esse efeito conforme a necessidade:

   var img = new Image();

img.onload = function () {

/* Remove o recurso de sombreamento para a 1a imagem */

ctx.shadowOffsetX = 0;

ctx.shadowOffsetY = 0;

ctx.shadowBlur = 0;

ctx.drawImage (img, 10, 10);

/* Aplica o recurso de sombreamento para as demais imagens */

ctx.shadowColor = "#2D90E0";

ctx.shadowOffsetX = 7;

ctx.shadowOffsetY = 10;

ctx.shadowBlur = 8;

/* Copia a imagem completa para um local no canvas */

ctx.drawImage (img, 110, 10);

/* Copia parte da imagem para um local no canvas */

ctx.drawImage (img, 10, 15, 45, 60, 220, 20, 45, 60);

}

img.src = '40anos.gif';

/* Para os textos, remove os efeitos de sombreamento */

ctx.font = "10pt Tahoma";

ctx.shadowColor = "black";

ctx.shadowOffsetX = 0;

ctx.shadowOffsetY = 0;

ctx.shadowBlur = 0;

ctx.fillText ("Normal", 30, 130);

ctx.fillText ("Com Sombra", 110, 130);

ctx.fillText ("Cópia parcial", 210, 123);

ctx.fillText ("com sombra", 210, 137);       Seu navegador (ou leitor de RSS) não suporta canvas ...

Note pelo exemplo anterior que mesmo na cópia de apenas parte de uma imagem o efeito de sombreamento se aplica.

Em outra oportunidade mostrarei mais recursos do canvas associado a cores e imagens (como rotação e criação de gradientes) e como misturar isso tudo.

Mais Informações
Trabalhando com a tag Canvas do HTML5 - parte I e parte II, Tutorial de Canvas na Fundação Mozilla, Definições da W3C para o uso de textos no Canvas,Definições da W3C para o uso de imagens no Canvas

Funcionamento do Certificate Store do Windows

2011-09-15T17:58:00.000-03:00

Tenho recebido com frequência dúvidas a respeito do acesso a certificados digitais importados no Certificate Store do Windows. Pela forma com que as dúvidas têm sido colocadas, percebi que faltou nos posts sobre esse assunto dar uma ideia global do que é o Certificate Store e como ele funciona.

Como disse no post sobre acesso ao Certificate Store do Windows com C#, o Certificate Store é um repositório centralizado onde são armazenados os certificados digitais disponíveis em um computador. Há uma aplicação que permite acessá-lo visualmente, sendo que uma forma fácil de iniciá-la é usando a opção Executar do menu Iniciar do Windows. Na caixa de edição que se abre, digite o comando abaixo:

mmc \windows\system32\certmgr.msc

Normalmente, a tela que aparece é a que está reproduzida a seguir:

Com essa aplicação, é possível gerenciar os certificados instalados no computador, importando novos e eliminando aqueles que não são mais desejados. Observe que o painel à esquerda mostra uma organização hierárquica, com uma raiz e diversas pastas embaixo dela. O nó raiz nesse exemplo apresenta o nome Certificates - Current User. Isso significa que todas as pastas sob ele bem como os certificados listados no painel à direita estão disponíveis apenas para o usuário que atualmente está logado no Windows.

As pastas servem para agrupar os certificados por semelhança na finalidade de uso. Na imagem, a pasta Personal está selecionada, permitindo-nos visualizar à direita os certificados catalogados como sendo de uso pessoal do usuário atual. Outros exemplos de pastas são as que contém certificados que identificam as Autoridades Certificadoras (CA), entidades responsáveis pela emissão dos certificados.

Do ponto de vista do programador que vai acessar o Store usando a classe X509Store (ou o CAPICOM), essas duas informações - nó raiz e pasta - são imprescindíveis. O construtor da X509Store aceita como parâmetros o Store Name e o Store Location, sendo que o name corresponde à "pasta" onde está o certificado e location é o nó raiz ao qual a pasta está atrelada. A pasta personal é mapeada com o nome "My" para essa função.

Agora, imagine que você construiu um serviço que acessa o Certificate Store. No Windows, cada serviço é executado com um usuário específico, o qual pode ser configurado na guia Log On das propriedades do serviço no gerenciador de serviços do Windows. Com isso, ele poderá entrar no ar mesmo que nimguém esteja logado no Windows - o login será feito automaticamente para o usuário que tiver sido associado ao serviço. Portanto, se você importou um certificado para seu usuário mas está executando o serviço com um usuário diferente, esse outro usuário não enxergará o seu certificado.

Isso vale também para aplicações ISAPI - sites construídos em ASP ou ASP.NET se encaixam nessa categoria - uma vez que elas rodam como parte do serviço do IIS (Internet Information Services). O IIS é atrelado normalmente a um usuário padrão do Windows chamado Local System e, portanto, loga-se no Windows com esse usuário, mesmo que você tenha feito login.

Para resolver esse impasse, podemos importar o certificado num Store Location acessível por todos os usuários. Como a aplicação disponível carrega apenas originalmente o Location "Current User", teremos que adicionar na mão um plugin para o Location com a característica que precisamos. Esse Location é o "Local Computer".

Para isso, execute o MMC.exe sem parâmetros no Iniciar -> Executar do Windows. No menu File da aplicação, clique na opção Add/Remove snap-in e então o botão "Add" para ativar a tela de adição dos plugins. Na lista de plugins que aparece, selecione certificates e novamente clique em "Add". A imagem abaixo mostra a tela de adição do plugin de gerenciamento de certificados com a opção "Computer Account" (o computer local) selecionada.

Após a adição, o console mostrará uma hierarquia similar à da imagem no início deste post, com a exceção de que o nó raiz será "Local Computer". Agora podemos importar certificados na pasta "Personal" e torná-los disponíveis para os programas, independentemente das credenciais do usuário que está executando esse programa ou serviço.

Certificados importados na pasta "Personal" do "Local Computer" podem, então, ser acessados abrindo-se o Certificate Store com os parâmetros mostrados abaixo:

X509Store lStore = new X509Store (StoreName.My, StoreLocation.LocalComputer);

/* ... */

Mais Informações
Trabalhando com o Certificate Store do Windows (C#), Acessando o Certificate Store do Windows com CAPICOM (Delphi), Microsoft Management Console

Trabalhando com a tag Canvas do HTML5 - parte II

2011-09-06T11:58:00.000-03:00

No último post, apresentei o funcionamento básico da tag Canvas do HMTL 5, sua inserção numa página HTML e código JavaScript simples para traçar linhas na área do Canvas. Avançando nesse assunto, gostaria de apresentar aqui outras funções de desenho e como lidar com cores.

Além de linhas, a lista de funções para traçar figuras geométricas básicas inclui também funções para criar retângulos e arcos. No caso dos retângulos, há 2 funções : uma para desenhar apenas a borda, sem preencher o interior - strokeRect - e outra para desenhá-lo preenchido - fillRect.

/* ... */

ctx.beginPath();

ctx.fillRect (10,10,60,100);

ctx.strokeRect (75,10,60,100);

ctx.clearRect (30, 50, 25, 25);

ctx.closePath();

var grausFin = 360;

var radFin = (Math.PI/180) * grausFin;

ctx.beginPath();

ctx.arc(180, myCanvas.height / 2, 25, 0, radFin, false);

ctx.stroke();

ctx.closePath();

ctx.beginPath();

ctx.arc(230, myCanvas.height / 2, 25, 0, radFin, false);

ctx.fill();

ctx.closePath();

Seu navegador não suporta canvas ...

Já a função clearRect que aparece no código acima serve para limpar uma área retangular do canvas, tornando-a transparente. Isto é, a área é totalmente preenchida com a cor de fundo da tag onde o Canvas está inserido, substituindo os pixels contidos na área. A utilidade desse recurso está em preparar o canvas para receber novos desenhos sem sofrer interferência daqueles que existiam anteriormente.

Os parâmetros das funções de retângulo são sempre o ponto superior esquerdo (x, y) seu comprimento e sua altura.

Como mostra o exemplo anterior, o desenho de um círculo é feito através da função arc. O que determina se ele será preenchido ou não é a função chamada depois : use fill para preenchê-lo ou stroke para desenhar apenas o seu contorno.

Os parâmetros da função para desenhar arco são o ponto central (x, y), seu raio, o ângulo na circunferência onde o desenho será iniciado, o ângulo final e um booleano indicando se o desenho será feito no sentido anti-horário. Como diz o nome da função, ela traça um arco entre o ângulo inicial e final, formando parte de um círculo com centro em (x, y) e o raio dado. Isso implica que temos que informar os ângulos 0 (zero) e 2pi se quisermos desenhar um círculo completo. Observe que os ângulos são informados em radianos e não em graus. A fórmula (PI * 180 / graus) que aparece no exemplo faz a conversão de graus para radianos.

As cores aplicadas em linhas e nos preenchimentos são controladas de forma independente entre si. Ao traçar linhas – aí incluindo a função para desenhar somente as bordas de um retângulo ou arco – a cor é ditada pela propriedade strokeStyle do canvas, enquanto para fazer qualquer preenchimento, a cor usada é aquela atribuída ao fillStyle.

/* ... */

ctx.beginPath();

ctx.fillStyle = "rgb(45,80,150)";

ctx.strokeStyle = "maroon";

ctx.fillRect (10,10,60,100);

ctx.strokeRect (75,10,60,100);

ctx.closePath();

var grausFin = 360;

var radFin = (Math.PI/180)* grausFin;

ctx.fillStyle = "#FFA500";

ctx.strokeStyle = "green";

ctx.beginPath();

ctx.arc(180, myCanvas.height / 2, 25, 0, radFin, false);

ctx.stroke();

ctx.closePath();

ctx.beginPath();

ctx.arc(230, myCanvas.height / 2, 25, 0, radFin, false);

ctx.fill();

ctx.closePath();

Seu navegador não suporta canvas ...

No exemplo acima, utilizei cores especificando diretamente seu nome (com em “green”) ou sua composição RGB (como em "rgb(45,80,150)"). Também poderia ter usado um código hexadecimal (como em "#FFA500"). Ou seja: são os mesmos mecanismos aceitos pelo CSS3.

Um outro aspecto importante para traçar linhas e desenhar bordas é a espessura que a linha deve ter. Podemos modificar o valor contido na propriedade lineWidth do canvas para obter linhas mais grossas. O valor padrão dela que corresponde a 1 unidade, sendo que ela aceita valores positivos.

/* ... */

var angIni = 3 * Math.PI / 2;

var angFin = Math.PI / 2, x, i;

/* Linhas e arcos */

x = 5;

for (i = 0; i < 10; i ++)

{

  ctx.lineWidth = i + 1;

  ctx.lineCap = "round";

  ctx.beginPath();

  ctx.moveTo (x, 5);

  ctx.lineTo (x, 35);

  ctx.stroke(); 

  ctx.closePath();

  ctx.beginPath();

  ctx.arc(x, 75, 20, angIni, angFin, false);

  ctx.stroke();

  ctx.closePath();

  x = x + 15;

};

/* Bordas de retângulos */

ctx.beginPath();

ctx.lineWidth = 8;

ctx.strokeRect(180,  5, 100, 100);

ctx.lineWidth = 6;

ctx.strokeRect(190, 15,  80,  80);

ctx.lineWidth = 4;

ctx.strokeRect(200, 25,  60,  60);

ctx.lineWidth = 2;

ctx.strokeRect(210, 35,  40,  40);

ctx.closePath();

Seu navegador não suporta canvas ...

No exemplo acima, modifiquei também a propriedade lineCap, que determina como o desenho de linhas será arrematado. Ao usar o valor "round", instruo o canvas a arredondar as pontas das linhas ao invés de deixá-las retas, como no comportamento padrão.

No próximo post, falo sobre uso de textos, imagens e como modificar o modo que os desenhos aplicados ao canvas interagem entre si, criando composições entre eles.

Mais Informações
Trabalhando com a tag Canvas do HTML5 - parte I, Tutorial do Canvas no site da Fundação Mozilla

Trabalhando com a tag Canvas do HTML5 - parte I

2011-08-29T16:44:00.000-03:00

Dentre as inovações introduzidas pelo HTML5, certamente a que causou maior impacto foi a adoção da tag Canvas. A discussão em torno desse recurso acabou ampliada pelo potencial que ele tem de eliminar a necessidade de outras tecnologias bem estabelecidas, como o Adobe Flash, usado para criar animações em páginas da Internet.

Mas, o que é a tag Canvas, como ela funciona e pra que exatamente ela serve ? A grosso modo, essa tag cria uma área retangular dentro de uma página HTML onde é possível desenhar livremente. Ela faz isso franqueando ao desenvolvedor acesso aos pontos (pixels) que compõem a área, o que pode ser combinado com eventos para criar animações. É um comportamento análogo ao disponível através da classe TCanvas que há no Delphi. Tal analogia é reforçada pelo fato que a tag Canvas em si apenas demarca a região na página HTML, sendo que quaisquer desenhos ou interações que se queira implementar têm que ser obtidos através de programação, usando os métodos e propriedades disponibilizados para uso com JavaScript.

Para começar, então, devemos incluir no corpo do texto HTML a marcação do lugar onde o Canvas será renderizado, exatamente do mesmo modo que fazemos com outras tags. O exemplo abaixo cria uma página HTML que possui apenas um Canvas, com comprimento de 400 pontos e altura de 200 pontos:

<body>

<canvas id="myCanvas" width="400" height="200"
style="border:1px solid #c3c3c3;">

Seu navegador não suporta canvas ...

</canvas>

/* ... */

</body>

O texto inserido na tag será exibido apenas se a página for aberta por um navegador que não implementa o recurso de Canvas. Neste caso, para obter um resultado mais profissional, o texto pode ser substituído por um conteúdo HTML apropriado - como uma imagem, por exemplo.

Daqui em diante, todo o trabalho em cima do Canvas tem que ser feito por JavasScript. Primeiro, precisamos recuperar o contexto para desenho pois é nele que o conteúdo apresentado pelo Canvas é criado e manipulado:

function desenha () {

var myCanvas = document.getElementById("myCanvas");

var ctx = myCanvas.getContext("2d");

/* ... */

}

Todas as funções disponíveis no contexto que recuperamos deverão informar coordenadas, isto é, pares de valores (x,y) para se referir a um ponto dentro do plano delimitado pela área do Canvas. A diferença em relação a um plano cartesiano é que no canvas o canto superior esquerdo é sempre (0,0), com os valores de X crescendo para a direita e os de Y crescendo para baixo, como mostra essa imagem da fundação Mozilla :

O exemplo abaixo é bastante básico : move a posição atual do cursor de desenho para o centro do Canvas, traça uma linha até o canto inferior esquerdo, outra até o canto inferior direito e uma terceira até o ponto original. Por fim, a figura fechada é preenchida com a cor corrente :

/* ... */
ctx.beginPath ();

ctx.moveTo (myCanvas.width / 2,
myCanvas.height / 2);
ctx.lineTo (0,
myCanvas.height);
ctx.lineTo (myCanvas.width, myCanvas.height);
ctx.lineTo (myCanvas.width / 2,
myCanvas.height / 2);

ctx.stroke();
ctx.fill();

ctx.closePath();
/* ... */

Vamos por partes ! As funções beginPath() e closePath() do contexto delimitam passos que constituirão um único desenho para o Canvas, não importando quantos passos são necessários para montá-lo. Com isso, os passos entre essas funções compartilham estilos para traçar linhas e preencher áreas, por exemplo. Então, se há partes com cores diferentes, elas deverão ser traçadas como desenhos diferentes dentro do Canvas.

No exemplo, o primeiro passo é uma chamada à função moveTo(). Ela em si não faz qualquer desenho, servindo apenas para estabelecer um ponto de partida para passos seguintes. Ou seja, é o ponto onde o pincel primeiro tocará a área de pintura. Assim, ao chamarmos a função lineTo(), traçamos uma linha reta a partir daquele ponto até o ponto indicado nos parâmetros do lineTo. Esse novo ponto, então, passa a ser a posição atual do pincel. Se fosse preciso, poderíamos mover novamente sua posição para qualquer outro ponto sem afetar visualmente o canvas.

A função stroke() efetiva todos os comandos dados antes, forçando as linhas a serem traçadas com os estilos estabelecidos. Como não comandamos nada diferente, o canvas usará o estilo padrão de cor, espessura e tracejado.

Para encerrar, a função fill() é chamada para preencher a área interna da figura - também usando estilos padronizados.

Há muitas outras funções para desenhar retângulos, arcos e até curvas mais elaboradas, além da capacidade de incluir textos e imagens externas, o que permite combinar vários recursos para compor figuras bastante complexas. Em outro post, mostra mais desses recursos.

Os exemplos mostrados neste post usam o contexto para desenhos 2D mas já há uma versão experimental de contexto 3D, baseado no WebGL. Veja um exemplo de uso neste link.

Mais Informações
Canvas element, Tutorial do Canvas no site da Fundação Mozilla

Atualização da especificação do C++ ganha aprovação unânime

2011-08-18T13:42:00.001-03:00

Já faz algum tempo, o órgão responsável por padronizações internacionais (ISO) tem um comitê para discutir novos recursos para a linguagem de programação C++. Após 8 anos de trabalho, um rascunho das especificações já tinha sido liberado no início deste ano para que a comunidade decidisse se aprovava ou não.

O foco principal das mudanças na especificação foi a adequação do C++ a arquiteturas mais modernas de processamento paralelo, isto é, teve como objetivo facilitar o desenvolvimento de software C++ para esse tipo de ambiente. Além de alterações na STL (Standard Template Library), o novo C++ também ganha tratamento para expressões lambda (veja funções anônimas) e novos tipos de dado para trabalhar com computação paralela. Há ainda mudanças sintáticas para melhorar a performance dos programas.

Um resumo das alterações introduzidas pode ser consultado no artigo da Wikipedia sobre o C++0x - nome pelo qual a versão era conhecida mas que agora foi batizado oficialmente como C++11.

Na semana passada, o rascunho foi finalmente aprovado - por unanimidade - e passa a ser a recomendação oficial para a linguagem C++. Abaixo, segue matéria da InfoWorld que anuncia a aprovação. A matéria original em inglês está neste link.

"Com a recente aprovação do upgrade para a linguagem C++, o ISO (International Organization for Standards) está fornecendo aos desenvolvedores ferramentas que alavancarão o uso de algorítmos paralelos e permitirão uma melhor performance", disse na terça-feira o presidente do comitê responsável pela linguagem, Herb Sutter.

"O C++11 é a primeira grande revisão do ISO C++", disse o presidente. "Foi introduzido no C++11 as funções lambda, que são peças chaves para os emergentes algorítmos paralelos e que revolucionam o uso da Standard Template Library (STL)", disse Sutter, que é também um dos principais arquitetos para linguagens nativas na Microsoft. "O que já existia na biblioteca padrão do C++98 se tornará imediatamente mais fácil de ser usado", disse. Além disso, alterações na semântica do C++11 trazem melhoria na performance. Os novos recursos para tratamento de concorrência incluem tipos de dados para programação portável e livre de locks.

A votação final para o padrão C++ se encerrou na quarta-feira passada e foi unanimemente aprovada, disse Sutter em seu blog. O C++11 era conhecido como C++0x e sua publicação oficial se dará dentro de algumas semanas. "A linguagem", ele diz, "é usada para quase tudo -- o mundo está construído sobre C++."

O C++, incluindo seu subconjunto, o C, é usado para criar compiladores e runtimes de virtualmente todas as linguagens que concorrem com ele, todos os principais navegadores da internet, todos os principais sistemas operacionais, diz Sutter. É também a principal linguagem usada pelo Google e pelo Facebook e a principal linguagem para quase todos os produtos da Microsoft, afirma. "O C++ é a linguagem a se escolher na construção de aplicações de alta performance, qualquer que seja o domínio dessa aplicação", diz Sutter.

"C++ é uma linguagem de uso geral", afirma Henry Skoglund, desenvolvedor C++. "Muito do que foi incluído no novo padrão eu diria que é importante para desenvolvimento de sistemas e de compiladores," ele diz. "Os recursos do Lamdba", assegura Skoglund, "permitem aos desenvolvedores escrever código com menos bugs e em menos linhas."

Também contempladas no C++11 estão as funções auto e decltype, onde a primeira é útil para dedução de tipos e a segunda permite obter o tipo de dado real de qualquer expressão. Ainda, ponteiros smart, tais como o unique_ptr, oferecem um gerenciamento de memória automatizado e padronizado.

O próximo passo para o padrão C++ é ser implementado pelos compiladores nos próximos um ou dois anos, afirma Sutter. "Enquanto isso se desenrola, o comitê de padrões continuará a trabalhar nos recursos já incluídos no C++11, incrementando a biblioteca padrão de modo que uma biblioteca maior, portável (que não requeira novos recursos da linguagem além dos que já foram incluídos), esteja disponível dentro de cada implementação C++." Está sendo cogitada também uma nova rodada de extensões à linguagem, como conceitos de template ou lambdas mais fortes para o C++11.

Mesmo antes de se tornar oficial, alguns compiladores - como o C++ da Embarcadero (C++ Builder XE) e da Microsoft (Visual C++ 2010) - já incorporaram às suas bibliotecas recursos definidos por esse novo padrão.

Mais Informações
C++ upgrade wins unanimous approval, Site do C++ Builder, Características do C++0x implementadas no Visual Studio

Recuperando emails de uma caixa postal com Delphi

2011-08-04T19:34:00.000-03:00

Até pouco tempo atrás, o ERP da ABC71 possuia um recurso que permitia aos usuários enviarem sugestões de melhorias do software por email. Uma aplicação em nossos servidores monitorava a caixa postal específica, interpretava algumas informações incluídas em cada email, vinculava a solicitação a um responsável e respondia automaticamente o email do usuário com uma mensagem pré-formatada preparada pelo atendimento a Clientes.

Hoje esse esquema não existe mais - foi substituído por outros canais com papel similar - mas a ideia da aplicação capaz de monitorar uma caixa postal ainda é válida e pode ser reaproveitada em outros cenários.

A solução adotada por nós é baseada no protocolo chamado POP3 (Post Office Protocol). Com ele é possível recuperar todas as mensagens existentes na caixa de entrada de uma conta de email. A implementação dele que usamos é a do Projeto Indy distribuida junto com o IDE do Delphi;

Da mesma forma que outros protocolos baseados no IP, usar o POP3 exige que se faça a conexão com o servidor antes de realizar qualquer operação. Temos, então, que informar o nome (ou endereço) desse servidor, a porta onde se conectar e um nome de usuário e sua senha, válidos para a operação desejada.

var _IdPOP3 : TIdPOP3;

begin

_IdPOP3 := TIdPOP3.Create (Nil);

   _IdPOP3.Host := _ServidorPOP;

   _IdPOP3.Port := _PortaPOP;

   _IdPOP3.Username := _Username;

   _IdPOP3.Password := _Userpwd;

   _IdPOP3.AutoLogin := True;

  _IdPOP3.Connect ();

A propriedade AutoLogin ajustada com o valor true indica que o componente tentará automaticamente fazer o login no servidor sempre que isso for necessário, evitando que tenhamos que comandar o login manualmente.

Uma vez que temos a conexão estabelecida, podemos iniciar a recuperação das mensagens da caixa de entrada. Há basicamente dois níveis de informação que conseguimos recuperar sobre uma mensagem. Em ambos os casos, as informações são armazenadas numa variável do tipo TIdMessage. No primeiro nível, são obtidos somente os dados de cabeçalho da mensagem - como o assunto, o remetente e os destinatários -, o que reduz o tráfego na rede. O trecho abaixo recupera o cabeçalho da primeira mensagem da caixa de entrada:

var msg : TidMessage;

begin

  msg := TidMessage.Create(self);

  _IdPOP3.RetrieveHeader (1, msg);

{ ... }

  msg.Free;

O segundo nível permite recuperar a mensagem completa, incluindo todas as informações do nível anterior, bem como o corpo da mensagem e todos os anexos dela. Ao utilizar esse método, a caixa postal marca automaticamente a mensagem como lida:

var msg : TidMessage;

begin
  msg := TidMessage.Create(self);

  _IdPOP3.Retrieve (1, msg);

{ ... }

  msg.Free;

Com as informações obtidas nesse nível, temos maior flexibilidade para customizar tratamentos para as mensagens. Por exemplo, podemos redirecionar a mensagem para outra pessoa de acordo com o conteúdo ou processar os anexos, salvando-os numa pasta do computador ou num banco de dados.

Não podemos esquecer que o conteúdo de um email pode ser composto de diversas partes distintas, conforme mostrei no post sobre envio de email com Delphi. Então, dependendo de como o email foi composto, recuperar o corpo da mensagem pode ser um simples acesso à propriedade msg.Body.Text ou significará termos que percorrer a lista de partes para determinar qual é o texto contido. Se o texto no corpo está em branco, basta percorrer a lista de partes procurando por uma que seja do tipo texto (TIdText):

var { ... }

    parte : TIdMessagePart;

    texto : TIdText;

    corpo : string;

begin

{ ... }

      _IdPOP3.Retrieve(1, msg);

      for j := 0 to msg.MessageParts.Count - 1 do begin

        parte := msg.MessageParts.Items[j];

{ Verifica se a parte é um texto }

        if (parte is TIdText) then begin

          texto := parte as TIdText;

          corpo := texto.Body.Text;

          break;

        end;

{ ... }

O tipo do texto contido numa parte fica informado na propriedade ContentType. Como é permitido ter mais que uma parte com texto, pode-se testar esse tipo para recuperar o texto que interessa. É comum enviar uma parte com texto HTML e outra com texto TEXT/PLAIN para que o programa leitor de email decida qual exibir, de acordo com a opção feita pelo usuário.

Da mesma forma que recuperamos o texto lendo as partes, podemos salvar os anexos. Para isso, a parte deve ser do tipo TIdAttachment. Também podemos determinar o tipo do conteúdo do anexo lendo a propriedade ContentType da parte em questão. Salvar o arquivo fica fácil :

{ ... }

for j := 0 to msg.MessageParts.Count - 1 do begin

        parte := msg.MessageParts.Items[j];

{ Verifica se a parte é um anexo }

        if (parte is TIdAttachment) then begin

          anexo := parte as TIdAttachment;

          anexo.SaveToFile('c:\temp\' + anexo.FileName);

        end;

{ ... }

Mas, como saber quais mensagens podem ser recuperadas ? A quantidade de mensagens existentes é conseguida através da função CheckMessages; podemos recuperar qualquer uma delas usando um número inteiro entre 1 e essa quantidade. A lista é trazida em ordem cronológica, com as mensagens mais antigas da caixa de entrada possuindo os menores números de identificação.

    for i := 1 to _IdPOP3.CheckMessages do

    begin

      msg := TidMessage.Create(self);

      _IdPOP3.RetrieveHeader (i, msg);

      if DeveRecuperarMsg (msg.MsgId) then

        TrataMsg (Msg);

      msg.Free;

  end;

As mensagens lidas permanecem na caixa até que sejam removidas. O POP3 permite fazer essa remoção mas nem sempre isso é uma opção. Para esses casos, uma sugestão é controlar manualmente as mensagens. Elas possuem uma string de identificação chamada MsgID que é única, como mostra o código acima. A ideia é recuperar apenas o cabeçalho da mensagem, testar se o MsgID atual já foi tratado antes e só então trazer a mensagem completa, se for necessário.

Quando concluir as operações na caixa postal, finalize a conexão com o POP3 usando a função Disconnect.

Como se pode ver pelo exemplo retratado neste post, o protocolo POP3 é bastante simples, limitando-se a poucas funcionalidades básicas. Se for preciso usar recursos mais avançados, tais como restringir as mensagens recuperadas usando filtros ou realizar operações envolvendo "pastas" na caixa postal, teremos que apelar a um protocolo mais completo, como o IMAP4. Mostro em outra oportunidade como usá-lo.

Mais Informações
Post Office Protocol

Adobe lança ferramenta para criação de conteúdo rico com HTML5

2011-08-01T16:46:00.000-03:00

Já faz algum tempo que a mídia especializada em TI vem prevendo dificuldades para a tecnologia Flash. Razões para isso não faltam. Primeiro, foi o surgimento do HTML5, cuja especificação inclui recursos que permitem desenvolver animações apenas com padrões abertos. Depois, as declarações de Steve Jobs criticando o excesso de bugs existentes no Flash, argumento usado para justificar a falta da tecnologia Flash no sistema usado pelos dispositivos móveis da Apple.

A própria Adobe parece estar de precavendo contra uma possível debandada no uso de sua tecnologia. Hoje eles anunciaram o preview de uma ferramenta onde as animações são construídas com padrões da internet - HTML5, CSS e JavaScript - ao invés do Flash. Com isso, procuram se manter no topo no nicho tecnológico em que conquistaram grande destaque. Ao que parece, se o Flash realmente naufragar, a Adobe ainda terá uma grande ferramenta para construção de animações. Caso ele sobreviva, nunca é demais dar ao desenvolvedor outras possibilidade de escolha, principalmente se há uma opção baseada em padrões abertos.

A ferramenta, que chama-se Edge, está disponível no site Adobe Edge como parte do laboratório da Adobe. O anúncio dela foi tema de um artigo na Infoworld.com, o qual reproduzo abaixo, traduzido:

Plantando sementes que têm o potencial de derrubar sua própria franquia de sucesso em desenvolvimento de animações Flash, a Adobe lançou um preview de uma nova aplicação chamada Adobe Edge, projetada para montar conteúdo web dinâmico usando HTML5 e outros padrões abertos relacionados, anunciou a empresa nesta segunda-feira.

"Esta é uma ferramenta para animações e interatividade para designers que queiram construir conteúdo web interativo usando padrões da Web", disse Devin Fernandez, gerente de produto da Adobe.

Tradicionalmente, Web designers têm usado o Adobe Flash, ou concorrentes como o Microsoft Silverlight, para acrescentar animações estilosas e conteúdo interativo a páginas Web, na forma de telas de abertura para o site, gráficos interativos, vídeos curtos ou propagandas. A Adobe estima que 99 porcento de todos os computadores desktop possuem o plug-in necessário para executar arquivos Flash.

Nos últimos anos, no entanto, a W3C (World Wide Web Consortium) e outros órgãos de padronização vêm desenvolvendo um punhado de especificações que podem ser usadas na criação de conteúdo rico semelhante ao Flash. Os fabricantes de navegadores estão incorporando esses padrões - tais como HTML5, a tag Canvas, JavaScript e CSS (Cascading Style Sheets) - em seus navegadores, o que elimina a necessidade de um plug-in externo para executá-los.

A Apple também não está ajudando a sorte da Adobe pois seu CEO, Steve Jobs, criticou o Flash no passado, afirmando que ele possui bugs demais e instando os desenvolvedores a usarem o HTML5 no lugar.

"Muitos trabalhos que estavam previamente reservados para o Flash estão agora sendo feitos com padrões Web," admitiu Fernandez. "Nós vemos como uma enorme oportunidade para a companhia ajudar as pessoas a extrairem o melhor do HTML5."

Esta ferramenta usa HTML5, CSS e Javascript para inserir conteúdo Web animado diretamente numa página HTML. Com uma abordagem similar à da ferramenta de criação do Flash, o Edge permite ao desenvolvedor alterar atributos de uma imagem ou de um elemento HTML ao longo de um intervalo de tempo, resultando numa página animada.

"A Adobe tem mostrado que pode se adaptar muito bem a novas tendências. Isto mostra que eles podem se manter como principais vendedores de ferramentas, não importa qual a tecnologia que está embarcada," disse Al Hilwa, analista de desenvolvimento de aplicações do IDC. "Há poucas empresas sintonizadas com as necessidades e sensibilidades de um designer como a Adobe está, e esta ferramenta realmente mostra isso. Ela traz o modelo de linha do tempo, que é familiar a muitos desenvolvedores Flash, para o mundo novo do HTML5 e JavaScript, enquanto mantém a integridade do código."

A Adobe não tem expectativa de que o Edge vá suplantar o Flash inteiramente, ao menos não no futuro próximo. "A tecnologia Flash permanecerá um componente chave para casos de uso específicos, como vídeos de qualidade e jogos," disse Fernandez. "Nós definitivamente vemos HTML5 e Flash coexistindo, e, por isso, continuaremos a trabalhar em soluções para ambos na Adobe. Os usuários decidirão qual tecnologia eles usarão."

A edição preview está disponível como um download gratuito. Adobe espera liberar a versão comercial final em 2012, segundo Fernandez. Haverá versões tanto para Microsoft Windows quanto para Apple Macintosh.

A matéria original em inglês pode ser encontrada nesse link.

Mais Informações
Adobe launches HTML5 rich media editor, Site do Adobe Edge

Usando um Web Service no Visual Studio - parte II

2011-07-20T19:21:00.000-03:00

Escrevi um post em 2009 explicando alguns detalhes sobre o funcionamento de Web Services e mostrando como usá-los em um projeto do Visual Studio. Aquele post descrevia como usar o IDE para gerar automaticamente uma classe proxy, necessária para fazermos a chamada das funções remotas disponibilizadas pelo serviço. Tal classe é chamada de "proxy" por ser projetada segundo o design pattern que leva esse nome.

Como se vê no post, gerar o proxy é um procedimento muito simples, assim como utilizá-lo para executar a função remota. Para a grande maioria das situações, usar o Web Service desse modo é suficiente. No entanto, há uma desvantagem na forma como isso é feito. Uma vez que o processo todo é automatizado e o trâmite da comunicação com o servidor fica escondido nas bibliotecas da plataforma .Net, não é possível customizar parte alguma da comunicação.

Mas, porque seria necessário interceptar a comunicação e alterar alguma coisa ? Uma razão óbvia é depuração. Isso é, se acontecer um erro, é interessante saber quais foram os comandos enviados e os respectivos retornos fornecidos pelo servidor. Um sniffer não conseguiria fazer esse serviço caso o web service esteja num canal seguro (HTTPS) pois as informações são criptografadas.

Uma outra razão seria customizar a serialização das informações, oportunidade para enxugar o texto trafegado, removendo-se partes sobressalentes. Ou, ainda, para adequar a formatação dos parâmetros da função que são trafegados. Do ponto de vista do proxy, a serialização é o processo pelo qual o nome da função remota e os parâmetros que passamos para ela são transformados em texto e empacotados num XML antes de serem enviados para execução no servidor. Ao receber uma resposta do servidor, o proxy tem que aplicar o processo inverso no XML recebido, isto é, fazer a desserialização, convertendo o conteúdo do XML em tipos de dados nativos da linguagem e associando-o ao valor de retorno da função. Lembre-se que o protocolo usado para comunicação com web services é o SOAP, que é baseado em XML. Portanto, um parâmetro com tipo de dado complexo pode exigir uma formatação especial pra funcionar.

Já que o código gerado automaticamente pelo IDE do Visual Studio não permite interceptar a serialização, teremos que optar por um método alternativo. O SDK do .NET vem com uma ferramenta de linha de comando chamada WSDL.EXE. Basicamente, nela você informa o arquivo descritor do Web Service (WSDL) e ela gera a classe proxy apropriada. O quadro abaixo mostra um exemplo básico de como usar a ferramenta:

wsdl /language:CS /n:"WNameSpace" WMeuServico.wsdl

Nesse exemplo, o WSDL.EXE interpretará a descrição contida no arquivo WMeuServico.wsdl e gerará um uma classe proxy em C# inserindo-a no namespace WNameSpace. A diferença em relação ao proxy gerado diretamente pelo Visual Studio está na infraestrutura de classes envolvidas. No caso do WSDL.EXE, o proxy é uma herança de SoapHttpClientProtocol. A execução dos métodos dessa classe pode ser extendida usando-se atributos que implementem as funções contidas em SoapExtension. Ou seja, cria-se uma herança de SoapExtension que então é aplicada como um atributo da função existente no Web Service. Quando a função remota é chamada, a serialização passa a ser controlada pela nossa versão do SoapExtension.

O cerne dessa solução é o método ProcessMessage. Ele recebe uma instância com a mensagem SOAP atual, permitindo manipulá-la conforme a necessidade.

public class TWTraceExtension : SoapExtension

{

/* ... */

    public override void ProcessMessage(SoapMessage message)

    {

      switch (message.Stage)

      {

        case SoapMessageStage.BeforeSerialize:

          break;

        case SoapMessageStage.AfterSerialize:

           StreamWriter w = new StreamWriter(_LogFile);

           w.WriteLine ("=> Serializado");

           w.Flush();

           message.Stream.Position = 0;

           Copy(message.Stream, fs);

           w.Close();

          break;

        case SoapMessageStage.BeforeDeserialize:

           StreamWriter w = new StreamWriter(_LogFile);

           w.WriteLine ("=> Desserializado");

           w.Flush();

           message.Stream.Position = 0;

           Copy(message.Stream, fs);

           w.Close();

          break;

        case SoapMessageStage.AfterDeserialize:

          break;

      }

    }

/* ... */

}

Agora que temos a extensão do processo de serialização e desserialização, precisamos criar um atributo que seja aplicável ao método do Web Service. Fazemos isso criando uma extensão da classe de atributo SoapExtensionAttribute, cujo objetivo principal é determinar qual classe deve ser usada para serializar. Veja um exemplo:

  [AttributeUsage(AttributeTargets.Method)]

  public class TWTraceExtensionAttribute : SoapExtensionAttribute

  {

/* ... */

     public override Type ExtensionType

    {

      get { return typeof(TWTraceExtension); }

    }

/* ... */

}

Veja que a propriedade ExtensionType é sobrescrita para retornar informações sobre nossa classe de serialização. Um outro detalhe é que a declaração de nossa classe de atributo é ela própria configurada por um atributo indicativo do tipo de uso esperado para ela : ser atributo de métodos de outras classes.

Por fim, devemos usar o novo atributo criado acima para configurar o método do Web Service que queremos consumir. Isso implica modificar o fonte gerado automaticamente pelo WSDL. Então, a configuração terá que ser refeita toda vez que gerar o fonte. Veja um exemplo:

/* ... */

public partial class Service1 : System.Web.Services.Protocols.SoapHttpClientProtocol

{

/* ... */
  
        [TWTraceExtensionAttribute(Filename = "c:\\log.txt")]

        public string consultaNFe ([System.Xml.Serialization.XmlAnyElementAttribute()] 

System.Xml.XmlElement Any)

{

/* ... */

        }

A mesma solução pode ser adotada para a classe servidora do Web Service, situação em que estaremos interceptando as mensagens que um Web Service desenvolvido por nós está trocando.

Um exemplo completo de customização do SoapExtension pode ser encontrado na documentação dessa classe no MSDN. No exemplo, as mensagens trafegadas são armazenadas num arquivo de log.

Mais Informações
Usando um Web Service no Visual Studio, Classe SoapExtension, Ferramenta WSDL.EXE, SOAP Extension – How does it work?

Design Patterns com Delphi: State - Parte II

2011-07-07T15:39:00.000-03:00

No último post, apresentei o conceito do Design Pattern comportamental State. Como exemplo de situação onde o padrão é aplicável, criei um controle simples de conta corrente no qual a conta tem comportamentos diferentes, reagindo ao nível do saldo que ela atualmente contém.

Para ficar mais fácil visualizar, reproduzo abaixo o diagrama de classes que representa uma solução para a situação do exemplo.

O modo como uma conta tem que se comportar é ditado por uma classe abstrata simples, chamada de TWEstadoConta no diagrama. Essa classe é apenas uma interface que introduz as funções e propriedades esperadas para a operação básica da conta em si. Os estados reais podem, então, ser implementados como heranças dessa interface, providenciando a diferenciação necessária.

TWEstadoConta = class

protected

      _Saldo : Double;

      _PorcRendim : Double;

      _LimInf, _LimSup : Double;

      _Conta : TWConta;
{ ... }

public

{ ... }

      procedure Depositar (AValor : Double);virtual;abstract;

      procedure Sacar     (AValor : Double);virtual;abstract;

      procedure AplicarRendimento;virtual;abstract;

end;

TWContaComum = class(TWEstadoConta)

protected

      _TaxaServico : Double;

      Constructor Create (AConta : TWConta);override;

public

      procedure Depositar (AValor : Double);override;

      procedure Sacar     (AValor : Double);override;

      procedure AplicarRendimento;override;

  end;

TWContaDiferenciada = class(TWContaComum)

protected

      _TaxaJuros : Double;

      Constructor Create (AConta : TWConta);override;

public

      procedure Depositar (AValor : Double);override;

      procedure Sacar     (AValor : Double);override;

      procedure AplicarRendimento;override;

end;

TWContaOuro = class(TWEstadoConta)

protected

      Constructor Create (AConta : TWConta);override;

public

      procedure Depositar (AValor : Double);override;

      procedure Sacar     (AValor : Double);override;

      procedure AplicarRendimento;override;

end;

As operações para depósito, saque e a que aplica rendimentos ao saldo da conta são abstratas na interface mas implementadas pela classe de cada estado possível. Veja, por exemplo, as diferenças da operação de saque:

procedure TWContaComum.Sacar (AValor : Double);

var lValorReal : Double;

begin

{ Conta comum, aplica a taxa de serviço }

  lValorReal := AValor + _TaxaServico;

  _Saldo := _Saldo - lValorReal;

end;

procedure TWContaDiferenciada.Sacar (AValor : Double);

var lJuros, lValorReal : Double;

begin

{ Na Conta diferenciada, aplica taxa de serviço, critica se extrapolar o limite de crédito e aplica uma taxa de juros se a conta ficar negativa }

  lValorReal := AValor + _TaxaServico;

  if (_Saldo - lValorReal) < _LimInf then

    raise Exception.Create('Saque não pode ser efetivado. Conta sem saldo.');

  lJuros := 0.0;

  if (_Saldo - lValorReal) < 0.0 then

    lJuros := (lValorReal - _Saldo) * _TaxaJuros / 100.0;

  _Saldo := _Saldo - lValorReal - lJuros;

end;

procedure TWContaOuro.Sacar (AValor : Double);

begin

{ Conta Ouro, não se preocupa com nada - apenas saca. }

  _Saldo := _Saldo - AValor;

end;

Os construtores das classes que representam estados têm que alimentar os valores das propriedades internas, caracterizando os respectivos estados. É isso que permitirá à classe da conta decidir qual estado deve estar ativo num determinado momento:

Constructor TWContaComum.Create (AConta : TWConta);

begin

  inherited;

  _PorcRendim := 1.0; { Rendimento padrão : 1%}

  _TaxaServico := 5.00; { Saques são cobrados }

{ Valores de saldo que delimitam um estado }

  _LimInf := 100.00;

  _LimSup := 999.99;

end;

Constructor TWContaDiferenciada.Create (AConta : TWConta);

begin

  inherited;

  _PorcRendim  :=  0.0; { Sem rendimento }

  _TaxaJuros   := 1.00; { Taxa de juros sobre saques qdo a conta fica sem saldo } 

  _TaxaServico := 10.00; { Saques são cobrados }

{ Valores de saldo que delimitam um estado }

  _LimInf := -100.00;

  _LimSup :=   99.99;

end;

Constructor TWContaOuro.Create (AConta : TWConta);

begin

  inherited;

  _PorcRendim := 2.00; { Rendimento Ouro : 2% }

  { Valores de saldo que delimitam um estado }

  _LimInf := 1000.00;

  _LimSup := 99999.99;

end;

A classe da Conta, então, deve guardar uma referência do estado atual para poder realizar as operações solicitadas. Portanto, ela age como uma ponte, transferindo para a classe de estado a responsabilidade de executar efetivamente a operação.

TWConta = class

private

      _Estado : TWEstadoConta;

{ ... }

public

{ ... }

      procedure Depositar (AValor : Double);

      procedure Sacar     (AValor : Double);

      procedure AplicarRendimento;

{ ... }

      function ObtemSaldo : double;

      function ObtemEstado : TWEstadoConta;

end;

Para que a implementação desse padrão funcione, é preciso trocar dinamicamente a instância de classe que representa o estado atual. E quando é necessário efetuar essa troca da instância de estado ? O bom senso diz que isso deve acontecer após qualquer operação que possa afetar o estado monitorado. No nosso caso, isso significa atuar em todas as operações que modifiquem o saldo da conta.

procedure TWConta.VerificaStatus;

var lNovoEstado : TWEstadoConta;

begin

{ ... }

  { Testa as variações de estado }

  lNovoEstado := Nil;

  if (_Estado._Saldo < _Estado._LimInf) then

  begin

    { Rebaixa de COMUM para DIFERENCIADA }

    if (_Estado.InheritsFrom (TWContaComum)) then

      lNovoEstado := TWContaDiferenciada.Create (Self);

    { Rebaixa de OURO para COMUM }

    if (_Estado.InheritsFrom (TWContaOuro)) then

      lNovoEstado := TWContaComum.Create (Self);

  end;

  if (_Estado._Saldo > _Estado._LimSup) then

  begin

    { Eleva de COMUM para OURO }

    if (_Estado.InheritsFrom (TWContaComum)) then

      lNovoEstado := TWContaOuro.Create (Self);

    { Rebaixa de OURO para COMUM }

    if (_Estado.InheritsFrom (TWContaOuro)) then

      lNovoEstado := TWContaComum.Create (Self);

  end;

  { Efetiva a troca de estado }

  if (lNovoEstado <> Nil) then

    SetEstado (lNovoEstado);

end;

procedure TWConta.Depositar (AValor : Double);

begin

  _Estado.Depositar(Avalor);

  VerificaStatus ();

end;

procedure TWConta.Sacar (AValor : Double);
begin

  _Estado.Sacar (AValor);

  VerificaStatus ();

end;

procedure TWConta.AplicarRendimento;

begin

  _Estado.AplicarRendimento ();

  VerificaStatus ();

end;

Pelo quadro acima, vemos que quem faz a troca é a própria conta pois as classes de estado não conhecem o fluxo de mudança, isto é, nenhuma delas sabe qual é o estado seguinte para o qual a conta pode ser lançada. Isso facilita a inclusão de novos estados já que apenas um ponto precisa ser modificado para levá-lo em consideração.

A recuperação de uma instância da classe de estado pode ser modelada para usar o Design Pattern criacional Factory ou ainda o Singleton.

Usar uma Factory como fizemos em VerificaStatus pode acarretar problemas de desempenho se as trocas de estado ocorrerem com muita frequência. O mesmo é válido se for grande o volume de dados que caracterizam os estados. Neste caso, optar por um Singleton é recomendável, sem esquecer de que ele deve se restringir ao escopo da classe. Isto é, cada instancia da classe deve ter seu Singleton particular; senão, o estado de uma instância poderá se confundir com o de outras que porventura existam ao mesmo tempo.

O download do projeto Delphi com esse exemplo pode ser feito a partir desse link.

Mais Informações
Posts sobre Design Patterns, Download do Exemplo para o padrão State

Design Patterns com Delphi: State - Parte I

2011-06-27T11:11:00.000-03:00

Ao longo de sua existência, um objeto em um sistema computacional pode sofrer variações em seu estado interno. Isto é, cada operação realizada com ele ou cada propriedade ajustada altera o valor de variáveis internas (membros), introduzindo mudanças no seu estado. Se o objeto tiver que se comportar de forma diferente de acordo com seu estado interno, a implementação dele tende a se tornar cada vez mais complexa à medida que a quantidade de estados possíveis aumenta, dificultando a manutenção do sistema como um todo.

O Design Pattern comportamental State foi concebido para atender a situações como as descritas no parágrafo anterior, simplificando a manutenção do sistema. Como exemplo do cenário onde o padrão é aplicável, imagine um sistema que controle contas correntes. Dependendo do saldo total, a conta é classificada de uma maneira que determina a disponibilidade de certas operações. Também determina se os serviços disponíveis para a conta são cobrados, a taxa de remuneração que se aplicará ao saldo (se aplicável), taxa juros sobre empréstimos (se aplicável), etc.

A base do conceito para implementarmos esse padrão é a existência de uma interface que torna públicas as operações disponíveis para a classe principal – a conta, no nosso exemplo. O estado interno é mantido por outra classe que tem o conhecimento de como se comportar adequadamente para esse estado específico. Quando a classe principal precisa realizar uma operação, ela delega a responsabilidade para a classe que mantém o estado. Podemos perceber, então, que cada conjunto diferente de comportamentos baseado no estado da classe principal será tratado por uma classe de estado diferente. O resultado desse arranjo é que a classe principal consegue comportar-se da forma planejada apenas trocando a instância interna da classe de estado, o que ocorre de forma transparente para quem usa a classe principal.

Veja no diagrama UML abaixo a relação entre as classes previstas para nosso exemplo:

Classes de objetos que podem alternar seu estado de acordo com uma lista previamente conhecida normalmente têm um Diagrama de Estados associado a elas quando modelamos o projeto usando UML. Esse diagrama documenta as mudanças de estado permitidas para o objeto. Com base no saldo existente, a conta do exemplo pode ser classificada como Ouro (melhores taxas de rendimento, menor preço para serviços), Comum (as taxas e preços normais se aplicam) e Diferenciada (o saldo baixo ou negativo leva a menor rendimento, serviços mais caros e proibição de saques e empréstimos).

Formalmente, as classes que participam da solução para o pattern State recebem os seguintes nomes:

Context é a classe que publica as operações que estarão disponíveis para as demais partes do sistema, sendo, por isso, a classe principal da solução. Ela mantém uma referência para a classe que contém o estado atual e o comportamento associado a este estado. No diagrama acima, a classe Context é a TWConta.

State é uma interface que define quais as operações do Context terão comportamento baseado num estado. Ela contém ainda as propriedades relevantes para determinar quando uma troca de estado deve acontecer. Esse papel é executado pela classe TWEstadoConta no diagrama acima. Por ser uma interface, ela normalmente será abstrata, isto é, muitas das funções serão implementadas somente por suas heranças.

Concrete State são as classes que provêem o comportamento adequado para cada estado possível. Elas herdam da interface State, promovendo a implementação necessária para cada operação introduzida por ela. No diagram há 3 classes nessa categoria: TWContaComum, TWContaOuro e TWContaDiferenciada.

Um Client é qualquer parte do sistema que solicite uma operação à classe Context. Esse é o papel da classe TWTelaOperConta no diagrama anterior.

O tipo de hierarquia proposta pelo State é muito semelhante àquela adotada no padrão estrutural Adapter. A diferença é que o Adapter serve para ocultar detalhes de implementação de objetos diferentes que têm a capacidade de executar tarefas similares, adaptando esses objetos a uma interface padronizada. Já o State simplifica a diferenciação de comportamentos dentro de um mesmo objeto. Ou seja, o primeiro foca no aspecto estrutural e envolve várias classes enquanto o segundo foca o comportamento de um único objeto.

No próximo post, mostro uma sugestão de como implementar em Delphi o exemplo usado aqui.

Mais Informações
Posts sobre Design Patterns, Diagramas de Estado

Representando dados binários como texto em Delphi

2011-06-16T18:08:00.001-03:00

Estou desenvolvendo para a ABC71 um projeto para automatizar o processo de implantação do nosso ERP. Parte do projeto consiste em deixar nossos consultores criar passos num tipo de assistente, aproveitando o conhecimento de campo deles para montar cenários de implantação. Ao criar um passo, eles podem até mesmo carregar uma imagem para representá-lo. Tudo isso é salvo como um arquivo XML, o que traz um problema : imagens são arquivos binários e um XML contem apenas texto.

Mesmo que eu usasse uma seção CDATA, teria que aplicar alguma transformação no conteúdo binário para que ele pudesse ser lido corretamente - certos bytes representam caracteres especiais que não podem ser exibidos, tais como o 27 (escape) e o 0 (zero sinaliza fim de uma string em C/C++).

Uma forma de converter o conteúdo binário num texto legível seria tomar cada byte e usar a representação hexadecimal dele. Por exemplo, ao invés do byte com valor 27, eu teria um texto com valor 1B. Um inconveniente salta aos olhos : como cada byte é representado por 2 caracteres, o conteúdo binário dobra de tamanho no processo de conversão !

A melhor solução que encontrei para esse problema é usar a codificação chamada Base64. Nesse algoritmo, uma sequência de bytes é processada para gerar um texto contendo apenas caracteres que podem ser exibidos, selecionados em uma lista fixa com 64 caracteres possíveis - daí o nome de Base64. Não sei se a VCL inclui uma implementação desse algoritmo; a versão que usei está disponível para download no site Koders.com. O texto resultante dessa conversão ainda é maior do que o conteúdo original mas ao menos não dobra de tamanho.

Trabalhar com a Base64 é relativamente simples. Há somente duas funções no fonte indicado: uma para codificar a informação binária (B64Encode) e outra para obter de volta a informação originalmente codificada (B64Decode). Como exemplo, o trecho de código abaixo carrega uma imagem a partir de um arquivo, codifica o conteúdo encontrado e retorna o resultado do processamento como uma string. Por ser um texto, esse resultado pode ser facilmente utilizado em outras partes do programa. No meu caso, eu o incluí como valor de uma tag num XML:

var lConteudo : String;

    lSsAux : TStringStream;

    lStreamOrg : TFileStream;

begin

{ Stream auxiliar para recuperar o conteúdo binário do arquivo }

    lSsAux := TStringStream.Create ('');

    lStreamOrg := TFileStream.Create (_ImgFilePath, fmOpenRead);

    { Copia o conteúdo do arquivo para o stream em memória }

    lSsAux.CopyFrom (lStreamOrg, 0);

    lSsAux.Position = 0;

    { Prepara o conteúdo binário, codificando-o como um texto }

    lConteudo := lSsAux.DataString;

    lConteudo := B64Encode(lConteudo);

    lStreamOrg.Free();

    lSsAux.Free();

    Result := lConteudo;

end;

Para obter o arquivo original de volta, basta decodificar o texto preparado pelo código anterior. O exemplo que segue traz um função que recebe esse texto, decodifica-o e grava o resultado num novo arquivo com o conteúdo original intocado:

procedure TWAssitente.DecodeContentToFile (AConteudo: String);

var lStreamDst : TFileStream;

    Buffer : PChar;

begin

    { Cria o novo arquivo vazio }

    lStreamDst := TFileStream.Create (_ImgFilePath, fmCreate);

    { Decodifica o conteúdo }

    AConteudo := B64Decode (AConteudo);

    { Grava o conteúdo decodificado no arquivo }

    Buffer := PChar (AConteudo);

    lStreamDst.Write (Buffer^, Length(AConteudo));

    lStreamDst.Free ();

end;

Como é possível deduzir da discussão até aqui, a Base64 pode ser usada para preparar qualquer conteúdo binário e não só imagens. Isto inclui tanto arquivos (documentos, planilhas, executáveis, músicas, etc.) quanto dados contidos em arrays e streams na memória de seu programa. Até mesmo o resultado de assinaturas digitais podem passar por esse processo, como mostra o post sobre a assinatura do XML de uma nota fiscal eletrônica.

Os cálculos do algoritmo da Base64 não são complexos. Caso queira analisá-lo (ou simplesmente utilizá-lo), o fonte completo pode ser acessado através desse link.

Mais Informações
Fonte Base64.pas para Delphi/C++ Builder no Koders.com, Base64 no Wikipedia

Há futuro para projetos em Delphi ?

2011-06-09T13:28:00.000-03:00

Algumas pessoas me enviaram email perguntando o que penso sobre o futuro do Delphi. A preocupação básica é a de que a linguagem vem perdendo terreno, enquanto cada vez mais projetos são levados a cabo com .NET, Java e principalmente com linguagens com forte apelo Web (PHP, Perl, Javascript), conforme atesta a lista mantida pela TIOBE Software.

Acho que essa é uma preocupação infundada. Em primeiro lugar, o IDE do Delphi vem ganhando novas versões de forma consistente, às quais têm sido incorporados novos recursos, sempre em sintonia com a evolução do mercado. Isso dá bastante tranquilidade de que a ferramenta não foi abandonada e que adotá-la (ou continuar com ela) não implicará em restrições ao uso de novas tecnologias.

Um outro ponto é a quantidade de acessos a este blog quando o tema está relacionado ao Delphi. Ainda, pelos emails que recebo a partir do blog com comentários e dúvidas, vejo que a linguagem tem uma comunidade bastante grande e ativa aqui no Brasil. Mesmo em sites fora do país eu encontro vasto material quando preciso pesquisar alguma coisa. Então, acredito que o uso do Delphi ainda continuará firme e forte.

Por fim, a Embarcadero havia comunicado em maio que haveriam mudanças nas parcerias deles por aqui. A promessa era ampliar os serviços através da homologação de novos parceiros. No entanto, notícia publicada hoje pela ComputerWorld informa que eles darão um passo ainda maior : abrirão escritório próprio no Brasil, mostrando claramente que pretendem dar continuidade no suporte à ferramenta.

Abaixo, reproduzo essa notícia:

A empresa norte-americana Embarcadero, dona da ferramenta de desenvolvimento Delphi, está desembarcando no Brasil e passará a operar com time local. Inicialmente, a companhia terá um escritório próprio, mas já faz parte de seus planos a abertura de uma subsidiária.

Até agora, as ferramentas Delphi e de desenvolvimento para banco de dados da companhia eram vendidos no Brasil pelo canal de distribuição da Micro Focus, que adquiriu a Borland há dois anos, dona desses produtos.

Embora a Embarcadero tivesse comprado essa linha da Borland em 2008, a empresa não estava presente no País nem em outros mercados da América Latina com operação direta.

Com a abertura de um escritório próprio no Brasil, a Embarcadero promete se aproximar mais de seus clientes e incrementar os negócios no País. Ao anunciar a inauguração da unidade local, o vice-presidente de vendas da empresa para a região das Américas, Allen Lovett, destacou que o mercado brasileiro foi considerado importante pela matriz pela sua economia crescente e por ser o maior da América Latina.

“Temos uma base grande de desenvolvedores Delphi no Brasil e enxergamos muitas oportunidades aqui para crescermos”, diz Lovett. A operação local será comandada pelo executivo José Eugênio Braga, que foi diretor comercial e de marketing da Borland.

Eugênio Braga será presidente da Embarcadero no Brasil e contará com apoio de um time de aproximadamente 15 pessoas, todas vindas da Borland e que já conheciam os produtos da marca.

Mais próxima dos desenvolvedores

De acordo com o presidente da Embarcadero no brasil, o País conta com uma comunidade de aproximadamente 100 mil desenvolvedores Delphi e já vendeu mais de 300 mil licenças da ferramenta. Entretanto, ele admite que houve uma queda na comercialização dos produtos da marca para sua base antiga. Mas ele garante que a empresa não perdeu mercado, pois 60% dos contratos são fechados com novos usuário.

Lovett complementa que a decisão da Embarcadero de ter uma operação local é para tentar fidelizar sua base, oferecendo serviço, suporte e treinamento em português. Faz parte dos planos também aumentar o número de desenvolvedores em Delphi que estão saindo da universidade.

Eugênio Braga lembra que na época da Borland havia um programa estruturado com universidades brasileiras para para treinar jovens em Delphi. Cerca de 300 universidades participavam da iniciativa. “Vamos investir no Brasil, oferecer treinamento, fazer campanhas e certificar nossos parceiros de negócios”, promete Lovett.

A empresa também promete trazer para o Brasil uma terceira linha de produtos, que será lançada mundialmente no terceiro trimestre, com soluções para controlar licenças de software nas grandes companhias.

Com a operação local, Lovetti espera aumentar a participação do mercado brasileiro na receita global da companhia, que hoje é de 10% e a meta é chegar em 2012 com uma contribuição de 15%. O valor do faturamento mundial da empresa não foi revelado.

Aqui na ABC71 usamos como linguagem principal o C++ Builder, ferramenta gêmea do Delphi em que a programação é feita em C++. Por conta de tudo que foi exposto aqui, não temos qualquer plano de trocar de ambiente num futuro próximo - até porque, nosso ERP tem mais de 5000 telas, processos e relatórios construídos com essa ferramenta.

A única coisa que me preocupa realmente é o fato de que os compiladores do Delphi e do C++ Builder ainda não gerarem código nativo para 64 bits. É um recurso que prometem a bastante tempo mas sobre o qual não tenho visto mais notícias. Veja aqui.

Mais Informações
Embarcadero passa a atuar no Brasil com escritório próprio, site oficial da Embarcadero

Microsoft mostra recursos da próxima versão do Windows

2011-06-02T18:32:00.000-03:00

Nem bem acabou de lançar o Windows 7, a Microsoft já estava planejando a nova versão. A empresa havia feito antes algumas revelações sobre como seria o Windows 8 mas em primeiro de junho chegaram a mostrar coisas mais concretas a esse respeito. Ao que parece, a proposta é aproximar o Windows Phone daquele voltado para desktops, de modo que a interação com o usuário seria idêntica em um e outro.

A aproximação ainda teria como objetivo preparar uma versão otimizada para tablets, disponibilizando a mesma usabilidade nas três plataformas. Apesar da pressa pra não perder o bonde, essa versão específica para tablets deverá ser entregue, na melhor das hipóteses, no começo de 2012. Mas, segundo o Citigroup, a Microsoft não está atrasada para a festa dos tablets pois há uma base muito grande de programas feitos para seu sistema operacional. Como ela está trabalhando para garantir que esses programas rodem também nos tablets, muitos dos que os usuários já estão acostumados a utilizar em seus pcs estarão automaticamente disponíveis nos dispositivos com o novo Windows.

Mesmo que seja um sistema operacional muito bem resolvido e abarrotado de recursos interesses - como parece ser o Windows Phone 7 - , somente o tempo dirá se eles estão ou não atrasados. Se demorarem muito, os usuários que hoje são fiéis a programas Windows já podem ter encontrado substitutos a altura nos sistemas de seus tablets.

O texto que vai abaixo é uma reprodução da matéria publicada pelo IDG Now! a respeito da apresentação dos recursos previstos para o Windows 8. A reportagem original pode se acessada aqui.

O Windows 8 está a caminho, e será bem diferente do Windows que conhecemos hoje. Esta foi a mensagem que a Microsoft passou na noite desta quarta-feira (01/06) durante a conferência anual D: All Things Digital, fealizada próxima a Los Angeles, EUA.

Na conferência a Microsoft apresentou uma versão preliminar do Windows 8, com uma interface radicalmente modificada. Em vez do tradicional desktop com janelas, barra de tarefas e Menu Iniciar, a interface se parece muito com a usada no Windows Phone 7, completa com "Tiles" otimizadas para uso com o toque.

A Microsoft também postou um vídeo que mostra alguns dos novos recursos. A empresa diz que a interface foi projetada não apenas para laptops e desktops, mas para tablets também. A nova interface com Tiles, "quadrados" coloridos que exibem informações e servem de atalho para aplicativos, substitui o tradicional menu iniciar e os ícones no desktop, de acordo com a empresa.

O Windows 8 irá rodar aplicativos Windows já existentes e terá suporte aos periféricos já existentes. No vídeo a Microsoft mostra aplicativos tradicionais, como o Office, rodando em uma interface desktop similar à do Windows 7, e é possível trocar entre a nova interface e o modo desktop ao toque de um botão.

O sistema também terá uma versão do navegador Internet Explorer 10 otimizada para toque, muito similar à versão do Internet Explorer utilizada no Windows Phone 7. Para facilitar o uso do sistema em Tablets a Microsoft também incluiu um teclado virtual completo, com um modo "separado" que agrupa as teclas nas laterais da tela para facilitar a digitação com os dedões.

Aplicativos desenvolvidos especialmente para o Windows 8 também serão diferentes, e usarão "o poder do HTML5, acessando recursos nativos do Windows através de JavaScript e HTML", diz a empresa. Ainda não está claro se isso significa que aplicativos para o Windows 8 serão exclusivamente baseados em HTML5, JavaScript e outras tecnologias originadas na web ou se haverá a possibilidade de usar ferramentas de desenvolvimento mais tradicionais já oferecidas pela Microsoft e outras empresas.

O que é interessante no Windows 8 é que ele é outro passo rumo à transformação dos computadores pessoais em aparelhos mais parecidos com tablets. A Apple também está deixando o Mac OS X mais similar ao iPad ao incorporar vários recursos do iOS ao Mac OS X 10.7 "Lion", embora o Windows pareça ir um passo adiante na fusão entre os tablets e os PCs.

A própria Microsoft confirma o escopo das mudanças, dizendo que o Windows 8 é "uma recriação do Windows, do processador à interface. Um PC com o Windows 8 é na verdade uma nova categoria de aparelho, que pode ir de telas pequenas sensíveis ao toque até os grandes monitores de um desktop, com ou sem um teclado e mouse".

Provavelmente haverá resistência a estas mudanças e teremos que esperar para ver como tudo funciona na prática. Mas o rumo está traçado.

Mais Informações
Windows 8 lembra o Windows Phone 7, no desktop, Microsoft não está atrasada para a festa dos tablets

Desmistificando o uso de ponteiros

2011-05-26T14:43:00.001-03:00

Uma das grandes vantagens de construir programas em linguagens como C e C++ é que elas são muito próximas do funcionamento de baixo nível dos computadores, o que costuma deixar a performance desses programas superior àquela conseguida com outras linguagens. Essa característica provavelmente explica a posição delas no ranking de linguagens mais usadas: respectivamente a 2a e 3a (em maio/2011).

A força das duas linguagens, no entanto, é também seu calcanhar de Aquiles. Muitos programadores temem C/C++ justamente por causa dessa proximidade com a linguagem de máquina, personificada no uso de um recurso-símbolo : os ponteiros. Alguns fatores contribuem para esse temor mas acredito que o principal é a falta de conhecimento sobre a sua real utilidade e funcionamento.

Então, pra começar, o que são exatamente os "ponteiros" e pra que servem ? Um ponteiro é uma variável cujo conteúdo é um endereço na memória do computador. Em outras palavras, é uma posição de memória que "aponta" para outra posição de memória. Com um diagrama fica mais fácil visualizar o conceito:

No quadro acima, nome é uma variável do tipo "ponteiro para char". Isto é, o conteúdo dela indica um local na memória do computador que será usado para armazenar caracteres. O que está acontecendo no programa retratado é uma alocação dinâmica de memória, onde o sistema operacional faz para nós a reserva de uma posição da memória e coloca o endereço reservado na nossa variável. Podemos, então, usar esse ponteiro para acessar o conteúdo da memória reservada.

Os ponteiros, portanto, flexibilizam o desenho de uma aplicação, permitindo a ela alocar memória dinamicamente para tratar situações nas quais não sabemos de antemão com quantos elementos teremos que lidar. Isso também permite adiar a alocação até que os elementos sejam efetivamente necessários, reduzindo o consumo de memória. Ainda, no caso de classes, a solução para o tratamento de heranças é uma implementação fortemente calcada em ponteiros.

Uma outra característica dos ponteiros é que eles facilitam o fluxo das informações dentro do programa; sem eles, passar estruturas grandes como parâmetro exigiria a movimentação de grande quantidade de bytes enquanto com eles é necessário trafegar apenas os bytes que carregam o endereço de memória (a quantidade exata depende do tipo de arquitetura do sistema mas em Win32 são 4 bytes).

Isso tudo levanta, então, outras questões: quando usar exclusivamente o ponteiro no meu código, quando e como acessar o conteúdo e que sintaxe usar para diferenciar ambos os casos ?

Na figura no início do post aparece o uso mais comum dos ponteiros, que é manter referência a alguma memória alocada dinamicamente. Obviamente, armazenar o endereço alocado é imprescindível para que possamos acessar o seu conteúdo e também para devolver a memória ao sistema operacional quando não formos mais usá-la.

typedef struct {

  bool  Assigned;

  long  Id;

    char  Nome[51];

  double Saldo;

} TWPessoa;

TWPessoa *lPessoa = new TWPessoa;

/* ... */

delete lPessoa;

lPessoa = NULL;

O valor NULL é um ponteiro especial para indicar que uma variável não está apontando para lugar algum, isto é, que a variável não está alocada.

Como regra, se o nome da variável aparece sozinho no código, sem decorações (como pontos, setas ou asteriscos) então estamos trabalhando com a variável ponteiro. Nesta situação, o que temos é o endereço de memória para onde nossa variável aponta. É o que está acontecendo no quadro anterior, onde a memória para a estrutura é alocada e o endereço que o sistema operacional reservou para ela é jogado em nossa variável.

A passagem de um ponteiro por parâmetro é outro uso corriqueiro. Formalmente, isso é conhecido como "passagem por referência", o que significa que apenas o endereço é trafegado. É por essa razão que as alterações feitas ao conteúdo de um parâmetro passado por referência são enxergadas também fora da função: ambos os lados apontam exatamente o mesmo endereço na memória.

Quando há alguma decoração anexada à variável no código, então estamos nos referindo ao conteúdo apontado por essa variável. Em C/C++, há várias sintaxes diferentes para acessar o conteúdo apontado, como mostra o trecho abaixo:

/* As 3 linhas abaixo fazem exatamente a mesma coisa :

     Vai até a posição de memória "apontada" por lPessoa;

     No local reservado para a variável Assigned, coloque o valor true.
     */

  lPessoa->Assigned = true;

  lPessoa[0].Assigned = true;

  (*lPessoa).Assigned = true;

O C/C++ ainda tem um sintaxe para que você possa recuperar o endereço de uma variável de alocação estática, independentemente se é um tipo atômico (int, double, char, etc.) ou um tipo criado pelo usuário (struct, class). Poder fazer essa recuperação é útil, por exemplo, para evitar trafegar o dado estático. Novamente, aqui você só trafegaria os bytes relativos ao ponteiro:

TWPessoa lPessoaEstatica;

ResetaPessoa (&lPessoaEstatica);

Pelo rumo dessa discussão, percebemos que qualquer que seja a linguagem utilizada por você, com certeza ela utiliza ponteiros internamente - mesmo que de forma disfarçada - já que eles são a base para o acesso à memória do computador. Assim, conhecer e utilizar bem esse recurso é um excelente começo para construir bons programas em qualquer linguagem.

Mais Informações Ranking de linguagens mais usadas, Pointers (Computing), Pointers and Pointer Types in Delphi

Enviando emails com Delphi - Parte III

2011-05-19T14:38:00.000-03:00

Vida de programador é difícil... No início de 2010, o Google fez uma alteração no sistema online de email deles, o GMail, para substituir o método de segurança SSL então vigente no serviço pela sua versão mais nova, chamada TLS.

Por causa dessa modificação simples, muitos programas que antes conseguiam enviar email tranquilamente através do GMail falharam. Para piorar, a versão 9 do Indy não implementa nativamente o tratamento do TLS - isso só aconteceu a partir da versão 10. Ou seja, programas Delphi ou C++ Builder construídos com o Indy 9 não tinham uma solução fácil à mão para essa questão.

Na versão 10 do Indy, a solução é extremamente simples : basta configurar a propriedade UseTLS da instância de IdSMTP e manter as demais configurações:

IdSMTP1.UseTLS := utUseExplicitTLS;

Manter as demais configurações significa que o servidor deve continuar sendo smtp.gmail.com, a porta 587, com autenticação de usuário e senha. Também é obrigatório atribuir um handler para tratar a comunicação SSL/TLS. Para mais informações sobre isso e outros aspectos das configurações básicas, veja este post.

Embora não seja um processo tão direto, é possível trabalhar com TLS em Indy 9. Basicamente, é preciso enviar ao servidor de email um comando STARTTLS logo após o SMTP ter se conectado. O trecho abaixo é um código genérico que testa configurações internas para determinar se a conexão é segura. Em caso positivo, um handler é destacado para fazer o tratamento da conexão. Neste ponto, o SMTP já foi preparado com as configurações básicas necessárias.

if (TipoSeguranca = SEGURANCA_SSL) Or (TipoSeguranca = SEGURANCA_TLS) then

begin
 
  IdSMTP.IOHandler := IdSSLIOHandlerSocket;

  if (TipoSeguranca = SEGURANCA_TLS) then

  begin

    IdSSLIOHandlerSocket.SSLOptions.Method := sslvTLSv1;

    IdSSLIOHandlerSocket.PassThrough := true;

  end;

end;

{ Tenta conectar no servidor com 1 minuto de timeout }

IdSMTP.Connect (60000);

{ Emula o comportamento do TLS }

if (TipoSeguranca = SEGURANCA_TLS) then

begin

  IdSMTP.SendCmd('STARTTLS', 220);

  IdSSLIOHandlerSocket.PassThrough := false;

end;

if (Autentica And (not IdSMTP.Authenticate () ) then

  Raise Exception.Create ('Falha na autenticação do usuário');

Ao detectar que a conexão segura exige TLS, alguns ajustes precisam ser feitos. Primeiro, mudo o método de segurança do handler para que adote o padrão para TLS. Depois, instruo o handler a codificar os comandos trocados entre ele e o servidor. Só então, podemos estabelecer a conexão.

Uma vez que a conexão está estabelecida, enviamos ao servidor o comando STARTTLS para ativar a comunicação segura na mesma porta. Por causa disso, o PassThrough que forçamos antes da conexão já pode ser desligado.

Autenticar manualmente o usuário e a senha é um preciosismo pois o método Send para envio da mensagem o fará por nós. Aqui no exemplo foi feita a autenticação explícita pra mostrar que é possível interceptar um erro de usuário/senha inválido antes de se tentar enviar a mensagem.

Agora, é só preparar uma instância do idMessage com os dados da mensagem (destinatários, assunto, corpo da mensagem, etc.) e enviá-la com o SMTP.

As considerações tecidas neste post também são válidas para quem usa o Hotmail como serviço para envio de email em suas aplicações. Há apenas duas diferenças importantes : o servidor de email, claro, é outro (smtp.live.com); também a forma de se especificar o usuário do serviço difere. No GMail, deve ser usado como nome do usuário somente o texto que vem antes do arroba (@) do endereço de email, enquanto no Hotmail o nome do usuário é o endereço completo.

Mais Informações
Enviando emails com Delphi - Parte I e Parte II, STARTTLS

Enviando emails com Delphi - Parte II

2011-05-09T18:42:00.000-03:00

Há alguns dias, escrevi um post sobre o envio de emails com Delphi, mostrando a configuração básica dos componentes Indy para SMTP e também as funções que devem ser chamadas para completar o processo. No exemplo, a mensagem incluída no email era um texto simples, sem qualquer tipo de formatação.

No começo, os programas leitores de email só conseguiam trabalhar com mensagens assim, onde apenas texto era trocado. É um comportamento básico mas que ainda tem sua utilidade, principalmente quando há questões de segurança envolvidas. Com a evolução da internet, entretanto, praticamente todos os leitores de email conseguem exibir mensagens com formatação rica. Usando HTML podemos compor emails com layouts complexos, usando cores e tipos de fontes diferentes, além da inclusão de imagens, links, tabelas, animações, entre outros. Uma grande vantagem desse formato é que ele já é utilizado para construir os sites da internet. Ou seja, HMTL é uma ferramenta bastante conhecida e amplamente suportada.

Do ponto de vista do envio de email, o que há de diferente em relação ao que foi apresentado no outro post ? Basicamente, apenas dois detalhes. O primeiro é uma propriedade da mensagem que determina o tipo de conteúdo que a mensagem está trafegando. Essa característica é chamada MIME (Multipurpose Internet Mail Extensions, ou Extensões Multipropósito para Correio na Internet). O padrão para essa propriedade no corpo de um email é o valor text/plain, que significa que a mensagem é composta por um texto simples. Como queremos montá-la como um HTML, temos que avisá-la disso:

IdMessage1.ContentType := 'text/html';

IdMessage1.CharSet := 'ISO-8859-1';

Veja que eu também modifiquei o charset da mensagem. Esta propriedade indica qual é o conjunto de caracteres que a mensagem está usando. Como o português usa acentuação, é preferível trocar o padrão americano pelo conjunto latino ('ISO-8859-1').

O outro detalhe é que o corpo da mensagem agora tem que respeitar o MIME configurado. Quero dizer com isso que teremos que montar um HTML para a mensagem:

IdMessage1.Body.Text := '<html><head>' +
 
   '<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">' + 

   '</head><body>' + 

   '<p>Essa mensagem é um <b>Teste</b> de email HTML.</p>' + 

   '</body></html>';

Embora pareça redundante, é importante informar de novo no cabeçalho do HTML quem é o MIME e o charset. Os leitores de email utilizam as informações desse cabeçalho para renderizar a mensagem recebida via SMTP.

E se quisermos incluir uma imagem em nosso HTML ? Algumas pessoas publicam a imagem na internet e referenciam o link dela no HTML da mensagem. Mas essa solução exige que o destinatário esteja conectado para poder buscar a imagem, coisa que nem sempre é verdade. Numa empresa, por exemplo, as mensagens são recebidas de forma centralizada por um servidor de email, dispensando a necessidade de ter internet local. Muitas delas adotam ainda restrições ao acesso à internet.

Uma maneira melhor de se fazer isso é enviar a imagem junto com o HTML. Ao invés de preencher o campo Body da mensagem, teremos que decompô-la em seus constituintes básicos para podermos identificar de forma separada o MIME de cada um. Isto é, o corpo da mensagem é um HTML enquanto a imagem é um arquivo binário com MIME próprio. O conjunto todo terá um MIME especial (multipart/mixed) que sinaliza que a mensagem está montada como múltiplas partes independentes.

Cada parte deverá ser anexada à mensagem através da propriedade MessageParts. Para o corpo, usamos o tipo TIdText. Para a imagem, o tipo tradicional para anexos (TIdAttachmentFile).

var

text : TIdText;

at : TIdAttachmentFile;

begin

  IdMessage1.MessageParts.Clear();

  IdMessage1.ContentType := 'multipart/mixed';

  text := TIdText.Create (IdMessage1->MessageParts, Nil);

  text.ContentType := 'text/html';

  text.CharSet := 'ISO-8859-1';

  text.Body.Text := PreparaHTML();

  at := TIdAttachmentFile.Create (IdMessage1->MessageParts,

        'C:\\Inetpub\\wwwroot\\winxp.gif');

  at.ContentType := 'image/gif';

  at.FileName := 'winxp.gif';

  IdSMTP1.Connect();

  IdSMTP1.Send(IdMessage1);

{ ... }

O HTML pode, então, fazer referência diretamente ao nome do arquivo anexado, sem precisar estipular um endereço na internet. A única coisa é que o nome do arquivo deve ser exatamente igual àquele informado na propriedade FileName do anexo:

function TForm1.PreparaHTML : String;

begin

{ ... }

Result := Result + '<img style="margin:1px 1px 1px 0px;" src="winxp.gif" />';

{ ... }

end;

Em tese, não há restrição a quantos recursos externos podem ser agregados ao email usando esse tipo de construção. Também não se restringe à inclusão de imagens, podendo ser usado para incorporar animações, scripts, folhas de estilo, etc. - desde que tenham os respectivos MIMEs devidamente configurados.

Estou com a versão 10 do Indy que vem com o Delphi XE mas acredito que os recursos mostrados aqui estejam disponíveis em versões anteriores também.

Mais Informações
Enviando emails com Delphi