Continue lendo »]]>

O Linux, desde quando Linus Torvalds disponibilizou o projeto para a comunidade de desenvolvedores, tem sido usado com diversas finalidades em servidores de rede, super máquinas para processamento, clusters, mainframes e até mesmo embarcado em pequenos dispositivos que temos ao nosso redor. Isso aconteceu graças a sua grande flexibilidade de customização, por ser um ambiente seguro e também pela compatibilidade com os mais diversos tipos de dispositivos de hardware. Por manter o foco nessas finalidades, a interface com o usuário de desktops ficou para trás. Nessa época o sistema operacional não tinha interface gráfica, sistemas de janelas e era muito difícil instalar programas / aplicativos. Isso só mudou após o surgimento de sistemas de gerenciamento de janelas como X Window System, de sistemas de gerenciamento de ambiente de trabalho como o KDE e Gnome, de gerenciadores de pacotes como o rpm, dpkg, yum e apt.

1 – Por que usar o Linux no Desktop?

Muitas pessoas gostariam de aprender a usar o linux. Um possível primeiro passo nesse aprendizado é instalar o sistema operacional no seu próprio desktop para o uso no dia a dia. Mas esse não seria o único motivo para usar linux, existe também o fato dele ser de graça e ter o código aberto ( oposto ao Windows ). Outro fator que influi é que a quantidade de falhas de segurança é bem menor nessa plataforma do que na plataforma da Microsoft, pois nem se ouve falar sobre ameaças como vírus no linux.

2 – Qual distribuição usar?

Em vários artigos na Internet onde essa pergunta surge, os escritores sempre se esquivam dizendo que “A melhor distribuição é aquela que você mais se identifica, comece testando uma delas e troque até encontrar a sua”. Eu não direi o mesmo aqui, porque o intuito desse artigo é falar o uso do linux em desktops. Logo de cara, a melhor distribuição para se usar em desktops de iniciantes na plataforma é o Ubuntu. Ele já vem com a maioria (se não todos) os programas que você irá usar para atividades corriqueiras como navegar na Internet, digitar e editar textos e se comunicar com amigos pelo Google Talk ou MS Messeger. Além disso, quase não é necessário se fazer configurações de repositórios e com poucas dicas de uso do apt, qualquer um será capaz de instalar programas adicionais.

Você deve estar se perguntando “Por que ele falou que o Ubuntu é o melhor para usuários iniciantes e escreveu um post sobre o Debian?”. O Debian e o Ubuntu são distribuições muito parecidas, isso se deve ao fato do primeiro ser a distribuição base usada no segundo. Porém, para usuários que preferem uma instalação mais limpa, instalando apenas os aplicativos necessários para o dia a dia, aconselho o uso do Debian. Como eu falei acima, o Ubuntu já é instalado com a maioria dos programas que precisaremos, porem também virá com muitos programas que nem chegaremos a usar.

3 – Debian no Desktop

Nesse artigo, não será abordado sobre a instalação do Debian propriamente dita. O intuito do mesmo é apenas mostrar detalhes sobre a instalação de aplicativos para facilitar as atividades dos usuários.

O uso de desktops está concentrado em exercer atividades como navegar na Internet, se comunicar com seus contatos do Microsoft Messeger e Google Talk, ler e-mails, assistir vídeos, escutar músicas entre outros. Mas isso só é possível com auxílio de alguns programas. Abaixo segue uma lista de alguns aplicativos que desempenham funções relacionadas à esse uso.

Os aplicativos aqui abordados serão:

• Gnome – Gerenciador de área de trabalho
• Pidgin – Cliente de mensagem para MSN e Gtalk
• Google Chrome – Navegador de Internet
• Flashplayer Plugin – Plugin para visualização de animações em flash nos navegadores WEB
• Sun Java Plugin – Plugin de JVM (Java Virtual Machine) para navegadores WEB
• BrOffice / OpenOffice – Pacote de aplicações para escritório
• Reprodutor de mídias VLC – Reprodutor de áudio e vídeo com suporte a uma grande quantidade de formatos
• Brasero – Gravador de CDS e DVDS
• Rar – Compactador / Descompactador de pacotes rar
• Firefox – Navegador de Internet
• Thunderbird – Cliente para servidores de e-mail

3.1 – Configurando os repositórios de pacotes

Antes de mais nada, é preciso editar o arquivo /etc/apt/sources.list. Esse arquivo, após a instalação do Debian, encontra-se como abaixo.

#

# deb cdrom:[Debian GNU/Linux 6.0.2.1 _Squeeze_ - Official amd64 DVD Binary-1 20110626-16:33]/ squeeze contrib main

deb cdrom:[Debian GNU/Linux 6.0.2.1 _Squeeze_ - Official amd64 DVD Binary-1 20110626-16:33]/ squeeze contrib main

deb http://ftp.br.debian.org/debian/ squeeze main
deb-src http://ftp.br.debian.org/debian/ squeeze main

deb http://security.debian.org/ squeeze/updates main contrib
deb-src http://security.debian.org/ squeeze/updates main contrib

# squeeze-updates, previously known as 'volatile'
deb http://ftp.br.debian.org/debian/ squeeze-updates main contrib
deb-src http://ftp.br.debian.org/debian/ squeeze-updates main contrib

#tentativa de efetuar download do flash
deb http://ftp.br.debian.org/debian/ squeeze main contrib non-free

Execute o comando sudo gedit /etc/apt/sources.list no terminal(shell), comente a linha 5 usando o caractere # e adicione contrib e non-free no final das linhas 7 e 8. O arquivo deve ficar como abaixo.

#

# deb cdrom:[Debian GNU/Linux 6.0.2.1 _Squeeze_ - Official amd64 DVD Binary-1 20110626-16:33]/ squeeze contrib main

#deb cdrom:[Debian GNU/Linux 6.0.2.1 _Squeeze_ - Official amd64 DVD Binary-1 20110626-16:33]/ squeeze contrib main

deb http://ftp.br.debian.org/debian/ squeeze main contrib non-free
deb-src http://ftp.br.debian.org/debian/ squeeze main contrib non-free

deb http://security.debian.org/ squeeze/updates main
deb-src http://security.debian.org/ squeeze/updates main contrib

# squeeze-updates, previously known as 'volatile'
deb http://ftp.br.debian.org/debian/ squeeze-updates main contrib
deb-src http://ftp.br.debian.org/debian/ squeeze-updates main contrib

Após isso, execute o comando sudo apt-get update.

3.2 – Instalando aplicativos usando o apt

Todos os aplicativos acima, com exceção do Firefox e do Thunderbird (que serão instalados de forma manual), serão instalados juntos. Se você optar por não instalar um determinado programa, apenas exclua o nome do pacote do comando de instalação. Veja a relação aplicativo X pacote na tabela abaixo.

Agora que você já conhece o nome de todos os pacotes que serão instalados, o comando de instalação fica como abaixo. Execute-a no terminal(shell).

sudo apt-get install gnome pidgin google-chrome-stable flashplugin-nonfree sun-java6-plugin broffice.org vlc brasero rar

3.3 – Instalando o Firefox

O Debian já possui uma versão alternativa ao Firefox que é instalado junto com o Gnome, o Iceweasel. Os navegadores são praticante idênticos, mas algumas pessoas ainda preferem ter o Firefox ao invés do Iceweasel. Se você está entre eles, siga as instruções abaixo.

Diferente dos pacotes instalados anteriormente, é preciso se preocupar se o kernel usado é para arquiteturas de 64 bits ou 32 bits. Para saber tais informações, execute o comando abaixo no terminal (shell).

sudo uname -m

A resposta do comando acima será algo como x86_64 ou i686, onde o primeiro significa que sua arquitetura é de 64 bits e o segundo de 32 bits.

Caso sua arquitetura seja de 64 bits, efetue o download da última versão do Firefox executando os comandos mostrados abaixo no terminal (shell).

cd ~/
wget ftp://ftp.mozilla.org/pub/firefox/releases/latest/linux-x86_64/br/firefox-*.tar.bz2
sudo mkdir -p /opt/mozilla/
sudo tar -jxf firefox-*.tar.bz2 -C /opt/mozilla/
sudo mv /usr/bin/firefox /usr/bin/firefox-old
sudo ln -s /opt/mozilla/firefox/firefox /usr/bin/firefox

Já se sua arquitetura for 32 bits, basta apenas trocar o comando wget ftp://ftp.mozilla.org/pub/firefox/releases/latest/linux-x86_64/br/firefox-*.tar.bz2, mostrado logo acima, por
wget ftp://ftp.mozilla.org/pub/firefox/releases/latest/linux-i686/br/firefox-*.tar.bz2. O resto se passa exatamente igual.

Agora, está faltando apenas criar o ícone do Firefox. Isso pode ser feito criando um arquivo com o nome Firefox.desktop na Área de trabalho / Desktop com o seguinte conteúdo.

[Desktop Entry]
Name=Navegador Web Firefox
GenericName=Navegador Web Firefox
Exec=firefox %u
Terminal=false
Icon=firefox
Type=Application
MimeType=text/html;text/xml;

O Firefox também poderá ser executado digitando o comando firefox no terminal(shell).

3.4 – Instalando o Thunderbirds

A instalação do Thunderbirds é bem parecida com a do Firefox mostrada acima. Os passos serão praticamente os mesmos.

Mais uma vez, é preciso se preocupar se o kernel usado é para arquiteturas de 64 bits ou 32 bits. Para saber tais informações, execute o comando abaixo no terminal (shell).

sudo uname -m

A resposta do comando acima será algo como x86_64 ou i686, onde o primeiro significa que sua arquitetura é de 64 bits e o segundo de 32 bits.

Caso sua arquitetura seja de 64 bits, efetue o download da última versão do Firefox executando os comandos mostrados abaixo no terminal (shell).

cd ~/
wget ftp://ftp.mozilla.org/pub/thunderbird/releases/latest/linux-x86_64/br/thunderbird-*.tar.bz2
sudo mkdir -p /opt/mozilla/
sudo tar -jxf thunderbird-*.tar.bz2 -C /opt/mozilla/
sudo ln -s /opt/mozilla/thunderbird/thunderbird /usr/bin/thunderbird

Já se sua arquitetura for 32 bits, basta apenas trocar o comando wget ftp://ftp.mozilla.org/pub/thunderbird/releases/latest/linux-x86_64/br/thunderbird-*.tar.bz2, mostrado logo acima, por
wget ftp://ftp.mozilla.org/pub/thunderbird/releases/latest/linux-i686/br/thunderbird-*.tar.bz2. O resto se passa exatamente igual.

Agora, está faltando apenas criar o ícone do Thunderbird. Isso pode ser feito criando um arquivo com o nome Thunderbird.desktop na Área de trabalho / Desktop com o seguinte conteúdo.

[Desktop Entry]
Name=Cliente de E-mail Thunderbird
GenericName=Cliente de E-mail Thunderbird
Exec=thunderbird %u
Terminal=false
Icon=thunderbird
Type=Application

O Thunderbird também poderá ser executado digitando o comando thunderbird no terminal(shell).

Download do Debian

Se você ainda não instalou o Debian e não sabe como conseguir a imagem de instalação, clique aqui para ser redirecionado ao site de download da distribuição.

Acredito que agora, sua instalação estará pronta para ser usada sem muitas dificuldades. Esperto ter ajudado quem está iniciando no linux e escolheu o Debian como distribuição.

Qualquer dúvida ou sugestão, use a área de perguntas e respostas logo abaixo do post.

Continue lendo »]]>

Ultimamente, a concorrência entre Apple e Android tem feito o mercado de aplicativos para smartphones explodir. Com isso, acredito que essa é uma ótima oportunidade para programar e comercializar os seus próprios aplicativos. Mas antes de começar a programar para qualquer uma das plataformas, é preciso um ambiente de desenvolvimento instalado e configurado.

Atualmente, o Android tem dois kits de desenvolvimento, o Android NDK (Native Developement Kit), que usa como base a linguagem de programação C++, e o Android SDK (Software Development Kit), que usa como base a linguagem de programação Java. Nesse tutorial, será abordado a instalação do Android SDK.

1 – Efetuando download de arquivos necessários

Java JDK (79,5 MB) – Windows
Eclipse Classic 3.7 INDIGO (174 MB) – Windows 32 bits / Windows 64 bits

2 – Instalando o Java Development Kit (JDK)

Como eu já havia falando, o Android SDK tem como base o Java, e para que ele funcione, precisaremos do Java JDK instalado. Veja o vídeo de como instalar o Java JDK abaixo.

3 – Efetuando o Download e Instalação do Eclipse

Para desenvolver aplicativos para Android, é necessário uma boa IDE de desenvolvimento e, por esse motivo, o Eclipse não pode ficar de fora dessa instalação.

O vídeo abaixo mostra passo a passo o procedimento usado para efetuar o download e instalação do Eclipse.

4 – Instalando o Plugin ADT no Eclipse

Para que o Eclipse possa ser usado, também é necessário a instalação do ADT Plugin (Android Development Tools), esse plugin pode ser encontrado em https://dl-ssl.google.com/android/eclipse/.

O vídeo abaixo mostra detalhes da instalação do ADT Plugin.

5 – Instalando o Android SDK

Logo na sequência da instalação do plugin ADT, o Eclipse requisitará o SDK. Nesse passo, há duas opções, apontar a localização de uma instalação do Android SDK ou efetuar uma nova instalação. Nesse tutorial, foi escolhido fazer uma nova instalação.

Veja o procedimento no vídeo abaixo

Com isso, você já pode começar a construir aplicativos próprios para a plataforma Android.

Se houver alguma dúvida sobre o procedimento aqui mostrado, sinta-se a vontade para usar a área de perguntas e respostas abaixo.

Continue lendo »]]>

Welcome to jQuery UI!

Esse foi um site que sempre me inspirou, principalmente por ser rico em exemplos e permitir criar aplicações com um design interessante e de modo simples e rápido.

Não digo que esta seja a melhor biblioteca para criação de interfaces gráficas com javascript nem a mais rápida, pois a avaliação desses quesitos depende de diversos fatores, como das características do navegador e da capacidade de processamento do lado do cliente web. Mas sua utilização tem permitido criar maior dinamismo e usabilidade em interfaces web com php de uma forma muito rápida, tanto em relação a sua implementação quanto ao tempo para entender seu funcionamento.

Não domino todos seus recursos, mas abaixo posto uma brincadeira com a função dialog dessa biblioteca, idéia que surgiu no comentário do meu post anterior.

O problema consiste em criar, com um único script, chamadas para janelas diferentes.

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>jQuery UI Example Page</title>
<link rel="stylesheet" type="text/css" href="http://ajax.googleapis.com/ajax/libs/jqueryui/1/themes/redmond/jquery-ui.css">

<script src="http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"></script>

<script src="http://ajax.googleapis.com/ajax/libs/jqueryui/1/jquery-ui.min.js"></script>

<script type="text/javascript">
$(function(){

	// Dialog
	$('.dialog').dialog({
		autoOpen: false,
		width: 600,
		buttons: {
		"Ok": function() {
		$(this).dialog("close");
		},
		"Cancel": function() {
		$(this).dialog("close");
		}
		}
	});

	// Dialog Link
	$('.dialog_link').click(function(){

	$('.dialog').dialog('close');

	var id_link = $(this).attr('id');
	var index = id_link.split('_');

	$('#txt_'+index[1]).dialog('open');

	return false;

	});

	//hover states on the static widgets
	$('.dialog_link, ul.icons li').hover(
	function() { $(this).addClass('ui-state-hover'); },
	function() { $(this).removeClass('ui-state-hover'); }
	);

});
</script>
<style type="text/css">

body{ font: 62.5% "Trebuchet MS", sans-serif; margin: 50px;}
.demoHeaders { margin-top: 2em; }

.dialog_link
            {
              padding: .4em 1em .4em 20px;
              text-decoration: none;position: relative;
            }

.dialog_link span.ui-icon
            {
               margin: 0 5px 0 0;position: absolute;
               left: .2em;top: 50%;margin-top: -8px;
            }

</style>
</head>
<body>
<h1>Welcome to jQuery UI!</h1>

<h2>Dialog</h2>

<p><a href="#" id="lk_1" class="dialog_link ui-state-default ui-corner-all"><span class="ui-icon ui-icon-newwin"></span>Open Dialog 1</a></p>
<br>
<p><a href="#" id="lk_2" class="dialog_link ui-state-default ui-corner-all"><span class="ui-icon ui-icon-newwin"></span>Open Dialog 2</a></p>
<br>
<p><a href="#" id="lk_3" class="dialog_link ui-state-default ui-corner-all"><span class="ui-icon ui-icon-newwin"></span>Open Dialog 3</a></p>
<br>
<p><a href="#" id="lk_4" class="dialog_link ui-state-default ui-corner-all"><span class="ui-icon ui-icon-newwin"></span>Open Dialog 4</a></p>
<br>
<p><a href="#" id="lk_5" class="dialog_link ui-state-default ui-corner-all"><span class="ui-icon ui-icon-newwin"></span>Open Dialog 5</a></p>

<div title="Dialog Title 1" id="txt_1"  class="dialog">
<p>Lorem ipsum dolor sit amet,  Nulla nec tortor.
Donec id elit quis purus consectetur consequat. </p>
<p>Nam congue semper tellus. Sed erat dolor, dapibus sit amet,
venenatis ornare, ultrices ut, nisi. Aliquam ante.
Suspendisse scelerisque dui nec velit. Duis augue augue, gravida euismod,
vulputate ac, facilisis id, sem. Morbi in orci. </p>
</div>

<div title="Dialog Title 2" id="txt_2" class="dialog">
<p>Nulla purus lacus, pulvinar vel, malesuada ac,
mattis nec, quam. Nam molestie scelerisque quam.
Nullam feugiat cursus lacus.orem ipsum dolor sit amet, consectetur
adipiscing elit. Donec libero risus, commodo vitae, pharetra mollis, posuere eu, pede.
Nulla nec tortor. Donec id elit quis purus consectetur consequat. </p>
</div>

<div title="Dialog Title 3" id="txt_3" class="dialog">
<p>Nam congue semper tellus. Sed erat dolor, dapibus sit amet, venenatis ornare,
ultrices ut, nisi. Aliquam ante. Suspendisse scelerisque dui nec velit.
Duis augue augue, gravida euismod, vulputate ac, facilisis id, sem. Morbi in orci.
Nulla purus lacus, pulvinar vel, malesuada ac, mattis nec, quam.
Nam molestie scelerisque quam. </p>
</div>

<div title="Dialog Title 4 " id="txt_4" class="dialog">
<p>Nullam feugiat cursus lacus.orem ipsum dolor sit amet, consectetur adipiscing elit.
Donec libero risus, commodo vitae, pharetra mollis, posuere eu, pede. Nulla nec tortor.
Donec id elit quis purus consectetur consequat. Nam congue semper tellus. Sed erat dolor,
dapibus sit amet, venenatis ornare, ultrices ut, nisi. Aliquam ante. </p>
</div>

<div title="Dialog Title 5" id="txt_5" class="dialog">
<p>Suspendisse scelerisque dui nec velit.
Duis augue augue, gravida euismod, vulputate ac, facilisis id, sem. Morbi in orci.
Nulla purus lacus, pulvinar vel, malesuada ac, mattis nec, quam. Nam molestie
scelerisque quam. Nullam feugiat cursus lacus.orem ipsum dolor sit amet, consectetur
adipiscing elit. Donec libero risus, commodo vitae, pharetra mollis, posuere eu, pede.
Nulla nec tortor. Donec id elit quis purus consectetur consequat.
Nam congue semper tellus. Sed erat dolor, dapibus sit amet, venenatis ornare,
ultrices ut, nisi. </p>
</div>

</body>
</html>

Esse é um código exemplo do que se pode fazer, manipulando os atributos dos elementos HTML.
Não sei dizer se é uma “gambi” utilizar um padrão no ID das divs, de modo que eu possa inclui-las em um loop via PHP, por exemplo. Mas espero que sirva de inspiração para códigos melhores

Continue lendo »]]>

Geralmente, quando estamos dispostos a testar um novo Sistema Operacional, mas não queremos instalá-lo diretamente no nosso disco rígido, então, a melhor opção é usar um programa capaz de emular uma máquina virtual. Entre as opções de aplicativos com essa finalidade, com certeza o VirtualBox é um dos mais famosos, pois além de ser gratuito para uso doméstico, ele também nos dá a possibilidade de criar máquinas virtuais compatíveis com a maioria dos Sistemas Operacionais hoje disponíveis no mercado.

Voltando ao tema do artigo, o Guest Additions é designado para instalação dentro da máquina virtual (no Sistema Operacional virtualizado) e ele é formado por alguns drivers de dispositivos e aplicativos que servem para otimizar o funcionamento do Sistema Operacional que está sendo emulado pelo VirtualBox.

Os instaladores do Guest Additions, para todos os Sistemas Operacionais suportados, estão presentes dentro da imagem de disco VBoxGuestAdditions.iso. A mesma pode ser no diretório de instalação do VirtuaBox e montada dentro da sua máquina virtual usando o driver de CD-ROM virtual ou simplesmente clique na janela da sua máquina virtual e navegue até Devices > Install Guest Additions e a imagem será automaticamente montada dentro do sistema virtual.

Entre as principais vantagens que se tornam disponíveis após a instalação do Guest Additions, estão:

• Compartilhamento de diretórios entre o Sistema Operacional instalado na máquina física e o da máquina virtual.
• Melhor suporte a vídeo (Aceleração 3D e 2D são ativadas).
• Área de transferencia compartilhada (clipboard).
• Sincronização do relógio do Sistema Operacional hospedeiro com o Sistema Operacional emulado ou hospede.

Outras vantagens podem ser encontradas clicando aqui (Inglês).

Eis que existe um bug de instalação do Guest Additions, mais precisamente na versão 4.1.8 do instalador, quando o Sistema Operacional virtualizado é o CentOS 6.2. Porém, a resolução desse bug e instalação passo a passo podem ser encontrados aqui (Inglês)

Abaixo seguem os comandos necessários para a instalação do Guest Additions 4.1.8 no CentOS 6.2 em português.

Entre com o usuário administrador no CentOS
$ sudo su
ou
$ su

Após isso, instale os arquivos do código fonte do kernel e algumas outras ferramentas necessárias para a compilação dos arquivos.

# yum groupinstall “Development Tools”
# yum install kernel-devel

Faça o download do patch de correção do Guest Additions e salve-o dentro do diretório /root

# cd ~/
# wget http://digitaldev.com.br/downloads/el6.patch

Se for necessário, monte a imagem do CD-ROM usando o comando

# mount /dev/cdrom

Para que isso funcione, é necessário que o arquivo de disco virtual VBoxGuestAdditions.iso esteja montado no driver de cd virtual da máquina hospedada, como explicado acima.

Agora, execute os comandos abaixo. Esse exemplo é válido para arquitetura x86_64 ou 64 bits.

# cd /media/VBOXADDITIONS_4.1.8_75467/
# ./VBoxLinuxAdditions.run –noexec –target ~/TMP/
# cd ~/TMP/
# mkdir ../TMP2
# tar jxvf VBoxGuestAdditions-amd64.tar.bz2 -C ../TMP2/
# cd ../TMP2/src/vboxguest-4.1.8/vboxvideo/
# patch -p0 < ~/el6.patch
# cd ~/TMP2/
# tar jcvf ../TMP/VBoxGuestAdditions-amd64.tar.bz2 *
# cd ~/TMP
# ./install.sh

Para a arquitetura i386 (32 bits), substitua VBoxGuestAdditions-amd64.tar.bz2 por VBoxGuestAdditions-x86.tar.bz2 nos comandos acima.

Após isso, reinicie o Sistema Operacional virtual e o Guest Additions estará instalado.

Qualquer dúvida, sugestão o crítica, usem a área de perguntas e respostas abaixo.

Continue lendo »]]>

Intercalar as cores de um uma tabela ou lista está muito presente no dia a dia de um programador ou webdesigner. Se você é desenvolvedor web, sabe bem do que estou falando.

Já vi muitos programadores escrevem códigos PHP ou ASP para produzir esse efeito de zebra, já vi tambem alguns webdesigners usam CSS + JavaScript para isso. Mas, graças ao CSS3, isso se tornou possível usando apenas duas linhas de código CSS.

tr:nth-child(even) {background: #FFF}
tr:nth-child(odd) {background: #EEE}

onde “even” corresponde às linhas pares e “odd” às linhas impáres.

esse pequeno bloco de código pode tambem ser usado em conjunto com vários outros componentes HTML ou em classes CSS. Veja um exemplo do uso em Listas.

li:nth-child(even) {background: #FFF}
li:nth-child(odd) {background: #EEE}

Agora, veja um exemplo do uso do zebrado anexado a uma classe css feita para formatar uma tabela.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
	<style type="text/css">

		/*css global tabela*/
		.full_table_list{width: 200px;border-collapse: collapse;}

		/*colocando bordas nas linhas*/
		.full_table_list tr{border:1px black solid;}

		/*Definido cor das linhas pares*/
		.full_table_list tr:nth-child(even) {background: #FFF}

		/*Definindo cor das Linhas impáres*/
		.full_table_list tr:nth-child(odd) {background: #EEE}		

	</style>
</head>

<body>
	<table class="full_table_list">
		<tr>
			<td>
				Linha 1
			</td>
		</tr>
		<tr>
			<td>
				Linha 2
			</td>
		</tr>
		<tr>
			<td>
				Linha 3
			</td>
		</tr>
		<tr>
			<td>
				Linha 4
			</td>
		</tr>
	</table>
</body>
</html>

Isso reproduziu o efeito mostrado na imagem abaixo.

Eu não sou nenhum especialista em CSS, mas se houver alguma dúvida relacionado ao assunto do post, usem a área de perguntas e respostas abaixo.

Continue lendo »]]>

Com o crescimento do Facebook como rede social, o desejo de desenvolvedores e donos de sites em conectar suas aplicações web com a mais famosa rede social do mundo vem se tornando cada vez mais comum.

Se você se enquadra nesse grupo de desenvolvedores, então veio ao lugar certo, pois nesse post irei explicar como conectar o seu site feito em PHP com o Facebook seguindo alguns passos e usando uma classe de comunicação escrita em PHP.

1º Passo – Criando uma App no Facebook

Antes de começarmos, precisaremos criar uma App do Facebook, ela servirá como um canal de comunicação entre o nosso script PHP e a rede social.

Entre no Facebook e efetue login usando seu usuário e senha, logo após, acesse a página de desenvolvedores do Facebook pelo endereço https://developers.facebook.com/ e clique em Aplicativos.

Na próxima página, clique em + Criar Novo Aplicativo.

Uma caixa de formulário se abrirá no meio da tela, preencha a mesma de acordo com os dados (nome) do aplicativo que você deseja criar e clique em Continuar.

Na próxima página, preencha o campo de validação de acordo com o texto que aparece na imagem e clique em Enviar.

Para garantir que sua conta de usuário no Facebook está realmente ligada a uma pessoa e que ela não é uma conta fake, o Facebook dirá que a conta precisa ser verificada. Você poderá fazer isso adicionando seu número de celular o cartão de credito (se você for usuário das operadoras Vivo ou Oi, aconselho optar pela validação por cartão de crédito)

Observação: Se sua conta no Facebook já foi validada anteriormente, você será redirecionado para a pagina final da criação do App.

Validação por Celular

Ao escolher a validação por celular, uma janela para adicionar seu telefone será exibida. Preencha a mesma como seu telefone e clique em Confirmar.

Na próxima tela, um código será requisitado, provavelmente você recebeu esse código por SMS. Preencha o campo com tal código e clique novamente em Confirmar.

Observação: Talvez o SMS demore alguns minutos, mas se o mesmo não chegar, clique em reenviar código ou refaça o procedimento optando pela validação por cartão de crédito.

Validação por Cartão de Crédito

Ao escolher a validação por cartão de crédito, sua senha poderá ser novamente requisitada. Preencha o campo Senha e clique em Continuar

Preencha o formulário de acordo com os dados do seu cartão de crédito e clique em Salvar.

Se tudo correu bem com a validação via cartão, o Facebook irá exibir os dados do seu cartão na próxima pagina.

Voltando para a criação do aplicativo

Após os passos de validação da conta, tanto via telefone ou cartão de credito, volte a página de criação do aplicativo. Se você não fechou a mesma, a página de criação da APP deve estar aberta em paralelo com a de validação da conta, caso contrario, terá que recomeçar o processo de criação do App (o processo de validação da conta não se repetirá)

Na tela mostrada pela imagem abaixo, clique em Continuar.

Novamente, você deve preencher o campo de validação de acordo com o texto que aparece na imagem mostrada pelo Facebook e clicar em Enviar.

Se tudo correu bem até agora, uma página com os dados da sua App do Facebook será mostrada. Nela você poderá modificar os dados da aplicação e fazer upload de um ícone.

Nessa página, preencha o campo App Domain com o domínio do seu site e o campo Site Url com a url de onde seu código de integração se encontra. No meu caso, o meu dominio é digitaldev.com.br e a pasta onde coloquei o script de integração é http://digitaldev.com.br/facebook, por esse motivo, preenchi os campos como mostra a imagem abaixo.

Ainda na mesma página, anote os números de App ID e App Secret. Pois eles serão usados pelo nosso script PHP para fazer referencia ao App do Facebook. Veja a localização dos mesmos visualizando a imagem abaixo.

Ao final do processo, clique em Salvar alterações

2º Passo – Escrevendo o script PHP

Para facilitar o nosso trabalho, iremos usar uma classe para gerenciar a comunicação entre nossa aplicação e o Facebook. Efetue o download da mesma clicando aqui.

Ao descompactar o pacote, constataremos a existência de alguns exemplos de uso da classe, mas os arquivos que realmente serão usados são os que se encontram dentro da pasta src. Copie-os para uma pasta dentro da sua aplicação, pois você precisará efetuar um include ou require deles dentro do arquivo de integração.

Vamos ao código PHP

<?php
//incluindo a classe de conexão com o facebook
require_once 'FacebookApi/facebook.php';

/*
* ID da App, vocé obteve isso na ultima
* página de geração do seu aplicativo no facebook
*/
$App_ID = '';

/*
* App Secret, você obteve isso na ultima
* página de geração do seu aplicativo no facebook
*/
$App_Secret = '';

//Instanciando o Objeto da classe do facebook
$facebook = new Facebook(array(
	    'appId'  => $App_ID ,
	    'secret' => $App_Secret
));

//Pegando Id do usuário Logado
$o_user = $facebook->getUser();

/*
* Verificando se está conectado
*/
if($o_user == 0)
{

	//Envia para a página de permissão do facebook, nela voce irá dar permissão ao aplicativo
	//acessar dados da sua conta
	$url = $facebook->getLoginUrl(array('scope' => array('publish_stream','read_stream')));
	header("Location:".$url);
}
else
{
	//Verificando se o comando de logout foi enviado
	if($_GET['action'] == 'finish' )
	{
		//Retirando a permissão do Aplicativo à sua conta no facebook
		session_destroy();
		header('Location: '.$facebook->getLogoutUrl());
	}
	else
	{
		//Atualizando seu status no facebook
		if( $_GET['action'] == 'publish' && strlen($_POST['status']) > 0 )
		{
			$post =  array('message' => $_POST['status']);
			$feed = $facebook->api('/me/feed', 'POST', $post);
		}
		else
		    //pegando as publicações do seu mural
			$feed = $facebook->api('/me/feed');
			//Use var_dump($feed) ou print_r($feed)
			//para ver todos os campos retornados

		//pegando as informações do usuário conectado
		$me = $facebook->api('/me');
		//Use var_dump($me) ou print_r($me)
		//para ver todos os campos retornados

		//pegando as publicações da sua home
		$home = $facebook->api('/me/home');
		//Use var_dump($home) ou print_r($home)
		//para ver todos os campos retornados
	}
}

?>

<!DOCTYPE unspecified PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
  <head>
   <title>Integração com o Facebook</title>
   <meta content='text/html; charset=utf-8' http-equiv='Content-Type'>
  </head>
  <body>
  <div align="center">
	<table width='600' border='1'>
		<tr>
			<td colspan="4" align="center">
				<a href="<?php echo $me['link']?>">
					<?php echo $me['name']?>
				</a>
			</td>
		</tr>
		<tr>
			<td align="right">
				Primeiro Nome:
			</td>
			<td align="center">
				<?php echo $me['first_name']?>
			</td>
			<td align="right">
				Ultimo Nome:
			</td>
			<td align="center">
				<?php echo $me['last_name']?>
			</td>
		</tr>
		<tr>
			<td align="right">
				Cidade Natal:
			</td>
			<td align="center">
				<?php echo $me['hometown']['name']?>
			</td>
			<td align="right">
				Cidate onde mora:
			</td>
			<td align="center">
				<?php echo $me['location']['name']?>
			</td>
		</tr>
	</table>
	<br/>

	<?php
	//Imprimindo publicações do mural do usuário
	if(is_array($feed['data']))
	{
	?>
		<table width="700" border="1">
			<tr>
				<td align="center">
					Seu Mural
				</td>
			</tr>
			<?php
			foreach($feed['data'] AS $hist)
			{
			?>
			<tr>
				<td align="center">
					<?php
					if(isset($hist['story']))
						echo $hist['story'];
					else
					{
						echo $hist['message'].'<br/>';
						if(isset($hist['picture']))
						?>
						<img src='<?php echo $hist['picture']?>'>
						<?php
					}
					?>
				</td>
			</tr>
			<?php
			}
			?>
		</table>
		<br/>
	<?php
	}
	?>

	<?php
	//imprimindo publicações da home do usuário
	if(is_array($home['data']))
	{
	?>
		<table width="700" border="1">
			<tr>
				<td align="center">
					Home
				</td>
			</tr>
			<?php
			foreach($home['data'] AS $hist)
			{
			?>
			<tr>
				<td align="center">
					<?php
					if(isset($hist['story']))
						echo $hist['story'];
					else
					{
						echo $hist['message'].'<br/>';
						if(isset($hist['picture']))
						?>
						<img src='<?php echo $hist['picture']?>'>
						<?php
					}
					?>
				</td>
			</tr>
			<?php
			}
			?>
		</table>
		<br/>
	<?php
	}
	?>

	<div>
		<form action="?action=publish" method="POST">
			<textarea name="status" rows="4" cols="20"></textarea>
		<br/>
		<button type="submit">Enviar</button>
		</form>
	</div>

	<a href="?action=finish">Sair</a>
</div>
</body>
</html>

Como você pode observar no código acima, eu copiei todo o conteúdo da pasta src do pacote que fizemos download para uma pasta chamada FacebookApi na raiz da pasta do meu script.

Para ver esse código funcionando, acesse http://digitaldev.com.br/facebook

Para fazer o download do código fonte do exemplo acima, clique aqui

Para melhorar o seu entendimento do código do exemplo, leia as documentações abaixo.
Graph API – https://developers.facebook.com/docs/reference/api/
PHP SDK overview – https://developers.facebook.com/docs/reference/php/

Espero ter ajudado aos leitores que desejam efetuar a integração entre uma aplicação em PHP e o Facebook. Qualquer dúvida, entre em contato usando a área de perguntas e respostas desse post.

Continue lendo »]]>

Web 2.0 está aí, exigindo cada vez mais interatividade dos sites com os usuários.

Como conseguir isso?

Um dos modos, é utilizando javascript, o que pode não ser tão fácil assim.

Por isso, existem bibliotecas gratuitas com MooTools, Dojo, Script.aculo.us e Prototype, que simplificam o desenvolvimento de aplicações web.

Entre elas, está jQuery, com vasta documentação e constante atualização.

Mas… Por que utilizar jQuery?

Porque ela pode reduzir o tempo de criação, por exemplo, de efeitos visuais em uma página html.

Como o próprio slogan diz: ” Escreva menos, faça mais” (Write less, do more).

É possível criar animações com pouquíssimas linhas de código javascript, ao invés de utilizar flash ou outros recursos.

Quer um exemplo? Que tal brincar um pouco com o efeito drag ‘n drop (arrastar e soltar) nessa página?

http://jqueryui.com/demos/droppable/#photo-manager

Outro fator importante é a grande compatibilidade entre navegadores.

Você não precisa se preocupar com a criação de funções específicas para cada um; a biblioteca já compatibiliza o código para você.

É possível utilizar requisições ajax de maneira muito fácil.

Gostou? Quer uma dica?

O jQuery tornou-se popular pelos inúmeros plugins disponíveis na internet. Esses plugins permitem criar novas funções com base nessa biblioteca.

A dica de hoje é o plugin para criação de máscara para moeda em campos html, ou seja, esse campo exibirá as casas decimais na digitação, por exemplo, do preço de um produto.

Recomendo o plugin MaskMoney.

Qual a diferença dos demais?

Ele permite a edição do campo sem a necessidade de apagar o valor completamente.

Muitas das máscaras disponíveis apresentam um bug quanto a isso.

É possível também customizar a máscara, para exibição de mais de duas casas após a vírgula com apenas uma linha de código.

Simples, não?

Mas cuidado na criação de código jQuery. Lembrem-se sempre de que o código é executado no navegador do cliente, então, se o código não for muito grande, pode travar o programa.

Fica a dica sobre alta performace com essa biblioteca:

http://geeklove.com.br/2009/11/09/escrevendo-jquery-de-alta-performace/

Continue lendo »]]>

Em uma aplicação Web dinâmica, as entradas de dados (formulários, Web Services, importação de arquivos) são responsáveis por alimentar e manter atualizada a nossa base de dados, ao mesmo tempo, essas entradas podem ser uma porta aberta para dados mal formatados, ataques do tipo script injection ou qualquer outro tipo de sujeira.

Nesse post iremos construir uma classe de validação que será capaz de filtrar, validar e criticar os dados de entrada de uma aplicação, garantindo a integridade dos dados e impedindo ataques.

Requerimentos

Para facilitar o entendimento do código abaixo, aconselho a leitura da documentação da classe Exception e das funções isset, strlen, str_replace, is_numeric, mb_detect_encoding, htmlentities, html_entity_decode, nl2br, strip_tags no site www.php.net.

1º Passo – Criando uma classe de tratamento de erros

Iremos criar uma classe para gerenciar os erros e exceções geradas por nossas classes principal e secundária e para que ela funcione adequadamente, deverá ser herdeira da classe Exception (nativa do PHP).

class DDException extends Exception
{

}

Você deve estar se perguntando “Por que não usar a classe Exception, já que a classe herdeira não tem nada implementado?”. Minha resposta é “Se em algum momento quisermos adicionar algum controle de erros ainda não implementado na classe Exception, basta modificar a classe DDException e tudo será resolvido”.

2º Passo – Implementando classe de gerenciamento dos dados a serem validados

Essa será a classe principal, ela será usada para armazenar e gerenciar os nossos dados

class DDDataValidation
{
	private $v_data_values;
	private $v_data_itens_object;

	//constantes de charset
	const UTF_8 = 1;
	const ISO_8859_1 = 2;

	//constantes para formato de data
	const DATE_EN = 1;
	const DATE_BR = 2;

	//constantes de erro
	const ErrorEmpty = 1;
	const ErrorNumeric = 2;
	const ErrorMaximum = 3;
	const ErrorMinimum = 4;
	const ErrorCPF = 5;
	const ErrorEmail = 6;
	const ErrorDate = 7;

	function __construct()
	{
		$this->v_data_values = array();
		$this->v_data_itens_object = array();
	}

	/**
	* Adiciona dados para ser validados
	*
	* @param string $st_alias - Alias definido pelo desenvolvedor para fazer referencia ao dado
	* @param mixed $mx_data - Dado a ser validado
	*/
	public function setData($st_alias,$st_value)
	{
		$this->v_data_values[$st_alias] = $st_value;
		$this->v_data_itens_object[$st_alias] = new DDDataValidationItem(addslashes($st_value));
	}

	/**
	* Retorna um objeto contendo dados a serem validados
	*
	* @param string $st_alias - Alias definido pelo desenvolvedor para fazer referencia ao dado
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function getData($st_alias)
	{
		if(isset($this->v_data_itens_object[$st_alias]))
			return $this->v_data_itens_object[$st_alias];
		else
			throw new DDException('Alias '.$st_alias.' not found');
	}

	/**
	* Retorna os dados sem nenhuma modificação
	*
	* @param string $st_alias - Alias definido pelo desenvolvedor para fazer referencia aos dados
	* @throws DDException
	*/
	public function getOriginal($st_alias)
	{
		if(isset($v_campos[$st_alias]))
			return $v_data_values[$st_alias];
		else
			throw new DDException('Alias '.$st_alias.' not found');
	}

	/**
 	* Retorna a quantidade de erros, idenpendente
 	* do alias referente ao campo
 	*
 	* @return integer
	*/
	public function countErrors()
	{
		foreach($this->v_data_itens_object AS $data_objects)
			$in_errors += $data_objects->countErrors();
		return $in_errors;
	}
}

3º Passo – Implementando classe responsável pelos filtros

Nesse momento, iremos implementar uma classe secundária. Ela será responsável por encapsular o dado propriamente dito e por executar os métodos de restrição, filtro e conversão dos dados.

class DDDataValidationItem
{
	private $mx_value;
	private $v_error;
	private $v_boolean_error;

	/**
	* O valor do dado pode ser definidos ou não
	*
	* @param mixed $mx_value
	*/
	function __construct($mx_value = null)
	{
		if($mx_value != null)
			$this->set($mx_value);
	}

	/**
	* Recebe o dado à ser validado
	*
	* @param mixed $mx_value
	*/
	public function set($mx_value)
	{
		$this->mx_value = $mx_value;
	}

	/**
	* Retorna o dado validado
	*
	* @return mixed
	*/
	public function get()
	{
		return $this->mx_value;
	}

	/**
	* Retorna, se houver, o erro referente ao alias de verficação
	*
	* @param flag $mx_erro_code
	* 	Use DDDataValidation::ErrorEmpty - retorna o erro de preenchimento do campo
	*		DDDataValidation::ErrorNumeric - retorna o erro da validação de numero
	*		DDDataValidation::ErrorMaximum - retorna o erro da validação de quantidade de caracteres
	*		DDDataValidation::ErrorMinimum - retorna o erro da validação de quantidade de caracteres
	*		DDDataValidation::ErrorCPF - retorna o erro da validação de CPF
	*		DDDataValidation::ErrorEmail - retorna o erro da validação de e-mail
	*		DDDataValidation::ErrorDate - retornar o erro da validação de data
	*
	* @return string
	*/
	public function getErrorMsg($mx_erro_code)
	{
		if(isset($this->v_error[$mx_erro_code]))
			return $this->v_error[$mx_erro_code];
		else
			return new DDValidationItem();
		return $this->v_error[$mx_erro_code];
	}

	/**
	* Retorna o último erro ocorrido
	*
	* @return string
	*/
	public function getLastErrorMsg()
	{
		$st_message = end($this->v_error);
		if(isset($st_message))
			return $st_message;
	}

	/**
	* Retorna o primeiro erro ocorrido
	*
	* @return string
	*/
	public function getFirstErrorMsg()
	{
		$st_message = reset($this->v_error);
		if(isset($st_message))
			return $st_message;
	}

	/**
	* Retorna positivo se houver erro e nega
	*
	* @param mixed $mx_erro_code - Alias de referencia do campo
	* @return boolean
	*/
	public function getError($mx_erro_code)
	{
		if(isset($this->v_boolean_error[$mx_erro_code]))
			return $this->v_boolean_error[$mx_erro_code];
	}

	/**
	* Retorna todos os erros, separados apenas pelo delimitador
	*
	* @param character $ch_delimiter - Delimitador
	* @return string
	*/
	public function getAllErrosMessages($ch_delimiter = ' - ')
	{
		foreach($this->v_error AS $st_error)
			if(isset($st_all_error))
				$st_all_error .= $ch_delimiter.$st_error;
			else
				$st_all_error .= $st_error;
		return $st_all_error;
	}

	/**
	* Retorna a quantidade de erros gerados para aquele campo
	*
	* @return integer
	*/
	public function countErrors()
	{
		return count($this->v_error);
	}

	/************************/
	/* Métodos de restrição */
	/************************/

	/**
	* Verifica se o dado passado está vazio
	*
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	*/
	public function isEmpty( $st_message = null, $mx_error_code = DDDataValidation::ErrorEmpty )
	{
		$mx_value = $this->trim()->get();
		if(!(strlen($mx_value) > 0))
		{
			if($st_message != null)
				$this->v_error[$mx_error_code] = $st_message;
			$this->v_boolean_error[$mx_error_code] = TRUE;
		}
		return $this;
	}

	/**
	* Verifica se o dado passado é um numero
	*
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	*/
	public function isNumeric( $st_message = null, $mx_error_code = DDDataValidation::ErrorNumeric )
	{
		$mx_value = $this->trim()->get();
		$mx_value = str_replace(',', '.', $mx_value);
		if(!(is_numeric($mx_value)))
		{
			if($st_message != null)
				$this->v_error[$mx_error_code] = $st_message;
			$this->v_boolean_error[$mx_error_code] = TRUE;
		}
		return $this;
	}

	/**
	* Verifica se o dado passado tem quantidade de
	* caracteres acima do limite passado como parametro
	*
	* @param integer $in_max_caracter_count - Quantidade máxima de caracteres
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function isMaximum( $in_max_caracter_count , $st_message = null , $mx_error_code = DDDataValidation::ErrorMaximum )
	{
		if(is_int($in_max_caracter_count))
		{
			if((strlen($this->mx_value) >= $in_max_caracter_count))
			{
				if($st_message != null)
					$this->v_error[$mx_error_code] = $st_message;
				$this->v_boolean_error[$mx_error_code] = TRUE;
			}
		}
		else
			throw new DDException('the variable in_max_caracter_count isn\'t numeric');
		return $this;
	}

	/**
	* Verifica se o dado passado tem quantidade de
	* caracteres abaixo do limite passado como parametro
	*
	* @param integer $in_min_caracter_count - Quantidade mínima de caracteres
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function isMinimum( $in_min_caracter_count , $st_message = null , $mx_error_code = DDDataValidation::ErrorMinimum )
	{
		if(is_numeric($in_min_caracter_count))
		{
			if(strlen($this->mx_value) <= $in_min_caracter_count)
			{
				if($st_message != null)
					$this->v_error[$mx_error_code] = $st_message;
				$this->v_boolean_error[$mx_error_code] = TRUE;
			}
		}
		else
			throw new DDException('the variable in_min_caracter_count isn\'t numeric');
		return $this;
	}

	/**
	* Verifica se o dado é um CPF válido
	*
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	*/
	public function isCPF( $st_message , $mx_error_code = DDDataValidation::ErrorCPF )
	{
		$st_cpf = $this->mx_value;
		$st_cpf = str_pad(ereg_replace('[^0-9]', '', $st_cpf), 11, '0', STR_PAD_LEFT);
		if
		(
			strlen($st_cpf) != 11 ||
			$st_cpf == '00000000000' ||
			$st_cpf == '11111111111' ||
			$st_cpf == '22222222222' ||
			$st_cpf == '33333333333' ||
			$st_cpf == '44444444444' ||
			$st_cpf == '55555555555' ||
			$st_cpf == '66666666666' ||
			$st_cpf == '77777777777' ||
			$st_cpf == '88888888888' ||
			$st_cpf == '99999999999'
		)
			$this->v_error[$mx_error_code] = $st_message;
		else
			for ($t = 9; $t < 11; $t++)
			{
				for ($d = 0, $c = 0; $c < $t; $c++)
					$d += $st_cpf{$c} * (($t + 1) - $c);

				$d = ((10 * $d) % 11) % 10;
				if ($st_cpf{$c} != $d)
				{
					if($st_message != null)
						$this->v_error[$mx_error_code] = $st_message;
					$this->v_boolean_error[$mx_error_code] = TRUE;
				}
			}
		return $this;
	}

	/**
	* Verifica se o dado é um e-mail válido
	*
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	*/
	public function isEmail( $st_message , $mx_error_code = DDDataValidation::ErrorEmail )
	{
		$st_email = $this->mx_value;
		$bo_valid = eregi
		(
			"^[0-9a-z]([-_.]?[0-9a-z])*@[0-9a-z]([-.]?[0-9a-z])*\\.[a-z]{2,3}$",
			$st_email,
			$check
		); 

		if(!$bo_valid)
		{
			if($st_message != null)
				$this->v_error[$mx_error_code] = $st_message;
			$this->v_boolean_error[$mx_error_code] = TRUE;
		}
		return $this;
	}

	/**
	* Verifica se o dado é uma data válida
	* @param integer $in_format - Usado para definir qual o formato da data
	* 		Use DDDataValidation::DATE_BR para formato DD/MM/AAAA
	* 		Use DDDataValidation::DATE_EN para formato AAAA/MM/DD
	*
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function isDate( $st_message = null , $in_format = DDDataValidation::DATE_BR , $mx_error_code = DDDataValidation::ErrorDate )
	{
		$dt_date = $this->mx_value;
		$v_date = preg_split('/[[:punct:]]/',$dt_date);
		if( !is_numeric($v_date[0]) || !is_numeric($v_date[1]) || !is_numeric($v_date[2])  )
		{
			{
					if($st_message != null)
						$this->v_error[$mx_error_code] = $st_message;
					$this->v_boolean_error[$mx_error_code] = TRUE;
				}
			return $this;
		}

		if($in_format == DDDataValidation::DATE_BR)
		{
			$in_day = $v_date[0];
			$in_month =  $v_date[1];
			$in_year =  $v_date[2];
		}
		elseif($in_format == DDDataValidation::DATE_EN)
		{
			$in_day = $v_date[2];
			$in_month =  $v_date[1];
			$in_year =  $v_date[0];
		}
		else
			throw new DDException('Invalid value for variable $in_format');

		if (!checkdate( $in_month , $in_day , $in_year ))
			$this->v_error[$mx_error_code] = $st_message;
		return $this;
	}

	/*********************/
	/* Métodos de filtro */
	/*********************/

	/**
	* Retira, por padrão, caracteres de espaço ( ), tab (\t), retorno de carro (\r)
	* e quebra de linhas (\n) no inicio e no fim do dado. Pode ser personalizada
	* usando a variável $st_characters
	*
	* @param string $st_characters - Caracteres que devem ser retirados no inicio
	* 		e no fim do dado, o valor padrão é " \t\n\r"
	*
	* @return DDDataValidationItem
	*/
	public function trim( $st_characters = " \t\n\r" )
	{
		$this->mx_value = trim( $this->mx_value , $st_characters );
		return $this;
	}

	/**
	* Retira, por padrão, todas as tags HTML encontradas no dado
	*
	* @param string $allowable_tags - Use-a para permitir tags especificadas
	* @return DDDataValidationItem
	*/
	public function noHTML( $allowable_tags = '' )
	{
		$this->mx_value = strip_tags($this->mx_value,$allowable_tags);
		return $this;
	}

	/**
	* Retira tudo que não for uma letra do alfabeto
	* ou um numero de 0 a 9 do dado
	*
	* @return DDDataValidationItem
	*/
	public function alphaNum()
	{
		$this->trim();
		$this->noHTML();
		$this->mx_value = ereg_replace("([[:punct:]]| )","",$this->mx_value);
		return $this;
	}

	/**
	* Retira tudo que não for um numero do dado
	*
	* @return DDDataValidationItem
	*/
	public function numeric()
	{
		$this->trim();
		$this->noHTML();
		$this->mx_value = ereg_replace("([[:punct:]]|[[:alpha:]]| )","",$this->mx_value);
		return $this;
	}

	/************************/
	/* Métodos de conversão */
	/************************/

	/**
	* Converte uma data do formato Brasileiro Ex: 10/11/2011
	* 	para o formato Americano Ex: 2011/11/10 ou vice-versa
	*
	* @param integer $f_actual_format - Especificar o formato atual da data
	* 	Use DDDataValidation::DATE_BR para formato Brasileiro
	* 	Use DDDataValidation::DATE_EN para formato Americano
	* @param integer $f_to_format - Especificar o formato de data desejado
	* 	Use DDDataValidation::DATE_BR para formato Brasileiro
	* 	Use DDDataValidation::DATE_EN para formato Americano
	* @param character $ch_delimiter - Especificar o caractere de separação
	* 	para dia mês e ano
	* @throws DDException
	*/
	public function convertDate($f_actual_format = DDDataValidation::DATE_BR , $f_to_format = DDDataValidation::DATE_EN , $ch_delimiter = '-' )
	{
		$dt_date = $this->mx_value;
		$v_date = preg_split('/[[:punct:]]/',$dt_date);

		if( !is_numeric($v_date[0]) || !is_numeric($v_date[1]) || !is_numeric($v_date[2])  )
			throw new DDException('this data isn\'t a valid date');

		if($f_actual_format != DDDataValidation::DATE_BR && $f_actual_format != DDDataValidation::DATE_EN)
			throw new DDException('$f_actual_format isn\'t a valid flag');

		if($f_to_format != DDDataValidation::DATE_BR && $f_to_format != DDDataValidation::DATE_EN)
			throw new DDException('$f_to_format isn\'t a valid flag');

		if($f_actual_format == DDDataValidation::DATE_BR)
		{
			$in_day = $v_date[0];
			$in_month =  $v_date[1];
			$in_year =  $v_date[2];
		}
		elseif($f_actual_format == DDDataValidation::DATE_EN)
		{
			$in_day = $v_date[2];
			$in_month =  $v_date[1];
			$in_year =  $v_date[0];
		}

		if (!checkdate( $in_month , $in_day , $in_year ))
			throw new DDException('this data isn\'t a valid date');

		if($f_to_format == DDDataValidation::DATE_BR)
			$this->mx_value = $in_day . $ch_delimiter . $in_month . $ch_delimiter . $in_year;
		elseif($f_to_format == DDDataValidation::DATE_EN)
			$this->mx_value = $in_year . $ch_delimiter . $in_month . $ch_delimiter . $in_day;
		return $this;
	}

	/**
	* Converte todos os caractéres especiais em suas
	* respectivas entidades HTML
	*
	* @return DDDataValidationItem
	*/
	public function htmlEntities()
	{
		$this->mx_value = htmlentities($this->mx_value);
		return $this;
	}

	/**
	* Converte entidades HTML em seus respectivos
	* caracteres especiais
	*
	* @return DDDataValidationItem
	*/
	public function htmlEntitiesDecode()
	{
		$this->mx_value = html_entity_decode($this->mx_value);
		return $this;
	}

	/**
	* Converte characteres de final de linha (\n) para
	* para a tag <br/> do HTML
	*
	* @return DDDataValidationItem
	*/
	public function nlToBr()
	{
		$this->mx_value = nl2br($this->mx_value);
		return $this;
	}

	/**
	* seta o charset do dado
	*
	* @param integer $in_actual_charset - Seta o charset atual do dado
	* 	Use DDDataValidation::ISO_8859_1 para ISO-8859-1
	* 	Use DDDataValidation::UTF-8 para UTF-8
	* @param integer $in_to_charset - Define o charset desejado
	* 	Use DDDataValidation::ISO_8859_1 para ISO-8859-1
	* 	Use DDDataValidation::UTF-8 para UTF-8
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function setCharset($in_actual_charset = DDDataValidation::ISO_8859_1 , $in_to_charset = DDDataValidation::UTF_8)
	{
		if($in_actual_charset != DDDataValidation::ISO_8859_1 && $in_actual_charset != DDDataValidation::UTF_8)
			throw new DDException('invalid actual charset variable'); 

		if($in_to_charset != DDDataValidation::ISO_8859_1 && $in_to_charset != DDDataValidation::UTF_8)
			throw new DDException('invalid to charset variable');

		if($in_actual_charset == DDDataValidation::UTF_8 && $in_to_charset == DDDataValidation::ISO_8859_1)
			$this->mx_value = utf8_decode($this->mx_value);

		if($in_actual_charset == DDDataValidation::ISO_8859_1 && $in_to_charset == DDDataValidation::UTF_8)
			$this->mx_value = utf8_encode($this->mx_value);
		return $this;
	}
}

Você deve está pensando “Nossa! Quanto código.“. Eu sei, é realmente muito código, mas ele será escrito apenas uma vez e usado milhares de vezes. Você só terá que mexer nele novamente se houver a necessidade de implementar um novo método ou fazer a manutenção em alguma parte do código. Resumindo, você só terá que entender o código (se você for um bom programador e não gosta de pegar código pronto na Internet) e aprender a usar.

4º Passo – Testando o código

Como teste, iremos usar nossa classe para validar um formulário. Veja o código em anexo abaixo.

<?php
//se o formulário foi enviado

require_once 'DDFormValidation.php';
$o_validation = new DDDataValidation();

//verificando se algo foi enviado
if(count($_POST))
{
	//encapsulando os dados
	$o_validation->setData('nome', $_POST['nome']);
	$o_validation->setData('email', $_POST['email']);
	$o_validation->setData('cpf', $_POST['cpf']);
	$o_validation->setData('data_nascimento', $_POST['data_nascimento']);

	//efetuando as validações

	//validando nome
	$o_validation->getData('nome')->isEmpty('Nome é obrigatório');

	//validando email
	$o_validation->getData('email')->isEmpty('E-mail é obrigatório');
	$o_validation->getData('email')->isEmail('E-mail inválido');

	//validando CPF
	$o_validation->getData('cpf')->isEmpty('CPF é obrigatório');
	$o_validation->getData('cpf')->isCPF('CPF inválido');

	//validando data de nascimento
	$o_validation->getData('data_nascimento')->isEmpty('Data de Nascimento é obrigatória');
	$o_validation->getData('data_nascimento')->isDate('Data de Nascimento inválida',DDDataValidation::DATE_BR);

	if($o_validation->countErrors() == 0)
		$st_mensagem =  'cadastrado com sucesso';
}	

	?>
<html>
<head>
<style>
body
{
font-family:"tahoma";
}
</style>
</head>
<body>
<div align=center>
	<br/>
	<br/>
	<form method="post">
		<table>
			<tr>
				<td colspan="2" align="center" style="font-size: 30px;">
					DigitalDev Form
				</td>
			</tr>
			<tr>
				<td>
					&nbsp;
				</td>
			</tr>
			<?php
			if(isset($st_mensagem))
			{
			?>
			<tr>
				<td colspan="2" align="center">
					<font color='red' size='4'><?php echo $st_mensagem?></font>
				</td>
			</tr>
			<?php
			}
			?>
			<tr>
				<td align="right">
					Nome:
				</td>
				<td>
					<input type="text" name="nome" value="<?php echo $_POST['nome']?>" maxlength="40">
					<font size='2' color='red'>
						<?php echo $o_validation->getData('nome')->getErrorMsg(DDDataValidation::ErrorEmpty)?>
					</font>
				</td>
			</tr>
			<tr>
				<td align="right">
					E-mail:
				</td>
				<td>
					<input type="text" name="email" maxlength="40" value="<?php echo $_POST['email']?>">
					<font size='2' color='red'>
						<?php echo $o_validation->getData('email')->getFirstErrorMsg()?>
					</font>
				</td>
			</tr>
			<tr>
				<td align="right">
					CPF:
				</td>
				<td>
					<input type="text" size="11" name="cpf" maxlength="14" value="<?php echo $_POST['cpf']?>">
					<font size='2' color='red'>
						<?php echo $o_validation->getData('cpf')->getFirstErrorMsg()?>
					</font>
				</td>
			</tr>
			<tr>
				<td align="right">
					Data de nascimento:
				</td>
				<td>
					<input type="text" size="10" name="data_nascimento" maxlength="10" value="<?php echo $_POST['data_nascimento']?>">
					<font size='2' color='red'>
						<?php echo $o_validation->getData('data_nascimento')->getFirstErrorMsg()?>
					</font>
				</td>
			</tr>
			<tr>
				<td colspan="2" align="center">
					<button type="submit">Cadastrar</button>
				</td>
			</tr>
		</table>
	</form>
</div>
</body>
</html>

Faça o download do código fonte do exemplo acima clicando aqui.

Apesar dessa classe de validação de dados de entrada ser capaz de nos auxiliar na validação, filtro e conversão de dados de entrada, sempre irá existir situações em que ela não poderá nos auxiliar. Nessas situações o programador deverá efetuar manutenções no código ou implementar novos métodos.

Faça o download do código fonte da classe clicando aqui.

Artigos Relacionados

Construindo uma classe em PHP para conexão com Banco de Dados
SQL Injection, como evitar esse tipo de ataque em páginas PHP

Continue lendo »]]>

Veremos aqui como alinhar objetos no centro da tela, usando css. Usaremos como exemplo o alinhamento de uma imagem com DIV. Verifiquem que o processo é o mesmo caso queremos alinhar tabelas contendo textos ou imagens.

Agora vejamos:

A imagem possui um tamanho de 400 x 300, respectivamente, largura e altura (width e height).

Insira a imagem dentro de um DIV, como abaixo:

<div>
     <img src=”imagem.jpg” alt=”" />
</div>

Explicando o CSS:
Acompanhando o tamanho da imagem, ou seja, 400px x 300px, definiremos no CSS uma largura de 400px e uma altura de 300px que “guardará” a imagem:

width: 400px;
height: 300px;

É necessário entender que o alinhamento não é feito a partir do centro do objeto. Neste caso alinhamos pelas extremidades, onde o canto esquerdo superior passa ser o centro.

Então definimos:

position: absolute;

E também:
Distância de 50% a partir do topo e 50% a partir do lado esquerdo:

top: 50%;
left: 50%;

Para encerrar faremos uma espécie de hack do CSS:
Definiremos valores negativos para a imagem, mais precisamente nas margens do topo e esquerda. Os valores negativos serão exatamente a metade da altura e da largura da imagem, conforme abaixo:

margin-top: -150px;
margin-left: -200px;

Vejamos agora como deverá ficar o CSS final:

.center {
     width: 400px;
     height: 300px;
     position: absolute;
     top: 50%;
     left: 50%;
     margin-top: -150px;
     margin-left: -200px;
}

Veja como ficou o html:

<html>
     <head>
          <title>Título<title>
     </head>
     <body>
          <div  class=”center”><img src=”imagem.jpg” /></div>
     </body>
</html>

Isso também é possível:

<html>
     <head>
          <title>Título<title>
     </head>
     <body>
<table width=”400″ border=”0″ cellspacing=”0″ cellpadding=”0″>
               <tr> 
                    <td>
<div  class=”center”><img src=”imagem.jpg” /></div>
</td>
</tr>
</table>
</body>
</html>

Espero ter ajudado.

Continue lendo »]]>

Ao se construir uma aplicação ou site em PHP que se comunique com algum banco de dados, uma classe de banco de dados de fácil uso e compreensão pode simplificar bastante o nosso trabalho.

Nesse artigo mostrarei como construir uma classe da banco de dados, baseada na classe PDO (nativa do PHP), capaz de fazer múltiplas conexões simultâneas e com suporte aos principais gerenciadores de banco de dados usados hoje em dia.

Requisitos

Como iremos usar a classe PDO do PHP na implementação de uma segunda classe, precisaremos que as extensões php_pdo_mssql, php_pdo_mysql, php_pdo_oci, php_pdo_pgsql, php_pdo_sqlite estejam ativas nas configurações do seu servidor PHP.

Para facilitar o entendimento do código abaixo, aconselho a leitura da documentação das classes PDO e Exception no site www.php.net.

1º Passo – Criando uma classe de configuração

Antes de mais nada, precisaremos construir uma classe para guardar as configurações de cada conexão, como por exemplo, endereço do banco, tipo do banco, porta, nome do banco, usuário e senha.

class DDConnectSettings
{
	const MYSQL = 1;
	const PGSQL = 2;
	const MSSQL = 3;
	const ORACLE = 4;
	const SQLite = 5;

	private $f_application;
	private $st_host;
	private $in_port;
	private $st_dbase;
	private $st_user;
	private $st_password;

	/**
	* define o gerenciador de banco de dados
	* @param int $f_aplication
	* @example $ob->setAplication(DDConnectSettings::MYSQL);
	*	Use
	* 	DDConnectSettings::MYSQL - para MySQL
	* 	DDConnectSettings::PGSQL - para PostgreSQL
	* 	DDConnectSettings::MSSQL - para Microsoft SQL Server
	* 	DDConnectSettings::ORACLE - para Oracle
	*	DDConnectSettings::SQLite - para SQLLite
	*/
	public function setApplication($f_aplication)
	{
		$this->f_application = $f_aplication;
	}

	/**
	* retorna qual o gerenciador de banco de dados definido
	* @return int
	*/
	public function getApplication()
	{
		return $this->f_application;
	}

	/**
	* define endereço (IP ou domínio) do servidor
	* @param string $st_host
	*/
	public function setHost($st_host)
	{
		$this->st_host = $st_host;
	}

	/**
	* retorna o endereço do servidor definido
	* @return string
	*/
	public function getHost()
	{
		return $this->st_host;
	}

	/**
	* define a porta a ser usada na conexão
	* @param int $in_port
	*/
	public function setPort($in_port)
	{
		$this->in_port = $in_port;
	}

	/**
	* retorna a porta definida
	* @return int
	*/
	public function getPort()
	{
		return $this->in_port;
	}

	/**
	* define o nome do banco de dados ou arquivo
	* @param string $st_dbase
	*/
	public function setDatabase($st_dbase)
	{
		$this->st_dbase = $st_dbase;
	}

	/**
	* retorna o nome do banco de dados ou arquivo definido
	* @return string
	*/
	public function getDatabase()
	{
		return $this->st_dbase;
	}

	/**
	* define o nome do usuário a ser usado em uma conexão protegida
	* @param string $st_user
	*/
	public function setUser($st_user)
	{
		$this->st_user = $st_user;
	}

	/**
	* retorna o nome do usuário definido no caso de uma conexão pretegida
	* @return string
	*/
	public function getUser()
	{
		return $this->st_user;
	}

	/**
	* define a senha de usuário a ser usado em uma conexão protegida
	* @param string $st_password
	*/
	public function setPassword($st_password)
	{
		$this->st_password = $st_password;
	}

	/**
	* retorna a senha de usuário definido no caso de uma conexão pretegida
	* @return string
	*/
	public function getPassword()
	{
		return $this->st_password;
	}
}

2º Passo – Criando uma classe de tratamento de erros

Também precisaremos de uma classe de tratamento de erros e para que ela funcione adequadamente, deverá ser herdeira da classe Exception (também nativa do PHP).

class DDDException extends Exception
{

}

Você deve estar se perguntando “Por que não usar a classe Exception, já que a classe herdeira não tem nada implementado?”. Minha resposta é “Se em algum momento quisermos adicionar algum controle de erros ainda não implementado na classe Exception, basta modificar a classe DDDException e tudo será resolvido”.

3º Passo – Implementando classe de dados

Esta classe de dados será responsável por encapsular os dados retornados na consulta SQL, como por exemplo, quantidade de linhas, colunas e dados propriamente ditos.

class DDData
{
	const OBJECT = 1;
	const ARRAY_ASSOC = 2;
	const ARRAY_NUM = 3;
	const ARRAY_BOTH = 4;	

	private $o_PDOStatment;	

	/**
	* Retorna dados de uma consulta SQL
	*
	* @param int $f_tout - Usada para formatar a saída dos dados
	* @example $ob->getData(DDData::ARRAY_NUM)
	* 	Use
	* 	DDData::ARRAY_NUM - para retornar um array multidimensional de índices numéricos
	*	DDData::OBJECT - para retornar um array contendo como valores, objetos stdClass com os dados de cada linha
	*	DDData::ARRAY_ASSOC - para retornar um array multidimensional contendo como índices os nomes dos campos
	*   DDData::ARRAY_BOTH - para retornar um array contendo índices numericos e os nomes dos campos
	* @return array
	* @throws DDDException
	*/
	public function getData($f_tout = self::OBJECT)
	{
		if(!is_a($this->o_PDOStatment,'PDOStatement'))
			throw new DDDException('Nothing to return');

		if($this->o_PDOStatment->columnCount() > 0)
		{
			$v_return = array();

			try
			{
				switch($f_tout)
				{
					case self::OBJECT:
						while($o_line = $this->o_PDOStatment->fetchObject())
							array_push($v_return, $o_line);
					break;

					case self::ARRAY_ASSOC:
						$v_return = $this->o_PDOStatment->fetchAll(PDO::FETCH_ASSOC);
					break;

					case self::ARRAY_NUM;
						$v_return = $this->o_PDOStatment->fetchAll(PDO::FETCH_NUM);
					break;

					case self::ARRAY_BOTH;
						$v_return = $this->o_PDOStatment->fetchAll(PDO::FETCH_BOTH);
					break;
				}
			}
			catch(PDOException $e)
			{
				throw  new DDDException($e->getMessage());
			}
		}
		else
			$v_return = FALSE;
		return $v_return;
	}

	/**
	* Recebe um objeto da classe PDOStatment,
	* este objeto será usado apenas pela classe DDDatabase
	* @param PDOStatement $o_PDOStatment
	*/
	public function setData(PDOStatement $o_PDOStatment)
	{
		$this->o_PDOStatment = $o_PDOStatment;
	}

	/**
	* Retorna o numero de linhas geradas na consulta SQL
	* @throws DDDException
	* @return integer
	*/
	public function getNRows()
	{
		if(!is_a($this->o_PDOStatment,'PDOStatement'))
			throw new DDDException('Nothing to return');

		return $this->o_PDOStatment->rowCount();
	}

	/**
	* Retorma o numero de colunas geradas na consulta SQL
	* @return integer
	* @throws DDDException
	*/
	public function getNCols()
	{
		if(!is_a($this->o_PDOStatment,'PDOStatement'))
			throw new DDDException('Nothing to return');

		return $this->o_PDOStatment->columnCount();
	}
}

4º Passo – Implementando a classe principal

A classe principal será responsavel por administrar as conexões e as requisições feitas por consultas SQL

class DDDatabase
{
	private $v_connections;
	private $v_database;

	/**
	* Estabele conexão com o gerenciador de banco de dados
	* @param string $st_database - Alias definido pelo desenvolvedor para uma conexão
	* @param DDConnectSettings $o_DDCSettings - Objeto contendo as configurações de uma conexão
	* @throws DDDException
	*/
	public function setConnectSettings($st_database, DDConnectSettings $o_DDCSettings)
	{
		$v_database[$st_database] = $o_DDCSettings;

		$st_dbname = $o_DDCSettings->getDatabase();

		switch($o_DDCSettings->getApplication())
		{
			case DDConnectSettings::MYSQL:
				$st_dsn = "mysql:dbname=$st_dbname";
			break;

			case DDConnectSettings::PGSQL:
				$st_dsn = "pgsql:dbname=$st_dbname";
			break;

			case DDConnectSettings::MSSQL:
				$st_dsn = "mssql:dbname=$st_dbname";
			break;

			case DDConnectSettings::ORACLE:
				$st_dsn = "oci:dbname=$st_dbname";
			break;

			case DDConnectSettings::SQLite:
				$st_dsn = "sqlite:$st_dbname";
			break;

			default:
				throw new DDDException('Invalid drive');
			break;
		}

		$st_host = $o_DDCSettings->getHost();
		$st_username = $o_DDCSettings->getUser();
		$st_password = $o_DDCSettings->getPassword();
		$in_port = $o_DDCSettings->getPort();

		try
		{
			if(isset($st_host))
			{
				$st_dsn .= ";host=$st_host";
				if(isset($in_port))
					$st_dsn .= ";port=$in_port";
			}

			if(isset($st_username) && isset($st_password))
			{
				$this->v_connections[$st_database] = new PDO($st_dsn, $st_username, $st_password );
			}
			else
			{
				$this->v_connections[$st_database] = new PDO($st_dsn);
			}	

			$this->v_connections[$st_database]->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
		}
		catch (PDOException $e)
		{
			throw new DDDException($e->getMessage());
		}
	}

	/**
	* Retorna um objeto contendo os dados das configurações de uma conexão
	* @param string $st_database - Alias defindo pelo desenvolvedor para a conexão em questão
	*/
	public function getConnectSettings($st_database)
	{
		return $this->v_database[$st_database];
	}

	/**
	* Executa uma consulta SQL, retornando uma instância da classe DDData
	* @param string $st_database - Alias da conexão que desenvolvedor deseja usar
	* @param  string $st_query - Consulta SQL
	* @return DDData
	* @throws DDDException
	*/
	public function execQuery($st_database,$st_query)
	{
		try
		{
			$v_row = $this->v_connections[$st_database]->query($st_query);
			$o_DDData = new DDData();
			$o_DDData->setData($v_row);
		}
		catch (PDOException $e)
		{
			throw new DDDException($e->getMessage());
		}
		return $o_DDData;
	}
}

5º Passo – Exemplo de como usar a classe

//Setando as configurações da conexão
$o_dbconfig = new DDConnectSettings();
$o_dbconfig->setApplication(DDConnectSettings::PGSQL);
$o_dbconfig->setHost('localhost');
$o_dbconfig->setUser('xxx');
$o_dbconfig->setPassword('xxx');
$o_dbconfig->setDatabase('digitaldev');
$o_dbconfig->setPort(5432);

//Instanciando a classe de banco
$o_db = new DDDatabase();
$o_db->setConnectSettings('ddev', $o_dbconfig);
$st_query = "SELECT * FROM control.tbl_usuario";
$o_data = $o_db->execQuery('ddev', $st_query);

//imprimindo dados
var_dump($o_data->getData(DDData::OBJECT));

//imprimindo numero de linhas
echo 'Linhas = '.$o_data->getNRows();

//imprimindo numero de colunas
echo 'Colunas = '.$o_data->getNCols();

Faça download de um outro exemplo de uso, dessa com SQLite, clicando aqui.

Apesar de poder ser usada na maioria das interações com banco de dados em uma aplicação PHP, essa classe ainda não possui métodos que permitem controle de transições. Fica a encargo dos desenvolvedores continuar a implementação de acordo com as necessidades de suas aplicações.

Quem quiser usar a classe, pode fazer o download da mesma clicando aqui.

Qualquer dúvida, usem a área de respostas abaixo do post.

Artigos relacionados
Classe, encapsulamento, herança, composição e agregação
O que é PHP e qual é sua historia?
Instalando o ambiente de desenvolvimento PHP (PHP 5.3.x + Apache + Eclipse)