junho 2009

junho 2009

junho 2009 03

Delphi Delphi

.NET Dicas Delphi Desafio The Club

Vitor M. Rodrigues

Delphi

índiceAplicação de outros idiomas em um mesmo projeto

Editorial Delphi

06Entre as muitas novidades do campo da informática que surgem todo dia, a que está chamando... 04

Plataforma de Serviços Azure

05Criando Interfaces e Métodos de classe no Delphi 2009 10

Lendo arquivos XML com TXMLDocument

14Diretivas de compilação - Parte II

18- Verificar se falta algum Edit para preencher- Verificar se a impressora está ligadaE mais... 24

Aplicação de outros idiomas em um mesmo projeto

28Caça-Palavras

30LegendaInicianteIntermediárioAvançadoNão confunda modess com modem, o slot é diferente.

Momento de Reflexão

junho 200904

Bem-vindo

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

pelos seus respectivos proprietários.

Marcos César Silva - Editor Chefemarcos@theclub.com.br

Entre as muitas novidades do campo da informática que surgem todo dia, a que está chamando mais atenção no momento é a plataforma Windows de Serviços Azure, num artigo “jogo rápido” o consultor Vitor Rodrigues nos dá uma visão geral desta plata-

forma em seu artigo de abertura nos mantendo atualizados das novidades que vem surgindo.

Nos dias de hoje com a facilidade de comercializar sistemas pelo mundo a fora, consequentemente surge à necessidade de criar aplicações com idio-mas diferentes, para isto podemos usar um recurso do Delphi que embora antigo, ainda é muito pouco conhecido e explorado que é a utilização de idiomas diferentes na mesma aplicação. Em seu artigo o consultor Marco Antonio, aborda de forma simples como utilizar este recurso que pode ser muito útil e produtivo.

Neste mês o consultor Antonio Spitaleri Neto vem com o artigo “Criando Interfaces e Métodos de classe no Delphi 2009”, neste artigo ele explora a linguagem Object Pascal usando conceitos de Orientação a objetos.

No último ano um dos assuntos mais discutidos na área da programação foi o desenvolvimento de soluções para Notas Fiscais Eletrônicas, como sabemos para “começo de conversa”, um das primeiras coisas que o de-senvolvedor precisa saber é como manipular arquivos XML no Delphi, neste mês em seu primeiro artigo para nossa revista Jonas Kirch escreve sobre leitura de arquivos XML usando TXMLDocument, um artigo de referencia inicial bastante importante.

Dando continuidade em seu artigo de Diretivas de Compilação, o con-sultor Luís Alexandre de Oliveira, finaliza a lista de opções de compilação, e também dá continuidade ao artigo sobre Silverlight escrevendo o artigo “SilverLight utilizando Datagrid”.

Aproveitem esta edição e continuem mandando sugestões de artigos para as próximas edições, um grande abraço 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

Copyright The Club Megazine 2009

Diretor TécnicoMarcos César Silva

Diagramação e ArteVitor M. Rodrigues

RevisãoMarcos César Silva

ColunistasAntonio Spitaleri Neto

Jonas KirchLuís Alexandre de OliveiraMarco Antonio Armando

Marcos César SilvaVitor M. Rodrigues

Impressão e acabamento:GRIL - Gráfica e EditoraRua São Paulo, nº 447

Cep: 18740-00 - Taquarituba-SPTel. (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.

junho 2009 05

vitor M. Rodrigues

A Plataforma de Serviços Azure da Microsoft consiste em um grupo de tecnologias da nuvem, que fornece um conjunto específico de serviços para desenvolvedo-

res de aplicativos. Muito se comenta sobre o “Windows Azu-

re” e mesmo assim ainda existem pessoas pensando que se trata do “Windows 7” o que não é verdade.

O “Windows Azure” é apenas um dos componentes dessa plataforma para exe-cução de aplicações na nuvem voltada aos desenvolvedores. Imagine você programar e armazenar seus projetos diretamente na web, resumindo é isso.

A Microsoft fornece os datacenters com toda a estrutura de armazenamento, softwares e o mais importante, processamento.

Isso faz com que os desenvolvedores não precisem se preocupar em adquirir máquinas com grande poder de processamento, instalar softwares e espaço em disco. Você precisará apenas de um computador com um browser e uma boa conexão de internet. O restante fica

por conta da Microsoft.Confesso que quan-

do comecei estu-dar sobre assunto fiquei com o “pé

atrás”. Afinal, esta-ríamos nos tornando

mais dependentes ainda. “- E se ficarmos

sem internet?” essa foi a primeira questão

levantada quando con-versei com o pessoal

aqui no escritório sobre o assunto. “- Que garantias teremos sobre a proteção de nossos projetos?” essa foi outra questão bastan-te citada.

Claro que são ques-tões que devem ser

Plataforma de Serviços Azurelevantadas, mas não podemos deixar isso se tornar uma paranóia.

Se voltarmos uns 15 anos, vamos nos lembrar que quando falávamos em implantar um sistema em alguma empresa, uma das pri-meiras questões era. “- E se acabar a energia como eu fico?” isso acontecia principalmente em cidades do interior onde a queda de energia era uma constante.

Os componentes da Plataforma de Servi-ços Azure podem ser usados por aplicativos locais executados em uma variedade de sistemas, inclusive vários tipos de sistemas operacionais Windows, dispositivos móveis ou outros. Esses componentes incluem:

Windows Azure: Fornece um ambiente baseado no Windows para executar aplicativos e armazenar dados nos servidores dos centros de dados da Microsoft.

Microsoft .NET Services: Oferece serviços de infra-estrutura distribuídos para aplicativos baseados em nuvem e locais.

Microsoft SQL Services: Fornece serviços de dados na nuvem baseados no SQL Server.

Live Services: Através do Live Fra-mework, fornece acesso aos dados a partir de aplicativos Live da Microsoft e outros. O Live Framework também permite sincronizar esses dados em estações de trabalho e dis-positivos, encontrando e fazendo o download de aplicativos, e muito mais.

Fiquem atentos, pois essa parece ser uma ótima saída para economizar em equipamen-tos e poupar tempo.

Caso queiram saber mais sobre o Azure acesse a URL: http://www.microsoft.com/azure/default.mspx

Aquele abraço e beijo nas crianças!

junho 200906

Delphi

Neste artigo, será demonstrado como o Delphi permite que um mesmo projeto, possa ser aplicado vários idiomas (Inglês, Espanhol, etc).

Para que o projeto de exemplo funcione corretamente, é altamente recomendável que as nomenclaturas dos componentes, quanto as Units, quando confeccionado pela primeira vez, acompanhe as descritas aqui.

Assim num primeiro momento, daremos inicio, construindo nosso projeto. Abra o Delphi, clique em “File” – “New” – “Application”. Nomeie o form, na propriedade name como “frmFuncionários”, e no caption do mesmo, insira “Funcionários”.

Completando, insira no form, um componente label, nomeando-o como “lbNome” e seu caption será “Nome”, na sequência, insira um Edit, e no Name, insira como “edNome”, e finalmente adicionaremos um componente Button, onde atribuiremos em Name, “btSalvar”, e em seu caption “Salvar”. Assim nosso projeto ficará como

Aplicação de outros Idiomas em um mesmo Projeto

na figura 1:

Salve o projeto nomean-do a Unit como “unFuncio-narios”, e por fim o projeto “Funcionarios”.

Neste ponto em diante, iremos trabalhar com os recursos de idioma, assim clicaremos em: Project – Languages – Add, aparecerá a seguinte mensagem, con-forme a figura 2:

Figura 1.

Figura 2.

junho 2009 07

Clicaremos em “Yes”, na sequência será apre-sentada a tela conforme a figura 3, clicaremos em “Next”, pois existe a opção de aplicar o recurso de idiomas a vários projetos de uma vez só, mas não será objeto neste artigo:

Veja a imagem Figura 3

Posteriormente aparecerá a tela conforme a figura 4, selecion “Inglês (Estados Unidos), clique em “Next”:

Veja a imagem Figura 4

O idioma selecionado será mostrado na tela seguido do projeto ao qual ele será aplicado, clique em “Next”, uma semelhante a figura 5, será mostrada:

Veja a imagem Figura 5

Uma nova tela será apresentada, mostrando onde a instância será criada, de acordo com idioma selecionado, de acordo com a figura 6:

Veja a imagem Figura 6

Finalmente, uma tela será disponibilizada, clique em “Finish”, conforme a tela 7:

Veja a imagem Figura 7

Ao clicar em “Finish” a mensagem: “This pro-ject needs to be compiled for the Resource DLL Wizard to finish. Compile the Project?, clique em “Yes” para concluirmos a inserção do recurso de Idioma . Ao término o compilador exibirá o que foi processado no projeto, veja na figura 8:

Figura 8

Por fim, o Delphi pedirá para seja salvo um novo Project Group, salve como “Idiomas”.

Abrindo o Windows Explorer, e abrindo a Pasta na qual foi salva o Projeto que criamos, verificare-

Figura 3.

Figura 4.

Figura 5.

Figura 6.

Aplicação de outros Idiomas em um mesmo Projeto

junho 200908

mos que foi criada uma nova pasta de nome “ENU”, a qual é uma cópia do projeto original e conterá as informações do outro idioma nela inseridas.

Continuando, feche o projeto. Clique em File – Open e vá para a pasta na qual esta nosso projeto e acesse a pasta “ENU” e abra o projeto “Funcionarios.dpr”. Clique agora em View – Trans-lator Manager abrirá uma tela conforme a figura 9 abaixo:

Veja a imagem Figura 9

Assim a cada coluna obedece a seguinte ordem:

Coluna 1 ( Quadro Vermelho) – Vermelho é a condição inicial quando o quadrado estiver cinza e indica que houve alteração; alteração;

Coluna 2 (ID ou Componentes do Form) - In-dica a propriedade dos componentes do Form. No nosso caso alteraremos apenas as propriedades Caption;

Coluna 3 (Português (Brasil) ) - Coluna com as propriedades do Projeto Original;

Coluna 4 (Status) - Indica se está traduzido, se não está traduzido ou então se não será tra-duzido;

Coluna 5 (Inglês (Estados Unidos)) - Essa coluna utilizaremos para fazer alterações das propriedades Caption dos componentes;

Agora iremos modificar a propriedade “Cap-tion” de cada componente, de acordo com o idioma. Assim indo para a coluna “ID”, vamos localizar frmFuncionarios.Caption. Na coluna “Inglês – Estados Unidos”, mude a propriedade Caption para “Employee”.

Repita o mesmo para o componente frmFun-cionario.lbNome, mudando para “Name”. Faremos o mesmo para o componente Button, alterando seu Caption para “Save”.

Feita as alterações como indicado, clique em View – Project Manager, será disponibilizada uma tela, semelhante a figura 10:

Figura 10

Clique com o botão direito do mouse sobre Funcionarios.exe, e clique em “Compile”. Repita essa mesma operação para Funcionarios.ENU.

Finalizando nosso trabalho, vamos compilar os projetos para verificar o resultado. Assim para “rodar” o projeto em Português basta apenas

pressionar a tecla F9. Para rodar o projeto em in-glês clique em Project – Languages – Set Active, e selecione Inglês(Estados Unidos) e posteriormente em “Finish”. Pressione F9 e veremos nosso projeto compilado em Inglês como na figura 11:

Figura 11

Conclusão Como podemos observar, o Delphi nos ofe-

rece essa excelente opção quando necessitamos desenvolver uma mesma aplicação em vários idiomas, o que em um mundo globalizado, como vivemos hoje, é circunstância que poderemos nos deparar.

Espero ter ajudado.

Até uma próxima oportunidade.

Sobre o autor

Marco Antonio ArmandoConsultor Técnico The club

Figura 9.

junho 2009 09

junho 200910

A plataforma de desenvolvimento Delphi 2009 e sua linguagem Object Pascal oferecem total suporte ao desenvolvimento utilizando o paradigma de orientação a objeto, porém esse suporte ainda é pouco utilizado em sua totalidade pelos desenvolvedores que utilizam o Delphi. Isso decorre do fato de que além do Delphi já oferecer recursos de orientação a objeto encapsulados em sua VCL que facilitam a vida do programador, a programação orientada a objeto abrange uma gama extensa de conceitos que talvez não despertem o interesse dos especialistas em automação comercial.

Entre os conceitos presentes na orientação a objeto dois que raramente são foco do interesse dos programadores sem dúvida são as interfaces e os métodos de classe. Nesse artigo estarei mos-trando como podemos criar e utilizar interfaces e métodos de classe no Delphi 2009 e explicando melhor o que são esses conceitos e assim procurar desmitificá-los um pouco.

Criando Interfaces

e Métodos de classe

no Delphi 2009

Interfaces

Quando se utiliza classes e herança se conse-gue até certo ponto uma padronização do sistema já que se pode criar uma classe base com poucos atributos e métodos e conforme a necessidade es-tender as funcionalidades dessa classe nas classes descendentes. Porém a padronização esbarra em um problema: As classes descendentes não estão obrigadas a seguir a risca o escopo da superclasse, isso pode deixar o sistema um pouco complexo para os programadores encarregados de executar a manutenção do mesmo.

Nesse contexto, a utilização de interfaces pode ser uma possível solução para o problema apresentado. E o que são interfaces?

Interfaces são como classes, porém com duas diferenças fundamentais: A primeira é que os mé-todos declarados na interface são obrigatoriamente abstratos, ou seja, serão implementados apenas nas classes descendentes. A segunda é que as classes descendentes da interface são obrigadas a implementar todos os métodos prototipados na interface, ou seja, a interface é como um contrato

que as classes descendentes precisam seguir, isso pode ser extremamente útil em termos de padro-nização do sistema.

Com o uso de interfaces, podemos definir um escopo base em nosso sistema e assim tornar o esquema de classes mais organizado.

Imaginemos agora que precisássemos criar um módulo para um sistema comercial que fosse ex-tensível, ou seja, outros programadores poderiam acrescentar funcionalidades extras ao módulo, de acordo com a necessidade. Com classes e herança até poderíamos fazer isso, porém, conforme o módulo fosse sendo estendido, a não obrigatorie-dade do seguimento de uma regra faria com que a manutenção ficasse confusa e o acréscimo de novas funcionalidades mais difícil.Com interfaces, definiríamos um escopo base e assim as classes que viessem a ser incluídas teriam que seguir esse escopo. Sem dúvida em termos de padronização é um grande ganho.

É claro que a princípio fica um tanto abstrato imaginar as situações em que o uso de interfaces seria produtivo, isso porém ficará mais claro à

junho 2009 11

Criando Interfaces

e Métodos de classe

no Delphi 2009

medida que o programador for se familiarizando com a idéia de por trás da utilização da orientação a objeto em seus projetos.

Para simplificar, estarei mostrando a seguir como declaramos interfaces e como elas devem ser utilizadas, isso já será útil para que a idéia seja melhor compreendida.Mãos a obra:

A declaração de interfaces no Delphi é muito semelhante à declaração de classes, no exemplo vamos implementar uma interface denominada ICalculadora que como o nome sugere, conterá métodos e propriedades que serão utilizados em cálculos. Veja a declaração:

type ICalculadora = Interface function getResult : double; procedure setResult

( value : double ); procedure calculate ( x, y : double ); property result : double read getResult write setResult; end;

É importante lembrar que todas as assinaturas de métodos em uma interface são públicas, além disso, não existem variáveis ou atributos internos apenas métodos e propriedades.

Outra consideração, talvez a mais importante, os métodos da interface são apenas prototipados, nunca implementados, a tarefa de implemen-tação será delegada as classes descendentes da interface.

Iremos agora criar as classes que farão referen-cia a interface Icalculadora e serão as responsáveis

por implementar os métodos prototipados. Serão duas classes: TSoma e TDivisao.Vamos ao código:

TSoma = class ( TInterfacedObject, ICalculadora )private fResult : double;protected function getResult : double; procedure setResult ( value : double ); procedure calculate ( x, y : double );end;TDivisao = class ( TInterfacedObject, ICalculadora )private fResult : double;protected function getResult : double; procedure setResult ( value : double ); procedure calculate ( x, y : double );end;

Como podemos observar além da interface ICalculadora, as classes tambem herdam de TInter-facedobject que é a classe que define o comporta-mento das interfaces e suas classes descendentes em Delphi.

Agora temos que implementar os métodos separadamente em cada classe já que, como dito anteriormente, as classes precisam seguir o “con-trato” definido na interface. Veja a implementação dos métodos:

function TSoma.getResult: double;begin result := Self.fResult;end;procedure TSoma.setResult(value: double);begin

junho 200912

self.fResult := value;end;function TDivisao.getResult: double;begin result := Self.fResult;end;procedure TDivisao.setResult(value: double);begin Self.fResult := value;end;procedure TSoma.calculate(x, y: double);begin setResult ( x + y );end;procedure TDivisao.calculate(x, y: double);var r : double;begin if ( y = 0 ) then begin setResult ( 0 ); raise exception.Create ( “Divisão por zero” ); end; setResult ( x / y );end;

Repare que o método calculate é implemen-tado de forma independente nas duas classes. A interface define apenas a assinatura do método e a implementação fica por conta das classes descendentes.

Vamos agora criar um pequeno projeto para ilustrar o uso da interface ICalculadora e de suas duas classes descendentes:

Inicie uma nova aplicação no Delphi 7 e inclua uma nova unit, salve a unit do formulário com o nome default e a unit incluída no projeto como uninterface.

Na uninterface, coloque as declarações da in-terface ICalculadora e das classes TSoma e TDivisão conforme mostrado no artigo.

Agora, monte o único formulário do nosso

exemplo conforme mostrado na figura 01: No evento onclick do botão “calcular” faça:

procedure TForm1.btncalcularClick(Sender: TObject);var x, y: double; calc : ICalculadora;begin x := strToFloat ( edit1.text ); y := strToFloat ( edit2.text ); try case grpOp.itemIndex of 0 : calc := TSoma.Create; 1 : calc := TDivisao.Create; end; calc.calculate( x, y ); showMessage ( floatToStr ( calc.result ) ); except raiseend;end;

Criamos a variável calc do tipo ICalculadora para servir como uma referência genérica à todas as classes que descendem da interface, com a variável calc também obtemos o resultado através

da propriedade result da interface.

Apesar do exemplo simples, o leitor já poderá constatar que o uso de interfaces é um recurso valioso quando se trabalha com orientação a objetos.

Métodos de classe

Quando se trabalha com orientação a objeto, os métodos são parte fundamental do desenvolvi-mento do sistema, utilizando o encapsulamento, agrupamos métodos e os dados que eles necessi-tam para funcionar em classes e depois, através de instâncias dessa classe, utilizamos esses métodos. Claro que a boa prática de programação nos diz que, uma vez que um método de uma classe não precise mais ser utilizado, devemos liberar a ins-tância da classe de memória.

Até aí sem segredos, porém a necessidade de liberarmos de memória a instância da classe a cada vez que o método não é mais necessário pode se tornar um incoveniente em determinadas situações. Imagine que em seu projeto exista um método em uma classe que faça a leitura de um arquivo de configuração e que esse método fosse utilizado várias vezes no projeto, nesse panorama estaríamos diante de um problema: Toda vez que precisássemos utilizar o método teríamos que criar uma instância da classe, utilizar o método e após isso liberar de memória a instância criada. Imagine ter de fazer isso várias vezes, sem dúvida não seria uma boa estratégia de programação.

Os métodos de classe são uma boa alternativa nesses casos. Esses métodos especiais não reque-rem que uma instância da classe ao qual pertencem

Figura 01

junho 2009 13

seja criada para que possamos utilizá-los. Sem dúvida no caso citado anteriormente o uso de métodos de classe vem de encontro ao problema da inprodutividade que instanciar e liberar de memória a instância da classe criada.

Um bom exemplo de uso dos métodos de classe em Delphi é a classe TObject, a classe mais alta na hierarquia das classes Delphi. Como se trata da classe mais básica, muitos de seus métodos precisam ser utilizados sem que uma instância de TObject seja criada, devido a isso esse métodos são declarados como métodos de classe.

É claro que o uso de métodos de classe é boa estratégia, porém deve ser utilizada em casos que a situação e as boas práticas de programação exigem. Assim como o uso das interfaces, a utilização de métodos de classe se bem aproveitada sem dúvida deixará o código de seus projetos muito mais limpo e organizado.

Vamos agora a um pequeno exemplo para ilustrar a situação anteriormente exposta. Um mé-todo de leitura em um arquivo de configuração que verifica se uma variável de ambiente e caso essa variável esteja com o valor true, o método retorna alguns valores desse arquivo de configuração. Esse método será utilizado no aplicativo a cada vez que um formulário for ativado, devido a isso o nosso método será declarado como um método de classe para que não precisemos instanciar e liberar de memória a classe que contém o método. Mãos a obra!

Primeiro, a declaração da classe com o mé-todo:

TRead=class Class function learquivo(variavelambiente:boolean):string;End;

Repare na declaração do método, incluímos a palavra class antes da declaração para indicar que esse é um método de classe e será utilizado sem que uma instância da classe TRead seja criada.

Vamos agora à implementação do método:

Class function TRead.learquivo(variavelambiente:boolean):string;Var arquivo:tinifile; valor:string;Begin If variavelambiente then Begin arquivo:=tinifile.create(‘configuracao.ini’); valor:=arquivo.readstring(‘confvalor’,’confvalor’,’’);Result:=valor; End; End;

Para chamarmos esse método nos eventos necessarios, bastaria fazer:

TRead.learquivo(nomevariavel);

Repare que com apena uma linha realizamos a chamada ao método da classe sem a necessidade de instanciá-la.

Isso também mostra a diferença que existe

Sobre o autor

Antonio Spitaleri Neto

Consultor Técnico The club

antonio@theclub.com.br

quando trabalhamos com orientação a objeto entre esses métodos de classe e os métodos tradicionais, chamados métodos de instância que requerem um objeto criado para serem utilizados.Essa diferen-ciação também é de grande importância quando vamos planejar as classes de nosso sistema

Conclusão

Métodos de classe são um recurso valioso da orientação a objeto, porém é importante lembrar que nem todos os métodos incluídos nas classes de um sistema podem ser declarados dessa forma apenas para poupar código. O programador deve analisar com cuidado quais métodos são mais adequados para serem utilizados como métodos de classe. Geralmente, métodos que não utili-zam ou dependem de atributos de sua classe e que irão ser utilizados em vários eventos são os mais indicados para serem métodos de classe. Já métodos que fazem uso de atributos da classe ao qual pertencem e que fazem chamadas a outros métodos da mesma classe devem ser declarados com métodos de instância.

Com relação as interfaces, devemos ter em mente que para utilizarmos esse conceito devemos antes fazer um “desenho” das classes do sistema e detectar a possível necessidade dessas classes seguirem uma regra de negócio. Caso haja essa ne-cessidade, a criação de uma interface é altamente recomendada para conter essa regra de negócio.

Nesse artigo procurei através de exemplos simples mostrar que esses dois conceitos: Métodos de classe e interfaces, são relativamente simples de se utilizar e são de grande ajuda em nossos projetos.

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

junho 200914

Introdução:

Atualmente com o avanço da tecnologia cada vez mais nós desenvolvedores temos a neces-sidade de trabalhar com arquivos xml. O caso mais recente é o XML

da Nota Fiscal Eletrônica e com base nisso vamos mostrar como ler essas informações usando o componente TXMLDocument.

Primeiro vamos criar um projeto novo e adicionar os seguintes componentes:

• Label1 : TLabel;• edArquivo : TEdit;• btnAbrir :TButton;• OpenDialog1 : TOpenDialog;• btnDados : TButton;• Memo1 : TMemo;

Podemos montar algo semelhante a figura 1. Agora vamos configurar o botão btnAbrir, que

será usado para escolher o arquivo xml.

No evento OnClick adicione o seguinte có-digo:

if OpenDialog1.Execute then edArquivo.Text := OpenDialog1.FileName;

Agora na clausula uses do projeto vamos adi-cionar a unit XMLDoc e XMLIntf

Figura1. Layout do formulário.

O próximo passo é configurar o botão btnDa-dos que será responsável por mostrar os Produtos da Nota Fiscal Eletrônica presentes no arquivo xml selecionado, e apresenta-los no Memo1. Para isso vamos colocar o seguinte código no evento OnClick:

Veja o Código 01.

junho 2009 15

var oXML : TXMLDocument; noNota,noDet,noProd : IXMLNode; vCodProd,vCodBarra,vNomeProd : string;begin if edArquivo.Text = ‘’ then begin MessageDlg(‘Primeiro selecione o arquivo XML.’,mtInformation,[mbOk],0); Exit; end;

oXML := TXMLDocument.Create(self); Try oXML.LoadFromFile(edArquivo.Text); Memo1.Lines.Clear;

// dados da nota noNota := oXML.DocumentElement.childNodes.First.ChildNodes.First.ChildNodes.FindNode(‘ide’); Memo1.Lines.Add(‘---------------------------------------------------------’); Memo1.Lines.Add(‘ DADOS DA NOTA FISCAL’); Memo1.Lines.Add(‘---------------------------------------------------------’); Memo1.Lines.Add(‘Nro Nota :’+noNota.ChildNodes[‘nNF’].Text); Memo1.Lines.Add(‘Série: ‘+noNota.ChildNodes[‘serie’].Text); Memo1.Lines.Add(‘---------------------------------------------------------’); Memo1.Lines.Add(‘ PRODUTOS’); Memo1.Lines.Add(‘---------------------------------------------------------’);

// dados dos produtos noDet := oXML.DocumentElement.childNodes.First.ChildNodes.First.ChildNodes.FindNode(‘det’); noDet.ChildNodes.First; // looping na tag <det> do xml repeat noProd := noDet.ChildNodes.FindNode(‘prod’);

// pega os dados do produto e armazena nas variaveis. if noProd <> nil then begin vCodProd := noProd.ChildNodes[‘cProd’].text; if noProd.ChildNodes[‘cEan’].IsTextElement then vCodBarra := noProd.ChildNodes[‘cEan’].text; vNomeProd := noProd.ChildNodes[‘xProd’].text; // adiciona o produto no memo Memo1.Lines.Add(‘ ‘+vCodProd+’ - ‘+vCodBarra+’ - ‘+vNomeProd ); end;

// vai para a proxima ocorrência <det> noDet := noDet.NextSibling; until noDet = nil; Except oXML.Free; end;end;

Cíódigo 01

junho 200916

Com isso finalizamos nossa aplicação. O resul-tado deve ser semelhante ao da figura2.

Veja a Figura 02.

Conclusão:

Nesse artigo vimos como ler os dados de um xml usando o componente TXMLDocument. O exemplo usado pode ser facilmente adaptado para gerar rotinas de entrada das Mercadorias no Estoque, muito útil no dia a dia em aplicações para automação comercial.

Figura2. Aplicação final.

Sobre o autor

Jonas Kirch

É membro da equipe de desenvolvimento da Office System Informática Ltda, que atua no mercado há mais de 15 anos e possui diversas soluções na área de TI ( www.offi-cesystem.com.br )

junho 2009 17

Bem, chegamos a segunda e última parte sobre as principais diretivas de compilação.

$EXTENDEDSYNTAX

Diretiva obsoleta, mantida apenas para compatibilidade retroativa. Permite definir uma chamada de função como se fosse uma chamada de procedure e ignorar o resultado da função. Também permite suporte para strings termi-nadas em nulo.

O mesmo que {$X+|-}.

{$EXTENDEDSYNTAX on} ou {$EXTENDEDSYNTAX off}

Exemplo:

Antes do nome da unit adicione {$ExtendedSyntax on}.

Exemplo:

{$ExtendedSyntax on}unit Unit1;procedure TForm1.Button1Click(Sender: TObject);begin GetValue;end;function TForm1.GetValue: Integer;begin Result:= 1;end;

Agora para chamar uma função como se fosse uma procedure, altere {$ExtendedSyntax Off} para {$ExtendedSyntax on} .

$H

Controla o significado da palavra reservada string quando usada sozinha em uma declaração de tipo. Se habilitada {$H+}, converte-a em um tipo An-siString; se desabilitada {$H-}, em ShortString, ou seja, cria-se dois tipos de string com o mesmo código.

DIRETIVAS DE COMPILAÇÃOParte II

junho 200918

var i,j: Integer;beginvar i,j: Integer;begin // Hints ativado {$Hints On} // atribui-se i a um valor conhecido i := 234;end;

Exibição do hint: [Hint] Unit1.pas(40): Value assigned to ‘i’ never used [Hint] Unit1.pas(34): Variable ‘j’ is declared but never used in ‘TForm1.

FormCreate’

Exemplo com Hint desativado

var i,j: Integer;begin // Hints desativado {$Hints off} // atribui-se i a um valor conhecido i:= 234;end;

procedure TForm1.Button2Click(Sender: TObject);var// Define uma string curta {$H-} littleString: string; // Define uma string longa {$H+}bigString : string;begin// Exibe o tamanho de uma string curta ShowMessageFmt(‘String pequena = %d’,[SizeOf(littleString)]); // Exibe o tamanho de uma string longa ShowMessageFmt(‘ String longa = %d’,[SizeOf(bigString)]);end;

$Hints

Emite (on) ou não (off) mensagens de dicas quando detectar variáveis e atribuições não utilizadas, laços for ou while que nunca serão executados e assim por diante.

Exemplo $ Hints on - gera mensagem que a variável j nunca será utili-zada

junho 2009 19

$I NomedoArquivo

Inclui o arquivo especificado na compilação (extensão defautl = pas)

$IfDef

Compila o código fonte até encontrar a diretiva {$Else} ou {$ENDIF} se o nome especificado não estiver definido.

Exemplo:

var text: string;begin // modo teste {$Define modoteste} text:= ‘Estamos no modo teste’; // Exibe um valor se estamos em modo texto {$IfDef modoteste} ShowMessage(‘teste = ‘+text); {$EndIf} // “desativa” modo teste {$UnDef modoteste} // Exibe um valor se estamos em modo texto {$IfDef modoteste} ShowMessage(‘teste = ‘+text); {$Else} ShowMessage(‘Não estamos em modo teste’); {$EndIf}end;

$J

O mesmo que $WRITEABLECONST.

$ L nomearquivo

Efetua a linkedição do arquivo OBJ especificado com o programa ou unit que estiver sendo compilada. Utilizado para linkeditar código escrito em outras linguagens para procedures e funções declaradas como external.

$LINK nomedoarquivo

O mesmo que {$L nomearquivo}

$MINENUMSIZE

Define o armazenamento mínimo de tipos enumerados

{$MINENUMSIZE 1} OU {$MINENUMSIZE 2}OU {$MINENU-MSIZE 4}

Exemplo:

type {$MinEnumSize 1} TCars1 = (Rover, Jaguar, Honda); //1 byte

junho 200920

TFruit1 = (Banana=255, Apple, Pear); // excede 1 byte {$MinEnumSize 4} TCars2 = (Ford, Nissan, Vauxhall); // 4 bytes TFruit2 = (Orange=255, Plum, Grape); 4 bytesBegin ShowMessage(‘TCars1 size = ‘+IntToStr(SizeOf(TCars1))); ShowMessage(‘TFruit1 size = ‘+IntToStr(SizeOf(TFruit1))); ShowMessage(‘TCars2 size = ‘+IntToStr(SizeOf(TCars2))); ShowMessage(‘TFruit2 size = ‘+IntToStr(SizeOf(TFruit2)));end;

$O e $Optimization

Efetua a otimização do código de máquina gerado. Corresponde á opção ProjetcOptionCompilerCode GenerationOptimization.

{$O+} ou {$O-}

$OVERFLOWCHECKS

Verifica a ocorrência de estouro (overflow) em operação com inteiros. Normalmente utilizada junto à diretiva {$R+|-}. A utilização da diretiva $Q torna mais lenta a execução e aumenta o tamanho do programa. Deve ser utilizada somente para depuração.

{$Q+} ou {$Q-}

Exemplo Captura de overflows

var Mumero: Byte;begin // verificação de overflow {$OverFlowChecks On} // um byte pode conter 255 Mumero:= 255; ShowMessage(‘Mumero = ‘+ IntToStr(numero)); // Mas se exceder 255 ocorrerá uma exceção Inc(Mumero); ShowMessage(‘Mumero = ‘+IntToStr(numero));end; Exemplo: Ignorando OverFlowvar Mumero: Byte;begin // verificação de overflow {$OverFlowChecks off} // um byte pode conter 255 Mumero:= 255; ShowMessage(‘Mumero = ‘+ IntToStr(numero)); Inc(Mumero); ShowMessage(‘Mumero = ‘+IntToStr(numero));end;

junho 2009 21

$R

Verifica a ocorrência de estouro de índices em matrizes e strings. A uti-lização desta diretiva torna a execução mais lenta e aumenta o tamanho do programa. Deve ser utilizada somente para depuração.

{$R+} ou {R$-}

Exemplo: Verificando problemas com arrays

var vetor: array[1..5] of string; i: Integer;begin // ativo a checagem {$R+}//observe o índice for i := 0 to 5 do Begin Vetor[i] := ‘Elemento ‘+IntToStr(i); ShowMessage(‘Vetor[‘+IntToStr(i)+’] = ‘+Vetor[i]); end;end;Exemplo ignorando o problema com vetorvar vetor : array[1..5] of string; i : Integer;begin // desativo a checagem {$R-}

// observe o índice for i := 0 to 5 do begin Vetor[i] := ‘Elemento ‘+IntToStr(i); ShowMessage(‘Vetor[‘+IntToStr(i)+’] = ‘+Vetor[i]); end;

$RUNONLY (somente para .dpk)

Indica que o pacote onde a diretiva aparece deve ser compilado como pacote runtime.

{$RUNONLY on} ou {$RUNONLY off}

$U

Gera código que detecta a falha de projeto do processador Pentium em divisão de ponto-flutanate.

{$U +} ou {$U-}

$Warnings

Gera mensagens de advertência quando forem detectadas variáveis não inicializadas, resultado de funções ausentes, construções de objetos abstratos e assim por diante.

{$WARNINGS ON) ou ($WARNINGS OFF)

junho 200922

$WRITEABLECONST

Permite a atribuição a constant tipadas. O mesmo que $J.

{$WRITEABLECONST on} ou {$WRITEABLECONST off}

$X

O mesmo que {$EXTENDEDSYNTAX }

Para finalizar, segue uma simples rotina para desabilitar um formulário de autenticação que em fase de desenvolvimento se torna uma grande chateação.

{$IFDEF NOLOGIN}

CodigoUsuario := 1; NomeUsuario := ‘Meu Nome’;{$ELSE} if not Login(CodigoUsuario, NomeUsuario) then begin ShowMessage(‘Usuario inválido’); Application.Terminate; end;

{$ENDIF}

A princípio, o código entre {$IFDEF} e {$ELSE} será simplesmente ignorado pelo compilador, porque a diretiva NOLOGIN não existe ainda. Somente o código entre {$ELSE} e {$ENDIF} será executado, que seria o código regular para ambiente de produção.

Basta escrever NOLOGIN no campo “Conditional defines” de “Project | Options…”, dar um Build no seu projeto e a diretiva {$IFDEF NOLOGIN} será avaliada como verdadeira pelo compilador. Aí o código entre {$IFDEF} e {$ELSE} será compilado e o código entre {$ELSE} e {$ENDIF} é que será ignorado. Dessa forma podemos configurar o programa sem alterar o código e sem deixar vestígios do código de testes no executável de produção.

É importante entender que as diretivas de compilação são interpretadas em tempo de compilação, não de execução. As diretivas de compilação con-dicional só podem ser definidas nas opções do projeto (”Conditional defines”) ou no próprio código.

O uso de diretivas de compilação é útil quando precisamos frequentemente ativar e desativar blocos de código. É importante aproveitarmos ao máximo os recursos da ferramenta para podermos ganhar o máximo de produtividade.

Luís Alexandre de Oliveira é Técnologo em Processamento de Dados ,graduado pela Faculdade de Técnologia de Sorocaba, Consultor técnico do The Club.

Docente do curso técnico informática - Etec de Avaré e do curso Tecno-logia em Redes de Computadores - Fatec Eduvale – Avaré

Sobre o autor

junho 2009 23

junho 200924

Uma das coisas mais bacanas do Silverli-ght são os controles de formulário. Na edição anterior utilizamos alguns objetos como o TextBox e o Button. Existem vários controles, e nesse artigo vou demonstrar a utilização do controle DataGrid.

Crie um novo projeto em Silverlight (Silverlight Application). Vamos chamá-lo de DataGrid e clicar em Ok. Para o tipo de projeto escolha Web Site e clique em OK.

No arquivo Page.xaml, vá para o source XAML e posicione o cursor dentro da tag<Grid>. Vá para a Tollbox, escolha o objeto DataGrid e clique duas vezes sobre ele ou clique - arraste, como mostra a Figura 1. Fazendo isso a tab DataGrid é inserida no XAML e é feita a referência ao System.Windows.Controls.Data.

Veja a Imagem 1

SILVERLIGHT

Imagem 1

junho 2009 25

Na tag UserControl vamos colocar a altura com 400px e a largura com 900 px e criar o handler do evento load através do parâmetro Loaded (utilize o Intellisense). Por fim, vamos informar o name do DataGrid como dgClient. Seu código xaml ficará como mostra a listagem.

Veja a Listagem 1

Vamos criar uma nova classe chamada Cliente dentro da namespace DataGrid para servir de mapeamento. Na classe vamos definir o get e o set para cada campo do registro cliente. Veja a listagem 2.

Veja a Listagem 2.

De volta à classe Page, vamos criar uma lista, chamada source, para receber os dados de um laço de repetição. Vamos criar uma variável source base-ado numa classe que manipula a lista de valores.

Logo em seguida fazemos um loop para adicio-nar os registros na nossa lista de clientes. Por fim, a lista é referenciada como source do DataGrid. Veja o código na listagem 3.

<UserControl xmlns:data=”clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data” x:Class=”DataGrid1.Page” xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation” xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml” Width=”900” Height=”400” > <Grid x:Name=”LayoutRoot” Background=”White”><data:DataGrid x:Name=”dbClientes”> </data:DataGrid> </Grid>

Listagem 1 – Código xaml com o DataGrid

public class Dados { public string Nome { get; set; } public string Sobrenome { get; set; } public int Idade { get; set; } public bool Disponivel { get; set; }

}

Listagem 2 .Classe Cliente

junho 200926

Sobre o autor

Luís Alexandre de Oliveira é Téc-nologo em Processamento de Dados ,graduado pela Faculdade de Técnologia de Sorocaba, Consultor técnico do The Club.

Docente do curso técnico informática - Etec de Avaré e do curso Tecnologia em Redes de Computadores - Fatec Eduvale – Avaré

Veja a Listagem 3

Por fim vamos customizar o DataGrid, vá ao arquivo Page.xaml. Observe a listagem 4 com o código xaml.

Veja Listagem 4.

Vamos compilar (CTRL + F5) e ver o resultado na Imagem 2.

Veja a Imagem 2

Nesse artigo ficou claro que é simples e que podemos codificar de forma semelhante ao ASP.NET. ou no Windows Forms.

Fontes: Desenvolvendo para Web usando Visual Studio 2008 – Editora Brasport.

http://silverlight.net/GetStarted/

data:DataGrid x:Name=”dbClientes” AutoGenerateColumns=”True” GridLinesVisibility=”None” HeadersVisibility=”All” RowBackground=”Cornsilk” AlternatingRowBackground=”LemonChiffon” ColumnWidth=”85” RowHeight=”30” IsReadOnly=”True” CanUserResizeColumns=”False”> </data:DataGrid>

Listagem 4 – Efeitos na DataGrid

Imagem 2 – DataGrid Customizado

public Page() { InitializeComponent();

List<Dados> source = new List<Dados>(); int itemsCount = 100;

for (int i = 0; i < itemsCount; i++) { source.Add(new Dados() { Nome = “Primeiro”, Sobrenome = “Ultimo nome”, Idade = i, Disponivel = (i % 2 == 0) }); }

dbClientes.ItemsSource = source;

}

Listagem 3

junho 2009 27

junho 200928

Dicas DELPHIVerificar se falta algum Edit para preencher

function CheckForBlankText : Boolean ;// Declare-a na clausula Private do form//varn : LongInt ;beginResult := false ;for n := 0 to ( ComponentCount - 1 ) dobeginif ( components[n].ClassType = TEdit ) thenbeginif TEdit (components[n]).text = ‘’ thenbeginResult := true ;Exit;end;end ;end ;End;

Verificar se a impressora está ligada

function tbTestLPT(Port: byte): boolean;var Pto : Word; Rdo : byte;begin Pto := Port -1; asm MOV DX,Pto MOV AX,$0200 {AH := $02 : Leer el estado de la impresora} INT $17 MOV Rdo,AH {Guarda el estado en AL} end; Result := Rdo = 144;end;

Validar UF

function ValidarEstado(Dado : string) : boolean;constEstados = ‘SPMGRJRSSCPRESDFMTMS GOTOBASEALPBPEMARN CEPIPAAMAPFNACRRRO’;varPosicao : integer;beginResult := true;if Dado <> ‘ thenbeginPosicao := Pos(UpperCase(Dado), Estados);if (Posicao = 0) or ((Posicao mod 2) = 0) then beginResult := false;end; end;end;

Validar PIS

function vpis(Dado: String):boolean;vari, wsoma, wm11, wdv, wdigito: integer;beginif Trim(Dado) <> ‘ thenbeginwdv := StrToInt(copy(Dado, 11, 1));wsoma := 0;wm11 := 2;for i := 1 to 10 dobeginwsoma := wsoma + (wm11 * StrToInt(Copy(Dado, 11 -i, 1)));if wm11 < 9 thenwm11 := wm11 + 1elsewm11 := 2;end;wdigito := 11 - (wsoma mod 11);

junho 2009 29

if wdigito > 9 thenwdigito := 0;if wdv = wdigito thenbeginApplication.MessageBox(‘O valor informado é válido!’, ‘Aviso!’, mb_IconStop+mb_ok);vpis := True;endelsebeginApplication.MessageBox(‘O valor informado não é válido!’, ‘Atenção!’, mb_IconStop+mb_ok);vpis := false;end; end; end;

Verificar ultimo dia útil do mês

function UltimoDiaDoMes( MesAno: string ): string;varsMes: string;sAno: string;beginsMes := Copy( MesAno, 1, 2 );sAno := Copy( MesAno, 4, 2 );if Pos( sMes, ‘01 02 03 04 05 06 07 08 09 10 11 12’ ) > 0 thenUltimoDiaDoMes := “31”else if sMes <> ‘02’ thenUltimoDiaDoMes := ‘30’else if ( StrToInt( sAno ) mod 4 ) = 0 thenUltimoDiaDoMes := ‘29’elseUltimoDiaDoMes := ‘28’;end;

Trocar as cores dos botões de um RadioGroup

No Object Inspector na propriedade Font coloque a cor verde.

procedure TForm1.RADIOGROUP1Click(Sender: TObject);

Vari : Integer;begin// Para trocar as cores dos botoes do RadioGroupfor i := 0 to RADIOGROUP1.Items.Count-1 do beginTRadioButton(RADIOGROUP1.Controls[i]).Font.Color := clGreen;TRadioButton(RADIOGROUP1.Controls[i]).Font.Style := [fsBold];end;TRadioButton(RADIOGROUP1.Controls[RADIOGROUP1.ItemIndex]).Font.Color := clRed;TRadioButton(RADIOGROUP1.Controls[RADIOGROUP1.ItemIndex]).Font.Style := [fsBold];end;

Tirar os espaços no inicio e final de uma string

Function Trim(J:String):String; Export; BeginWhile J[Length(J)]=#32 do Dec(J[0]);If Length(J)>1 thenWhile (J[1]=’ ‘) doBeginDelete(J,1,1);If Length(J)<=1 then J:=’’;end;Result:=J;end;

Anuncie

conosco

Solicite um orçamento:

Skype: theclub_cadastro

E-mail: cadastro@theclub.com.br

Fone: (14) 3732-1529

Anuncie na revista e ganhe um

banner publicitário no site do The Club

junho 200930

junho 2009

junho 2009