novembro2013

novembro2013

novembro2013 03

Autor: Thiago C. Montebugnoli

27

13

Autor: João Marcos SakalauskaÍndice

Editorial

04

08

Autor: Hamden Vogel

05

Autor: Luciano Pimenta

20Criando fomulário de layout padrão - Delphi 7

Autor: Lucas Vieira de Oliveira

Criando aplicações com o Ribbon

TFileHV:Gerenciamento Básico de Arquivos – Parte 2

Desenvolva uma Aplicação Desktop em C# e MySQL – Parte 4

SoapUIFerramenta para Open Source para consumir Web Services

novembro201304

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

pelos seus respectivos proprietários.

Thiago Montebugnoli - Editor Chefethiago@theclub.com.br

Olá amigos do The Club, é sempre com muita satisfação e alegria que preparamos mais uma revista recheada de assuntos interessantes aos senhores. Começando com nosso consultor técnico Lucas de Oliveira, que aborda um assunto de grande utilidade no desenvolvimento de aplicações Desktop, como devemos criar um Formulário de Layout Base utilizando o Delphi 7, podendo ser englobada em todas as versões do Delphi. Hamden Vogel finaliza o artigo “TFileHV – Gerenciamento Básico de Arquivos”. Um dos tópicos desta segunda parte ele nos ensina a realizar uma Conexão com o servidor FTP via “TFileHV”, muito útil para quem necessita deste recurso em seus programas. Nosso colaborador Luciano Pimenta utiliza o Ribbon, um estilo incorporado pela Microsoft na suíte Office desde versões anteriores do Delphi. Este recurso nos permite incorporar estilos elegantes e diferentes em suas aplicações. João Marcos Sakalauska finaliza sua série de artigos de desenvolvimento de uma aplicação Desktop em C# junto com o Banco de Dados Mysql. Nesta quarta parte ele disponibiliza a aplicação completa para download para quem deseja aprender um pouco mais sobre esta tecnologia. Para Finalizar nossa série de artigos, apresento uma ferramenta Freeware chamada “SoapUI”, muito indicada para Consumir e testar diversos tipos de Web Services.

Fiquem a vontade para nos dar sugestões de artigos e dicas para artigos futuros.

Vou Ficando por aqui, um forte abraço e até o mês que vem!

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

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

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 2013

Diretor TécnicoMarcos César Silva

DiagramaçãoVitor M. Rodrigues

DesignVitor M. Rodrigues

RevisãoDrielly Cristini Patrinhani

ColunistasHamden Vogel

Jeferson Silva de LimaLuciano Pimenta

Thiago Cavalheiro Montebugnoli

JuninhoJeferson Silva de Lima

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.

Editorial

novembro2013 05

Ribbon é um estilo incorporado pela Microsoft na suíte Office a partir da versão 2007. A ideia era agrupar várias funciona-lidades em uma mesma barra de ferramenta para facilitar a vida do usuário. Além disso, possui um menu para concentrar as funcionalidades mais acessadas da aplicação.

O Delphi possui suporte ao Ribbon a partir da versão 2009. Vou mostrar neste artigo como usar das facilidades do Ribbon no Delphi. Veja na Figura 1 os controles que compõem a paleta Ribbon Controls da Tool Palete.

Figura 1. Ribbon Controls

Crie um novo projeto VCL. O trabalho principal esta concentrado no ActionManager, que irá disponibilizar as ações (itens), para adicionarmos no Ribbon. Adicione o controle em tela, assim como um ImageList. Escolha as imagens de sua preferencia.

Configure o ImageList com a propriedade Images do ActionManager. Adicione um Ribbon ao formulário (Figura 2).

Criando aplicações com o Ribbon

Figura 2. Ribbon adicionado no formulário

Para criar um grupo (RibbonPage), basta clicar com o botão direito e esco-lher Add Tab. Na aba, temos as propriedades para sua configuração (Caption, Hint etc), semelhante ao TabSheet do PageControl. Dentro da aba, podemos adicionar os grupos (RibbonGroup), para isso, clique com o botão direito e escolha Add Group.

Dentro desses grupos, teremos os itens (botões) que vamos usar. Agora, precisamos configurar as actions do ActionManager. Dê um duplo clique no ActionManager e acesse a aba Actions (Figura 3).

Figura 3. Editor de actions no ActionManager

novembro201306

Para quem já trabalhou com ActionList, a tela é bastante familiar. Após, vamos configurar essas actions para o Ribbon. Acesse a propriedade ActionBars do ActionManager e adicione um ActionBarItem. No ActionBarItem, vamos vincular com cada grupo que criamos anteriormente, ou seja, cada grupo terá um ActionBarItem vinculado.

Acesse a propriedade Items do ActionBarItem e para cada item que deseja adicionar, você pode vincular para com uma ação (propriedade Action). Pronto, cada item (action) deve ser colocado em um grupo (ActioBarItem) e um ou mais grupos podem estar dentro de um aba (RibbonPage). Veja na Figura 4.

Figura 4. Ribbon configurado

Podemos adicionar Action pré-definidas, basta clicar na propriedade Action e escolher New Standar Action, onde temos uma lista das actions que podemos configurar para o item.

Nota: Caso a imagem não fique proporcional no botão (isso depen-de do tamanho da imagem usada), altere para bsLarge a propriedade CommandProperties>ButtonSize.

Controles no Ribbon

A propriedade CommandProperties do ActionClientItem (o botão adicio-nado com o Action), possui muitas sub-propriedades interessantes para sua configuração. ButtonSize indica o tamanho do botão. Em ButtonType temos as seguintes opções:

• btNone: botão normal;• btDropDow: uma seta indica que temos um menu ao clicar no botão

(para configurar os itens do menu, acesse a propriedade Items e adicione os menus que deseja);

• btGallery: exibe uma galeria suspensa;• btSplit: Uma seta indica um menu, mas o botão também possui a

funcionalidade em seu clique.

Outra propriedade interessante é o CommandStyle onde podemos mudar o botão para um CheckBox, RadioButton, ComboBox por exemplo.

Configurando controles

Para criar um CheckBox ou RadioButton, basta escolher a opção no Com-mandStyle. Caso deseje criar um Combobox, arraste um RibbonComboBox da Tool Palette para dentro de um grupo. Preenche o combo, usando a proprie-dades Items do controle recém adicionado.

Veja na Figura 5 um Ribbon contendo botões, CheckBox, RadioButton, menus e ComboBox.

Figura 5. Várias possibilidades do Ribbon

Usamos a mesma facilidade para usarmos o SpinEdit. Basta adicionar um RibbonSpinEdit diretamente no grupo.

Menu de acesso rápido

Como comentei anteriormente, o Ribbon trouxe a funcionalidade de um menu com acesso rápido a documentos adicionados, funcionalidades de impressão, salvar etc. Clique com o botão direito no Ribbon e escolha Add Ap-plication Menu. Será adicionado um botão na parte superior esquerda das abas. Ao clicar nele (mesmo em tempo de design) um menu é mostrado. Podemos adicionar funcionalidades nesse menu, acessando a propriedade OptionsItems.

Cada item representa uma Action e cada item adicionado será mostrado na parte inferior do menu do Application Menu (Figura 6). Ideal para comandos de fechar a aplicação, configurações etc.

Figura 6. Adicionando botões no menu

Para adicionar itens no menu, clique no botão e acesse a propriedade Items. Para cada funcionalidade adicione um item, atribuindo uma Action (semelhante ao que fizemos com os itens dos grupos do Ribbon). Veja na Figura 7, o itens adicionados ao menu.

novembro2013 07

Figura 7. Itens no Application Menu do Ribbon

Para alterar o ícone, clique no Ribbon e acesse a propriedade ApplicationMenu>Icon. Agora, vamos adicionar um menu de acesso rápido. Clique com o botão direito no Ribbon e escolha Add Quick Access Toolbar. Será adicionado um controle ao lado do botão. Se rodar a aplicação, teremos algumas configurações do próprio Ribbon (Figura 8).

Figura 8. Menu de acesso rápido

Nota: o ActionManager possui quatro propriedades para imagens (DisabledImages, Images, LargeDisabledImages e LargeImages). Para que possamos trabalhar com imagens pequenas e grandes, temos que configurar as quatro propriedades (usando o mesmo índice para a ima-gem nos quatro ImageLists). Para mostrar a imagem grande, usamos a propriedade CommandProperties>ButtonSize.

Para adicionar itens, acesse a propriedade ActionBars do ActionManager. No editor, selecione o ActionBar do Quick Access Tolbar. Na propriedade Items, adicionamos os itens que queremos. Veja o resultado na Figura 9.

Figura 9. Ribbon configurado com a Quick Access Toolbar

Conclusões

Vimos nessa dica rápida, como usar o Ribbon para criar aplicações com visual moderno, com o Delphi. Já tive a experiência de usar o controle em uma aplicação e o resultado foi muito bom, sendo que o usuário da aplicação achou o visual mais limpo e organizado.

Um grande abraço a todos e até a próxima!

www.lucianopimenta.net

Luciano PimentaLuciano Pimenta (NOVO DOMINIO: www.lucianopimenta.com) é desenvolvedor Delphi/C#

para aplicações Web com ASP.NET, Windows com Win32 e Windows Forms com .NET. Palestrante da 4ª edição da Borland Conference (BorCon) e da 1ª Delphi Conference.

É MVP Embarcadero, grupo de profissionais que ajudam a divulgar o Delphi no mundo. Atualmente é desenvolvedor da SoftDesign fábrica de softwares em Porto Alegre-RS.

Autor de mais de 90 artigos e de mais de 600 vídeos aulas publicadas em revistas e sites especializados, além de treinamentos presenciais e multimídias. É consultor da FP2 Tecnologia (www.fp2.com.br) onde ministra cursos de programação e banco de dados.

Sobre o autor

novembro201308

Exemplo de Conexão com o servidor FTP via TFileHV.

Código Fonte da função LoadFTP

No capítulo anterior, vimos a primeira utilização prática do componente, que é a procura automática de arquivos e procura por strings de dentro deles; vimos também que ele retorna as linhas das ocorrências encontradas e quando clicado em um TListView associado a ele, é mostrada uma

tela dinâmica com o arquivo-texto carregado mais a linha selecionada contendo a string procurada.

Além disso, foi explicado sobre o processo de anexação de arquivos (basi-camente a utilização de um arquivo de recursos para ser associado juntamente com a aplicação) podendo ser também extraído para os arquivos originais. Todo processo é dinâmico e embutido dentro do componente, até a compilação pelo Delphi em linha de comando sem precisar de instalá-lo.

Agora, vem a segunda parte, que é sobre o tema FTP e versionamento automático de arquivos.

Começando pelo começo: Conectando o Servidor FTP pelo TFileHV

Conectar um Servidor FTP pelo componente é tão fácil quanto conectar manualmente (sem o componente), mas o componente oferece outros recursos de conexão embutidos através da função booleana LoadFTP. Basicamente a maneira mais prática é passando diretamente os parâmetros para o compo-nente. Um exemplo segue abaixo (também disponível ele e os outros demais do escopo deste artigo para download):

with FileHV1 do begin FTPHost := edtHost.Text; FTPUserName := edtUserName.Text; FTPPassWord := edtPassword.

TFileHV - Gerenciamento Básico de Arquivos Parte 2

Text; FTPPort := StrToIntDef(edtPort.Text, 21); Result := LoadFTP; end;

Olhando para dentro da função LoadFTP, ele vai chamar internamente uma instância privada de TIdFTP (pacote Indy da Borland) , em que é primeiramente criado; se já criado ele é desconectado para ser conectado novamente.

function TFileHV.LoadFTP: Boolean;begin if (fHost = ‘’) or (fUserName = ‘’) or (fPassWord = ‘’) then begin Result := False; Exit; end;

Result := True; if not Assigned(tempFTP) then tempFTP := TIdFTP.Create(Self) else tempFTP.Disconnect;

tempFTP.Host := fHost; tempFTP.Username :=

novembro2013 09

Exemplo de padronização de nomes de arquivos

Código Fonte

fUserName; tempFTP.Password := fPassWord; tempFTP.Port := fPort; try tempFTP.Connect; except Result := False; tempFTP.Disconnect; FreeAndNil(tempFTP); end;end;

Código-Fonte da função LoadFTP, utilizada em todas as conexões com o Servidor FTP feitas pelo nosso componente.

Conectei-me. E agora, o que podemos usufruir de bom do Componente?

O melhor está por vir: o componente e seu tema central deste artigo explorará o processo de versionamento de arquivos, histórico de versões, upload, download (que equivale a visualização do mesmo), exclusão, exclu-são/visualização automática da última versão, renomear arquivos, etc, tudo isso providenciado pelo próprio componente - não será necessário escrever código-fonte para todas essas operações, bastando-se apenas suas chamadas de funções que são em grande maioria de uma a duas linhas de código no máximo. Isso não chega a ser prático?

Versionamento

O processo de Versionamento do componente é um tanto complexo; existem muitas operações embutidas; primeiramente o arquivo é subido para o Servidor. Quando o próximo for subido, o componente verifica se já existe uma primeira versão deste arquivo - e se existir, ele vai comparar se a versão do arquivo que está sendo subido é superior à última versão que está no Servidor (através da data de modificação de ambos os arquivos) - e no caso do Servidor possuir a última versão desta comparação, vai confirmar ao usuário se deseja realmente subir assim mesmo - se sim, sobe e o processo é concluído com sucesso - se não, o caso de uso deste processo é encerrado.

O outro aspecto deste processo é como ele armazena os arquivos. O componente consegue reconhecer sozinho todo um histórico de um mesmo arquivo, sem a necessidade de se recorrer à uma tabela de algum banco de dados para obter essa informação: temos muito mais vantagens que desvanta-gens neste processo; as vantagens são a eficiência e rapidez (pelo motivo citado anteriormente de não se recorrer a banco de dados), praticidade, possibilidade de extensão do algoritmo, fácil recuperação de arquivos e fácil customização dos diretórios-raízes do processo. As desvantagens: o nome do arquivo precisa ser único (pelo fato do mesmo ser utilizado neste processo como identificador exclusivo - semelhante a uma chave primária de uma tabela); a outra desvanta-gem é que não há logs ou registros de transações - pelo menos nesta primeira versão esse requisito não está implementado.

Portanto, o Versionamento vai consistir para o histórico apenas um mesmo nome de arquivo e suas versões correspondentes. E todo arquivo será zipado no servidor (utilizando-se a biblioteca ZLB para compactação/descompactação de arquivos) - esse processo de compactação será feito somente para armaze-namento de um arquivo novo, enquanto o de descompactação será feito toda vez em que for visualizar um arquivo (deve-se fazer download, descompactar e finalmente visualizar) e comparar versões quando no momento de armazená-lo (conforme já explicado acima).

Após subido o arquivo, ele será compactado e consequentemente terá sua extensão renomeada para “zip”, e a novidade é que terá um prefixo com um hífen, para indicar a ordem do versionamento (e é assim que o componente identifica a ordem cronológica do versionamento), por exemplo:

Arquivo: “teste.txt”Histórico: “1-teste.zip”;“2-teste.zip”,“3-teste.zip”, etc.

Arquivo: “Faturamento.pdf”Histórico: “1-Faturamento.zip”;“2-Faturamento.zip”;“3-Faturamento.zip”,etc.

Exemplo de padronização de nomes de arquivos utilizados no processo de versionamento de arquivos do TFileHV.

A função para retornar sempre a última versão de um arquivo é comple-xa: envolvendo um TClientDataSet para guardar temporariamente todos os arquivos que satisfaçam à procura pelo parâmetro do arquivo a ser pesqui-sado (sempre o nome do arquivo, retirando o prefixo numérico mais o hífen e a extensão “zip”). O papel fundamental do TClientDataSet é obter a última versão do arquivo, guardando todas as ocorrências de DirectoryListing.Items[i].ModifiedDate (da classe TIdFTPListItem, descendente de um TCollectionItem que implementa métodos e propriedades utilizadas em arquivos no FTP) - em um campo agregado criado dinamicamente (assim como todo o TClientDa-taSet) chamado MODIFIEDDATE do tipo Data/Hora; um pequeno trecho do fonte segue abaixo:

with tempClientDataSet.Aggregates.Add do begin Expression := ‘MAX(MODIFIEDDATE)’; AggregateName := ‘MaxData’; Active := True; end;

novembro201310

Trecho da criação do campo agregado MODIFIEDDATE, que tem o papel de retornar o último registro (mais recente) de Data/Hora em que o arquivo foi subido no Servidor FTP.

Figura 10 - Fluxograma do processo de Versionamento de Arquivos pelo compo-nente TFileHV.

Figura 11 - Programa Demo mostrando o TFileHV interagindo com o ListView e exibindo em um combobox os arquivos versionados armazenados no Servidor.

Uma última consideração sobre o versionamento é a criação de diretórios no Servidor - o componente criará todos os diretórios embaixo de um diretório--base (pai), sendo que todos os demais serão seus subdiretórios. A propriedade FTPDefaultFolder (default “Sources”) contém o nome do diretório pai, em que no nosso caso nada mais é que um “agrupador” de todos os diretórios criados pelo TFileHV. E quando e como esses diretórios são criados? Toda vez que um arquivo for armazenado, o componente pegará o primeiro diretório do caminho em que ele se encontrava no momento de sua solicitação de armazenagem para o componente. Exemplificando, se o arquivo “teste.txt” está no caminho “c:\Daniel\Documentos\teste.txt” o diretório a ser criado será “Daniel”, que será o subdiretório debaixo do diretório-pai definido na propriedade FTPDe-faultFolder, conforme explicado anteriormente.

Figura 12 - Continuação do Demo, exibindo o histórico de um arquivo em um Lis-tView associado ao TFileHV. Note que a maioria dos dados retornados também podem ser obtidos por qualquer método que dê suporte a TStrings (um memo, listbox, etc).

novembro2013 11

Código Fonte

Código Fonte

Obtendo a Última Versão do Arquivo

Ao solicitar ao componente para obter a última versão de um arquivo, ou mesmo para simplesmente visualizar qualquer versão do mesmo, será exibida uma tela para que seja informado o caminho de onde será “baixado” o arquivo do Servidor, de acordo com a seguinte figura abaixo:

Figura 13 - Tela de Informação do Caminho onde será efetuado o download do arquivo para a sua visualização.

Ambos os métodos DownloadLastVersion e DeleteLastVersion chamam a função GetLastFileVersion para retornar a última versão de um arquivo. Graças ao método ModifiedDate de DirectoryListing.Items[i] (da classe TIdFTPListItem) explicado anteriormente é possível descobrir o último arquivo daquela versão que foi inserido no servidor: é só buscar a sua data/hora de inclusão e com a ajuda de um campo agregado do tipo data/hora de um ClientDataSet fazer um “max” em seus registros para obter a última data/hora de um registro. Basicamente é isso: filtra-se o arquivo e sua última data/hora de inclusão no servidor, por exemplo: tempClientDataSet.Filter := ‘MODIFIEDDATE = ‘ + QuotedStr(tempClientDataSet.Aggregates.Find(‘MaxData’).Value); onde MaxData é o nome do nosso campo agregado criado em run-time para esta finalidade.

Como obter dados a pesquisar de um arquivo: Método Ge-tInfoFile em ação:

GetInfoFile é uma função booleana com dois parâmetros (assinatura: function TFileHV.GetInfoFile(const myFullPathFile: string = ‘’): Boolean) - se a constante myFullPathFile não for preenchida, então presume-se que você deverá informá-la seu caminho completo, e para isso será criado um TOpen-Dialog para que o usuário especifique o caminho do documento; do outro lado o programa pode fornecer diretamente o caminho via parâmetro, como em

If not FileHV1.GetInfoFile(‘c:\fontes\TIdFTP-Teste\teste.txt’) then Exit;

Com isso o caminho do documento é passado e tratado pelas variáveis internas do componente, para obter a primeira pasta deste caminho, verificar se o caminho informado é inválido, etc.

Última consideração sobre os métodos RenameFTPFile e DeleteFTPFile:Através das funções RenameFTPFile e DeleteFTPFile, o componente pode

renomear e deletar um arquivo versionado, respectivamente. Para isso basta chamar os métodos correspondentes, em apenas uma linha de código. Segue exemplos abaixo:

//renomear arquivos://modo 1://FileHV1.RenameFTPFile(‘Fontes\100-teste.zip’, ‘12-teste.zip’);//modo 2:// FileHV1.RenameFTPFile(‘3-teste.zip’, ‘333-teste.zip’);//deletar arquivos://modo 1://FileHV1.DeleteFTPFile(‘Fontes\1-teste.zip’);//modo 2:// FileHV1.DeleteFTPFile(CbFiles.Items.Strings[CbFiles.itemIndex]);

Explicação: o modo 1 acima citado realizará a operação diretamente no diretório especificado. Se o diretório não existir, a operação falha. Do outro lado, se o diretório não é fornecido, então o componente percorrerá a nossa estrutura de diretórios criados (abaixo do diretório-pai) para localizar o arquivo citado, e se encontrado, efetuará a operação solicitada. Vale ressaltar que o componente não percorrerá todo o FTP, e sim apenas nos diretórios criados pelo componente explicados anteriormente.

Conclusão

Primeiramente discorremos sobre a eficiência e a praticidade de procurar arquivos, strings dentro de arquivos, exibir a linha selecionada de um arquivo,

novembro201312

manipulação de arquivos, etc, de uma forma mais automatizada pelo compo-nente, economizando várias (dezenas) de linhas de código-fonte necessárias para obtenção do mesmo resultado se feito fora do componente; além de mos-trar uma forma personalizada de anexação e extração de arquivos, acionando externamente o compilador do Delphi sem a necessidade de instalá-lo; técnicas avançadas com o ListView (evento duplo-clique avançado, criação e manipu-lação dinâmica, etc) e com o ClientDataSet (operações utilizando TFileStream, TBlobField para armazenamento de arquivos, criação de campos agregados e índices dinamicamente, criação e destruição de colunas automática, etc).

Também vimos uma forma alternativa, prática e eficiente de versionamen-to de arquivos feito inteiramente pelo componente, podendo ser parametrizada muitas opções de diretórios, arquivos, etc. Podem ser versionados quantos arquivos forem necessários, de qualquer extensão, de qualquer tamanho e de qualquer diretório, sendo todos compactados para ganhar mais espaço. O bom é que tudo está embutido de dentro do componente, guardando por sua conta a relação de histórico para cada arquivo versionado, oferecendo praticidade em vários processos padronizados e facilmente customizados, podendo ser estendidos para aperfeiçoá-los através do código-fonte disponí-vel. O retorno das informações também está eficiente e intuitivo, através da utilização personalizada e prática de um TListView, componente escolhido por ser muito intuitivo e prático, podendo ser personalizado de várias formas de apresentação (modos de visualização diversos - lista, detalhe, etc) - sendo que

a grande maioria das funções podem ser acessadas a partir de um TStrings, disponíveis para um Memo, Listbox, etc;

Portanto, foram explicadas todas as funcionalidades desta corrente versão do TFileHV; na minha página pessoal está disponível sempre a nova versão do mesmo. Dicas, críticas e sugestões também são bem-vindos. O código-fonte do componente e os programas Demo também estão disponíveis para download.

suporte@theclub.com.br

Hamden VogelAnalista de Sistemas pós-graduado em Engenharia de Software pela

UPIS e Programador Delphi com larga experiência desde 2000, tem de-senvolvido e vendido softwares em Delphi para a África e Estados Unidos, além do mercado nacional. Colaborou com dicas e componentes para sites especializados em Delphi. Também desenvolve em outras linguagens como C/C++, ASP, PHP e .NET.

Sobre o autor

novembro2013 13

Nos artigos anteriores, iniciamos o desenvolvimento da aplicação verificando aspectos pertinentes ao desenvolvi-mento, mas devido a quantidade de informações, tivemos que dividir o artigo.

Nessa última etapa, fecharemos todos os tópicos propostos na primeira parte do artigo, explanando apenas um dos módulos da aplicação, mas não se preocupem, a aplicação completa estará a disposição para os assinantes.

Nota: As referências de imagens estão diretamente relacionadas a terceira parte desse artigo, sendo assim, é necessário estar ter iniciado o desenvolvimento da aplicação pela terceira parte.

Continuando...

LINQ + Entity Framework na Mini Aplicação

Voltando a nossa aplicação, faremos uso desses poderosos recursos a fim de que nossa aplicação fique enxuta e robusta, além de funcional.

Então, para começar, vá até a janela Solution Explorer, clique com o botão direito no projeto MiniAplicacao e escolha Add -> New Item.

Na janela que se abrirá “Add New Item – MiniAplicacao” selecione a op-ção “Data” em “InstalledTemplates” e a primeira opção “ADO.NET Entity Data Model” e coloque o nome de MAplic.edmx conforme imagem 11.

D e s e n v o l v a u m a Aplicação Desktop em C# e MySQL – Parte 4

Imagem 11 – inclusão do Entity Data Model

Na janela que se abrirá você estará na etapa “ChooseModelContents”, clique em “GeneratefromDatabase” (pois, nesse caso, já temos o modelo e as entidades do banco serão reconhecidas automaticamente) e em seguida clique em Next conforme imagem 12:

Imagem 12 – opção “GeneratefromDatabase” selecionada.

novembro201314

Na etapa “Chooseyour data Connection” clique em “New Connection” e selecione “MySQLDatabase” e depois clique em “Continue” conforme imagens 13 e 14:

Imagem 13 – Seleção de nova conexão clicando em “New Connection”

Imagem 14 – Seleção do nosso Data SourceMySQLDatabase

Observação: Descobri recentemente que a versão mais atualizada do MySQLConnector não funciona com a versão que estamos trabalhando para esse artigo. Então, fique atento as seguinte informações para não ter problema nessa etapa:

IDE: Visual Studio 2010MySQL:<Indiferente>.NET FW: 4.0MySQLConnector: 6.6.5

Consulte a referência no seu projeto para verificar a versão, conforme imagem 15.

Imagem 15 – Versão do MySQLConnector

Voltando a configuração...

Em “Connection Properties” informe os dados para acesso conforme imagem 16.

Server Name: LDCUser Name: rootPassword: <Vazio>

Imagem 16 – Connection Properties.

Clique em “Test Connection” até mesmo para confirmar se você subiu o serviço do MySQL corretamente e caso esteja tudo certo clique em “OK”.

Repare que ao retornar para “Chooseyour Data Connection” o campo “Entity Connection String” estará preenchido. Aproveitando, renomeieopção

novembro2013 15

“Save entity connection string in App.Config as:”para “MAEntities” confor-meimagem 17.

Imagem 17 – Nomeando a entidade após escolha do “DataSource”.

Após renomear a entidade para “MAEntities” clique em “Next”.

Na etapa “ChooseyourDatabaseObjects”, selecione a opção “Tables” e renomeie o “ModelNamespace” para “MAModel” e clique em “Finish” con-forme imagem 18.

Imagem 18 – Renomeando ModelNamespace.

Após concluir as configurações o Visual Studio abrirá a janela MAplic.edmx mostrando as entidades do nosso banco de dados LDC conforme imagem 19.

Imagem 19 – Maplic.edmx apresentando as entidades do BD LDC.

Observação: Repare que o campo “usuario” não pode ter o mesmo nome da entidade, por isso o mesmo foi renomeado automaticamente para “usuario1”. Isso não é impeditivo para o projeto (mesmo nesse artigo), porém, por questões de Arquitetura e Projeto, tomem cuidado para não cair nesse tipo de situação, pois, dependendo da complexidade do projeto isso pode se tornar um problema sim. Imagine que você esteja desenvolvendo um projeto complexo e seu cliente é uma SoftwareHouse. O Responsável pode muito bem receber o código fonte e questiona-lo a ponto de pedir que isso seja alterado e é aí que vem o pior, pois, depen-dendo da etapa do seu projeto, o impacto poderá ser grande e custoso.

Voltando...

Com nosso modelo estabelecido, temos uma série de coisas que poderiam ser feitas nesse arquivo EDMX para deixar nossa aplicação melhor estruturada e modelada possível.

Mas vamos focar no básico para que o básico seja feito da melhor forma.

Abra a classe Usuario.cs e inclua uma variável do tipo string que servirá para indicação da ação que será realizada (linha em Negrito).

public partial class frmUsuario : MAAcoes{public string strAcao = string.Empty; …

Dê um duplo clique no botão “Novo” e inclua o código a seguir:

private void btnNovo_Click(object sender, EventArgs e){this.AjustaCamposFormulario(this.Controls, true);this.AjustaBotoesFormulario(this.Controls, true);this.AjustaValorCamposFormulario(this.Controls);this.strAcao = “NOVO”;}

Dê um duplo clique no botão “Alterar” e inclua o código a seguir:

novembro201316

private void btnAlterar_Click(object sender, EventArgs e){this.AjustaCamposFormulario(this.Controls, true);this.AjustaBotoesFormulario(this.Controls, true);this.strAcao = “ALTERAR”;}

Dê um duplo clique no botão “Cancelar” e inclua o código a seguir:

privatevoidbtnCancelar_Click(objectsender, EventArgs e){if (MessageBox.Show(“Deseja cancelar a operação atual?”, this.Text, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation) == DialogResult.Yes){this.AjustaBotoesFormulario(this.Controls, false);this.AjustaCamposFormulario(this.Controls, false);this.AjustaValorCamposFormulario(this.Controls);}}

Dê um duplo clique no botão “Salvar” e inclua o código a seguir:

privatevoidbtnSalvar_Click(objectsender, EventArgs e){if ((!string.IsNullOrEmpty(txtNome.Text)) && (!string.IsNullOrEmpty(txtUsuario.

Text)) && (!string.IsNullOrEmpty(txtSenha.Text))){switch (this.strAcao) {case “NOVO”: using (MAEntities context = new MAEntities()) {usuario u = new usuario();u.nome = txtNome.Text; u.usuario1 = txtUsuario.Text;u.senha = txtSenha.Text;context.usuario.AddObject(u);context.SaveChanges();MessageBox.Show(“Informações inseridas com sucesso.”, “Aviso”, MessageBoxButtons.OK, MessageBoxIcon.Information);}break;

case “ALTERAR”:using (MAEntities context = new MAEntities()){intintID = Convert.ToInt32(txtID.Text);usuario u = context.usuario.First<usuario>(pu =>pu.idusuario == intID);u.nome = txtNome.Text; u.usuario1 = txtUsuario.Text;u.senha = txtSenha.Text;context.SaveChanges();MessageBox.Show(“Informações alteradas com sucesso.”, “Aviso”, MessageBoxButtons.OK, MessageBoxIcon.Information);}break;}

this.AjustaCamposFormulario(this.Controls, false);this.AjustaBotoesFormulario(this.Controls, false);this.AjustaValorCamposFormulari

novembro2013 17

o(this.Controls);}else{MessageBox.Show(“Preencha o campos antes de Salvar “, “Aviso”, MessageBoxButtons.OK, MessageBoxIcon.Warning);}}

Dê um duplo clique no botão “Excluir” e inclua o código a seguir:

privatevoidbtnExcluir_Click(objectsender, EventArgs e){if (MessageBox.Show(“Deseja excluir registro atual?”, this.Text, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation) == DialogResult.Yes){if (txtID.Text == string.Empty){MessageBox.Show(“Selecione um registro no botão \”Pesquisar\” antes de \”Excluir\”.”, “Aviso”, MessageBoxButtons.OK, MessageBoxIcon.Information);}else {intintID = Convert.ToInt32(txtID.Text);

using (MAEntities context = new MAEntities()) {usuario u = context.usuario.First<usuario>(pu =>pu.idusuario == intID); context.DeleteObject(u);context.SaveChanges();MessageBox.Show(“Informações excluidas com sucesso.”, “Aviso”, MessageBoxButtons.OK, MessageBoxIcon.Information);}

this.AjustaValorCamposFormulari

o(this.Controls);}}}

Espere um pouco... Estou falando de Alteração e Exclusão, mas, não temos como buscar nossos dados na aplicação, temos?

Temos, temos sim e eu separei um tempo para que nossa aplicação fique cada vez melhor.

Primeiro, crie o form de consulta que deve possuir os controles Textbox, 2 Button e um DataGridView conforme imagem 20.

Imagem 20 – Formulário de Pesquisa.

Com o formulário criado, insira o código em negrito:

public partial class Consulta : MAAcoes{publicConsulta() {InitializeComponent(); }

public string formName = string.Empty;

publicConsulta(MAAcoes fc = null) {if (fc != null) {formSender = fc;this.Text += formSender.Text; }InitializeComponent(); }

private void btnSair_

novembro201318

Click(object sender, EventArgs e) {this.Close();this.Dispose(); }

private void dgvDados_Click(object sender, EventArgs e){if (dgvDados.RowCount> 0) {

this.setID(dgvDados.SelectedCells[0].Value.ToString());this.formSender.chamarMetodo(“carregaDados”, this.ID);this.formSender.Show();this.Close();this.Dispose();}}

...

Depois, dê um duplo clique em btnPesquisar e insira o código em negrito a seguir:

private void btnPesquisar_Click(object sender, EventArgs e){switch (this.formSender.Text) {case “Usuário”:using (MAEntities context = new MAEntities()) {IEnumerable<usuario>usuario = (from u in context.usuariowhereu.nome.Contains(txtDescricao.Text)select u).ToList();dgvDados.DataSource = usuario;}

dgvDados.Columns[“idusuario”].Width = 189;dgvDados.Columns[“idusuario”].HeaderText = “ID”;dgvDados.Columns[“nome”].Width = 400;dgvDados.Columns[“nome”].HeaderText = “Nome”;dgvDados.Columns[“usuario1”].

Width = 189;dgvDados.Columns[“usuario1”].HeaderText = “Usuário”;dgvDados.Columns[“senha”].Visible = false;dgvDados.Columns[“contato”].Visible = false;break;}}

Em seguida, temos que colocar o botão pesquisar no formulário de Usu-ários. Sendo assim, insira um botão e chame-o de “btnPesquisar” e coloque o texto “Pesquisar” como mostra a imagem 21.

Imagem 21 – Botão Pesquisar

Com o novo botão, teremos que modificar algumas coisas na classe MA-Acoes e na Classe frmUsuario, então vamos começar pela classe MAAcoes inserindo o código em negrito:

public class MAAcoes : Form{publicMAAcoesformSender;public string senderFormName;public string ID;

public virtual void chamarMetodo(stringstrMetodo, string optionalParam = “”) { }

public virtual void setFormName(string nome) {senderFormName = nome; }

public virtual void setID(string strID){this.ID = strID;}

...

Na classe frmUsuario, insira o código em negrito a seguir:

novembro2013 19

public partial class frmUsuario : MAAcoes{publicMAAcoesformConsulta;public string strAcao = string.Empty;

Ainda na classe frmUsuario, dê um duplo clique no botão Pesquisar e insira o código em negrito:

private void btnPesquisar_Click(object sender, EventArgs e){this.formConsulta = new Consulta(this);this.formConsulta.setFormName(this.Name);this.formConsulta.Show();}

public override void chamarMetodo(string strMetodo, string optionalParam = “”){switch (strMetodo){case “carregaDados”: carregaDados(optionalParam); break;}}

private void carregaDados(string strID){intintID = Convert.ToInt32(strID);

using (MAEntities context = new MAEntities()) {IEnumerable<usuario>usuario = (from u in context.usuariowhereu.idusuario == intIDselect u).ToList();

foreach (var u in usuario) {txtID.Text = u.idusuario.ToString();txtNome.Text = u.nome.ToString();txtUsuario.Text = u.usuario1.ToString();txtSenha.Text = u.senha.ToString();}

}}

Ao testar nossa aplicação, devemos obter o resultado mostrado na imagem 22.

Imagem 22 – Aplicação fazendo busca e trazendo o resultado na tela.

Conclusão

A aplicação completa poderá ser baixada através do site da revista.Vale a pena lembrar que foram deixados muitos links da MSDN no artigo

que detalham os assuntos abordados nesse artigo. Leiam, questionem-se, pesquisem, analisem. Não tomem apenas esse artigo por verdade absoluta quando na verdade estou apresentando uma opção no meio de tantas.

Referente a projetos, avaliem a real necessidade do cliente, os impactos de manutenção e evolução do sistema. Não saiam aplicando a tecnologia apenas porque é rápida e prática, uma boa analise sobre as arquiteturas disponíveis são sempre bem-vindas no inicio do projeto.

Caso precise fazer alterações referentes a acesso a dados com base nesse artigo, utilize o Appconfig para saber o que alterar num projeto já criado e configurado.

suporte@theclub.com.br

João Marcos SakalauskaColunista The Club.

Sobre o autor

novembro201320

Olá pessoal, neste artigo vamos mostrar uma das variadas formas de trabalhar com a padronização dos componentes visuais no Delphi. A escolha da versão 7 do Delphi se deve a sua popularidade na comunidade da ferramenta e também porque as versões mais atuais do Delphi possuem muitos

recursos para a padronização de estilos dos componentes, contudo, a prática utilizada neste artigo poderá ser utilizada em qualquer versão do Delphi, visto que se trata de manipulação via programação e este é um recurso comum em todas as versões.

Objetivo

O objetivo deste artigo é ensinar uma prática de padronização do layout dos componentes visuais no Delphi. Essa prática possibilita o ajuste e a visualização dos componentes em tempo de projeto, para isso utiliza-se um formulário, onde serão dispostos os componentes visuais com as características que ser-virão como padrão para a aplicação inteira, ou apenas para os formulários que necessitarem utilizar esse padrão, pois podemos definir isso via programação.

Conceito de CSS

Quem já desenvolveu um website algum dia, conhece ou já ouviu falar do uso do CSS para a configuração do layout de uma página HTML.

Existem três formas de se trabalhar com o CSS, são elas:

• Embutido – quando o estilo é aplicado diretamente à tag HTML;• Interno – quando o código CSS fica disposto entre as tags STYLE no

próprio documento HTML;• Externo – quando o código CSS fica disposto num arquivo separado

no documento HTML, esta é uma das formas mais dinâmicas de se trabalhar, pois um único arquivo pode ser o responsável por configurar o estilo de inú-meras páginas HTML. Com este método os elementos HTML podem ser criados de forma padrão sem se preocupar com seus estilos, pois serão ajustados ao serem carregados no webbrowser.

Criando um formulário de layout padrão - Delphi 7

É este último conceito, o de CSS externo, que iremos citar neste artigo, pois essa prática de padronização de layout será tratada de forma parecida, porém, ao invés de se ter um arquivo CSS externo, terá um formulário criado apenas para disponibilizar os componentes que servirão de base para os demais formulários do projeto. E da mesma forma que temos que fazer a chamada do arquivo CSS na página HTML quando queremos utilizar seu estilo, teremos que fazer a chamada do formulário padrão de layout nos formulários que iremos utilizar essa padronização.

Para reforçar o entendimento do conceito de CSS nesta prática vamos tomar como exemplo a utilização do CSS no HTML. É sabido que ao utilizar um arquivo CSS externo para a estilização de um documento HTML, este último pode ser criado com seus elementos padrão, ou seja, sem nenhuma formatação ou alteração de características. Com essa prática de estilização dos componen-tes no Delphi que iremos ensinar o conceito será o mesmo, para cada novo formulário que for criar no projeto, bastará apenas chamar via programação o formulário de estilo padrão, basta adicionar os componentes sem precisar se preocupar com os ajustes visuais, pois serão ajustados em tempo de execução pelo formulário base de layout.

Métodos e comportamentos

Com essa prática, além de podermos configurar o visual dos componentes da aplicação, podemos também predefinir alguns métodos e comportamentos para determinados componentes, como por exemplo, Edit que aceita apenas números inteiros e Label que se destaca com o movimento do mouse ao passar por cima dele entre outros métodos corriqueiros. Mas devemos fazer uma ressalva, pois ao definir os métodos nos componentes do formulário base de layout, devemos ter em mente que estes métodos serão vinculados aos componentes dos demais formulários em tempo de execução.

Para explicar melhor o cuidado que se deve tomar ao utilizar métodos nos componentes de layout padrão, iremos utilizar o exemplo do Edit que aceita apenas números, essa programação será feita no evento OnKeyPress do Edit e ao executar o projeto, ela é vinculada aos componentes Edit dos demais formulários do projeto, isso indica que, se em algum Edit tiver alguma outra programação no mesmo evento, OnKeyPress, esta será substituída pela

novembro2013 21

programação do Edit que aceita apenas números inteiros.

Por esse motivo indicamos que sejam criados apenas métodos genéricos e específicos e se possível em eventos que comumente não se utilize, pois assim evitará que ocorra esta substituição de eventos, pois esta prática funciona de maneira diferente de quando utilizamos uma herança de formulários, nesta última, o código no formulário base é adicionado ao código no formulário que recebe a herança, ou seja, não ocorre perda de codificação, que é o que acontecerá se um evento for substituído por outro como é feito nesta prática.

Contudo ainda não deixa de ser uma prática interessante, pois podemos por exemplo, criar vários estilos de Edit, alguns com codificações e outros comuns sem nenhuma codificação, diferenciando-os apenas pela sua pro-priedade Tag.

Escolhendo o estilo pela propriedade Tag

Depois que fizermos toda a programação no formulário de base de layout, bastará informar nos componentes dos demais formulários qual o estilo que será aplicado em cada um. Isso será defino através da propriedade Tag de cada componente.

A Tag padrão para qualquer componente criado pelo Delphi possui o valor 0 (zero), portanto todo estilo que for representado pela Tag 0 deve ser o mais comum em sua aplicação, ou seja, o estilo que será tido como padrão, pois facilitará muito na sua configuração posterior. Os demais podem ser apenas uma variação do componente para casos mais específicos. Para casos em que não se deva aplicar estilo algum, bastará informar no componente uma Tag com valor negativo ou qualquer outro valor que não tenha sido definido como um estilo, por exemplo, -1.

Quais propriedades podem ser padronizadas?

Essa é uma pergunta muito importante a ser feita, pois visto que iremos fazer uma padronização de layout, devemos ter em mente o que tanto po-deremos padronizar. Por exemplo, talvez não seja interessante alterarmos a largura dos componentes, pois poderemos nos deparar com casos em que o componente atravesse outro componente no escopo do formulário ou mesmo saia do campo de visão do usuário. Isso iria causar uma grande dor de cabeça.

Outro caso que talvez não seja interessante padronizar é o tamanho e estilo da fonte (negrito, itálico, etc...) , pois pode acontecer como o que foi citado anteriormente, e na hora da execução o texto que estava dentro do escopo do formulário em tempo de projeto com uma fonte sem estilo, pode desalinhar com o estilo padrão assumido em tempo de execução, com uma fonte com um tamanho maior e um estilo em negrito por exemplo.

Fizemos um apanhado das propriedades comuns entre os componentes visuais do Delphi que podem ser úteis nesta padronização sem causar dores de cabeça, veja abaixo a lista:

• Cursor – Define o cursor padrão do mouse quando está sobre o componente;

• Font.Color – Define a cor da fonte do componente;• Font.Name – Define qual o tipo de fonte que será aplicado ao

componente. Algumas fontes como Courier New, podem alongar o texto, por isso tome cuidado ao escolher o estilo de fonte;

• ShowHint – Define se será exibido o texto de ajuda do componente. Se estiver definido como True e a propriedade Hint estiver vazia, não será mostrado nada ao usuário.

É claro que podemos padronizar outras propriedades, pois cada compo-nente possui várias propriedades que podem ser manipuladas via programação, por exemplo, no formulário podem ser alteradas as seguintes propriedades além das que já foram citadas na lista anterior:

• Color – Define qual será a cor de preenchimento do formulário;• Position – Define qual será a posição inicial do formulário ao ser

exibido;• BorderIcons – Define quais serão os botões apresentados na borda

da janela (Minimizar, Maximizar e Fechar);• BorderStyle – Define qual o estilo da borda do formulário;

Alguns componentes podem ter mais propriedades para configurar do que outros. Isso irá variar para cada caso.

Criando o formulário base de layout

Criaremos um formulário para definir alguns estilos de Edit, SpeedButton, Label, Panel e alguns outros componentes visuais. É importante reforçar que pode-se trabalhar com vários componentes, isso dependerá da necessidade e da criatividade do desenvolvedor.

Crie um nova aplicação no Delphi 7. O primeiro formulário será o nosso formulário base para layout, defina em sua propriedade Name o nome “fr-mFormBaseLayout”, salve a Unit com o nome unFormBaseLayout e o projeto com o nome de sua preferência em um diretório em seu computador.

Adicionando estilos de Label

Adicione ao frmFormBaseLayout um componente TGroupBox, nomeie-o como “gbLabel”, altere a propriedade Caption para “Label”. É dentro desse grupo que ficarão os estilos diferentes de Label. Adicione 2 componentes TLabel dentro do gbLabel, nomeie-os da seguinte forma: “Label0” e “Label1”.

Repare que a nomenclatura utilizada, é composta pelo nome do compo-nente e um número que começa a partir do zero. Este número, na nomen-clatura, irá representar qual a o valor que deve-se indicar na propriedade Tag para utilizar este estilo.

Defina para o componente Label0 a propriedade Font.Name para “Taho-ma” e na propriedade Font.Color a cor “clNavy”. Para a Label1 defina sua Font.Name para “Cambria”, na propriedade Font.Color defina a cor “clRed” e por fim altere a sua propriedade Cursor para “crHandPoint” e sua propriedade ShowHint para “True”. A Label0 será nossa Label padrão e a Label1 será utili-zada para casos em que a Label irá funcionar como um HiperLink disparando algum evento ao ser clicada. Na Label1 vamos adicionar dois eventos, são eles: OnMouseEnter e OnMouseLeave. Eles darão um destaque à Label quando o mouse passar por cima dela. Veja na listagem 1 os códigos dos eventos citados.

novembro201322

Listagem 1 – Codificação dos eventos da Label1

Listagem 2 – Declaração e codificação do método AjustaLabel

Listagem 3 – Codificação do evento OnKeyPress dos Edits 2, 3 e 4

procedure TfrmLayoutBase.Label1MouseEnter(Sender: TObject);begin { Altera a cor de fundo da Label } TLabel(Sender).Color := TLabel(Sender).Color + $1;end;

procedure TfrmLayoutBase.Label1MouseLeave(Sender: TObject);begin { Define a cor de fundo para a cor do componente Parent } TLabel(Sender).ParentColor := True;end;

Vamos agora criar o método que irá incorporar o estilo nas demais Labels. Consiste num procedimento com um parâmetro de entrada do tipo TLabel. Esse procedimento possui uma variável X também do tipo TLabel, que será utilizada para incorporar as propriedades da Label0 ou da Label1. Será cha-mado de AjustaLabel. Veja na listagem 2 a declaração na seção private e a codificação do evento.

private { Private declarations } procedure AjustaLabel(C: TLabel); {Tecle Ctrl + Shift + C para gerar o corpo do método}

procedure TfrmFormBaseLayout.AjustaLabel(C: TLabel);var X: Tlabel;Begin X := nil; case C.Tag of 0: X := Label0; { Label comum } 1: X := Label1; { Label link } end;

if X <> nil then begin C.Cursor := X.Cursor; C.ShowHint := X.ShowHint; C.Font.Name := X.Font.Name; C.Font.Color := X.Font.Color;

C.Transparent := X.Transparent;

if C.Tag = 1 then begin C.OnMouseEnter := X.OnMouseEnter; C.OnMouseLeave := X.OnMouseLeave; end; end;end;

No primeiro trecho do código serão atribuídas à variável X as proprieda-des de um dos componentes especificados como estilo. No segundo trecho, verifica-se se a variável X recebeu alguma atribuição. Em caso de verdade, o parâmetro C receberá as propriedades da variável X. Por fim ainda temos mais uma verificação, se o parâmetro faz referência ao estilo de Tag 1, se for, passam também os eventos da Lable1.

A estrutura deste método será igual para o ajuste dos demais componen-tes. O case utilizado no primeiro trecho é o que facilitará para a inclusão de um novo estilo, pois bastará incluir mais uma linha dentro do bloco do case atribuindo o novo componente de estilo à variável X, assim não será preciso alterar o restante do método.

Adicionando estilos de Edit

Adicione ao frmFormBaseLayout mais um GroupBox, altere seu Name para “gbEdit”. Adicione 5 componentes Edit dentro do gbEdit e nomeie-os da seguinte forma: “Edit0”, “Edit1”, “Edit2”, “Edit3” e “Edit4”. As características destes são as seguintes:

• Edit0: Será o Edit padrão da aplicação;• Edit1: Será o Edit somente para leitura;• Edit2: Será o Edit que aceita apenas números inteiros;• Edit3: Será o Edit que aceita números com duas casas decimais;• Edit4: Será o Edit que aceita números com N casas decimais.Selecione os 5 Edits segurando a tecla Shift e clicando com o ponteiro do

mouse em cada um deles, após todos estarem selecionados, acesse o painel Object Inspector do Delphi e altere as propriedades Font.Name para “Arial”, BorderStyle para “bsNone” e BevelKind para “bkFlat”, desta forma os edits assumirão um layout mais chapado, sem a aparência 3D.

Selecione o Edit1 (somente leitura) e altere as seguintes propriedades: Color para “clMoneyGreen”, Font.Color para “clBackground” e ReadOnly para “True”.

Os Edits 2, 3 e 4 terão cada um deles uma programação no evento OnKey-Press, que será responsável por atribuir a eles suas características. Veja na listagem 3 a codificação para cada um dos eventos.

procedure TfrmFormBaseLayout.Edit2KeyPress(Sender: TObject; var Key: Char);begin

novembro2013 23

Listagem 4 – Codificação do método AjustaEdit

{ Admite apenas números inteiros } if not (Key in [‘0’..’9’, #8]) then {#8 representa a tecla Backspace} Key := #0;end;

procedure TfrmFormBaseLayout.Edit3KeyPress(Sender: TObject; var Key: Char);const QDecimal = 2; { Defina aqui a Qtde de casas decimais }var S: string; P, Q: Integer;begin { Admite número com um número definido de casas decimais na constante QDecimal } if not (Key in [‘0’..’9’, ‘,’, #8]) then Key := #0 else begin S := TEdit(Sender).Text; P := Pos(‘,’, S); if (P > 0) and (Key in [‘0’..’9’, ‘,’]) then begin S := Copy(S, P, Length(S) - P); Q := Length(S); if (Q = QDecimal) or (Key = ‘,’) then Key := #0; end; end;end;

procedure TfrmFormBaseLayout.Edit4KeyPress(Sender: TObject; var Key: Char);var S: string; P: Integer;begin { Admite números com N casas decimais } if not (Key in [‘0’..’9’, ‘,’, #8]) then Key := #0 else begin S := TEdit(Sender).Text; P := Pos(‘,’, S); if (P > 0) and (Key = ‘,’) then Key := #0; end;end;

Como podemos ver, fizemos uma trava para cada um destes três Edits seguindo a característica de cada um. Podemos executar o projeto agora e testarmos se estes eventos estão funcionando corretamente. Este é um exemplo de evento que pode ser útil para se padronizar, contudo ainda de-vemos lembrar, que o Edit que for utilizar algum destes 3 estilos não deverá ter nenhuma codificação no evento OnKeyPress, pois a esma será substituída por esta codificação.

Vamos agora criar o método AjustaEdit que irá definir os estilos dos edits em tempo de execução. Como foi dito, este método será semelhante ao AjustaLabel. Veja na listagem 4 os códigos do procedimento AjustaEdit. A declaração deste método é feita abaixo da declaração do método AjustaLabel na sessão private da Unit.

procedure TfrmFormBaseLayout.AjustaEdit(C: TEdit);var X: TEdit;begin { Caso seja ReadOnly mas não esteja definida pela Tag, define a Tag 1 } if (C.ReadOnly) and (C.Tag <> 1) then C.Tag := 1;

{ Identifica o estilo pela Tag } X := nil; case C.Tag of 0: X := Edit0; { Edit comum } 1: X := Edit1; { Edit somente leitura } 2: X := Edit2; { Edit só inteiros } 3: X := Edit3; { Edit só decimais 2 casas } 4: X := Edit4; { Edit só decimais N casas } end;

{ Transfere as propriedades do componente base para o componente passado como parâmetro } if X <> nil then begin C.Cursor := X.Cursor; C.ShowHint := X.ShowHint; C.Font.Name := X.Font.Name; C.Font.Color := X.Font.Color;

C.Color := X.Color; C.BorderStyle := X.BorderStyle; C.BevelKind := X.BevelKind; C.ReadOnly := X.ReadOnly;

novembro201324

Listagem 5 – Codificação do método AjustaSpeedButton

Listagem 6 – Codificação do método AjustaPanel

{ Caso necessário transfere os eventos } if C.Tag in [2, 3, 4] then C.OnKeyPress := X.OnKeyPress; end;end;

O que podemos destacar de diferente neste código é que a primeira verificação se faz necessária para identificar se o componente passado como parâmetro foi definido como somente leitura pela propriedade ReadOnly, mas não foi definido o seu estilo na propriedade Tag, por isso alteramos a Tag para 1. Podemos ver que no caso dos Edits já foram transferidos mais propriedades que na Label. A verificação para a transferência dos eventos é semelhante ao método AjustaLabel, com a diferença que agora temos mais dois estilos que têm eventos a serem passados.

Adicionando os estilos de SpeedButton

O componente TSpeedButton é muito interessante, pois com ele podemos trabalhar com Flat (quando o botão apresenta apenas seu rótulo no formulário, mas quando o mouse passa por cima dele ele assume a forma de um botão comum) e imagens. Vamos criar dois estilos de SpeedButton um com Flat e outro sem o recurso de flat, que seria um botão comum.

Adicione ao frmFormBaseLayout um GroupBox e nomeie-o como “gbS-peedButton”, adicione dentro do gbSpeedButton, recém-criado, dois Speed-Buttons, nomeie-os seguindo o padrão de nomenclatura citado, o nome do componente mais um número sequencial a começar pelo zero. Selecione os dois SpeedButtons e altere as propriedades Cursor para “crHandPoint”, Font.Name para “Century” e Font.Color para “clHighlight”. Em seguida selecione apenas o SpeedButton1 e altere sua propriedade Flat para “True”.

Nota: Estamos usando fontes de tipos diferentes nos componentes para demonstrar de forma mais clara o objetivo deste artigo que é mostrar a va-riedade de estilos que podemos criar com este formulário base para layout.

Não há necessidade de adicionarmos nenhum evento aos SpeedButtons, neste caso apenas iremos criar o método AjustaSpeedButton. Veja na listagem 5 sua codificação. Lembrando que a declaração deste método é feita abaixo da declaração do método AjustaEdit.

procedure TfrmFormBaseLayout.AjustaSpeedButton(C: TSpeedButton);var X: TSpeedButton;begin X := nil; case C.Tag of 0: X := SpeedButton0; { SpeedButton comum } 1: X := SpeedButton1; { SpeedButton Flat ativo } end;

if X <> nil then begin C.Cursor := X.Cursor; C.ShowHint := X.ShowHint; C.Font.Name := X.Font.Name; C.Font.Color := X.Font.Color;

C.Flat := X.Flat; C.Layout := X.Layout; C.Transparent := X.Transparent; end;end;

Adicionando estilos de Panel

Este será o último exemplo de estilos de componentes. Iremos criar três estilos diferentes de Panel, um mais simples, outro com uma borda transpa-rente que não ficará visível para o usuário (bom para casos em que devemos agrupar alguns componentes para facilitar o desenvolvimento do layout da aplicação, mas não deve ficar visível ao usuário esse agrupamento) e por fim outro Panel com uma borda diferenciada.

Adicione ao frmFormBaseLayout mais um GroupBox chamando-o de “gbPanel” e adicione dentro dele três componentes Panel nomeando-os como “Panel0”, “Panel1” e “Panel2”. Selecione os três Panels e altere as propriedades Font.Name para “Trebuchet MS” e ParentColor para “True”.

Selecione o Panel0 e altere sua propriedade BevelWidth para “2”. Será o Panel comum do projeto.

Selecione p Panel1 e altere a propriedade BevelOuter para “bvNone”. Será o Panel que ficará invisível para o usuário.

Por fim selecione o Panel2 e altere suas propriedades BevelInner para “bvLowered” e BevelWidth para “2”. Desta forma teremos um Panel com uma borda diferenciada, semelhante a um quadro.

Vamos criar também o método AjustaPanel, que seguirá o mesmo padrão dos demais métodos apenas adicionando algumas propriedades particulares do Panel. Veja na listagem 6 a codificação deste último método de exemplo. Lembre-se de declarar o procedimento abaixo do último método criado na sessão private.

procedure TfrmFormBaseLayout.AjustaPanel(C: TPanel);var X: TPanel;begin X := nil; case C.Tag of 0: X := Panel0; { Painel comum }

novembro2013 25

Listagem 7 – Declaração e codificação do método AjustaForm

1: X := Panel1; { Painel invisível } 2: X := Panel2; { Painel com bordas de quadro } end;

if X <> nil then begin C.Cursor := X.Cursor; C.ShowHint := X.ShowHint; C.Font.Name := X.Font.Name; C.Font.Color := X.Font.Color;

C.Alignment := X.Alignment; C.BevelInner := X.BevelInner; C.BevelOuter := X.BevelOuter; C.BevelWidth := X.BevelWidth; C.BorderStyle := X.BorderStyle; C.BorderWidth := X.BorderWidth; C.ParentColor := X.ParentColor; end;end;

Criando o método AjustaForm

Este método é o mais importante, pois ele será a ponte entre este formu-lário base de layout e todos os outros que precisarem usufruir de seus estilos padrões. Portanto deverá ser um método público, para que os demais formu-lários possam acessá-lo. O mecanismo funcionará de forma parecida com os demais métodos, será passado como parâmetro um formulário do tipo TForm, que primeiro irá verificar se as propriedades do formulário serão alteradas, logo após será feito uma varredura pelos componentes do formulário passado como parâmetro, e para cada tipo de componente será feito a chamada para o seu respectivo método. Veja na listagem 7 a declaração na sessão public e a codificação deste método.

public { Public declarations } procedure AjustaForm(Frm: TForm);

procedure TfrmFormBaseLayout.AjustaForm(Frm: TForm);var C: TComponent; I: Integer;begin

{ Ajusta apenas Form com tag 0 } if Frm.Tag = 0 then begin Frm.Cursor := Self.Cursor; Frm.ShowHint := Self.ShowHint; Frm.Font.Name := Self.Font.Name; Frm.Font.Color := Self.Font.Color;

Frm.Color := Self.Color; Frm.Position := Self.Position; Frm.BorderIcons := Self.BorderIcons; Frm.BorderStyle := Self.BorderStyle; end;

{ Ajusta os componentes visuais do Form } for I := 0 to Frm.ComponentCount - 1 do begin C := Frm.Components[I]; if C <> nil then begin if C is TLabel then AjustaLabel(TLabel(C)) else if C is TEdit then AjustaEdit(TEdit(C)) else if C is TSpeedButton then AjustaSpeedButton(TSpeedButton(C)) else if C is TPanel then AjustaPanel(TPanel(C)); end; end;end;

Vamos explicar o que ocorre no segundo trecho deste código, já que o primeiro trecho vimos em outros métodos, neste segundo trecho faremos um laço de repetição para varrer todos os componentes do parâmetro Frm, e dentro adicionamos o componente do Frm à variável C do tipo TCompo-nent. Servirá para verificarmos se é do tipo de algum componente que tenha método de configuração de estilo, como Tlabel, TEdit e os demais. Depois de garantirmos que se trata de um componente com um método definido, basta fazermos a chamada do método.

O conceito da prática é bem simples e seguindo a linha de raciocínio po-demos criar métodos para inúmeros componentes do Delphi e parametrizar várias de suas propriedades, basta depois adicionar a chamada do método nesta sequência de Ifs do método AjustaForm.

Ou seja, o que você poderá fazer utilizando esta técnica vai depender de sua criatividade. Veja na figura 1 como ficou o nosso formulário base de layout em tempo de projeto.

novembro201326

Listagem 8 – Chamada do método AjustaForm no evento OnCreate do frmTeste

suporte@theclub.com.br

Lucas Vieira de OliveiraConsultor Técnico The Club.

Sobre o autor

Figura 1 – Ilustração do frmFormBaseLayout

Testando o ajuste de layout

Chegou a hora de vermos em prática o funcionamento desses métodos. Crie mais um formulário em seu projeto no Delphi e chame de “frmTeste”

salve sua Unit com o nome “unTeste”. Adicione vários Edits, Labels, SpeedBut-tons e Panels. Altere a propriedade Tag de cada um de forma aleatória para ver os variados estilos que teremos.

Após adicionar os componentes iremos fazer a chamada do método AjustaForm, veja na listagem 8 como é simples fazer essa chamada no evento OnCreate do frmTeste.

procedure TfrmTeste.FormCreate(Sender: TObject);begin frmFormBaseLayout := TfrmFormBaseLayout.Create(Self); frmFormBaseLayout.AjustaForm(Self); FreeAndNil(frmFormBaseLayout);end;

Veja a transformação do frmTeste que fizemos para essa exemplificação nas figuras 2 (em tempo de projeto) e 3 (em tempo de execução). Antes de fazer este teste acesse o menu do Delphi (Project / Options) e mova o frmForm-BaseLayout para a lista Available forms com um clique duplo sobre seu item. Assim, o formulário principal passará a ser o frmTeste. Execute e verifique a alteração nos estilos dos componentes do formulário.

Figura 2 – frmTeste em tempo de projeto

Figura 3 – frmTeste em tempo de execução

Pode-se reparar que todos os componentes que foram configurados com Tags válidas de estilo assumiram o padrão definido. Apenas o 4º edit, “Edit com tag negativa -1”, que não assumiu nenhuma alteração, se manteve com a aparência padrão do Delphi 7. Essa foi a maneira sugerida para não se aplicar estilo base quando for necessário, basta informar uma Tag que não tenha sido definida como estilo, neste caso -1.

Conclusão

Nesse artigo vimos uma técnica de padronização de layout de formulários e componentes nos projetos em Delphi. Explicamos o conceito inicial da ideia e demonstramos o dinamismo que a ideia possui, pois ela pode servir para inúmeros componentes que podem ser inseridos nos formulários.

Demonstramos também um simples exemplo para mostrar a simplicidade de se invocar a estilização nos demais formulários – se utilizar algum formulário base para a criação dos seus forms de cadastros por exemplo, bastará fazer a chamada no form base, que esses estilos se aplicarão a todos os formulários de cadastro.

É importante lembrar que essa técnica pode ser utilizada nas demais versões do Delphi sem nenhuma restrição, até mesmo porque se trata apenas de uma codificação.

Bom pessoal, espero que tenham gostado do artigo e que o mesmo seja de grande utilidade para vocês. Um abraço a todos e até uma próxima.

novembro2013 27

Neste artigo irei abordar o uso desta ferramenta Open-Source para utilização junto com Web Services. SoapUI é uma so-lução gratuita e com uma interface gráfica muito intuitiva permitindo rapidamente consumir e testar Web Services. Para fins de curiosidade, ela foi escrita em Java e é baseada

em XML e HTTP, cuja principal função é disponibilizar serviços interativos na WEB podendo ser acessados por qualquer outra aplicação, independente de plataforma ou linguagem. Por exemplo, podemos criar um Web Service em Delphi, .Net, Java ou até mesmo utilizar um serviço pronto na internet que esta ferramenta nos proporcionará os testes com os resultados necessários facilitando todo o processo de criação e depuração por meio de uma inter-face gráfica agradável e de fácil manuseio. A seguir podemos citar umas das principais características.

Principais Características

- Software de fácil manuseio;- A Importação utilizando o protocolo WSDL é demonstrada como uma

árvore hierárquica para uma melhor visualização;- Gerencia um número ilimitado de requisições SOAP;- Geração automática de “Requests” do “Schema” associado;- Permite realização de testes funcionais e de cargas;- Formatação automática do ambiente;- Suporta expressões XPATH, entre outras...

Requisitos do Sistema

É importante lembrar que esta ferramenta é multi-plataforma, ou seja, podemos utilizá-la em qualquer Sistema Operacional. Como temos uma maioria de usuários em nosso suporte técnico iremos informar apenas os requisitos para utilização junto com o Windows.

- 1 GHz ou superior processador de 32-bit ou 64-bit;- 512 MB de RAM;- 200MB de espaço em disco para instalação;- Windows XP ou mais recente.

SoapUI - Ferramenta para Open Source para consumir Web Services

Download

Para realização do download entre no site:

www.soapui.org

Na região superior localize no Menu o descritivo “Downloads” e escolha “Download SoapUI” (No caso estamos trabalhando com a versão Freeware). Seremos redirecionados para próxima página que é onde finalizamos o processo clicando no botão “Download”. A versão que está disponível para este artigo até o momento é a versão “4.6.1” em um tamanho total de aproximadamente 150mb. Ver Figura 01.

Figura 01: Download do Software.

Instalação

A instalação é simples, o clássico “next, next, next and install”. A seguir a tela indicando que a instalação foi completada com sucesso e em seguida devemos executar o programa. Ver Imagem 02.

novembro201328

Figura 02: Concluindo a Instalação.

Observação: Geralmente no primeiro acesso poderá ocorrer o bloqueio pelo Firewall, basta permitir o acesso para prosseguir.

A tela inicial poderá ser conferida conforme a Figura 03.

Figura 03: Tela de Boas Vindas.

Criando o Exemplo

Para inicializar deveremos clicar em “File/New SOAP Project” como pode ser visto na Imagem 04. Em “Project Name” defina como “ConsultaCep” (Será o nome do projeto em questão) e em “Initial WSDL” usaremos um Web Service de consulta de ceps, o mesmo abordado em artigos anteriores. Veja abaixo o endereço completo.

http://www.byjg.com.br/site/webservice.php/ws/cep?WSDL

Figura 04: Criando um novo Projeto.

A opção “Create Request”, que significa para criarmos solicitações, deverá estar checada, pois deveremos criar solicitações para todas as operações deste Web Service. Em “Create TestSuite” iria criar uma suíte de testes para o WSDL importado, já o “Relative Paths” armazenaria todos os caminhos dos arquivos relacionados ao projeto. Portanto deixaremos apenas a primeira opção sele-cionada. Clique em Ok para darmos início ao exemplo.

Teremos uma estrutura de árvore idêntica ao da Imagem 05, contendo todos os serviços listados seguindo os métodos do Web Service em questão.

Figura 05: Navegador do Projeto.

Para efeitos didáticos e de entendimento, o exemplo deste Web Service apresentado daqui por diante irá nos retornar o logradouro a partir do CEP ou o CEP a partir do Logradouro. Possuirá alguns métodos como “ObterCEP”, “ObterCEPAuth”, “ObterLogradouro”, “ObterLogradouroAuth” e “ObterVersao”.

Usaremos o método “ObterLogradouro”, para isto clique no mesmo para expandir e com o botão direito sobre “Request” escolha “Show Request Editor”. Ver Imagem 06.

Figura 06: Solicitando o Web Service.

novembro2013 29

Listagem 01: Código XML para chamar o Método ObterLogradouro. Listagem 02: Código de retorno.

Automaticamente a ferramenta irá gerar um XML, o mesmo sendo respon-sável por invocar o método que desejamos, Veja a listagem 01.

<soapenv:Envelope xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xmlns:xsd=”http://www.w3.org/2001/XMLSchema” xmlns:soapenv=”http://schemas.xmlsoap.org/soap/envelope/” xmlns:byjg=”urn:http://www.byjg.com.br”><soapenv:Header/> <soapenv:Body> <byjg:obterLogradouro soapenv:encodingStyle=”http://schemas.xmlsoap.org/soap/encoding/”> <cep xsi:type=”xsd:string”>?</cep> </byjg:obterLogradouro></soapenv:Body></soapenv:Envelope>

Devemos-nos focar na tag:

<cep xsi:type=”xsd:string”>?</cep>

Aqui é onde informamos o parâmetro do método do Web Service, no nosso caso temos apenas um parâmetro do tipo string.

Exemplo:

<cep xsi:type=”xsd:string”>18730000</cep>

Na região superior esquerda escolha a opção “Submit request to specified endpoint URL” para termos um retorno. Ver Imagem 07.

Figura 07: Executando.

Caso não ocorra nenhum erro, o resultado será outro XML idêntico ao da listagem 02.

<SOAP-ENV:Envelope SOAP-ENV:encodingStyle=”http://schemas.xmlsoap.org/soap/encoding/” xmlns:SOAP-ENV=”http://schemas.xmlsoap.org/soap/envelope/” xmlns:ns1=”http://www.byjg.com.br” xmlns:xsd=”http://www.w3.org/2001/XMLSchema” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xmlns:SOAP-ENC=”http://schemas.xmlsoap.org/soap/encoding/”> <SOAP-ENV:Body> <ns1:obterLogradouroResponse> <return xsi:type=”xsd:string”>VOCE PRECISA ESTAR AUTENTICADO. MAIORES INFO ACESSE O SITE, Centro, Itaí, SP,</return> </ns1:obterLogradouroResponse> </SOAP-ENV:Body></SOAP-ENV:Envelope>

Devemos-nos focar no código abaixo, onde serão retornados os dados.

<return xsi:type=”xsd:string”>VOCE PRECISA ESTAR AUTENTICADO. MAIORES INFO ACESSE O SITE, Centro, Itaí, SP,</return>

A figura 08 é a interface básica para testar o acesso o Web Service.

Veja a figura 08.

Outras Funcionalidades

Test Case

Significa “Caso de Teste”. Esta funcionalidade nos proporciona realizar tes-tes com as requisições, para isto clique com o botão direito sobre a requisição Padrão criada no tópico anterior e escolha “Add to TestCase”. Aparecerá uma janela para definição de um nome da “Test Suite” e o nome do “Test Case”. (recomendo deixar como “TestSuite1” e “TestCase1” )

novembro201330

Uma “Test Suite” serve para agrupar um conjunto de “Test Cases” com características em comum. Dentro de cada “Test Case” teremos um ou mais “Test Steps”. Cada “Test Step” representa uma requisição que será enviada ao Web Service.

Figura 09: “Test Case”.

Asserções

Basicamente, as asserções são validações que são feitas para confirmar se a resposta de uma requisição contém as informações esperadas. Se as asserções falharem, o “Test Step” e o “Test Case” indicarão um status de falha.

Podemos criar uma asserção por meio da janela “Test Step Editor”, poden-do também definir asserções (ou verificações) que serão executadas contra a resposta da requisição. Outra dica para adicionar uma asserção, seria clicando com o botão direito do mouse na aba “Assertions” localizada na parte inferior da janela “Test Step Editor”. Ver Figura 10.

Figura 10: Adicionado Asserções.

Figura 08: Interface de testes.

O SoapUI oferece cinco tipos diferentes de asserções (ou verificações) para validar a resposta de uma requisição, sendo:

Schema Compliance: Valida as respostas das requisições contra o xml--schema definido no WSDL.

Simple Contains: Verifica a existência de uma string nas respostas das requisições.

Simple NotContains: Verifica a não existência de uma string nas respostas das requisições.

SOAP Fault: Verifica se a resposta da requisição não contém um soap-fault.

XPath Match: Compara o conteúdo das respostas das requisições contra uma expressão XPATH.

Referências

www.soapui.org

Conclusão

Muitas vezes nós programadores nos deparamos com situações que de-vemos consumir um web Service que nunca vimos ou até mesmo em pouco tempo hábil. Esta ferramenta se encaixa perfeitamente nestes casos, redu-zindo e muito o tempo de testes para este serviço em questão. O propósito deste artigo é de demonstrar um pouco das funcionalidades desta ferramenta gratuita. Explorei suas principais características a fim de proporcionar futuras adequações conforme achem necessário.

Um forte Abraço, até o mês que vem!

thiago@theclub.com.br

Thiago Cavalheiro Montebugnoliadora aprender novas tecnologias. Formado pela Faculdade de Tecnologia de Botucatu

– SP (FATEC), já desenvolveu softwares utilizando a plataforma .NET, Delphi junto com Banco de Dados SQL Server e Firebird. Atualmente trabalha no Centro de Processamento de Dados da Prefeitura Municipal de Itaí-SP é colunista mensal da Revista The Club Megazine e é consultor Técnico do The Club. Possui as seguintes certificações: MCP - Microsoft Certified Professional, MCTS - Microsoft Certified Technology Specialist, MCAD - Microsoft Certified Application Developer e MCSD - Microsoft Certified Solution Developer.

Sobre o autor

novembro2013 05

novembro2013