Olá pessoal, neste artigo será demonstrado como popular selects através de requisições AJAX a scripts em PHP, retornando os dados no formato JSON. Como exemplo, será construída uma página contendo listagens de Países, Estados e Cidades inseridas em selects, que serão filtrados conforme a opção selecionada.

Para construirmos esse exemplo, será necessário o seguinte ambiente de desenvolvimento, na seção links seguem endereço para downloads:

• Pacote WampServer (pode ser outro da preferência do leitor);
• Biblioteca jQuery (atualmente na versão 1.9.1);
• Editor de texto (Bloco de Notas, Notepad++, Dreanweaver, etc.);

Será utilizado CSS para melhorar o visual da única página “index.php”, mas não serão detalhadas suas funcionalidades, pois o mesmo não faz parte do objetivo desse artigo, o nome do arquivo será “estilo.css”.

Para executarmos as requisições AJAX no formato JSON, será utilizada a função “$.getJSON()”, lembrando que ela pertence à biblioteca jQuery. Então se torna indispensável linkar na página o caminho para essa biblioteca.

Visando a simplicidade, do artigo será criado apenas um script de consulta PHP, “consulta.php”, onde através do método GET serão diferenciadas as funções de consultas (PAIS, ESTADO e CIDADE). Essas funções irão retornar os dados em JSON, para posteriormente serem consumidos pela função “$.getJSON()”.

Todos os dados estão gravados em uma base de dados “atlas” no MySQL, o que torna necessário configurar uma conexão com o banco para executarmos consultas. Será criado um arquivo conexao.php contendo o script de conexão em PDO.

Como exemplo, serão adicionados na página “index.php” 3 selects, onde, conforme for selecionado um País, serão carregados os estados daquele país no select “cmbEstado”, quando selecionado um estado, serão carregadas as cidades daquele estado no select “cmbCidade”, ou seja, um filtro bem dinâmico.

O nosso banco irá conter:

• Todos os Países do mundo;
• Todos Estados (somente do Brasil);
• Todas as Cidades (somente do Brasil);

Observação: Por motivos obvieis, não foram cadastrados todos os estados de todos os países do mundo, o mesmo vale para cidades. No banco existe um cadastro aproximado de todos os Países, todos os estados do Brasil e aproximadamente todas as cidades do Brasil, mas já serve como exemplo para esse artigo.

Antes de iniciar o desenvolvimento, é interessante organizar os arquivos dentro da pasta principal do projeto para melhor entendimento e organização do exemplo.

Figura 1: Organização das pastas e arquivos

Como mencionado acima, todas as informações estão gravadas em uma base de dados “atlas” no MySQL, abaixo segue o script para criação do banco e das tabelas.

Listagem 1: Instruções SQL para criar a base de dados

CREATE DATABASE IF NOT EXISTS;

CREATE TABLE IF NOT EXISTS `pais` (
  `sigla` char(2) NOT NULL,
  `iso3` char(3) NOT NULL,
  `numcode` smallint(6) NOT NULL,
  `nome` varchar(255) NOT NULL,
  PRIMARY KEY (`sigla`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

CREATE TABLE IF NOT EXISTS `estado` (
  `id` int(2) unsigned zerofill NOT NULL AUTO_INCREMENT,
  `sigla` varchar(2) NOT NULL DEFAULT '',
  `nome` varchar(20) NOT NULL DEFAULT '',
  `pais` char(2) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=31 DEFAULT CHARSET=utf8;

CREATE TABLE IF NOT EXISTS `cidade` (
  `id` int(4) unsigned zerofill NOT NULL AUTO_INCREMENT,
  `uf` varchar(4) NOT NULL DEFAULT '',
  `nome` varchar(50) NOT NULL DEFAULT '',
  UNIQUE KEY `id` (`id`),
  KEY `id_2` (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=9715 DEFAULT CHARSET=utf8;
 

Abaixo seguem os scripts em PHP.

conexao.php

Esse script possui uma função “Conectar()”, que retorna uma conexão PDO devidamente configurada.

Listagem 2: Script para conexão com o banco de dados

<?php
function Conectar(){
	try{
		$opcoes = array(PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES UTF8');
		$con = new PDO("mysql:host=localhost; dbname=atlas;", "root", "011224", $opcoes);
		return $con;
	} catch (Exception $e){
		echo 'Erro: '.$e->getMessage();
		return null;
	}
}
?>

consulta.php

Nesse script está toda a lógica das consultas que serão consumidas na página principal através das requisições AJAX. Poderíamos criar um script para cada consulta (PAÍS, ESTADO e CIDADE), mas usando um “SWITCH” podemos selecionar qual consulta será disparada dentro do mesmo script. Conforme a requisição, também será enviado um parâmetro para a instrução SQL que também é tratado nesse “SWITCH”.

Uma vez selecionada uma das funções de consulta, a mesma irá retornar os dados no formato JSON, atendendo assim o tipo de requisição feita.

Listagem 3: Script para consultas no banco de dados

<?php
require_once('conexao.php');
$opcao = isset($_GET['opcao']) ? $_GET['opcao'] : '';
$valor = isset($_GET['valor']) ? $_GET['valor'] : ''; 
if (! empty($opcao)){	
	switch ($opcao)
	{
		case 'pais':
			{
				echo getAllPais();
				break;
			}
		case 'estado':
			{
				echo getFilterEstado($valor);
				break;
			}
		case 'cidade':
			{
				echo getFilterCidade($valor);
				break;
			}
	}
}

function getAllPais(){
	$pdo = Conectar();
	$sql = 'SELECT sigla, nome FROM pais';
	$stm = $pdo->prepare($sql);
	$stm->execute();
	sleep(1);
	echo json_encode($stm->fetchAll(PDO::FETCH_ASSOC));
$pdo = null;	
}

function getFilterEstado($pais){
	$pdo = Conectar();
	$sql = 'SELECT sigla, nome FROM estado WHERE pais = ?';
	$stm = $pdo->prepare($sql);
	$stm->bindValue(1, $pais);
	$stm->execute();
	sleep(1);
	echo json_encode($stm->fetchAll(PDO::FETCH_ASSOC));
$pdo = null;	
}

function getFilterCidade($estado){
	$pdo = Conectar();
	$sql = 'SELECT nome FROM cidade WHERE uf = ?';
	$stm = $pdo->prepare($sql);
	$stm->bindValue(1, $estado);
	$stm->execute();
	sleep(1);
	echo json_encode($stm->fetchAll(PDO::FETCH_ASSOC));
$pdo = null;		
}
?>

Observações: Foi utilizada a função “sleep()” somente para atrasar o retorno da função em 1 segundo, assim será exibido na tela uma mensagem de aviso para usuário. Não é aconselhável usar esta prática para o desenvolvimento, uma vez que o próprio processamento na WEB já acarreta certo atraso no retorno das informações.

estilo.css

Para deixar o visual da página “index.php” mais agradável, será utilizado CSS. Para o leitor que se interessar, no portal DevMedia existem vários cursos sob

...

Olá pessoal, neste artigo será demonstrado como configurar uma conexão carregando os parâmetros de um arquivo INI com extrema simplicidade. Será utilizado como exemplo uma base de dados no MySQL e para acessá-la vamos configurar componentes de conexão do ZEOS e DBExpress. É interessante mencionar que para o perfeito entendimento do artigo é necessário que o leitor tenha a suíte dos componentes ZEOS Lib instalado no Delphi.

A utilização de arquivos INI contendo parâmetros de conexão para um determinado banco de dados se tornou muito comum entre os desenvolvedores. Essa prática traz muita flexibilidade para aplicação, pois podemos alterar o local do banco, user, password, porta e etc., sem a necessidade de recompilar aplicação, sendo apenas necessário abrir o arquivo em um editor de texto comum e editá-lo conforme sua necessidade.

Esse tipo de dúvida é muito comum, principalmente envolvendo a engine de conexão ZEOS, pois a maioria dos exemplos na internet sempre é voltada para engine DBExpress. As rotinas que serão demonstradas abaixo tem como objetivo serem as mais simples possíveis, mas se for da vontade do leitor pode-se customizar essas rotinas criando uma classe específica para ler e manipular informações do arquivo INI.

Para esse artigo somente será demonstrado funções de leitura das informações do INI focando na simplicidade. Mesmo sendo apenas para leitura, existem diferentes funções recebendo os mesmos parâmetros, mas retornando diversos tipos de dados, para esse exemplo vamos utilizar somente 2 funções.

• ReadString (Retorna uma string)
• ReadInteger (Retorna um integer)

Essas funções recebem 3 parâmetros que visam mapear as informações contidas no arquivo INI:

1. Nome da Seção
2. Identificação da variável
3. Valor padrão

Nesse exemplo foi criado um arquivo “String_Conexao.ini” para carregar informações do DBExpress e ZEOS, essas informações serão diferenciadas pelo nome da seção.

Figura 1: Layout do arquivo INI.

Observem que existem 2 seções que estão entre colchetes, “[Conexao_DBX]” e “[Conexao_ZEOS]”, cada uma possui configurações específicas para conexão com as diferentes engines de acesso (DBExpress e ZEOS). Abaixo das seções estão as variáveis seguidas dos seus respectivos valores. É interessante gravar esse arquivo no mesmo diretório onde está localizado o arquivo executável da aplicação, facilitando assim sua leitura e a criação de scripts de instalação.

Como exemplo foi criado uma base de dados “devmedia” no MySQL 5.5, essa base contém apenas uma tabela meramente ilustrativa, pois a mesma não será utilizada em nenhum ponto desse artigo.

Listagem 1: Instrução SQL para criar a base de dados.

CREATE DATABASE IF NOT EXISTS `devmedia` 

CREATE TABLE IF NOT EXISTS `tb_cliente` (
  `ID` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `NOME` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8; 

Para nossa aplicação no Delphi será utilizado um Data Module e um Form apenas, sendo que o componente Data Module serve para dar mais aderência ao exemplo, pois o mesmo é amplamente utilizado nos dias atuais. O Form só terá a responsabilidade de solicitar a ABERTURA e o FECHAMENTO da conexão com o banco de dados.

O Data Module será renomeado para “dmConexao” e serão incluídos 2 componentes de conexão, segue abaixo:

Componentes

Configurações das Propriedades

...

Olá pessoal, neste artigo será demonstrado como construir uma aplicação para efetuar downloads utilizando o componente TIdHttp da paleta Indy Clients que faz a conexão entre a aplicação e o servidor de onde pretendemos baixar o arquivo.

As paletas de componentes Indy (Indy Clients, Indy Servers, Indy I/O Handlers, Indy Intercepts, Indy Misc e Indy SASL) acompanham o Delphi há várias versões. Entre os componentes mais famosos e usados frequentemente podemos citar o conjunto (TIdMessage, TIdSMTP, TIdSSLIOHandlerSocket) utilizado para envio de e-mails através do Delphi.

Mas hoje não vamos falar sobre envio de e-mails, mas sim sobre como fazer downloads no Delphi utilizando o componente TIdHttp. É muito simples, os componentes Indy facilitam muito a vida dos desenvolvedores, principalmente no controle de tráfego dos bytes.

Vamos iniciar um novo projeto no Delphi. Para essa aplicação será necessário apenas um Form, onde serão adicionados os seguintes componentes no formulário:

Componentes

Configurações das Propriedades

...

Olá pessoal, neste artigo será demonstrado um conjunto de configurações na propriedade ProviderFlags do componente TSQLQuery que possibilita gerar instruções SQL de Update e Delete para os campos de uma tabela, mesmo quando nossa consulta envolve relacionamento com várias tabelas.

No início parece meio confuso, mas com o decorrer do artigo será visto como esse tipo de funcionalidade pode ser muito útil no cotidiano.

Será utilizado o SGBD MySQL 5.5, Delphi XE e os componentes da paleta DBExpress para acessar os dados, mas nada impede de serem utilizados outros SGBDs, versões anteriores ou posteriores do Delphi ou engines de acesso (ZEOS, ADO etc.), pois essa propriedade ProviderFlags está presente em todas as engines mencionadas.

Para esse artigo vamos construir o seguinte cenário: criar um banco de dados “devmedia” contendo 3 tabelas (“cliente”, “vendedor”, “pedido”).

Tabela para cadastro de clientes

Na tabela de “cliente” vamos criar campos básicos, apenas para ilustração das informações do cliente. Segue o script abaixo:

Listagem 1: Script para criar a tabela de “cliente”

CREATE TABLE `cliente` (
  `id` smallint(11) NOT NULL AUTO_INCREMENT,
  `nome` varchar(60) DEFAULT NULL,
  `fone` char(12) DEFAULT NULL,
  `celular` char(12) DEFAULT NULL,
  `email` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

Figura 1: Clientes previamente cadastrados

Tabela para cadastro de vendedores

Na tabela de “vendedor” vamos criar apenas dois campos, sendo que o principal é nome do vendedor, segue script abaixo:

Listagem 2: Script para criar a tabela de “vendedor”

CREATE TABLE `vendedor` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `nome` varchar(40) DEFAULT NULL,
  `comissao` decimal(9,2) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

Figura 2: Vendedores previamente cadastrados

Tabela para cadastro de pedidos

Na tabela de “pedido” vamos criar alguns campos básicos, somente para ilustração, o detalhe nessa tabela são os campos que fazem relacionamento com as tabelas de “cliente” (campo id_cliente) e “vendedor” (campo id_vendedor). Notem que não vamos gravar dados do cliente como: nome, email, telefone e nem o nome do vendedor, pois essas informações serão capturadas com a instrução SQL. Segue o script abaixo:

Listagem 3: Script para criar a tabela de “pedido”

CREATE TABLE `pedido` (
  `id` smallint(11) NOT NULL AUTO_INCREMENT,
  `id_cliente` int(11) DEFAULT NULL,
  `valor_total` decimal(9,2) DEFAULT NULL,
  `data_venda` date DEFAULT NULL,
  `id_vendedor` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 

Observação: Não foram criadas chaves estrangeiras (FK) na tabela “pedido”, o objetivo do artigo não é explanar integridade dos dados, mas sim facilidades que tais configurações podem trazer. Não foi criada uma tabela de “itens_pedido”, os valores na tabela de “pedido” foram cadastrados aleatoriamente.

Figura 3: Pedidos previamente cadastrados

Finalizada a fase de criação da base de dados, vamos abrir o Delphi e criar um novo projeto. Nesse projeto será necessário apenas um formulário, onde será possível visualizar, editar e excluir registros no DBGrid. Para melhor ilustrar o desempenho das configurações na propriedade ProviderFlags, vamos utilizar um componente (TSQLMonitor) da paleta DBExpress, muito interessante para o monitoramento das instruções SQL que são enviadas para o banco de dados.

Vamos inserir no form os seguintes componentes:

Componentes

Configurações das Propriedades

...

Neste artigo será demonstrado como podemos controlar estoques internamente no MySQL usando triggers (gatilhos) e stored procedures.

Uma funcionalidade básica e obrigatória dos sistemas desenvolvidos para o comércio e empresas em geral é o controle do estoque dos produtos, desse modo o vendedor consegue consultar no sistema e verificar a disponibilidade de um determinado produto em tempo real. Com essas informações setores como compras e PCP conseguem planejar melhor as atividades de compra e produção.

Existem várias técnicas para se controlar os estoques, cada programador desenvolve um controle de estoque que atenda as necessidades do seu cliente. Aqui será demonstrada uma forma de implementar esse controle, tomando como exemplo os estoques de uma papelaria.

Vamos construir um pequeno banco de dados “PAPELARIA” usando o MySQL 5.5.24, nesse banco vamos criar quatro tabelas e alguns triggers e um procedure:

• PRODUTO
• ENTRADA_PRODUTO
• ESTOQUE
• SAIDA_PRODUTO

Abaixo segue uma breve descrição e Script para cada tabela:

TABELA “PRODUTO”

A tabela de “PRODUTO” vai conter o cadastro dos produtos que a papelaria vende, nesse exemplo foram criados somente os campos básicos para esse tipo de cadastro, segue abaixo o Script para criação dessa tabela.

Listagem 1: Script de criação da tabela Produtos

CREATE TABLE `produto` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`status` CHAR(1) NOT NULL DEFAULT 'A',
`descricao` VARCHAR(50) NULL DEFAULT NULL,
`estoque_minimo` INT(11) NULL DEFAULT NULL,
`estoque_maximo` INT(11) NULL DEFAULT NULL,
PRIMARY KEY (`id`))

Para adiantar um pouco foram cadastrados alguns produtos. Vale uma observação para o campo “STATUS”, que indica se o cadastro está ativo “A” ou inativo “I”, somente para fins didáticos.

Figura 1: Lista de produtos já cadastrados na tabela PRODUTO

TABELA “ENTRADA_PRODUTO”

Nessa tabela serão gravadas todas as compras de produtos efetuadas para papelaria e através de triggers vamos controlar as inserções na tabela de “ESTOQUE”, segue abaixo o Script para criação dessa tabela.

Listagem 2: Script de criação da tabela ENTRADA_PRODUTO

CREATE TABLE `entrada_produto` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`id_produto` INT(11) NULL DEFAULT NULL,
`qtde` INT(11) NULL DEFAULT NULL,
`valor_unitario` DECIMAL(9,2) NULL DEFAULT '0.00',
`data_entrada` DATE NULL DEFAULT NULL,
PRIMARY KEY (`id`))

Para esse artigo não estaremos usando Foreign Keys (Chaves Estrangeiras), notem que o campo “ID_PRODUTO” não está configurado como FK. Imaginem que todas as compras serão lançadas nessa tabela.

TABELA “ESTOQUE”

Essa tabela somente recebe os dados conforme as ações executadas nas tabelas de “ENTRADA_PRODUTO” e “SAIDA_PRODUTO”. O usuário não tem interação direta como INSERÇÕES, UPDATES E EXCLUSÕES, a tabela “ESTOQUE” é somente o resultado das ações de compra e venda de produtos. Segue abaixo o script para criação dessa tabela.

Listagem 3: Script de criação da tabela ESTOQUE

CREATE TABLE `estoque` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`id_produto` INT(11) NULL DEFAULT NULL,
`qtde` INT(11) NULL DEFAULT NULL,
`valor_unitario` DECIMAL(9,2) NULL DEFAULT '0.00',
PRIMARY KEY (`id`))

TABELA “SAIDA_PRODUTO”

Nessa tabela serão gravadas todas as saídas (Vendas) de produtos e através de triggers essas ações serão refletidas na tabela de “ESTOQUE”. Segue abaixo script para criação dessa tabela.

Listagem 4: Script de criação da tabela SAIDA_PRODUTO

CREATE TABLE `saida_produto` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`id_produto` INT(11) NULL DEFAULT NULL,
`qtde` INT(11) NULL DEFAULT NULL,
`data_saida` DATE NULL DEFAULT NULL,
`valor_unitario` DECIMAL(9,2) NULL DEFAULT '0.00',
PRIMARY KEY (`id`))

Agora vamos criar apenas um procedure que vai atualizar os estoques na tabela de “ESTOQUE”. Notem que nas quatro tabelas criadas existem dois campos em comum “ID_PRODUTO” e “QTDE”, são estes campos que serviram como parâmetros para inserção e baixa de estoque nos procedures.

Abaixo segue uma breve descrição e script para cada procedure.

PROCEDURE “SP_AtualizaEstoque”

Esse procedure recebe três parâmetros (id_prod, qtde_comprada, valor_unit) e tem a finalidade de inserir ou debitar produtos na tabela de “ESTOQUE” de acordo com o os parâmetros que são passados.

Listagem 5: Script de criação do procedure SP_AtualizaEstoque

DELIMITER //
  CRE

...

Olá pessoal, nesse artigo será demonstrado como executar consultas em um banco de dados MySQL utilizando AJAX e PHP. Exibir resultados de consultas utilizando PHP é bem comum, mas nesse exemplo vamos incrementar a nossa consulta utilizando AJAX.

Mas o que é AJAX?

Resposta: Ajax é uma sigla para Asynchronous JavaScript and XML. Basicamente é o uso metodológico de tecnologias como JavaScript e XML, providas por navegadores, para tornar páginas Web mais interativas com o usuário, utilizando-se de solicitações assíncronas de informações.

Observação: AJAX não é uma linguagem, mas uma forma de construir um site utilizando diversas tecnologias.

Para desenvolver esse artigo foram utilizadas as seguintes ferramentas:

• WAMPSERVER (Apache, MySQL, PHP5)
• Netbeans 7.2 (Você pode utilizar o editor de sua preferência)
• MySQL Query Browser (Gerenciamento do banco de dados)

* Todas as ferramentas podem ser adquiridas gratuitamente na internet.

Vamos criar um banco de dados “Agenda” contendo apenas uma tabela de “Contato”. Para criar a base de dados usamos a ferramenta MySQL Query Browser, segue abaixo script:

Listagem 1: Script para criar o banco “Agenda”.

CREATE DATABASE `Agenda`;
CREATE TABLE `Contato` (
  `ID` int(11) NOT NULL AUTO_INCREMENT,
  `NOME` varchar(100) DEFAULT NULL,
  `FONE` varchar(15) NOT NULL,
  `CELULAR` varchar(15) NOT NULL,
  `EMAIL` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`ID`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

Agora vamos criar três arquivos:

• index.html - vai ser nossa página de interação com o usuário;
• ajax.js - esse arquivo vai possuir toda a lógica para as requisições;
• contato.php - onde será feita a conexão com o banco e executada as consultas.

Aqui não será feito uso de CSS ou personalização de componentes na página, esse não é o foco do artigo.

O arquivo index.html

Listagem 2: Código HTML da página index.html

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title></title>
    </head>
    <body>
        <script type="text/javascript" src="ajax.js"></script>
        <div id="Container">
            <h1>Agenda de Contatos utilizando AJAX</h1>
            <hr/>

            <h2>Pesquisar Contato:</h2>
            <div id="Pesquisar">
                Infome o nome: 
                <input type="text" name="txtnome" id="txtnome"/> 
                <input type="button" name="btnPesquisar" value="Pesquisar" onclick="getDados();"/>
            </div>
            <hr/>

            <h2>Resultados da pesquisa:</h2>
            <div id="Resultado"></div>
            <hr>

        </div>
    </body>
</html>

Figura 1: Página no navegador

O código HTML não tem muito segredo, mas vale destacar duas linhas que merecem importância nesse código.

Estamos importando no arquivo que vai executar toda a mágica do AJAX:

No evento onclick do botão estamos chamando a função getDados() que foi escrita no arquivo ajax.js:

O arquivo ajax.js

Como estamos falando em arquivo ajax.js então vamos criar o código, como segue abaixo:

Listagem 3: Conteúdo do arquivo ajax.js.

/**
  * Função para criar um objeto XMLHTTPRequest
  */
 function CriaRequest() {
     try{
         request = new XMLHttpRequest();        
     }catch (IEAtual){
         
         try{
             request = new ActiveXObject("Msxml2.XMLHTTP");       
         }catch(IEAntigo){
         
             try{
                 request = new ActiveXObject("Microsoft.XMLHTTP");          
             }catch(falha){
                 request = false;
             }
         }
     }
     
     if (!request) 
         alert("Seu Navegador não suporta Ajax!");
     else
         return request;
 }
 
 /**
  * Função para enviar os dados
  */
 function getDados() {
     
     // Declaração de Variáveis
     var nome   = document.getElementById("txtnome").value;
     var result = document.getElementById("Resultado");
     var xmlreq = CriaRequest();
     
     // Exibi a imagem de progresso
     result.innerHTML = '<img src="Progresso1.gif"/>';
     
     // Iniciar uma requisição
     xmlreq.open("GET", "Contato.php?txtnome=" + nome, true);
     
     // Atribui uma função para ser executada sempre que houver uma mudança de ado
     xmlreq.onreadystatechange = function(){
         
         // Verifica se foi concluído com sucesso e a conexão fechada (readyState=4)
         if (xmlreq.readyState == 4) {
             
             // Verifica se o arquivo foi encontrado com sucesso
             if (xmlreq.status == 200) {
                 result.innerHTML = xmlreq.responseText;
             }else{
                 result.innerHTML = "Erro: " + xmlreq.statusText;
             }
         }
     };
     xmlreq.send(null);
 }

O código está comentado, mas vale ressaltar que para trabalhar com requisições AJAX temos que criar um objeto do tipo XMLHTTPRequest, mas esse objeto não é padrão para todos os navegadores, então a função “CriaRequest()” executa uma série de verificações sobre o tipo de navegador e retorn

...

Olá pessoal, neste artigo vou demostrar algumas funções que o SGBD MySQL nos fornece para manipularmos horas internamente no banco usando SQL. Geralmente efetuamos esse tipo de tratamento internamente na aplicação, independente da linguagem em que esteja sendo desenvolvida a aplicação.

Nesse artigo vou usar o MySQL 5.5.13, sem nenhum tipo de interface gráfica para gerenciamento, vamos acessar o MySQL através do prompt de comando do próprio Windows 7.

Para iniciar o prompt basta clicar em INICAR>EXECUTAR e digitar “cmd” ou vá até acessórios e selecione a opção correspondente.

Iniciando MySQL no prompt basta digitar: “mysql –u -p ”

Figura 1: Imagem inicial de acesso ao MySQL via prompt

Função CURTIME() ou CURRENT_TIME()

Vamos começar demonstrando como retornar a data atual do servidor. Podemos usar a função “CURTIME()” ou “CURRENT_TIME()”. Digite no prompt a seguinte instrução:

Listagem 1: Instrução SQL para retornar data atual do servidor

SELECT CURTIME();
ou
SELECT CURRENT_TIME();

Figura 2: Hora atual do servidor

Função TIME_FORMAT()

Essa função tem a finalidade de formatar horas, ela é muito semelhante à função “DATE_FORMAT()” para formatar datas. Podemos usar especificadores de formato tais como: hora, minuto, segundo e microsegundos. Para usá-la temos que passar 2 parâmetros, o primeiro tem que ser o valor da hora que será formatada e o segundo uma string especificando o tipo de formato.

Listagem 2: Função TIME_FORMAT(), passando como parâmetro hora atual e o formato desejado

SELECT CURTIME() AS HORA, TIME_FORMAT(CURTIME(), '%h - %i - %s') AS HORA_FORMATADA;

Figura 3: Descrição

Notem que nesse exemplo a instrução retornou 2 valores, o primeiro exibe a hora no formato normal e o segundo exibe de acordo com o formato que foi passado como parâmetro.

Observações:o parâmetro “%” é obrigatório antes de informar os caracteres de formato. Abaixo seguem alguns formatos aceitos:

Especificação

Descrição

...

Olá pessoal, neste artigo vou demostrar algumas funções que o SGBD MySQL nos fornece para manipularmos datas internamente no banco usando SQL, geralmente efetuamos esse tipo de tratamento internamente na aplicação, independente da linguagem que esteja sendo desenvolvida.

Nesse artigo vou usar o MySQL 5.5.13, sem nenhum tipo de interface gráfica para gerenciamento, vamos acessar o MySQL através do prompt de comando do próprio Windows 7.

Para iniciar o prompt basta clicar em EXECUTAR e digitar “cmd” ou vá até acessórios e selecione a opção correspondente.

Para iniciar MySQL via prompt basta digitar: “mysql –u <seu_usuário> -p <sua_senha>”

Figura 1: Imagem inicial de acesso ao MySQL via prompt

Vamos começar demonstrando como retornar a data atual do servidor, podemos usar a função CURDATE() ou CURRENT_DATE(). Digite no prompt a seguinte instrução:

Listagem 1: Instrução SQL para retornar data atual do servidor

SELECT CURDATE();
ou
SELECT CURRENT_DATE();

Figura 2: Retorno das duas funções

Podemos aproveitar esse retorno “2012-08-2012” para demonstrar outra função muito interessante. A função “DATE_FORMAT()” que recebe dois parâmetros(<data_para_formatar>, <formato_desejado>) e tem a finalidade de alterar o formato da data, geralmente trabalhamos com datas nesse formato “MM/DD/AAAA”. Podemos alterar esse retorno da seguinte maneira.

Listagem 2: Instrução SQL DATE_FORMAT()

SELECT DATE_FORMAT(CURDATE() ‘%d/%m/%Y’);

Figura 3: Data atual formatada no padrão nacional

Observações:O parâmetro “%” é obrigatório antes de informar os caracteres de formato. Abaixo seguem alguns formatos aceitos:

Especificação

Descrição

...

Olá pessoal, neste artigo vou demonstrar como trabalhar com functions e procedures no delphi, passando por definições, tipos de parâmetros de entrada, chamadas e etc.

Esse artigo é destinado para o leitor iniciante em Delphi, geralmente existe sempre a dúvida de como trabalhar com essas sub-rotinas. Para os leitores que tem conhecimento em Java ou C#, pode ser estranho esse termo procedure e function pois nessas linguagens existem somente chamada à métodos que podem ou não retornar valores, para diferenciar basta usar a palavra reservada “void” na assinatura do método, que indica que tal método não retorna valor. Já no Object Pascal linguagem base do Delphi existem várias definições diferentes em literaturas e na internet, mas em particular gosto de usar essa:

PROCEDURE: Sub-rotina que processa informações e não retorna valor.

FUNCTION: Sub-rotina que processa informações e retorna um valor.

Sintaxe:

Uma Function pode receber nenhum, um ou vários parâmetros de entrada e retornar um determinado valor, vamos a sintaxe básica:

Listagem 1: Sintaxe de um Function

Function NomeFunção(Parâmetro1:Tipo;Parâmetro2:Tipo): Tipo de Retorno;
Var
  {declaração de variáveis se necessário}
Begin
{Instruções}
//Para retornar o valor desejado podemos usar a palavra reservada Result.
Result := Valor de Retorno;

//ou o nome da função.
NomeFunção := Valor de Retorno;
End;

Um Procedure pode receber nenhum, um ou vários parâmetros de entrada mas não retorna nenhum tipo de valor, salvo exceções que explico mais adiante.

Listagem 2: Sintaxe de um Procedure

procedure NomeProcedure(Parâmetro1:Tipo;Parâmetro2:Tipo);
Var
  {declaração de variáveis se necessário}
Begin
{Instruções}
End;

Exemplos:

Vamos ao exemplo de uma função muito popular na internet para somar dois valores inteiros e retornar um valor inteiro. Notem que essa função vai receber 2 parâmetros do tipo integer e retornar a soma que é do tipo integer.

Listagem 3: Função para somar 2 valores e retornar o valor da soma

function Soma(a, b: integer): integer;
begin
    //Retorna o valor da soma a + b.
    Result := a + b;
end; 

Agora um exemplo de procedure que vai receber um valor inteiro e verificar se esse valor é par ou ímpar, ao final emite uma mensagem na tela.

Listagem 4: Procedure para verificar se o valor é par ou ímpar

procedure VerificaParImpar(a: integer);
begin
    if a mod 2 = 0 then
        ShowMessage('Número par!')
    else
        ShowMessage('Número Ímpar!');
end; 

Notem que a procedure emite uma mensagem avisando se o valor é par ou ímpar, essa mensagem não pode ser considerada com um valor de retorno mas sim parte das instruções de processamento das informações. Já no caso da function ela processa a soma de “a + b” e retorna o valor da soma, podemos atribuir esse valor a um determinado componente ou variável, na procedure não podemos executar esse tipo de atribuição, pois ela não possui valor de retorno.

Parâmetros:

Como já foi mencionado se necessário podemos passar parâmetros para functions e procedures, esses parâmetros podem ser por valor ou referência.

Valor: Nos 2 exemplos acima foram passados parâmetros por valor, ou seja, internamente no compilador será preenchido o parâmetro que está entre parênteses com uma cópia do valor de origem, para que esse valor seja usado dentro da function ou procedure, mas o valor original não será alterado, exemplo:

Listagem 5: Exemplo de parâmetro por valor

procedure TForm1.btn1Click(Sender: TObject);
var
  a, b: Integer;
begin
    //Inicia "a" com valor 1
    a := 1;
    //Variável "b" recebe o valor de retorno da função SomaValor passando a vairável "a" como parâmetro.
    b := SomaValor(a);
    //Emite mensagem com os valores
    ShowMessage('Valor de (a) antes chamada da função: ' + IntToStr(a) + #13 +
                'Valor de (b) após chamada da função: ' + IntToStr(b)  + #13 +
                'Valor de (a) após chamada da função: ' + IntToStr(a));
end;

function TForm1.SomaValor(x: integer): Integer;
begin
     //Adiciona 1000 ao valor de a
     x := x + 1000;
     //Retorna o valor de a
     Result := x;
end;

Figura 1: Mensagem exibindo os va

...

Olá pessoal, neste artigo vou demonstrar exemplos de conexões com vários SGBDs utilizando a engine de acesso ZEOSLIB. Pesquisando no Google pode-se encontrar exemplos individuais de acesso para cada um dos banco mencionados, mas nesse artigo estou utilizando as versões mais recentes de cada SGBD com exceção do SQLServer, seguem a versões:

• Firebird 2.5.1
• PostgreSQL 9.1.4
• Sqlite 3.7.13
• MySql 5.5.13
• SQLServer 2008 R2

O foco desse artigo não é apresentar comparações entre PostgreSQL, Sqlite, Firebird, MySql e SQLServer, mas sim demonstrar peculiaridades que cada conexão exige, como problemas com DLLs, Codepage, Protocolos e etc. Outro objetivo desse artigo é sanar dúvidas quanto a questão da continuidade do projeto ZeosLib, que segundo comentários a versão 7 estaria estacionada no estado Alpha ou até mesmo que o projeto estaria sendo descontinuado.

Em primeiro lugar, gostaria que os leitores visitassem o site oficial do projeto neste link: http://zeos.firmos.at/. Esse site possui um fórum muito ativo sobre todas as versões do projeto, tanto a já conhecida como versão 6.6 estável, como a versão 7 Alpha que está em teste. Existe um tópico explicando o porquê de a versão 7 ainda não ter passado para o estado Beta de teste. De acordo com os administradores do projeto, antes da versão 7 se tornar estável, ela tem que passar por 3 fases de teste, sendo:

1. Alpha
2. Beta
3. Gama

Essa prática faz com que todas as correções possíveis sejam feitas na fase de teste, ainda neste site podemos atualizar o SVN: https://zeoslib.svn.sourceforge.net/svnroot/zeoslib/branches/testing-egonhugeist para a versão de testes da comunidade. Os exemplos desse artigo foram desenvolvidos usando essa versão, o processo de instalação é o mesmo de sempre para ZeosLib. Como todo projeto OpenSource, são muito importantes as informações de problemas ou anomalias com o componente, todas as postagens de possíveis bugs no fórum são analisadas por um administrador e posteriormente corrigidas, se necessário, na versão de teste. Posteriormente uma nova verão para SVN é lançada. Essa prática é muito importante porque é através desse feedback que são corrigidos os bugs encontrados por nós programadores que utilizamos todos dias essa engine.

Para esse artigo vamos criar um banco de dados com o nome “AGENDA”, dentro desse banco criaremos uma tabela chamada “CONTATO”, lembrando que vamos criar essa mesma estrutura de banco no Firebird, MySql, SQLServer, Sqlite e PostgreSQL, ou seja, vamos repetir campos e tipos de dados. Vou postar o script para criação da tabela mas vale ressaltar que: como estamos trabalhando com 5 tipos de SGBD alguns comandos podem variar principalmente na questão do campo “ID” que é auto_increment, segue abaixo o script básico:

Listagem 1: Script para criação da tabela Contato

CREATE TABLE CONTATO(
  ID INT NOT NULL IDENTITY, 
  NOME VARCHAR(50),
  FONE VARCHAR(15),
  CELULAR VARCHAR(15), 
  EMAIL VARCHAR(50),
  PRIMARY KEY(ID));

Vamos iniciar um novo projeto no Delphi e adicionar os componentes no form, sendo que como pré-requisito temos que ter a suíte de componentes ZeosLib instalada. Vou exibir todas as configurações necessárias para o componente ZConnection, sendo que o ZTable e DataSource seguem o padrão normal de configuração.

Figura 1: Exibe os componentes da paleta Zeos Access

Observação: Notem que existem alguns componentes adicionais nessa paleta se comparado com a versão tradicional, a funcionalidade de tais componentes pode ser tema para um próximo artigo. Destacando que não é necessário utilizar ClientDataSet para navegação entre os registros, pois o componente ZTable é bidirecional e move-se tanto para cima quanto para baixo dos registros.

1 - PageControle (TPageControl) Align= alClient 5 Page, 1 para cada SGBD 5 - DBGrids (1 para cada Page) Align=alClient 5 - ZConnection 1º - Name=”ConexaoMySQL” 2º - Name=”ConexaoSQLSever” 3º - Name=”ConexaoPostgreSQL” 4º - Name=”ConexaoSQLite” 5º - Name=”ConexaoFirebird” 5 - Ztable 1º - Name=”tblMySQL” 2º - Name=”tblSQLSever” 3º - Name=”tblPostgreSQL” 4º - Name=”tblSQLite” 5º - Name=”tblFirebird” 5 - DataSource 1º - Name=”dtsMySQL” 2º - Name=”dtsSQLSever” 3º - Name=”dtsPostgreSQL” 4º - Name=”dtsSQLite” 5º - Name=”dtsFirebird”

Para conexão simultânea aos 5 SGBDs estou usando um conjunto de componentes para cada conexão (ZConnection, ZTable, DataSource), é evidente que no

...

Olá pessoal, neste artigo vou demostrar alguns comando básicos para capturar informações do DataSet que está ligado ao DBGrid. As informações contidas nesse artigo não são nenhuma novidade para os desenvolvedores Delphi mais experientes.

Notei que existem algumas dúvidas bem simples sobre como obter certas informações do DBGrid relacionadas ao DataSet ligado ao banco de dados, tais como: título das colunas, trocar o Tab pelo Enter para avançar para próxima coluna, exibir a quantidade das colunas existentes no DBGrid e etc. Alguns colegas podem se perguntar:

Mas para que eu vou usar esse tipo de informação?

Resposta: tanto os programadores mais novos quanto os mais experientes que desenvolvem aplicações ligadas a um banco de dados, já utilizara,m pelo menos uma vez na vida, esse componente DBGrid para exibir dados gravados no banco. E posso garantir que em determinadas situações foram necessárias obter algumas das informações que estarei demonstrando nesse artigo.

Para esse artigo vamos desenvolver uma aplicação bem simples, vou utilizar um DBGrid ligado à uma base de dados Firebird (EMPLOYEE.FDB), assim não teremos que perder tempo gerando script para criação de uma base de dados pois esse banco acompanha as instalações do Firebird, no meu caso ela está no seguinte endereço: “C:\Program Files\Firebird\Firebird_2_5\examples\empbuild\EMPLOYEE.FDB”.

Vamos usar como engine de acesso o Framework DBExpress. Vou arrastar para o form os seguintes componentes:

• SQLConnection (Name = “Conexao”)
• SQLTable (Name = “tblCustomer”, TableName = “CUSTOMER”, SQLConnection = Conexao)
• DataSetProvider (Name = “dspDados”, DataSet = tblCustomer)
• ClientDataSet (Name = “cdsDados”, ProviderName = dspDados)
• DataSource (Name = “dtsDados”, DataSet = cdsDados)
• DBGrid (Name = “grdDados”, DataSource = dtsDados)
• 6 Buttons:
      - Name = “btnlstCampos”, Caption = “Lista os Títulos das Colunas”
      - Name = “btnQtdeColunas”, Catpion = “Exibir Quantidade de Colunas”
      - Name = “btnTituloColuna”, Caption = “Exibir Título da Coluna selecionada”
      - Name = “btnTituloColuna”, Caption = “Exibir o conteúdo da coluna”
      - Name = “btnLengthCampo”, Caption = “Exibir o Length do Campos selecionado”
      - Name = “btnVerificaType”, Caption = “Exibir tipo de dados dos campos”
  

Observação: não vou me ater a detalhes sobre a configuração dos componentes, no portal DevMedia existem vários artigos e vídeos sobre o assunto. Nesse exemplo estou usando um SQLTable para facilitar o desenvolvimento pois essa aplicação não envolve nenhuma complexidade que necessite do uso do SQLQuery.

Figura 1: Exibe Layout final da tela

Nas listagens abaixo vamos trabalhar com evento OnClick de cada um dos botões que foram adicionados ao form. Para exibir as informações vou usar a instrução ShowMessage(). É importante salientar que esse exemplo foi baseado nas informações (quantidade de colunas, nome dos campos, tamanho e etc.) da tabela Customer que pertence ao banco de dados Employee.FDB.

EXEMPLO 1

Listagem 1: Código para o botão “btnLstCampos” listar o título de todas colunas do DBGrid

procedure TfrmPrincipal.btnLstCamposClick(Sender: TObject);
var
  I: Integer;
  s: TStringBuilder;
begin
    try
        s := TStringBuilder.Create;
        for I := 0 to grdDados.FieldCount -1 do
        begin
            s.Append(grdDados.Fields[i].FieldName + #13);
        end;
        ShowMessage(s.ToString);
    finally
        FreeAndNil(s);
    end;

...

Olá pessoal, notei que existem muitas dúvidas postadas nos fóruns sobre como gravar imagens em uma determinada base de dados e depois exibi-las na aplicação, principalmente sobre qual seria a melhor prática para esse tipo de desenvolvimento. Podemos desenvolver de 2 maneiras: a primeira seria criando um campo do tipo Blob na tabela desejada e dentro da aplicação seria codificado para gravar a imagem nesse campo, pessoalmente não gosto muito dessa técnica pois imaginem um cadastro de peças contendo 1000 imagens uma para cada peça, essa base de dados ficaria enorme e com isso poderíamos perder performance tanto da aplicação quanto do servidor. A segunda maneira seria criar um campo do tipo VARCHAR na tabela desejada e dentro da aplicação gravar no banco somente o caminho para imagem, eu sei que muitos podem questionar a questão de se trabalhar em rede, poderia ser difícil capturar as imagens em estações diferentes, nesse caso o mais sensato seria gravar essas imagens em uma pasta no servidor da rede, desse modo quando fosse necessário tanto gravação ou exibição da imagem a aplicação iria consultar somente uma pasta contendo todas as imagens no servidor.

Nesse artigo vou demonstrar a segunda maneira que é gravando somente o caminho para imagem no banco e posteriormente vamos navegar entre os registros e exibir novamente as imagens na tela, bem chega da conversa vamos codificar...

Para esse artigo criei uma base de dados utilizando o Firebird 2.5 + IBExpert com o nome de DEVMEDIA, e também uma tabela Imagens. Na listagem 1 exibe o script de criação da tabela.

Listagem 1: Script da Tabela Imagens

CREATE TABLE IMAGEM (
    ID INTEGER NOT NULL,
    TITULO_IMAGEM VARCHAR(40) CHARACTER SET WIN1252 COLLATE WIN1252,
    CAMINHO_IMAGEM VARCHAR(500) CHARACTER SET WIN1252 COLLATE WIN1252);
ALTER TABLE IMAGEM ADD CONSTRAINT PK_IMAGEM PRIMARY KEY (ID); 

Agora vamos criar um novo projeto no Delphi, e arrastar para o form alguns componentes, abaixo segue uma breve descrição sobre as configurações necessárias:

1 - TLabel
- Caption = “Descrição da Imagem:”

1 - TEdit
- Name = edtDescricao
- CharCase = ecUpperCase

1 - TImage
- Name = imgImagem
- Strech = true

1 - TDBGrid
- Align = AlBotton
- Name = grdImagem
- ReadOnly = true
- Options > dgEditing = false, dgRowSelect = true

4 - TBitBtn

1 - Name = btnCarregar
- Caption = “Carregar Imagem”
- Cursor = crHandPoint
- Hint = “Carregar Imagem”
- ShowHint = true

2 - Name = btnIncluirImagem
- Caption = “Gravar Imagem”
- Cursor = crHandPoint
- Hint = “Incluir imagem no banco de dados”
- ShowHint = true

3 - Name = btnAlteraImagem
- Caption = “Alterar Imagem”
- Cursor = crHandPoint
- Hint = “Alterar imagem gravada”
- ShowHint = true

4 - Name = btnExcluirImagem
- Caption = “Excluir Imagem”
- Cursor = crHandPoint
- Hint = “Excluir Imagem”
- ShowHint = true

Os componentes foram organizados como mostra a imagem abaixo:

Figura 1: Exibe layout final da tela

Os componentes para acesso ao banco de dados e o TOpenDialog para informar o caminho da imagem a ser gravada foram criados em RunTime, desse modo o código ficou um pouco extenso. Como a finalidade deste artigo é apenas demonstrar como podemos gravar o caminho e visualizar imagens através do das informações gravadas no banco de dados então não pretendo estender a explicação de criação de componentes em tempo de execução.

Gravar o caminho da imagem: primeiro temos que capturar seu caminho e para isso vamos usar um TOpenDialog, depois informamos uma descrição para imagem no edtDescricao e pressionamos o botão “Incluir Imagem”.

Alterar um caminho: temos que primeiro selecionar o registro no DBGrid depois pressionar o botão “Carregar Imagem” e selecionar qual será a nova imagem a ser capturado o caminho e depois pressionar o botão “Alterar Imagem”.

Excluir caminho: e bem simples, seleciona o registro no DBGrid e pressiona o botão “Excluir Imagem”.

Abaixo seguem várias listagens com os devidos códigos para o processamento das informações:

Listagem 2: Procedimento para conectar-se ao banco de dados

procedure TForm2.Conectar;
begin
    //Procedimento para conectar-se ao banco de dados
    Conexao := TSQLConnection.Create(nil);

    try
        //Passa os parâmetros para o objeto Conexao
        Conexao.Connected := false;
        Conexao.LoginPrompt := false;
        Conexao.Params.Clear;
        Conexao.ParamsLoaded := True;
        Conexao.DriverName := 'Firebird';
        Conexao.GetDriverFunc := 'getSQLDriverINTERBASE';
        Conexao.LibraryName := 'dbxfb.dll';
        Conexao.Ve

...

Olá pessoal, neste artigo vou demonstrar como melhorar o visual da aplicação usando o componente SkinManager da paleta AlphaLite(veja como instalar estes componentes aqui: Instalando Componentes Alpha Controls Lite Edition - Delphi ). Esse pacote vem com uma quantidade limitada de componentes mas pode ser usado sem limitações, caso gostem é só adquirir o pacote pago que vem com vários componentes.

No Delphi XE2 já existe uma ferramenta que altera a aparência da aplicação chamado de VCLStyles, mas as versões anteriores não possuem essa melhoria, então temos que apelar para componentes de terceiros caso seja do nosso interesse melhorar o visual da nossa aplicação, a paleta de componentes Alpha possuem botões, edit, panel, gauge, checbox e etc., entre eles temos o SkinManager como mostra a figura 1.

Figura 1: Exibe todos os componente da paleta AlphaLite.

Vamos criar uma aplicação básica com alguns componentes da paleta AlphaLite e vamos mudar a aparência do Form em tempo de execução, apenas com um clique sobre o Skin desejado.

Quando instalamos os componentes Alpha todos os Skins são copiados para uma pasta no diretório “C:\Skins”, aproximadamente 79 tipos diferentes de pele. Vamos usar um TFileListBox para listar todos os skins em tempo de execução, essa lista será carregada no evento OnCreate do Form. Vamos adicionar os seguintes componentes ao Form:

• 1 TFileListBox (renomear para lstSkin)
• 2 TsLabelFX (paleta AlphaLite)
• 1 TsSkinManager (paleta AlphaLite, renomeado para skm)

Os componentes foram arranjados da seguinte forma no formulário:

Figura 2: Exibe a organização dos componentes.

Vamos usar o componente SkinManager para gerenciar os skins da aplicação em tempo de execução. Como já foi mencionado exis

...

Neste artigo vou demonstrar como instalar o pacote de componentes AlphaControls Lite Edition, que nada mais é do que uma versão reduzida mas gratuita da suíte de componentes Alpha. Esses componentes têm como objetivo principal melhorar o visual das aplicações desenvolvidas tanto em Delphi como em C++ Builder. Uma das grandes vantagens desses componentes são as constantes atualizações, sendo que os mesmos estão disponíveis para download para todas as versões do Delphi incluindo XE2. Vamos instalar a versão gratuita que contém alguns componentes visuais e skins, nada comparado à versão paga que contém inclusive editor de skins e componentes DB-Aware.

Clique no link abaixo para download e selecione a opção “Versão Gratuita”: http://www.alphaskins.com/dwnld.php

Após baixar o pacote, descompacte-o no diretório de sua preferência, eu particularmente gosto de copiar todos os pacotes de componentes de terceiros para dentro do diretório raiz de instalação do delphi, mais precisamente dentro da pasta “Embarcadeiro”. O processo de instalação é bem simples para esse artigo vou usar o Delphi 2010. Primeiro vamos adicionar o caminho das Units(Compiladas) ao Library path no Delphi, vá até o menu “Tools/Options..”, na janela Options clique no botão “...” como mostra a figura 1.

Figura 1: Exibe a janela de configuração Options.

Na próxima janela clique no botão com a imagem de uma pasta e informe o caminho até as units, de acordo com a versão do Delphi que esteja sendo usada como mostra a figura 2.

Figura 2: Exibe a janela Directories para informa

...

Olá pessoal, vou demonstrar nesse artigo um resumo sobre alguns comandos e utilitários que acompanham a instalação do Firebird e suas finalidades, esses aplicativos estão localizados no diretório raiz de instalação do SGBD na pasta bin.

Atualmente existem vários programas para gerenciamento de banco de dados com interfaces muito amigáveis e intuitivas, no caso do Firebird um dos mais utilizados é a ferramenta IBExpert que é disponibilizada tanto com a versão free com algumas limitações, como a versão paga que vem com funcionalidades bem interessantes. O IBExpert torna a tarefa de manipulação da base da dados (CRUD) bem mais fácil e ágil, mas podem existir certas situações em que não teremos uma ferramenta gráfica para manipularmos nossa base de dados, então para essas ocasiões o próprio Firebird já disponibiliza uma ferramenta para gerenciamento do banco sem interface gráfica em que podemos trabalhar através de digitação de comandos.

Essa ferramenta fica no diretório raiz de instalação do Firebird na pasta bin, o nome do aplicativo é “isql” , com ela podemos executar consultas, inserções, updates e exclusões contra uma base de dados. Notem que nessa pasta bin existem vários aplicativos cada qual com sua finalidade especifica para executar tarefas na base de dados, como mostra a figura 1.

Figura 1: Exibe em destaque o caminho para o aplicativo isql.

Não se engane com a tela preta de prompt que surge quando se dá um duplo-click sobre o ícone isql.exe, com essa telinha feia podemos executar muitas funções.

Figura 2: Exibe a tela inicial do isql.

Agora que vimos onde encontrar o isql vamos facilitar o acesso para todos os aplicativos da pasta bin, para podermos acessar tanto o isql como os outros utilitários através do prompt do Windows é só acrescentar na variável de ambiente “Path” o caminho até a pasta bin do Firebird e reiniciar a máquina, explicação sobre como trabalhar com variáveis de ambiente não faz parte do escopo desse artigo.

Agora é só abrir o prompt e digitar isql, vamos nos conectar ao banco de dados desejado, nesse exemplo vou utilizar o banco que acompanha a instalação do Firebird, o famoso EMPLOYEE.FDB na instalação padrão fica gravado no seguinte caminho: “C:\Program Files\Firebird\Firebird_2_5\examples\empbuild\EMPLOYEE.FDB”

Para conectar - se a uma base de dados usando o isql temos que informar o user e o password, nesse caso estou usando o padrão (USER: sysdba PASSWORD: masterkey), é importante mencionar que todos os comandos digitados no isql tem que terminar com ponto e vírgula “;”.

Usamos a seguinte sintaxe: connect user password ;

...

Olá pessoal, neste artigo vou demonstrar alguns exemplos básicos de como a nova RTTI (RunTime Type Information) pode facilitar o desenvolvimento deixando nossas aplicações mais abstratas. A definição mais básica sobre RTTI seria uma variedade de informações que o compilador disponibiliza sobre os Tipos (Classes) em tempo de execução, essas informações podem ser consultadas e alteradas caso as mesmas sejam propriedades.

Esse recurso sempre esteve presente no Delphi, mas existiam algumas limitações tais como: as classes teriam que possuir a diretiva {$M+} ou serem descendentes de uma classe que possuía essa diretiva, só assim as informações poderiam ser lidas, as propriedades deveriam estar declaradas na seção published e mesmo assim o compilador ainda não fornecia informações tão precisas sobre os tipos dos objetos. A partir do Delphi 2010 a RTTI foi devidamente reformulada, incrementada e documentada.

Atualmente existem muitos exemplos de uso da RTTI na internet, nesse artigo vou demonstrar exemplos relacionados à alguns componentes da VCL, veremos como obter informações dos componentes do Form em tempo de execução e modificaremos as propriedades dos mesmos.

Uma técnica interessante para ser usada quando trabalhamos com RTTI é o TypeCast, para melhor definir essa técnica encontrei essa definição.

”Trata-se de uma forma de “forçar” o compilador a enxergar, considerar, uma variável, um valor, um objeto de um tipo específico como se fosse outro tipo. Entenda “Objeto” como uma instância de uma classe, uma variável que aloca memória dinamicamente para um determinado tipo de classe.”

A grande maioria dos eventos ligados a objetos da VCL passa como parâmetro Sender que é um ponteiro para o objeto que disparou o evento, esse ponteiro é do tipo TObject, como mostra o exemplo da figura 1, com esse parâmetro podemos fazer um TypeCast para determinado componente.

Listagem 1: Código da imagem 1

procedure TForm1.Button1Click(Sender: TObject);
begin
	
end;

Figura 1: Exibi o evento OnClick e o parâmetro Sender em destaque.

Para se fazer um TypeCast é muito simples, a própria RTTI nos fornece 2 operadores “is” e “as”, sabendo usá-los podemos atingir um código legível e ao mesmo tempo seguro contra exceptions. Podemos usar o operador “is” para v

...

Olá pessoal, neste artigo vou demonstrar como trabalhar com 3 controles bem interessantes dessa fantástica suíte de componentes ACBr. Algumas semanas atrás postei um artigo sobre como instalar esses componentes no Dephi 2010.Esse controles são de fácil utilização, não requerem muitas linhas de codificação e são extremamente úteis no nosso dia a dia.

Segue abaixo a descrição das funcionalidades de cada um:

ACBrEnterTab: Componente utilizado para simular o acionamento da tecla TAB, ou seja, avançar o foco para o próximo componente do form seguindo a ordem doTabOrder.

ACBrValidador: Componente utilizado para diversos tipos de validações numéricas,entre elas: CEP, CNPJ, Insc. Estad., CPF, Cartão de Crédito, etc...

ACBrExtenso:Componente utilizado para escrever valores monetários por extenso a partir de um valor numérico. Ex.: (1,00) -> Resultado “Um real”.

Vamos criar um novo projeto no delphie adicionar os seguintes componentes.

3 - TLabel (Para identificar nossos Edits)

4 - TEdit (Receber as informações)

3 - TButton (Para disparar os devidos eventos)

1 - TACBrValidador

1 - TACBrEnterTab

1 -TACBrExtenso

O form deve ficar semelhante a figura 1. No mesmo formpodemos trabalhar com os 3 componentes, assim o exemplo fica bem simples.

Figura 1: Exibe o layout final do form.

Nosso form possui 3 edits, no 1º edit(edtDocumento) será informado um CNPJ para testarmos o componente ACBrValidador, no 2º edit (edtValorMonetario) será informado o valor monetário para que o componente ACBrExtenso converta em valor por extenso e exiba essa informação no 3º edit (edtValorExtenso).

Agora vamos configurar os componentes:

- 1ºACBrEnterTab: Esse componente é o mais fácil, basta setar sua propriedade “EnterAsTab” para o valor true como mostra a figura 2, com isso já podemos mudar o foco entre osedits apenas pressionado a tecla enter.

Figura 2: Mostra a propriedade EnterAsTab alterada.

- 2º ACBrValidador: Nesse componente vamos alterar a propriedade “AjustarTamanho” para true, caso o CNPJ digitado não esteja com a quantidade correta de números o componente completa com zeros. Nesse exemplo alterei a propriedade “PermiteVazio” para true, com isso podemos deixar em branco o edit e pressionar o botão VALIDAR e não será disparado uma exceção. O último passo será informar o tipo de documento que será validade na propriedade “TipoDocto”nesse exemplo selecionamos “docCNPJ”.

Figura 3: Mostra todas propriedadesque foram alteradas.

...

Olá pessoal, nesse artigo vou apresentar a classe TStringBuilder que foi implementada a partir do Delphi 2009 e veio para “melhorar” a manipulação de strings. Na maioria das vezes a manipulação de strings tais como concatenação gera um certo ônus tanto para o compilador como para memória, então a partir do Delphi 2009 foi implementada a classe TStringBuilder que segundo consta na documentação veio para melhorar essa questão.

Não vou me preocupar muito com os detalhes sobre ganho de performance entre o método de concatenação normal e usando a classe TStringBuilder, até porque existe muita discordância dentro da comunidade Delphi sobre se existe vantagens e até que ponto é viável o uso dessa nova classe.

O que realmente temos de interessante é na questão do método Append, que é sobrecarregado para aceitar a inserção de diversos tipos de dados, desde strings até pontos flutuantes, sem a necessidade de especificar um tipo de conversão explicita. Na figura 1 segue a relação de tipos aceitáveis pelo método Append.

Outra coisa interessante é na questão da escrita e entendimento do código que se torna mais legível para compreensão, pois no método normal de concatenação usamos vários “+” dependendo da quantidade se torna um pouco cansativo até para manutenção do código.

Figura 1: Exibe os tipos de dados que o método Append aceita.

Vou exibir algumas comparações do modo normal e usando a classe TStringBuilder, sempre lembrando que antes de utilizar essa classe temos que instanciá-la, pois iremos trabalhar com um objeto da classe TStringBuilder.

Abaixo segue 2 exemplos de concatenações de strings, listagem 1 usando o modo normal com o operador ‘+’ e a listagem 2 usando um objeto do tipo TStringBuilder.

Li

...

Olá pessoal, nesse artigo demonstrarei como pesquisar e destacar uma palavra ou texto dentro do componente RichEdit, não é muito comum esse tipo de prática por esse motivo resolvi escrever esse artigo.

O componente RichEdit é muito usado para exibir grandes quantidades de texto tais como observações, complementos etc., sendo que em certas situações pode ser necessário destacar determinada palavra ou frase contida no texto exibido pelo componente.

Vamos construir a tela, adicione os seguintes componentes:

- 1 TEdit (para pesquisar o conteúdo do RichEdit)

- 1 TRichEdit (para exibir o texto)

Figura1: Layout final da tela.

Agora vamos adicionar um texto no RichEdit, no Object Inpector selecione a propriedade Lines e clique no botão “...”, será aberta uma nova janela como mostrado na figura 2, onde adicionaremos o texto que será exibido no componente RichEdit.

Figura2: Mostra a janela para adicionar o texto no RichEdit.

Para esse exemplo adicionei o seguinte texto:

- PORTAL

- DEVMEDIA

- TUDO EM UM SÓ LUGAR!

Agora vamos selecionar na aba Events do Object Inspector o evento OnChange do componente Edit que nesse caso foi renomeado para “edtPesquisa”, esse evento será disparado todas vez que o edtPesquisa receber um caracter.

Figura3: Mostra o evento OnChange selecionado do componente edtPesquisa.

Com um duplo clique será carregado o evento no editor, agora vamos codificar digite o seguinte código.

Listagem 1: Esta listagem mostra o código do evento OnChange

...

Bom pessoal, demonstrarei nesse artigo como instalar a suíte de componentes ACBr no delphi 2010, nessa suíte são disponibilizados vários componentes de muita utilidade para nós desenvolvedores, alguns: criação, validação e envio de NFe, preenchimento de valores numéricos por extenso, consulta de CEP via WebServices, abrir e fechar gavetas de caixas registradoras e por aí vai...

Existem muitas dúvidas sobre a instalação desses pacotes eu mesmo já tive vários problemas no início, coisa que hoje vejo que não é tão complicado assim.

Para instalar essa suíte de componentes primeiro temos que seguir alguns passos indicados no site: http://acbr.sourceforge.net/, lá será detalhado todo o processo para se baixar primeiro o SVN (Uma alternativa para ter sempre a ultima versão do projeto (a de desenvolvimento)) e posteriormente os pacotes do ACBr, uma das vantagens do SVN é que ele cria a estrutura correta de diretórios e sub-diretórios dos códigos fontes, outra vantagem é que podemos sempre atualizar os pacotes com a última versão lançada.

Após o download e instalação do SVN, vamos criar uma pasta com o nome Acbr e informar para o SVN que será nessa pasta o destino dos pacotes Acbr baixados.

Eu prefiro copiar a pasta que foi criada “Acbr” para o diretório raiz de instalação do Delphi.

Figura 1: Mostra a organização das pastas no diretório raiz do delphi 2010.

Figura 2: Mostra a disposição dos sub-diretórios da pasta Acbr.

Observação: Note que a pasta Acbr e seus sub-diretórios contém uma marcação em verde, isso significa que os códigos fontes estão com a versão mais recente ou com a versão corrente do Acbr. O SVN marca as pastas de acordo com suas atualizações. Existem outros tipo de marcadores tais como: modificada, excluída, etc... para mais detalhes acesse a propriedade settings do SVN.

A instalação não é tão complicada, mas requer alguns detalhes de início, tais como informar o caminho dos fontes no delphi, essa iniciativa reduz consideravelmente o número de erros durante o processo de instalação, geralmente executamos esse processo após a instalação do componente, mas no caso do Acbr temos que informar antes de compilar e instalar os pacotes.

Para isso abra IDE do delphi, e clique no Menu - Tools>Options>Item: Library - Win32, será exibida a janela Options como mostrado na figura 3, em Library path clique no botão “...”, será exibida outra janela Directories como mostrado na figura 4, onde será informado o caminho para os fontes do Acbr.

...