dezembro 2010

dezembro 2010

dezembro 2010 03

Delphi

Gerando boletos no ASP.NET

23Autor: Victory Fernandes

Desafio The Club

- Dicas Delphi

Dicas

- Cruzada

30

DelphiDelphi

.NET

índiceJedi

Editorial

13Chegamos a mais um final de ano e

é nesse momento que fazemos aquele popular balanço final para avaliarmos o que fizemos de bom... 04

Criação de jogos e utilização de win32API, DirectX e OpenGL em Delphi05

Assinatura Digital para CT-e

17 29

LegendaInicianteIntermediárioAvançado

Autor:Bruno Alcarás

Autor: Luciano Pimenta

Autor: Antonio Spitaleri

dezembro 201004

Bem-vindo

Delphi é marca registrada da Borland International, as demais marcas citadas são registradas

pelos seus respectivos proprietários.

Antonio Spitaleri Neto - Editor Chefeantonio@theclub.com.br

Chegamos a mais um final de ano e é nesse momento que fazemos aquele popular balanço final para avaliarmos o que fizemos de bom durante o ano e o que ficou faltando. Espero que o balanço de todos esse ano tenha sido positivo.

Para fecharmos bem esse ano de 2010, nós do The Club preparamos quatro bons artigos para que o final de ano de todos os nossos sócios seja o mais pro-dutivo possível.

Na matéria de capa desse mês temos nosso colaborador Victory Fernandes fa-lando sobre o Conhecimento Eletrônico de Transportes, CT-e, no artigo “Assinatura digital para CT-e”. Quem acompanha nossa revista sabe que Victory Fernandes é um dos profissionais do Brasil mais envolvido com essa parte de Ct-e, Nf-e e Sintegra e sempre nos traz importantes dicas sobre o assunto.

Para mostrar que Delphi é uma ferramenta que não se limita ao desenvol-vimento de sistemas comerciais, esse mês trago, no artigo: “Criação de jogos e utilização de Win32 API, DirectX e OpenGL em Delphi”, como podemos utilizar API’s gráficas para criarmos jogos em Delphi. Para quem gosta dessa área, é um grande material para servir de ponto de partida.

Nosso consultor Bruno Alcarás mais uma vez assume o papel de “desbravador” Delphi e esse mês nos mostra a suíte Jedi, muito conhecida da comunidade Delphi e que possui componentes para as mais variadas funções.

Para fechar, nosso colaborador especialista em .NET, Luciano Pimenta, mostra esse mês, em “Gerando Boletos em ASP.NET”, como podemos integrar nossos sites ASP.NET à geração de boletos bancários tornando nosso trabalho mais profissional.

É isso. Um grande Natal e Ano Novo a todos e tenham a certeza que 2011 será melhor ainda.

Abraço e sucesso a todos!

Av. Profº Celso Ferreira da Silva, 190 Jd. Europa - Avaré - SP - CEP 18.707-150

Informações: (14) 3732-1529 Suporte: (14) 3733-1588

Internethttp://www.theclub.com.br

Cadastro: cadastro@theclub.com.brSuporte: suporte@theclub.com.br Informações: info@theclub.com.brSkype Cadastro: theclub_cadastro

Skype Suporte: theclub_linha1 theclub_linha2 theclub_linha3

www.twitter.com/theclubbr

Copyright The Club Megazine 2009

Diretor TécnicoMarcos César Silva

Diagramação e ArteVitor M. Rodrigues

RevisãoTassiane Fileto

ColunistasAntonio Spitaleri Neto

Bruno AlcarásLeonora Golin

Luciano PimentaVictory Fernandes

Impressão e acabamento:GRIL - Gráfica e Editora

Taquarituba-SP - Tel. (14) 3762-1345

ReproduçãoA utilização, reprodução, apropriação, armazenamento em banco de dados, sob qualquer forma ou meio, de textos, fotos e outras criações intelectuais em cada publicação da revista “The Club Megazine” são terminantemente proibidos sem autorização escrita dos titulares dos direitos autorais.

dezembro 2010 05

Delphi

A ferramenta Delphi se consagrou e é amplamente utilizada na parte de desenvol-vimento de softwares voltados a automação comercial, que é a parte do desenvolvimento de softwares voltada para o comércio e indús-tria e visa automatizar processos de venda, administração, etc.

Embora tenha tido seu desenvolvimento muito mais focado na área de automação co-mercial, Delphi não está limitado a essa área. Utilizando Delphi é possível criar aplicações para as mais diversas áreas, como segurança, interfaces gráficas e jogos.

Quando se fala na criação de jogos, em geral nos vem à mente linguagens de nível mais baixo que o Delphi como, por exemplo, C++ e Java. É claro que essas linguagens oferecem maiores recursos e possuem maior documentação disponível sobre desenvolvimento de jogos.

Porém é importante salientar para os progra-

C r i a ç ã o d e j o g o s e utilização de Win32Api, DirectX e OpenGL em Delphi.

madores Delphi que, diretamente ou através da utilização de API’s, é totalmente possível criar jogos em Delphi. Vale lembrar que o principal requisito quando se pensa em desenvolvimento de jogos é o desempenho da aplicação, já que jogos utilizam muito dos recursos gráficos do computador e a linguagem precisa ser robusta em termos de desempenho. Nessa questão Delphi não fica de-vendo em nada a linguagens de alto desempenho como C++, portanto desenvolver jogos em Delphi é totalmente possível.

Quando se fala na criação de jogos, alguns conceitos são importantes e devem ser destacados: Game Engine e API gráfica.

Game Engine é a base sobre a qual o jogo se “sustenta”. Na Game Engine estão os comandos e rotinas que formam a base do jogo. Existem hoje disponíveis de forma gratuita ou não na internet diversas Game Engines já prontas a partir das quais é possível criar um jogo sem a dificuldade de se criar uma base inicial.

API Gráfica são as funções que cuidam do

acesso aos recursos de vídeo do hardware do computador, abstraindo para o desenvolvedor toda a tarefa de transformação dos códigos do jogo em imagens, a chamada renderização.

As API’s Gráficas são sem dúvida a parte fun-damental do desenvolvimento de um jogo. Sem as API’s, a criação de um jogo seria uma tarefa bem difícil, já que o programador teria de desenvolver toda a parte de acesso ao hardware de vídeo. Essa sem dúvida uma tarefa bem complicada não só para programadores Delphi como programadores de outras linguagens.

API’s Gráficas

Quando desenvolvemos para Windows, na maior parte do tempo estamos fazendo uso de forma direta ou não da API Win32. A Win32 não é uma API puramente gráfica, já que contém funções para todas as tarefas possíveis no Windows, como acesso a discos, manipulação de diretórios e pastas e funções de registro do sistema entre outras.

dezembro 201006

Porém toda a parte de criação e manipulação de janelas Windows está contida na API Win32, o que faz dela uma API com recursos para aplicações gráficas.

É a Win32 que controla todas as tarefas de criação e posterior manipulação das janelas em ambiente Windows. Embora em Delphi não neces-sitemos fazer uso de forma direta da Win32 para criar uma janela, alterar sua cor, etc. As bibliotecas da VCL do Delphi responsáveis pela parte gráfica fazem amplo uso da Win32 e nem poderia ser diferente, já que o Windows bloqueia o acesso direto ao hardware do computador por parte de aplicativos que rodem sob sua “supervisão”.

Como também possui funções gráficas, a Win32 pode ser utilizada no desenvolvimento de jogos em ambiente Windows. Com Win32 e seus objetos podemos fazer aplicações de razoável qualidade gráfica, incluindo desenhos simples e formas geométricas.

A utilização da Win32 para a criação de aplica-tivos gráficos, incluindo-se aí os jogos proporciona menor desempenho se comparada às API’s com funções essencialmente gráficas. Porém quando se trata de jogos de dinâmica mais simples, a Win32 leva vantagem devido a sua simplicidade.

Utilizando Win32 estaremos trabalhando sem-pre sobre a área visual da janela. Essa área visual e seus objetos para manipulação são representados na VCL Delphi pelo objeto Canvas. É através do Canvas que manipularemos os objetos gráficos das janelas criadas em Delphi. Estaremos vendo a utili-zação do Canvas em um exemplo mais adiante.

Essa abstração da API e sua parte gráfica por parte da VCL do Delphi tornam a utilização da Win32 ainda mais simples para os programadores Delphi.

Em ambiente Windows, além da possibilidade da utilização da API Win32, podemos fazer uso de API’s específicas para gráficos. Essas API’s foram criadas para aproveitar da melhor forma possí-vel os recursos de vídeo dos computadores, até mesmo emulando a existência de um processador de vídeo caso a máquina não o possua. Como oferecem desempenho muito superior e, portanto complexidade maior, essas API’s são utilizadas em projetos de grande escala, como jogos com várias telas e situações e aplicativos de exibição captura

e gravação de vídeo. A utilização das API’s essen-cialmente gráficas gera grande aproveitamento do hardware de vídeo por parte dos aplicativos, porém o desenvolvimento utilizando essas API’s é muito mais complexo e requer grande dedicação do programador.

Para Windows, duas API’s gráficas se destacam: DirectX e OpenGL.

DirectX foi criada pela Microsoft e acompanha a instalação do Windows. Portanto não há neces-sidade de instalação extra de recursos quando desejamos rodar um jogo que utiliza a tecnologia DirectX em Windows.

Na verdade é incorreto tratar DirectX como sendo algo único, já que DirectX é um conjunto de API’s que abrangem todas as tarefas de manipu-lação e criação de gráficos em Windows além de renderização 3D e manipulação de áudio.

Como se tornou mais popular, DirectX aca-bou se tornando uma espécie de padrão para as empresas desenvolvedoras de placas de vídeo, o que aumenta a integração e consequentemente o desempenho de aplicações que fazem uso do DirectX.

Para desenvolvimento de jogos utilizando Di-rectX, é necessário ter no computador os headers do DirectX. Esses headers estão disponíveis para download no site da Microsoft, porém estão em C++. Para a utilização com Delphi, pode ser utilizada a biblioteca de componentes DelphiX, gratuita. No exemplo que faremos mais adiante estaremos utilizando esse componente.

OpenGL é uma API gráfica que tem como prin-cipal característica o fato de ser multi-plataforma, podendo ser utilizada em Windows, Linux, entre outras plataformas operacionais.

OpenGL também possui como característica ser gratuita e Open Source, o que a torna interes-sante quando se pensa nos custos de um projeto de software.

Nos últimos anos a utilização de OpenGL tem crescido entre a comunidade de desenvolvedores de jogos Freelancers, já que várias Engines existen-tes possuem melhor integração com OpenGL.

O desenvolvimento de jogos é uma área bas-

tante interessante e que requer grande disposição para estudos por parte do desenvolvedor que esti-ver interessado em ingressar nessa área.

Nesse artigo estaremos através de exemplos simples iniciando nessa área e vendo que é possí-vel fazer jogos, sejam simples ou mais complexos utilizando o Delphi.

Começaremos com um exemplo utilizando a API Win32, passando em seguida para DirectX com os componentes DelphiX e para finalizar a utilização de OpenGL.

Exemplo com Win32

Inicie uma nova aplicação no Delphi.

No formulário principal, defina as seguintes propriedades como segue:

Caption=’Jogo da Velha’;BorderStyle=bsSingle;BorderIcons=[bsSystemMenu];Color=clBtnHighLight;ClientHeight=600;ClientWidth=600;

Nesse formulário iremos criar um tabuleiro para jogo da velha.

A seguir faremos a codificação que irá de-senhar o tabuleiro no formulário. A partir desse momento passaremos a fazer uso do objeto Canvas, que representa a área visual do formulário e é uma abstração da GDI da API Win32.

O código a seguir deverá ficar no evento OnPaint do formulário. Esse código irá desenhar quatro linhas, duas horizontais e duas verticais, dividindo o formulário em nove quadrantes.

Veja o código:

procedure TForm1.FormPaint(Sender: TObject);begin

// Alteramos cor e

dezembro 2010 07

espessura da linha a ser // desenhada Canvas.Pen.Color:=clBlack; Canvas.Pen.Width:=2;

// 1ª linha horizontal Canvas.MoveTo(0,200); Canvas.LineTo(600,200);

//2ª linha horizontal Canvas.MoveTo(0,400); Canvas.LineTo(600,400);

//1ª linha vertical Canvas.MoveTo(200,0); Canvas.LineTo(200,600);

//2ª linha vertical Canvas.MoveTo(400,0); Canvas.LineTo(400,600);

end;

O formulário, em execução, deverá ficar como na imagem 1:

Na sequência faremos a rotina que irá marcar os quadrantes com “X” ou “O” dependendo da jogada.

Antes da rotina, declare na seção var global da unit do formulário:

bXPlayer:Boolean=false;

Essa variável irá dizer a rotina de marcação dos quadrantes qual símbolo deve marcar no quadrante clicado.

Vamos a implementação da rotina. Essa deverá ficar no evento OnMouseDown do formulário:

procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);var XPosition,

YPosition:integer; Rect:TRect;begin // Calculos para verificação da posição // do clique do mouse XPosition:=(X div 200)*200; YPosition:=(Y div 200)*200;

// Desenho dos símbolos do jogo de // acordo com a jogada case bXplayer of True: // Se “X” Begin // Alteração da cor do pincel Canvas.Pen.Color:=clRed; // Desenho das linhas que compõem o “X” Canvas.MoveTo(XPosition, YPosition);

Canvas.LineTo(XPosition+200,YPosition+200); Canvas.MoveTo(XPosition,YPosition+200); Canvas.LineTo(XPosition+200,YPosition); end;

False: // Se “Y” Begin // Para desenhar o círculo, precisamos preencher // uma estrutura TRect com os limites do círculo Canvas.Pen.Color:=clGreen; Rect.Left:=XPosition; Rect.Right:=XPosition+200; Rect.Top:=YPosition; Rect.Bottom:=YPosition+200; Canvas.

Imagem 1

dezembro 201008

Ellipse(Rect); end; end; bXplayer:=not bXplayer;// Alteração da jogadaend;

Veja que com a utilização do objeto Canvas podemos fazer vários tipos de desenhos na janela, sem a utilização de componentes.

No caso utilizamos o Canvas para desenhar os símbolos que compõem o jogo da velha. Porém outros tipos de desenhos podem ser feitos de acordo com a necessidade do programador e da circunstância do jogo.

No caso de nosso Jogo da Velha, ao clicarmos em algum dos quadrantes do tabuleiro, um “X” ou “O” será desenhado, alternadamente.

Veja o aplicativo em uso na imagem 2: Teste o aplicativo e salve as alterações.

Exemplo com DirectX

Para o desenvolvimento de aplicativos utilizan-do DirectX, é necessária a instalação dos headers do DirectX, disponibilizados pela Microsoft no DirectXSDK.

É importante salientar que esse headers pos-suem “tradução” de suas DLL’s para as linguagens C++ e Visual Basic, duas linguagens amplamente utilizadas pela Microsoft e inclusas no Visual Studio, que é a suíte de desenvolvimento da Microsoft.

Para uso com Delphi, podemos “traduzir” os headers para Pascal ou então utilizar bibliotecas já prontas com essa “tradução”.

No exemplo a seguir estaremos utilizando a biblioteca DelphiX, que é gratuita e compatível com diversas versões do Delphi.

O download do DelphiX pode ser encontrado em:

http://www.gamedev.com.br/downloads/

delphix.zip

Após o download, realize a instalação do Del-phiX através da .dpk.

Após a instalação, será criada a aba com os componentes DelphiX como mostra a imagem 3:

Os componentes principais dessa aba são:

DXDraw: Componente principal do DirectX, faz as imagens, objetos, camadas, enfim todos os obje-tos que irão aparecer na tela. Existem propriedades semelhantes ao dos formulários standard Delphi, como Width, Height, Color, Display, etc.

Para o exemplo que criaremos, inicie uma nova aplicação no Delphi e inclua esse componente no

formulário.

Você irá perceber que o DXDraw se assemelha a um Panel. É em sua área visual que as ações irão acontecer, como se o DxDraw fosse uma tela.

Configure do jeito que você preferir, tamanho, cor de fundo, apenas no display, deixe do jeito que está para não ter problemas com cores agora no inicio.

Crie uma imagem, por exemplo, um círculo de 20x20 pixels no Paint e salve com o formato Ball.dib para ser nosso objeto principal, não esqueça de colocar um fundo com uma cor que você não usa na imagem por exemplo pink ou vermelho para usar como cor de transparência

Imagem 2

Imagem 3

dezembro 2010 09

Coloque agora em seu programa a biblioteca de imagens chamada DXImageList que funciona como o DXDib só que dá um auxilio melhor quando trabalhamos com muitas imagens.

DXImageList: Componente basicamente definido como container de imagens que irão ser utilizadas em seu programa, pode conter cores de transparência e animações (loop) de uma única imagem.

Devemos carregar a imagem nesse momento, para isso coloque um componente DXImageList no formulário, em sua propriedade Items, crie uma nova imagem e carregue-a em Picture e de o nome de Ball. Note que a transparência já foi incluída, verifique se está correto e feche a janela. Devemos ligar o objeto DXImageList para o DXDraw do nosso formulário, para isso, clique no objeto DXImageList e depois em Object Inspector e em DXDraw sele-cione o DXDraw do nosso formulário.

Após isso, coloque um objeto DXSpriteEngine no formulário.

DXSpriteEngine: Componente mais importante na criação de jogos, ele cria seus objetos interativos (Sprites) no DXDraw, todos aqueles que tem suas propriedades e métodos. O interessante é que podemos interagir um objeto com outro.

Antes de começar a escrever, vamos ligar o DXSpriteEngine com nosso DXDraw para orientá-lo para onde desenhar, lembrando que o responsável por desenhar na tela nossos objetos interativos é o nosso DXSpriteEngine. Selecione o componente DXSpriteEngine, em sua propriedade DXDraw selecione o nosso objeto DXDraw.

Bom, se você olhar a palheta tem um relógio chamado DXTimer, funciona da mesma maneira que o TTimer do Delphi só que é mais eficaz para tempos com intervalos mínimos. Vamos colocá-lo também em nosso formulário.

DXTimer: Componente que controla a Time-Line de seu jogo, você pode modificar o intervalo de cada Clock (chamada de seu evento onTimer). Funciona em grande velocidade se colocado interval = 0.

Com os objetos devidamente inseridos no formulário, iremos iniciar a codificação, porém antes mais um componente deve ser adicionado

ao formulário, que é o DXInput.

O componente DXInput faz a interface de comunicação entre nosso aplicativo e joysticks e o teclado, ou seja, o hardware com o qual o usuário irá interagir com o jogo.

Com todos os objetos inseridos no formulário, o layout do mesmo ficará assim:

Veja a imagem 4;

A codificação será iniciada pela criação da classe que irá representar o objeto principal do jogo. No caso o círculo que fizemos no Paint e carregamos no DXImageList.

Veja a codificação da classe:

type TBall=class(TImageSprite) public FXMove:integer; FYMove:integer; protected procedure DoMove(MoveCount:integer);override;end;

procedure TBall.DoMove(MoveCount: integer);begin

inherited DoMove(MoveCount);end;

FXMove e FYMove irão armazenar a direção a ser tomada pelo objeto, nos eixos X e Y. A procedure DoMove será a responsável pela movimentação do objeto na tela de acordo com os comandos recebidos pelo DXInput.

No evento OnCreate do formulário iremos passar alguns parâmetros iniciais importantes para a aplicação. Veja o código:

procedure TForm1.FormCreate(Sender: TObject);var PlayerSprite:TSprite;begin PlayerSprite:=TBall.Create(Self.DXSpriteEngine1.Engine);

TBall(PlayerSprite).Image:=DXImageList1.Items.Find(‘Ball’); TBall(PlayerSprite).X:=0; TBall(PlayerSprite).Y:=0; TBall(PlayerSprite).Z:=0;

Imagem 4

dezembro 201010

TBall(PlayerSprite).FXMove:=0; TBall(PlayerSprite).FYMove:=0; TBall(PlayerSprite).Height:=20; TBall(PlayerSprite).Width:=20;

DXTimer1.Enabled:=true;end;

Criamos um objeto da classe que criamos ante-riormente e carregamos a imagem anteriormente armazenada no DXImageList para ser a imagem do objeto. Também nesse código definimos tamanho do objeto e posições iniciais do mesmo.

Veja que no método Create de nosso TBall já passamos a Engine do objeto DXSpriteEngine. É o objeto DXSpriteEngine que fará as movimentações e desenhos no DXDraw.

A TimeLine, ou sequência dos acontecimentos em nosso aplicativo será controlada pelo objeto DXTimer. No evento OnTimer desse componente faremos a codificação para acionar a movimentação do DXSpriteEngine e consequentemente do objeto TBall na tela.

Veja o código:

procedure TForm1.DXTimer1Timer(Sender: TObject; LagCount: Integer);begin if not(DXDraw1.CanDraw)then Exit;

DXInput1.Update; DXSpriteEngine1.Move(LagCount); DXSpriteEngine1.Dead; DXDraw1.Surface.Fill(0); DXSpriteEngine1.Draw; DXDraw1.Flip; end;

Na primeira linha testamos se o objeto DXDraw está pronto para criar os desenhos e movimenta-ções. Caso não esteja, saímos da procedure.

Na sequência atualizamos o DXInput para cap-turar os comandos vindos do teclado ou joystick.

A linha DXSpriteEngine.Move(LagCount) é a mais importante dessa procedure pois faz com que o DXSpriteEngine desenhe e consequentemente crie o movimento para o objeto TBall.

Os comandos na sequência preenchem a área do jogo corretamente e garantem sua atualização constante, já que estamos em um Timer.

Quando chamamos o método Move do objeto DXSpriteEngine esse objeto por consequência irá chamar o método DoMove do objeto TBall. É nesse método que passaremos os parâmetros de posição e movimento para o objeto baseados nos comandos recebidos pelo DXInput.

A lógica do movimento será bem simples e baseada nas setas do teclado, que farão os movi-mentos e na barra de espaço, que irá parar todos os movimentos.

Veja a codificação da procedure DoMove do TBall:

procedure TBall.DoMove(MoveCount: integer);begin inherited DoMove(MoveCount);

if((X+Width>Form1.DXDraw1.ClientWidth)or(X<0))then FXMove:=FXMove*-1;

if((Y+Height>Form1.DXDraw1.ClientHeight)or(Y<0))then FYMove:=FYMove*-1;

if( isLeft in Form1.DXInput1.States)then FXMove:=-5;

if( isRight in Form1.DXInput1.States)then

FXMove:=5;

if( isUp in Form1.DXInput1.States)then FYMove:=-5;

if( isDown in Form1.DXInput1.States)then FYMove:=5;

if( isButton1 in Form1.DXInput1.States)then Dead; X:=X+FXMove; Y:=Y+FYMove;end;

Veja que primeiro testamos se o objeto não atingiu os limites da tela, para que o mesmo não “desapareça” do campo visual ao atingir esses limites.

Na sequência verificamos o States do DXInput para definir o movimento do objeto baseado nas setas do teclado.

Veja o aplicativo em execução:

Veja a imagem 5. OpenGL

OpenGL é uma API gráfica que permite o desenho de formas geométricas primitivas e desenhos 3D.

O funcionamento do OpenGL difere um pouco do DirectX por não se basear em um conjunto de API’s e sim em apenas uma com os objetos e fun-ções para desenho.

A utilização de OpenGL se assemelha a utiliza-ção da GDI do Windows, devido ao fato de possuir um objeto de desenho que manipula a área visual da janela, assim como o DC da GDI.

O Delphi possui a unit OpenGL que contém as declarações das funções contidas na dll OpenGL, nativa do Windows.

Faremos um exemplo simples que irá desenhar um triângulo na tela.

dezembro 2010 11

Inicie uma nova aplicação em Delphi e altere as seguintes propriedades do formulário principal:

Caption=’Teste OpenGL em Delphi’

A utilização de OpenGL se baseia na defini-ção de uma base e posteriormente o desenho na “cena” OpenGL através do uso da base e do objeto base OpenGL.

Para definir a base, criaremos a procedure SetupPixelFormat, onde serão definidas as confi-gurações básicas do desenho da cena.

Veja o código:

procedure setupPixelFormat(DC:HDC);

const pfd:TPIXELFORMATDESCRIPTOR = ( nSize:sizeof(TPIXELFORMATDESCRIPTOR); // Tamanho nVersion:1; // Versão dwFlags:PFD_SUPPORT_OPENGL or PFD_DRAW_TO_WINDOW or PFD_DOUBLEBUFFER; iPixelType:PFD_TYPE_RGBA; // Tipo da cor cColorBits:24; // Extensão da cor cRedBits:0; cRedShift:0; cGreenBits:0; cGreenShift:0; cBlueBits:0; cBlueShift:0; cAlphaBits:0; cAlphaShift:0; // Sem alpha buffer ou transparência cAccumBits: 0; cAccumRedBits: 0; cAccumGreenBits:

0; cAccumBlueBits: 0; cAccumAlphaBits: 0; cDepthBits:16; cStencilBits:0; cAuxBuffers:0; iLayerType:PFD_MAIN_PLANE; // Camada principal bReserved: 0; dwLayerMask: 0; dwVisibleMask: 0; dwDamageMask: 0; );

var pixelFormat:integer;

begin pixelFormat := ChoosePixelFormat(DC, @pfd); if (pixelFormat = 0) then exit; if (SetPixelFormat(DC, pixelFormat, @pfd) <> TRUE) then exit;end;

Veja que temos uma estrutura TPIXELFORMA-TDESCRIPTOR que armazena todas as informações para a montagem do objeto principal. Não entrarei nos detalhes de cada informação, já que é uma

parte mais técnica do OpenGL.

Após a criação de SetupPixelFormat, criaremos a procedure de desenho do OpenGL.

Veja o código:

procedure Draw;const S=1.0; D=5.0;begin glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT); glLoadIdentity; glTranslatef(0.0, 0.0, -12.0); glBegin(GL_TRIANGLES); glVertex3f( -S, 0, D); glVertex3f(S, 0, D); glVertex3f(0, S, D); glEnd; SwapBuffers(wgl GetCurrentDC);end;

Nessa procedure e executamos os comandos para que o OpenGL faça o desenho na tela.

Temos de fazer agora a procedure de iniciali-zação do objeto OpenGL:

procedure GLInit;begin

Imagem 5

dezembro 201012

glMatrixMode(GL_PROJECTION); glFrustum(-0.1, 0.1, -0.1, 0.1, 0.3, 25.0); glMatrixMode(GL_MODELVIEW); glEnable(GL_DEPTH_TEST);end;

Aqui chamamos funções essenciais para que o OpenGL monte a cena e posteriormente realize os desenhos.

As procedure de inicialização do OpenGL são necessárias para que o programa tenha uma refe-rência de memória do objeto que fará o desenho. Com essa referência, o desenho que é feito na procedure Draw se torna possível.

Agora faremos os eventos do formulário que irão chamar as funções que criamos. Dois eventos serão utilizados: OnCreate e OnPaint.

Veja as codificações:

OnCreate:procedure TForm1.FormCreate(Sender: TObject);var DC:HDC; RC:HGLRC; i:integer;begin DC:=GetDC(Handle); SetupPixelFormat(DC); RC:=wglCreateContext(DC); wglMakeCurrent(DC, RC); GLInit; end;

No OnCreate pegamos objeto DC, que é parte da GDI e colocamos ele no contexto OpenGL com a função SetupPixelFormat, criada anteriormente.

OnPaint:procedure TForm1.FormPaint(Sender: TObject);

begin Draw;end;

Aqui apenas executamos a função de desenho, já que a criação e configuração dos objetos OpenGL já foram feitas no evento OnCreate.

Execute o aplicativo. Em execução, a tela deverá ficar assim:

Veja a imagem 6.

Conclusão

Nesse artigo não estão todas as informações técnicas que envolvem o desenvolvimento de jogos e a utilização de API’s gráficas em Delphi.

Procurei mostrar que o desenvolvimento de jogos não fica restrito a linguagens de médio nível como C++ e que a VCL, combinada com API’s gráficas, pode ajudar e muito no desenvolvimento

de jogos.

Na questão do desempenho, Delphi não apre-senta problemas quanto a velocidade de resposta de aplicativos, o que faz dessa ferramenta se não a ideal mas uma boa alternativa para quem já programa em Delphi e deseja ingressar no mundo do desenvolvimento de jogos.

A possibilidade de utilização das mais conheci-das API’s gráficas, caso de DirectX e OpenGL, torna a tarefa de desenvolvimento mais fácil e com a possibilidade de agregar robustez na comunicação com placas de vídeo dos computadores.

Para quem deseja entrar nessa área, a re-comendação é de muito estudo e se possível a escolha de apenas uma API gráfica, para que o foco seja maior.

Espero que tenham gostado e até a próxima!

Referências:GameDev: http://www.gamedev.com.brMicrosoft Developer Network: msdn.micro-

soft.com

Consultor Técnico The Club.

Sobre o autor

Antonio Spitaleri Neto

antonio@theclub.com.br

Imagem 6

dezembro 2010 13

Os usuários do antigo RxLib devem se lembrar de como essa suíte provia grandes re-cursos aos escassos componentes dos Delphi mais antigos, quando os componentes RxLib pararam de ser atualizados se “fundiram” ao Jedi, que hoje em dia contempla as versões do Delphi da 6 até a 2010. A biblioteca é construída com códigos doados por uma comunidade que é chamada de comunidade Jedi. Antes de serem adicionados à biblioteca os componentes passam por uma série de testes feitos pelos membros da comunidade, se passarem são documentados e adicionados à biblioteca.

Os componentes Jedi são liberados para uso sob os termos da Mozila Public License (MPL) e po-dem ser usados livremente em todos os ambientes, sejam eles em projetos de aplicativos Freewares, projetos de código fonte aberto, projetos comer-ciais ou sharewares. Os arquivos de código fonte incluídos no Jedi, no seu cabeçalho, tem uma seção que, como obrigatório, declara que ele é protegido sobre a licença MPL..

O Jedi é uma grande suíte de componentes,

Jediquando digo grande é por que é grande mesmo, se instaladas todas as suas packages são geradas aproximadamente 40 abas de componentes no seu Delphi e mais de 600 (isso mesmo, 600!!) componentes que provem todos os tipos de fun-cionalidades imagináveis.

Dentre todos esses componentes, existem botões dos mais variados tipos, edits, componente para acesso ao Banco de Dados, Labels de todas as formas e usos, alguns dialogs personalizados entre outros espalhados nas suas diversas abas.

Com certeza o Jedi pode conter aquele componente que você está necessitando e não encontrou no Delphi, ou freeware em outra suíte de componentes. Mas devo lembrar novamente que o Jedi gera muitas abas no seu Delphi, se você souber quais as packages necessita pode retirar as ademais no momento da instalação.

Nesse artigo mostrarei alguns componentes interessantes do Jedi, digo alguns porque seria impossível mostrar todos, e também porque não sei pra que servem pelo menos metade dos componentes. Focarei esse artigo principalmente nos componentes que considero “diferentes”, que podemos usar em nossos projetos do dia a dia, que

proporcionam funcionalidades que não estão pre-sentes nos componentes do Delphi nativamente, e que só podem ser conseguidas apenas com muitas linhas de código.

Instalação

Como dito anteriormente os componentes Jedi são livres para o uso em qualquer tipo de aplicação, os seus arquivos para instalação podem ser encontrados no site da SourceForge no seguinte endereço:

http://sourceforge.net/projects/jvcl/

Os arquivos tem um tamanho aproximado de 19,4mb.

Para fazer a instalação proceda da seguinte maneira:

1. Extraia os arquivos para a pasta deseja-da;

2. Com o Delphi fechado, execute o arqui-vo Install.bat presente na pasta jcl;

dezembro 201014

3. O prompt de comando será aberto e executará algumas instruções, após isso será exibida a seguinte tela:

Veja a imagem 1.

Nessa tela serão exibidas nas abas todas as versões do Delphi instaladas em seu computador. Selecione a aba correspondente à versão que você quer instalar e clique em Install. Na imagem 2 foi selecionado o Delphi 7.

Veja a imagem 2. Após clicar em Install serão compilados todos

os arquivos necessários para o Jedi. Isso pode levar alguns minutos.

4. Após essa etapa ser completada, vá até a pasta jvcl e execute o arquivo com o mesmo nome do anterior, install.bat;

5. Novamente será exibido o prompt de comando que executará as ações de preparo da instalação;

6. A seguinte tela será exibida:

Veja a imagem 3. Selecione a opção New Instalation/ Upgrade

for a older version e clique me next.

7. Na tela seguinte selecione a versão de Delphi em que o Jedi será instalado, caso exista mais de uma versão do Delphi instalada na sua máquina e clique em Next;

8. Na tela seguinte serão exibidas algumas opções, mas só as mude se for estritamente neces-sário, caso contrário clique em Next

9. Na próxima tela você pode definir quais as packages que serão instaladas (pra quem não conhece as packages do Jedi recomendo que não retire nenhuma), após decidir quais serão instala-das, clique em next:

Veja a imagem 4.

Tela para seleção de packages a serem ins-taladas.

10. Nas próximas telas serão exibidos um resumo da instalação, clique em Install. O proces-so será o mesmo, serão compiladas as packages necessárias para a instalação.

Imagem 1.

Imagem 2.

Imagem 3.

dezembro 2010 15

Após compiladas você já pode abrir o Delphi que os componentes já estarão na sua IDE, sem você se preocupar em apontar o LibraryPath para a pasta onde estão os arquivos do Jedi.

Vamos dar uma passada agora em algumas abas e mostrar os seus componentes mais inte-ressantes.

Aba JvNon-Visual

Essa aba contém os componentes não visuais do Jedi, pode-se destacar os seguintes compo-nentes:

• JvEnterAsTab – o componente imple-menta a funcionalidade de o Enter funcionar com Tab;

• JvBaloonHint – os hints serão mostra-dos em balões;

• JvCalculator – quando executado mos-tra uma calculadora no seu aplicativo;

Aba JvVisual

Essa aba traz alguns componentes visuais interessantes, como por exemplo:

• JvZoom – esse componente cria uma pequena tela de zoom no seu aplicativo, esse zoom pode ser definido a gosto do programador;

• JvClock – é exibido um pequeno relógio digital no seu form.

Aba JvApplication, Forms

Aqui estão presentes alguns componentes paa modificar sua aplicação e seus forms:

• JvAnimTitle – aplica um efeito de pisca-pisca ao caption do form;

• JvGradientCaption – a barra do form ganha um efeito gradiente, as cores podem ser definidas no próprio componente;

Aba JvEncrypt, Compress

Existem nessa aba, vários componentes de criptografia e de compactação de arquivos, pode-mos destacar:

• JvCaesarCipher – esse componente

aplica a uma string a famosa “Cifra de César”, que no meu último artigo (“Métodos de Criptografia” – Novembro 2010) foi citada;

• JvZlibMultiple – usado para fazer a compactação de um ou mais arquivos;

• JvSerialMaker – através de uma string informada gera uma espécie de “código serial”;

Aba JvButtons

Essa aba contém os mais variados tipos de botões, entre Bitbtns e botões com formas dife-rentes, os mais interessantes que posso destacar são os seguintes:

• JvSwitcher – esse botão assume a forma de um “interruptor”;

• JvHTButton – um botão comum ,como os nativos Buttons do Delphi, mas que permite que seja inserido um glyph e também que sua cor seja alterada.

Aba JvBars, Panels

Nessa aba estão presentes componentes de barras e panels para seu form, os principais são:

• JvRuler – é criada uma espécie de régua no seu form;

• JvGradientHeaderPanel – é adicionado um panel ao form, esse panel assume um efeito gradiente;

• JvGradient – o form ganha um efeito gradiente, definido no componente;

• JvGradientProgressBar – é criado um ProgressBar com efeito gradiente;

Aba JvLabels

Aqui se encontram algumas labels que podem assumir formas diferentes, como por exemplo:

• JvWinampLabel – essa label assume um efeito parecido, para quem conhece, com os antigos textos do Winamp;

• JvBehaviorLabel – com essa label você pode decidir entre uma série de tipos de efeitos para seu texto, esses efeitos são definidos na pro-priedade Behavior do componente;

• JvLinkLabel – através da propriedade Text desse componente podemos definir, através de HTML, um link para essa label;

Aba JvLists, Combos, Trees

Nessa aba estão alguns Combos e TreeViews diferentes, entre todos os presentes posso destacar os seguintes:

Imagem 4.

dezembro 201016

Consultor Técnico The Club.

Sobre o autor

Bruno Alcarás

bruno@theclub.com.br

• JvRegistryTreeView – abre o RegEdit na forma de um TreeView no seu form;

• JvCheckedComboBox – os itens desse ComboBox permitem a multiseleção, pois cada um de seus itens tem um CheckBox ao lado que pode ser marcado para mais de um item. Todos os itens marcados são exibidos no ComboBox, separados por um vírgula;

• JvCheckListBox – como no componente acima, através desse ListBox podemos selecionar os itens desejados;

• JvFontComboBox – esse componente lista todas as fontes que estão instaladas em seu computador;

• JvColorComboBox – é trazida uma lista com todas as cores disponíveis.

Aba Jv Scrollers

Aqui estão presentes alguns tipos de Scrollers, o principal que posso destacar é o seguinte:

• JvScrollText – os textos incluídos nesse componente assumem um efeito estilo “créditos do Jornal Nacional”.

Aba Edits

Existem nessa aba, componentes de edits que podem ser muito úteis para seu projeto, destacam–se os seguintes:

• JvFilenameEdit – abre um OpenFile-Dialog para que seja selecionado um arquivo, o caminho desse arquivo fica guardado no edit;

• JvDateEdit – clicando nesse edit é aberto um calendário para que se selecione uma data;

• JvCalcEdit – nesse componente é aberta uma calculadora, e os resultados dos cálculos nela feitos são exibidos no edit;

Aba Jv Images, Animator

Aqui são encontrados componentes para trabalho com imagens, entre os quais posso destacar:

• JvGIFAnimator – com esse componente

se tem a possibilidade de exibir um gif no Delphi.

• JvAVICapture – através desse compo-nente é possível fazer a captura de um vídeo em AVI.

Aba JvDialogs

Na aba JvDialogs podemos encontrar diversos tipos de “telas” para informações no sistema, as mais interessantes são:

• JvTipOfDay – quando executado esse, componente exibe uma tela no estilo “Dica do dia”, essas dicas devem ser inseridas através da propriedade Tips do componente, sendo que cada linha será uma dica diferente;

• JvRunDialog – esse componente, quando executado, abre a tela “Executar” do Windows;

• JvProgressDialog – exibe um Progress-Bar em uma “telinha” de dialogo.

Existem ainda em outras abas de componentes mais específicos alguns componentes que podem ser usados em nossos projetos também, posso destacar os seguintes:

• JvgProgress (Aba JVCL Globus1) – esse progress pode ser “decorado” com um efeito gra-diente durante seu progresso;

• JvgDigits (Aba JVCL Globus2) – exibe um valor na forma “digital”, com se fosse um relógio digital;

• JvgHint (Aba JVCL Globus2) – é exibido o um hint com um Glyph, que pode ser definido pelo programador;

• JvLED (Aba JvHMI) - esse componente se assemelha a uma pequena luz LED que possui

dois estados On/Off(definidos na propriedade status) cada um desses estados assume uma cor diferente;

• JvClipboardViewer (Aba JvSystem) – um dos componentes interessantes em minha opinião, ele exibe o que está presente na área de transfe-rência, seja ele uma imagem ou um texto;

• Aba JvWizard – nessa aba estão presen-tes alguns componentes para que seu form seja transformado em um form estilo wizard;

• Aba JvXpControls – aqui estão alguns componentes(Button, ProgressBar, etc) que assu-mem o estilo do Windows XP, sem a necessidade de se usar o componente XPManifest.

Desinstalando o Jedi

Para desinstalar o Jedi é muito simples:

Execute o arquivo Install.bat da pasta jvcl, após aberta a tela selecione Uninstall JVCL e clique em Next, selecione em qual versão do Delphi vai desinstalar os componentes e clique em Next no-vamente, na próxima tela novamente para efetuar a desinstalação.

Conclusão

O Jedi é uma ótima suíte de componentes que provem muitas funcionalidades que não são encontradas no Delphi. Vale a pena “garimpar” e procurar aquele componente que vai servir como uma luva para sua aplicação. Como recomendado anteriormente, procure instalar somente as pa-ckages dos componentes que irá usar, para evitar o acumulo de abas no seu Delphi.

E isso é tudo pessoal. Até outra hora.

dezembro 2010 17

No último artigo da série abordamos e exemplificamos os aspectos envolvidos na especificação, aquisição e uso de certificados digitais para aplicações de CTe, mais especifi-camente os certificados digitais da CertiSign. Desta forma os leitores tiveram contato com um caso de sucesso cujo detalhamento da do-cumentação deixa os leitores mais tranqüilos em realizar os investimentos necessários.

O CT-e é um documento emitido e armazenado eletronicamente, com validade jurídica garantida por processo de assinatura digital. Este novo modelo de documento fiscal eletrônico, instituído pelo AJUSTE SINIEF 09/07 (25/10/2007), pode ser utilizado para substituir um dos seguintes docu-mentos fiscais:

• Conhecimento de Transporte Rodoviá-rio de Cargas, modelo 8;

• Conhecimento de Transporte Aquaviá-rio de Cargas, modelo 9;

• Conhecimento Aéreo, modelo 10;• Conhecimento de Transporte Ferroviá-

rio de Cargas, modelo 11;• Nota Fiscal de Serviço de Transporte

Ferroviário de Cargas, modelo 27;• Nota Fiscal de Serviço de Transporte,

modelo 7, quando utilizada em transporte de cargas.

O principal objetivo da implantação desta nova modalidade é o acompanhamento em tempo real das operações de transporte pelo Fisco e a substi-tuição do modelo atual de emissão de documentos fiscais em papel, de forma a simplificar uma série de obrigações do contribuinte. Maiores informações podem ser obtidas através do portal nacional do

Assinatura Digital

para CT-eAbordagem prática assinaturaCTe32dll

ambiente de produção em http://www.cte.fazenda.gov.br ou do portal nacional do ambiente de homo-logação em http://hom.cte.fazenda.gov.br/

Seguindo a linha de publicações voltadas às so-luções para Conhecimento de Transporte Eletrônico (CT-e) damos continuidade a esta série mantendo o foco no processo de assinatura digital dos mesmos, onde uma vez definido o certificado a ser utiliza-do, partimos para demonstrar de forma simples e prática como é possível assinar digitalmente, a partir da sua aplicação, os arquivos XML gerados. Para realizar o processo de assinatura utilizamos a assinaturaCTe32dll.dll.

CTe e a assinatura digital

Os certificados digitais são documentos eletrô-nicos que identificam pessoas físicas ou jurídicas e através do uso de criptografia asseguram a confia-bilidade, privacidade, integridade, inviolabilidade e autenticidade de informações de transações realizadas via Internet.

O processo de assinatura digital utilizando certificados digitais nas operações via Internet tem validade jurídica para ser utilizado como assinatura de próprio punho, comprovando que seu proprietá-rio concorda com o documento assinado.

Os conceitos detalhados sobre certificados digitais foram abordados em artigo anterior inti-tulado “Certificação Digital para CTe, Abordagem Prática para CertSign” cuja leitura é altamente recomendada para o melhor entendimento do presente artigo.

No caso específico do conhecimento de trans-porte eletrônico de todos os arquivos assinados

digitalmente são arquivos .XML. Consultando o ma-nual de integração disponível no portal nacional de CT-e é possível identificar quais arquivos requerem assinatura digital observando a presença ou não do campo Signature na tabela que define a estrutura de cada arquivo. A Figura 01 apresenta o leiaute do arquivo de Cancelamento de CT-e, que contém o campo Signature, logo requer assinatura digital.

Figura 01: Leiaute do arquivo de cancelamento de CT-e indicando a necessidade de assinatura digital do mesmo.

A Tabela 01 apresenta uma lista completa de todos os arquivos de CT-e que devem ser gerados pelo seu software aplicativo, indicando a necessi-dade de assinatura em cada um deles conforme manual de integração disponível no portal nacional de CT-e.

Veja a Tabela 01.

dezembro 201018

A Figura 02 apresenta o digrama completo do processo que envolve a assinatura digital de arquivos de CTe, processo este que será detalhado no decorrer do presente artigo.

Veja a Figura 02.

Gerando uma CT-e para testes de assinatura

Para testar a assinatura digital em um CT-e de teste, utilizamos o aplicativo disponibilizado no site http://www.igara.com.br/produto.php?cod_produto=116. O aplicativo mostrado da Figura 03 é um demo desenvolvido em Delphi, totalmente funcional que permite a geração de CT-e a partir de informações digitadas pelo usuário em campos de texto que seguem o layout específico vigente.

Após abrir o aplicativo, clicamos no botão “Novo CT-e” e depois no botão “Salvar CT-e”. Por fim selecionamos o diretório onde desejamos sal-var o arquivo .XML gerado. O aplicativo sugere um nome para o arquivo gerado e este nome não deve ser alterado, pois segue padrão de nomenclatura específico exigido com base no conteúdo da CT-e em questão.

Veja a Figura 03.

O arquivo gerado pode ser visualizado no Internet Explorer ou em qualquer outro browser de internet com suporte a XML, e o resultado é conforme mostrado na Figura 04.

Neste artigo não entraremos em detalhes so-bre o processo de geração do CT-e, pois este será o tema de outros artigos que virão.

Veja a Figura 04.

Até o momento, o arquivo gerado não tem valor jurídico, pois ainda não foi assinado de forma que o emissor possa certificar a validade das informações fornecidas, bem como não há nada que garanta que este documento não foi alterado por terceiros sem o conhecimento prévio do emitente.

Para tanto, é preciso assinar este documento. Em edições anteriores demonstramos como utilizar o aplicativo de assinatura de CT-e disponibilizado para download gratuito no portal oficial da CT-e em www.cte.fazenda.gov.br. No entanto, neste artigo o objetivo é demonstrar como assinar digitalmente os arquivos a partir da sua própria aplicação, e para isso utilizaremos a assinaturaCTe32dll.dll.

Assinatura de CTe com uso da assina-turaCTe32dll.dll

Para demonstrar como é fácil assinar uma CTe,

Arquivo Finalidade Padrão de Nomenclatura Requer Assinatura

CTe CT-e propriamente dito Chave de Acesso + “-cte.xml” Sim

enviCTe Mensagem de envio de lote de CT-e.

Número do lote + “-envlot.xml” Não

consReciCTe M e n s a ge m d e co n s u l ta processamento do lote de CT-e transmitido.

Número do recibo “-ped-rec.xml” Não

cancCTe Chave de Acesso + “-ped-can.xml” Sim

inutCTe UF+Ano_inutilização+CNPJ+Emitente+Modelo+Serie+Nº Inicial+Nº Final+“-ped-inu.xml”

Sim

consSitCTe Mensagem de consulta da situação atual da CT-e.

chave de acesso + “-ped-sit.xml” Não

consStatCTe M e n s a ge m d a co n s u l ta do status do serviço de autorização de CT-e.

D a t a h o r a n o f o r m a t o “AAAAMMDDTHHMMSS” + “-ped-sta.xml”

Não

Tabela 01: Lista de arquivos de CT-e vs. necessidade de assinatura.

Figura 02: Digrama do processo que envolve a assinatura digital de arquivos de CTe

dezembro 2010 19

utilizaremos a assinaturaCTe32dll.dll e o aplicativo demo que acompanha a mesma pode ser obtido a partir do site http://www.igara.com.br/produto.php?cod_produto=116.

Após o download, executamos o aplicativo e clicamos no botão “1. Selecione o arquivo XML do CTe”. Um componente da classe TOpenDialog é utilizado para apresentar ao usuário uma caixa de seleção de arquivos, onde o mesmo indicará o arquivo .XML a ser assinado. O código do evento OnClick do botão é conforme mostrado a seguir.

procedure TForm1.Button12Click(Sender: TObject);begin opendialog1.InitialDir := ExtractFileDir(application.ExeName);

if OpenDialog1.Execute then begin cte_filename := OpenDialog1.FileName;

WebBrowser1.Navigate(cte_filename); memo1.Lines.LoadFromFile(cte_filename); end;end;

A Figura 03 apresenta o resultado da execução de tal procedimento, onde após a seleção do arqui-vo .XML, o mesmo é carregado em componentes da classe TMemo e TWebBrowser, conforme mostrado no lado esquerdo da Figura 05.

Veja a Figura 05

Uma vez carregado o arquivo desejado clique no botão “2. Assinar CTe Selecionado Delphi” para dar início ao processo de assinatura. O código executado no evento OnClick do botão é confor-me segue.

O procedimento executa uma chamada à função fncAssinarXML contida na dll passando como parâmetro do tipo TStrings as linhas do ar-quivo .XML carregado anteriormente. O resultado da chamada da função é atribuído a um segundo componente da classe TMemo.

Se tudo estiver correto, o retorno da função fncAssinarXML será o arquivo da Conhecimento de Transporte Eletrônico devidamente assinado. Caso contrário, o retorno será uma String vazia.

procedure TForm1.Button1Click(Sender: TObject);var

Figura 03: Aplicativo em Delphi para geração de CT-e

Figura 04: Arquivo .xml de CT-e visualizado no Internet Explorer

Figura 05: Aplicativo demo de assinatura de CT-e. Seleção da CT-e a ser assinada.

dezembro 201020

cte_assinada, cte_nao_assinada: String;begin try //testa se memo1 preenchido if memo1.lines.Count > 0 then begin cte_nao_assinada := Memo1.Lines.text;

//chama a função de assinatura passando como parâmetro o conteúdo do arquivo selecionado //Esta função NÃO é compatível para ser chamada por outras linguagens que não delphi //Esta função NÃO é compatível para ser chamada por inferiores ao Delphi6 cte_assinada := fncAssinarXML(Memo1.Lines);

if cte_assinada[1] <> ‘-’ then //Testa se CTe asinada corretamente begin //se nenhum erro ocorreu o retorno é a CTe assinada //Atenção para salvar em formato remover caracteres iniciais do resultado assinado (lixo) memo2.Lines.Text := copy(cte_assinada, 4, length(cte_assinada));

memo1.Lines.Text := cte_nao_assinada;

showmessage(‘CTe assinada com sucesso’); end else memo2.Lines.Text := cte_assinada; //Apresenta erro/advertência retornado pela dll end else showmessage(‘Conteúdo inválido. Selecione o arquivo XML da CTe’) except showmessage(‘Erro durante o processo de assinatura. Verifique!’); end;

No momento da execução do código apresen-tado, surgirá uma tela para seleção do certificado digital a ser utilizado no processo de assinatura, conforme mostrado na Figura 06. Importante ressaltar que nesta tela é possível verificar as informações contidas no certificado, de forma a diferenciar os certificados entre si, para os casos

de mais um certificado disponível em uma mesma máquina.

Caso a opção “Usar este certificado como padrão e não perguntar novamente” seja marcada, será criado um arquivo do tipo DefCertificado.res contendo a informação do certificado a ser utilizado como padrão. Sempre que um arquivo DefCerti-ficado.res é encontrado a assinaturaCTe32dll.dll não solicita ao usuário que selecione o certificado e procede a assinatura digital do arquivo utilizan-do o certificado padrão. Basta excluir o arquivo para que o sistema volte a solicitar a seleção do certificado.

Veja a Figura 06

Após selecionar o certificado desejado, clique no botão “Ok”. Surgirá então a tela apresentada na Figura 07 a seguir. Neste momento, para finalizar o processo e efetivamente assinar o documento é preciso se fornecer a senha de registro do certifi-cado digital selecionado. Conforme abordado no artigo anterior no momento da aquisição do token, uma senha de acesso deve ser fornecida, sendo pessoal e intransferível, onde somente através dela é possível se utilizar das funcionalidades do certificado.

Figura 07: Confirmação de senha para uso do certificado.

Após preencher a senha e clicar no botão “Ok”, o arquivo .XML selecionado anteriormente será assinado e o conteúdo do XML assinado será apresentado conforme demonstrado na Figura 08 a seguir.

Veja a Figura 08.

Agora basta clicar no botão “3. Salvar CTe Assinado” para que o procedimento de OnClick do botão execute a chamada a um componente da classe TSaveDialog, utilizado para apresentar ao usuário uma caixa de seleção de arquivos, onde o mesmo indicará o local onde o arquivo .XML assi-nado deve ser salvo. O código do evento OnClick do botão é conforme mostrado a seguir.

procedure TForm1.Button2Click(Sender: TObject);{var UTF8_Str: String; }begin try //configura o SaveDialog savedialog1.InitialDir := ExtractFileDir(application.ExeName); SaveDialog1.FileName := ExtractFileName(cte_filename);

//Realiza o salvamento do arquivo conforme path escolhido pelo usuário if savedialog1.Execute then begin //Alterações para realizar salvamento em formato UTF-8

Figura 06: Seleção de certificado a ser utilizado no processo de assinatura.

dezembro 2010 21

//UTF8_Str := Memo2.Lines.Text; //UTF8_Str := UTF8Encode(UTF8_Str); //UTF8_Str := char($EF) + char($BB) + char($BF) + UTF8_Str; //adding BOM //Memo2.Lines.Text := UTF8_Str;

//Salvando o arquivo memo2.Lines.SaveToFile(savedialog1.filename);

//Testa tamanho do arquivo final //Conforme Manual de Integração o tamanho máximo dos arquivos para transmissão é de 500Kb! if Tamanho_Arquivo(savedialog1.filename) > 500 then showmessage(‘ATENÇÃO: Tamanho máximo de 500KB excedido. Arquivo não pode ser trasmitido’); end; except showmessage(‘Erro durante o salvamento do arquivo de CTe assinado’); exit; end;

showmessage(‘Atenção: Para transmitir arquivos de CTe é preciso antes gerar um arquivo de Lote contendo uma ou mais CTe assinadas’ + #13#10 + ‘Consulte o demo localizado na pasta Geracao_XML\enviCTe para informações sobre geração de lotes de CTe’)

Qual o código necessário para chamar a função de assinatura da dll e executar esta aplicação? Pri-meiramente é preciso fazer a declaração da função da dll conforme mostrado a seguir

var Form1: TForm1; cte_filename: String;

implementation

{$R *.dfm}

Function fncAssinarXML(sXml: TStrings): String; SafeCall; external

‘assinaturaCTe32dll.dll’;Function fncAssinarXML_(sXml_Path: Pchar): integer; SafeCall; external ‘assinaturaCTe32dll.dll’;

Uma vez feita a declaração, é preciso realizar uma única chamada à função de assinatura da dll conforme mostrado

memo2.Lines.Text := fncAssinarXML(memo1.Lines);

Note que não foi preciso ter nenhum conheci-mento aprofundado sobre como se dá o processo

de assinatura digital, e dessa forma abstrai-se completamente a camada relativa às funções ne-cessárias e tecnologias utilizadas. Com a chamada de uma única função o arquivo desejado já está assinado!

A diferença entre o arquivo não assinado e o arquivo assinado digitalmente estará no conteúdo das últimas chaves do arquivo XML em questão, que anteriormente estavam sem preenchimento, e após a assinatura terão um conteúdo, conforme mostrado na Figura 09.

Veja a Figura 09.

Após o processo de assinatura, os campos de DigestValue, SignatureValue e X509Certificate passaram a conter dados criptografados que iden-tificam unicamente o arquivo .XML em questão e atestam que o mesmo foi assinado somente por

Figura 08: Aplicativo demo de assinatura de CT-e. Assinatura da CT-e.

Figura 09: Arquivo .xml de CT-e após o processo de assinatura

dezembro 201022

pessoa detentora de determinado token e da senha de acesso do mesmo.

Pronto! O arquivo da CT-e está pronto para ser enviado! Mas, por enquanto é só, pois o processo de envio da CT-e será tema de outros artigos que virão. Continue acompanhando a coluna pois em breve teremos mais artigos sobre o tema.

Sobre a assinaturaCTe32dll.dll

A assinaturaCTe32dll.dll é um produto de-senvolvido para facilitar e agilizar o processo de assinatura digital de arquivos de Conhecimento de Transporte Eletrônico. O objetivo é disponibilizar uma solução simples e acessível a todos os desen-volvedores onde, através da chamada de uma única função, seja possível se indicar o conteúdo a ser as-sinado, abstraindo a complexidade desta camada, que envolve conhecimentos aprofundados acerca de funções e tecnologias de certificação.

Sendo assim a dll contém um única função que recebe como parâmetro uma variável TStrings com o conteúdo a ser assinado e retorna o conteúdo devidamente assinada como String. Mais simples que isso, impossível!

Function fncAssinarXML(sXml: TStrings): String; StdCall; external ‘assinaturaCTe32dll.dll’;

O uso da dll permite ao desenvolvedor abstrair completamente a camada de assinatura do arquivo magnético, dispensando o estudo e aprofunda-mento teórico relativo às ferramentas e funções complexas aplicadas no processo.

O produto é uma solução pioneira no merca-do e dá ao desenvolvedor total flexibilidade para implementar recursos de CT-e em suas aplicações, adequando seus sistemas às obrigações exigidas pelo Fisco.

Maiores informações, bem como o download do demo de uso do produto e da versão de ava-liação 100% funcional da assinaturaCTe32dll.dll pode ser feito pelo site http://www.igara.com.br/produto.php?cod_produto=116

Descrição Simplificada do Processo

De maneira simplificada o modelo operacional da CT-e pode ser assim descrito:

1. A empresa emissora da CT-e gera um arquivo eletrônico contendo as informações fiscais da operação comercial em questão.

a. O arquivo eletrônico tem extensão .XML (Extensible Markup Language) e deve ser gerado conforme padrão pré-estabelecido vigente.

b. Este documento eletrônico contém informações equivalentes às informações contidas no modelo atual de notas fiscais em papel.

2. O documento da CT-e emitido deve ser assinado digitalmente, de maneira a garantir a integridade dos dados, a autoria do emissor e a validade jurídica do documento.

a. O processo de assinatura digital deve ser feito utilizando-se certificado digital tipo A1 ou A3 emitido por autoridade certificadora cre-denciada pela Infra-estrutura de Chaves Públicas Brasileira – ICP-Brasil (www.icpbrasil.gov.br).

b. Neste artigo foram utilizados certi-ficados emitidos pela empresa CertSign (www.certisign.com.br), devidamente credenciada no ICP-Brasil.

c. A escolha do fornecedor do certificado abordado neste artigo se deu primeiramente pela CertSign ser devidamente certificada no ICP-Brasil e também pelo fato de ser uma das empresas líderes deste mercado e dispor de Autoridade de Registro (AR) sediada em nossa cidade, Salvador – Ba. No entanto sinta-se o leitor livre para escolher entre qualquer uma das empresas disponíveis no merca-do, todas elas dispõem de processos semelhantes aos apresentados e toda a teoria mostrada no que tange a CT-e continua sendo válida.

3. O arquivo deve então ser transmitido, via Internet, para a Secretaria da Fazenda do Estado (SEFAZ) onde reside o contribuinte emissor.

4. Após receber o arquivo, a SEFAZ realiza um processo de pré-validação e devolve uma Auto-rização de Uso, permitindo com isso o trânsito da mercadoria e a continuação da transação comer-cial.

5. Para acompanhar o trânsito da merca-doria o sistema deve imprimir, em papel comum, geralmente em única via, uma representação gráfica simplificada da CT-e, chamada de DACTE (Documento Auxiliar do Conhecimento de Trans-porte)

a. O DACTE deve conter impressa uma chave de acesso que possibilita a consulta da CT-e na internet, de forma que qualquer pessoa possa confirmar as informações impressas com as infor-mações contidas no site da SEFAZ.

b. O DACTE não é uma nota fiscal, nem a substitui, servindo apenas como instrumento auxiliar para consulta da CT-e na internet.

Atualmente, a estratégia de implantação na-cional é de que, voluntaria e gradualmente, inde-pendente do porte, as empresas se interessem por emitir Conhecimento de Transporte Eletrônico.

Conclusão

Com este artigo abordamos conceitos gerais sobre assinatura digital no que tange a CT-e, e vimos como é fácil emitir e assinar tais docu-mentos. O CT-e já é uma realidade, e muito em breve todos serão obrigados a adotar este novo formato. Mesmo as empresas não obrigadas, estão interessadas em ter seus sistemas atualizados para trabalhar nesta nova modalidade de emissão de documentos fiscais.

Demos continuidade à nossa série de artigos sobre CTe, e desta vez, demonstramos como reali-zar de forma simples e prática a assinatura digital a partir da sua aplicação, com o uso da assinatu-raCTe32dll.dll. De agora em diante, assinar um Conhecimento de Transporte Eletrônico é questão apenas de chamar uma função e indicar o conteúdo a ser assinado, simples assim!

Professor do Departamento de Engenharia da UNIFACS, Engenheiro Mestrando em Redes de Computadores, e desenvolvedor sócio da TKS Soft-ware - Soluções de Automação e Softwares Dedicados. Pode ser contatado em victory@igara.com.br, ou através dos sites www.igara.com.br – www.igara.com.br/victory

Sobre o autor

Victory Fernandes

victory@igara.com.br

dezembro 2010 23

Vimos no artigo anterior a opção que temos de gerar boletos usando o CobreBemX. Esse componente é pago, então, pode ser um impecilho para o desenvolvedor iniciante, quando o desenvolvedor não pode desembol-sar valor ou quando o cliente não o quer.

Pesquisando na internet, encontrei uma classe muito interessante, presente no framework da Net.Raptors (totalmente gra-tuito), que gera boletos. Essa classe faz parte do framework e seu uso é muito fácil, basta incorporá-la no projeto ASP.NET.

Caso deseje conhecer mais a fundo, vamos dar uma olhada em seu código-fonte, pois é bastante simples de entender. Sua linguagem é C#, mas você pode usá-la em projetos VB.NET sem nenhum problema.

Entendo Boleto de cobrança

Boleto de cobrança é um documento utilizado como instrumento de pagamento de um produto ou serviço prestado. Através do boleto, seu emissor (cedente) pode receber do pagador (sacado) o valor

Gerando boletos no ASP.NET

referente àquele pagamento.

Alguns campos que são padrões e obrigatórios em um boleto:

• Banco: instituição financeira que esta emitindo o boleto. Também pode ser responsável pela cobrança (dependendo do tipo de carteira usada no boleto) junto ao sacado do documento.

• Sacado: quem paga o documento.

• Cedente: quem emite a cobrança do documento. Quem recebe o valor pago.

• Valor: valor a ser pago do documento.

• Data de vencimento: data limite de pagamento. Podemos agregar a informação de cobrança de multa e juros se o documento for pago após a data de vencimento.

• Código de barras: representação gráfica dos números referentes aos dados de pagamento do boleto.

Veja na Figura 1 as principais informações de um boleto.

Figura 1. Dados do boleto

dezembro 201024

O formato e características do boleto é desen-volvido pelo Centro Nacional de Estudos da Arreca-dação Bancária (CENEABAN) e é padronizado pela Federação Brasileira de Bancos (FEBRABAN)

A maioria dos bancos, utilizam duas moda-lidades de boletos: cobrança registrada e não-registrada. Na registrada o banco, recebe um arquivo de remessa com as informações do boleto e pode realizar serviços de protesto de título junto ao sacado quando esse for inadimplete. O banco pode cobrar por esse serviço, quando o arquivo de remessa é enviado ao banco.

Na modalidade não registrada, o banco não recebe arquivos de remessa com os dados e não se responsabiliza pela cobrança do documento. O cedente que deve verificar a inadimplência do sa-cado. Existe também a cobrança nessa modalidade, mas o banco cobra apenas quando o sacado efetua o pagamento. Fonte: wikipédia.

Neste artigo, não entraremos em detalhes, relativo a arquivos de remessa. Vamos conhecer como funciona a classe que gera o boleto em apli-cações ASP.NET e fazer um exemplo.

Conhecendo a geração do boleto

A classe Boleto.cs, cria o layout do boleto e re-passa os dados através de propriedades para serem exibidos em tela. Nela, temos uma classe abstrata, chamada Boleto com métodos e propriedades comuns a qualquer tipo de boleto, independente das informações referente ao banco emissor, que muda de acordo com o banco.

Nota: O arquivo Boleto.cs, esta disponi-vel para download no site da The Club, assim como o projeto de exemplo do artigo. Se deseja conhecer o framework, acesse: http://dotnetraptors.wordpress.com.

Na classe do banco emissor (herdada de Bole-to), temos as propriedades referente ao número do banco, código DV, logotipo do banco etc, ou alguma configuração a mais que o banco emissor tenha em relação aos outros. A montagem do campo nosso número esta presente na classe Boleto, mas tam-bém pode ser modificada na classe herdada.

No arquivo Boleto.cs, temos opções do se-guintes bancos: Bradesco, Itaú, BB, HSBC e CEF. Acredito que a adaptação para outros bancos, não é muito trabalhoso, mas deve ser tomado todo o

cuidado. Uma dica é procurar o banco que você deseja emitir boletos e verificar se o mesmo possui documentação/manual para auxiliar na criação desses boletos.

Em Boleto.cs temos a classe TMLBoleto, res-ponsável por criar o código HTML gerado para o bo-leto. O método MontaInicioArquivo, é responsável pela criação do HTML que vai mostrar o cabeçalho do boleto. Veja na Listagem 1 o código.

Listagem 1. Método que inicia a criação do boleto em HTML

_Buffer.Append(“<HTML>”);_Buffer.Append(“<HEAD>”);_Buffer.Append(“<title>WebForm1</title>”);_Buffer.Append(“<style type=text/css>.ti { FONT: 9px arial, helvetica, sans-serif }”);_Buffer.Append(“.ct { FONT: 9px arial narrow; COLOR: #000000 }”);_Buffer.Append(“.cn { FONT: 9px arial; COLOR: #000000 }”);_Buffer.Append(“.cp { FONT: bold 11px arial; COLOR: #000000 }”);_Buffer.Append(“.ld { FONT: bold 11px arial; COLOR: #000000 }”);_Buffer.Append(“.bc { FONT: bold 18px arial; COLOR: #000000 }”);_Buffer.Append(“.lLinhaDigitavel { FONT: bold 15px arial; COLOR: #000000 }”);_Buffer.Append(“.SaltoDePagina { PAGE-BREAK-AFTER:always }”);_Buffer.Append(“.nbanco { FONT: bold 25px arial }”);_Buffer.Append(“</style>”);_Buffer.Append(“</HEAD>”);_Buffer.Append(“<body>”);

O método MontaFimArquivo, tem o cuidado de fechar as tags HTML:

_Buffer.Append(“</body>”);_Buffer.Append(“</html>”);

Para ter o “corpo” do boleto, a classe possui o método AddBoleto, que recebe como parâmetro um tipo Boleto para poder repassar as informações das propriedades. Como o método é extenso, vou colocar na Listagem 2, apenas uma parte, onde esta sendo configurado o inicio do boleto e a seção recibo do sacado.

Listagem 2. Método que cria o corpo do boleto

if( _Encerrado) throw new Exception( “Após ter obtido o(s) boleto(s) montados pelo método ToString não é permitido adicionar novos boletos.”);

string lNossoNumero, lLinhaDigitavel, lCodigoBarras;lBoleto.MontaCodigos(out lNossoNumero, out lLinhaDigitavel, out lCodigoBarras);

lLinhaDigitavel = lLinhaDigitavel.Replace( “ “, “&nbsp;&nbsp;”);

string sImgBarra = _ImagesFolder + @”/barra.gif”;string sImgCorte = _ImagesFolder + @”/corte.gif”;string Codiodebarras = CodigoBarras25I( lCodigoBarras);

_Counter++;if( _Counter>=2) _Buffer.Append(“<p class=SaltoDePagina></p>”);

...

//Recibo do Sacado_Buffer.Append(“<table cellSpacing=0

dezembro 2010 25

cellPadding=0 width=\”100%\” border=0>”);_Buffer.Append(“<tr><td width=150><img src=\”” + _ImagesFolder + @”\” + lBoleto.BancoLogoTipo + “\”></td>”);_Buffer.Append(“<td vAlign=bottom width=2><IMG src=\”” + sImgBarra + “\” height=22 width=2 border=0 ></td>”);_Buffer.Append(“<td vAlign=bottom align=center width=75 class=\”nbanco\”><spam id=nb2>” + lBoleto.BancoCodigoCompleto() + “</spam></td>”);_Buffer.Append(“<td vAlign=bottom width=2><IMG height=22 src=\”” + sImgBarra + “\” width=2 border=0 ></td>”);_Buffer.Append(“<td class=ld vAlign=bottom align=right>&nbsp;Recibo do Sacado&nbsp;</td></tr></table>”);_Buffer.Append(“<table borderColor=#000000 cellSpacing=0 cellPadding=0 width=\”100%\” border=1>”);_Buffer.Append(“<TR><TD vAlign=top colSpan=5><table cellSpacing=0 cellPadding=0 width=\”100%\” border=0>”);_Buffer.Append(“<tr><td class=ct>&nbsp;Local de Pagamento</td></tr>”);_Buffer.AppendFormat(“<tr><td class=cp>&nbsp;{0}</td></tr></table></TD>”, lBoleto.LocalPagamento);_Buffer.Append(“<TD vAlign=top width=140 bgColor=#cccccc><table cellSpacing=0 cellPadding=0 width=\”100%\”

border=0>”);_Buffer.Append(“<tr><td class=ct>&nbsp;Vencimento</td></tr>”);_Buffer.Append(“<tr><td class=ld align=center><spam id=dtavencto2>” + lBoleto.DtVencimento.ToString( Boleto.DATEFORMAT) + “</spam></td></tr></table></TD></TR>”);_Buffer.Append(“<TR><TD vAlign=top colSpan=5><table cellSpacing=0 cellPadding=0 width=\”100%\” border=0>”);_Buffer.Append(“<tr><td class=ct>&nbsp;Cedente</td></tr>”);_Buffer.Append(“<tr><td class=ld>&nbsp;<spam id=Cedente2>” + lBoleto.CedenteNome + “</spam></td></tr></table></TD>”);_Buffer.Append(“<TD vAlign=top width=140><table cellSpacing=0 cellPadding=0 width=\”100%\” border=0>”);_Buffer.Append(“<tr><td class=ct>&nbsp;Agência / Código do Cedente</td></tr>”);_Buffer.Append(“<tr><td class=ld align=center><Spam id=CodCedente2 >” + lBoleto.AgenciaCedente() + “</spam></td></tr></table></TD></TR>”);_Buffer.Append(“<TR><TD vAlign=top><table cellSpacing=0 cellPadding=0 width=\”100%\” border=0>”);_Buffer.Append(“<tr><td class=ct>&nbsp;Data Documento</td></tr>”);_Buffer.

Append(“<tr><td class=ld align=center><spam id=dtadocumento2 >” + lBoleto.DtDocumento.ToString( Boleto.DATEFORMAT) + “</spam></td></tr></table></TD>”);_Buffer.Append(“<TD vAlign=top><table cellSpacing=0 cellPadding=0 width=\”100%\” border=0>”);_Buffer.Append(“<tr><td class=ct>&nbsp;Número Documento</td></tr>”);_Buffer.Append(“<tr><td class=ld align=center><spam id=numerodocumento2 >” + lBoleto.Documento + “</spam></td></tr></table></TD>”);_Buffer.Append(“<TD vAlign=top><table cellSpacing=0 cellPadding=0 width=\”100%\” border=0>”);_Buffer.Append(“<tr><td class=ct>&nbsp;Espécie Doc.</td></tr>”);_Buffer.Append(“<tr><td class=ld align=center><aspam id=especiedocumento2 >” + lBoleto.pEspecieDoc + “</spam></td></tr></table></TD>”);_Buffer.Append(“<TD vAlign=top><table cellSpacing=0 cellPadding=0 width=\”100%\” border=0>”);_Buffer.Append(“<tr><td class=ct>&nbsp;Aceite</td></tr>”);_Buffer.Append(“<tr><td class=ld align=center><spam id=aceite2>” + lBoleto.Aceite + “</spam></td></tr></table></TD>”);_Buffer.Append(“<TD vAlign=top><table

dezembro 201026

cellSpacing=0 cellPadding=0 width=\”100%\” border=0>”);_Buffer.Append(“<tr><td class=ct>&nbsp;Data Processamento</td></tr>”);_Buffer.Append(“<tr><td class=ld align=center><spam id=dtaprocess2 >” + lBoleto.DtProcessamento.ToString( Boleto.DATEFORMAT) + “</spam></td></tr></table></TD>”);_Buffer.Append(“<TD vAlign=top width=140><table cellSpacing=0 cellPadding=0 width=\”100%\” border=0>”);_Buffer.Append(“<tr><td class=ct>&nbsp;Nosso Número</td></tr>”);_Buffer.Append(“<tr><td class=ld align=center><spam id=nossonumero12>” + lNossoNumero + “</spam></td></tr></table></TD></TR>”);_Buffer.Append(“<TR><TD vAlign=top><table cellSpacing=0 cellPadding=0 width=\”100%\” border=0>”);_Buffer.Append(“<tr><td class=ct>&nbsp;Uso da Empresa</td></tr>”);

Veja que estamos repassando entre as tags HTML, as propriedades da classe Boleto, assim nosso documento será montado na página ASPX. Temos mais propriedades e métodos interessantes nas classes, como por exemplo a pasta que possui as imagens do boleto (código de barras, logotipo de banco), que deve ser indicada, mensagens de informações de pagamento etc.

Criando o exemplo

Vamos criar um exemplo simples para mostrar o funcionamento do boleto. Você pode usar o

exemplo do artigo que fiz sobre o CobreBem que tem uma loja virtual.

Nota: Para aprender a construir uma loja virtual, indico meu treinamento mul-timídia onde é mostrado como criar uma aplicação e-commerce com o Visual Web Developer. Para saber mais, acesse www.lucianopimenta.net.

Vamos modificar a opção de pagamento com boleto bancário. Veja na Figura 2, a adaptação do projeto, onde criamos uma tela depois de finalizar com a opção de pagamento por boleto, para inser-ção dos dados do cedente.

Veja a Figura 2.

O botão Confirmar, redireciona para a página que vamos criar a seguir. Essa página será chamada de “boleto2.aspx” (já existe uma página boleto.aspx), que vai mostrar o boleto. Veja na Listagem 3 o código do botão.

Listagem 4. Salvando os dados e redirecionan-do para o boleto

DataTable dt = new DataTable();

dt.Columns.Add(“AGENCIA”, Type.GetType(“System.String”));

dt.Columns.Add(“CONTA”, Type.GetType(“System.String”));dt.Columns.Add(“DVCONTA”, Type.GetType(“System.String”));dt.Columns.Add(“CEDENTE”, Type.GetType(“System.String”));dt.Columns.Add(“INSTRUCAO”, Type.GetType(“System.String”));

DataRow row = dt.NewRow();row[“AGENCIA”] = txtAgencia.Text;row[“CONTA”] = txtConta.Text;row[“DVCONTA”] = txtDV.Text;row[“CEDENTE”] = txtNome.Text;row[“INSTRUCAO”] = txtInstrucao.Text;

dt.Rows.Add(row);Session[“dadosboleto”] = dt;

Response.Redirect(“boleto2.aspx”);

Vamos salvar os dados que devem ser mostra-dos no boleto, usando um DataTable repassando o mesmo entre os formulários através de uma variá-

Figura 2. Opção de pagamento por boleto

dezembro 2010 27

vel de sessão. Fique a vontade de usar outra técnica (Profile, por exemplo), para salvar esses dados.

Nota: Em uma aplicação real, os dados que vamos digitar, devem ser oriundos do banco de dados, por exemplo.

Vamos usar um boleto do BB neste exemplo. No Page_Load da página boleto2.aspx, vamos utilizar o código da Listagem 4.

Listagem 4. Criando o boleto

using dotnetraptors.Brazil.Boleto;using System.Data;

...

Boleto boletoBB = new BoletoBrasil();DataTable dt = (DataTable)Session[“dadosboleto”];DataSet ds = Session[“venda”] as DataSet;DataRow dr = dt.Rows[0];

boletoBB.Aceite = true;boletoBB.CedenteAgencia = dr[“AGENCIA”].ToString();boletoBB.CedenteConta = dr[“CONTA”].ToString();boletoBB.CedenteContaDV = dr[“DVCONTA”].ToString();boletoBB.CedenteNome = dr[“CEDENTE”].ToString();boletoBB.Carteira = 16;boletoBB.Instrucao1 = dr[“INSTRUCAO”].ToString();

boletoBB.Sequencial = 123456;boletoBB.Documento = “0001”;boletoBB.DtDocumento = DateTime.Now;boletoBB.DtEmissao = DateTime.Now;boletoBB.DtProcessamento = DateTime.Now;boletoBB.DtVencimento = DateTime.Now.AddDays(7);boletoBB.Valor = float.Parse(ds.Tables[0].Rows[0]

[“TOTAL”].ToString());

boletoBB.SacadoNome = “The Club”;boletoBB.SacadoEndereco = “Rua”;boletoBB.SacadoCPF_CNPJ = “111.111.111-11”;boletoBB.SacadoCidade = “Cidade”;boletoBB.SacadoUF = “Estado”;boletoBB.SacadoBairro = “Bairro”;

boletoBB.SacadoCEP = “00.000-000”;

HTMLBoleto boleto = new HTMLBoleto();boleto.ImagesFolder = “imgBoleto”;boleto.AddBoleto(boletoBB);boleto.SaveToFile(“boletoBB”);Response.Write(boleto.ToString());

Figura 3. Parte superior do boleto mostrado na aplicação Web

Figura 4. Parte inferior do boleto mostrado na aplicação Web

dezembro 201028

Entendendo o código. Primeiramente, instan-ciamos a classe BoletoBrasil, que é herdada de Boleto (veja a definição no Boleto.cs). Repassamos para as propriedades os valores (nesse caso, temos um DataTable, que esta em uma Session, com as informações).

Após, instanciamos uma variável do tipo HTMLBoleto que recebe as informações sobre o diretório que possui as imagens do boleto (código de barras e logotipo do banco) e utilizamos o método AddBoleto e SaveToFile para configurar o boleto. Por fim, utilizamos o Response.Write para mostrar o boleto em tela, usando o ToString da variável boleto.

Algumas informações foram colocadas no código, como datas (documento, emissão, pro-cessamento, vencimento), carteira, dados do sacado, número de documento etc. mas esses dados podem ser customizados/parametrizados.

Outra informação, como a instrução d epaga-mento, também deve vir de uma pré-configuração. Foi dada a opção de digitação, apenas para fins didáticos, para poder visualizar o que for digitado

em tela, seja mostrado no boleto.Veja na Figura 3 e 4 o boleto em execução.

Veja a Figura 3.

Veja a Figura 4.

Conclusões

Vimos que podemos gerar boletos simples, com uma classe C#, sem nenhum custo. Caso

É Técnico em Processamento de Dados, desenvolvedor Delphi/C# para aplicações Web com ASP.NET e Windows com Win32 e Windows Forms. Palestrante da 4ª edição da Borland Conference (BorCon).

Autor de mais de 60 artigos e de mais de 300 vídeos aulas publicadas em revistas e sites especializados. É consultor da FP2 Tecnologia (www.fp2.com.br) onde ministra cursos de programação e banco de dados. É desenvolvedor da Paradigma Web Bussi-ness em Florianópolis-SC.

Sobre o autor

Luciano Pimenta

www.lucianopimenta.net

sua necessidade seja por cobranças registradas e precise de uma ferramenta que gere os arquivos de remessa, sugiro verificar o CobreBemX, que é uma ferramenta mais completa.

Não quis indicar, qual a melhor para gerar boletos (classe free ou CobreBem), apenas mostrar os dois lados e deixar o leitor escolher aquele que atenda a sua necessidade. Um grande abraço a todos e sucesso em seus projetos!

dezembro 2010 29

Dicas DELPHIFORMATAÇÃO DE NÚMEROS COM ZEROS À ESQUERDA

Seguem 2 exemplos. O primeiro, no Delphi e o segundo no SQLServer.

No primeiro exemplo supõe-se que um número é digitado pelo usuário.

1) Abrir um projeto com um form, dois edits e um button (Standard) conforme figura abaixo.

2) No evento OnClick do button, insirir:

procedure TForm1.Button1Click(Sender: TObject);

begin

Edit2.Text := FormatFloat(‘000000’,StrToFloat(Edit1.Text));

//a quantidade de zeros se refere à quantidade de dígitos desejados.end;

No segundo exemplo, os números estão gravados em uma tabela em um banco de dados e se deseja incluir os zeros em todos os números já existentes e nos futuros também.

1) Criar uma tabela, por exemplo:

Create Table Zeros (Codigo int, Nome Varchar(50));

Insert into Zeros Values(2, ‘Antonio’);Insert into Zeros Values(4, ‘Bruno’);Insert into Zeros Values(12, ‘Eduardo’);Insert into Zeros Values(240, ‘Vitor’);Insert into Zeros Values(1200, ‘Marcos’);Insert into Zeros Values(20000, ‘Tassi’);

2) Para que sejam acrescentados os zeros à esquerda do Código, vamos utilizar a função Right do SQLServer.

RIGHT(TEXTO, N)

Retorna os últimos ‘N’ caracteres (da direita para a esquerda) do texto.

Select Codigo, RIGHT(‘00000’+CONVERT(VARCHAR, Codigo),5), NomeFrom ZerosOrder by RIGHT(‘00000’+CONVERT(VARCHAR, Codigo),5)

De ‘00000’ serão trazidos os 5 caracteres da direita pra esquerda, ou seja, se o número é 7, retorna 00007.

3) Que resultará em:

Código Nome00005 Antonio00007 Bruno00012 eduardo00150 Vitor01200 Marcos20000 Tassi

Uma grande utilidade para os inúteis zeros à esquerda.

dezembro 201030

dezembro 2010

dezembro 2010