Isto é muito utilizado para destacar a separação das linhas do grid, sem, no entanto, utilizar as bordas do mesmo, o que não gera um efeito plenamente satisfatório.

Vamos ao código!

O primeiro passo é criar uma classe que irá conter a cor de fundo:

<style type="text/css">
.bgCinza { background-color: #f5f5f5; }
</style>


No caso, eu utilizei um tom de cinza para fazer a alternância das linhas.

Em seguida, basta incluir no header da página o seguinte código:

<script type="text/javascript"><br />
$(document).ready(function () { $('table tr:even').addClass('bgCinza'); });<br />
</script>


Se preferir, você pode setar uma classe para a table e fazer a chamada acima para a classe criada. Assim, ao invés de setar a classe bgCinza para todas tabelas, somente aqueles que tiverem a classe serão modificadas:

$(document).ready(function () { $('.grid tr:even').addClass('bgCinza'); });

Note que, obviamente, você também deverá incluir, antes do código javascript acima, uma chamada para o core do jQuery:

<script type="text/javascript" src="/path/to/jquery.1.6.2.min.js"></script>


O resultado final fica como mostrado na imagem abaixo:

Espero que sirva para você também!

Apesar de ser uma solução ótima, melhor do que a comparação simples (=, >, <), há sempre uma pequena confusão com o resultado da operação.

Os valores possíveis são 1, 0 ou -1. Mas, afinal, qual deles vem em que situação?

Veja a tabela abaixo e acabe com as dúvidas de uma vez por todas:

Exemplo:


if (data.CompareTo(new DateTime(2009, 11, 17)) > 0)
{
// "data" é maior do que o dia de hoje
}


Resumindo, se a “data”, que está na esquerda, for maior, o resultado do if é true.

Ou seja, se você fizer um data.CompareTo(outraData), caso o resultado retorne 1, é porque “data” é maior do que “outraData” (veja que “data” está à esqueda, equivale ao “> 0″). Caso retorne 0, elas são iguais. Caso retorne -1, “outraData” é maior do que “data” (repare que “outraData” está à direita, equivale ao “< 0″).

Espero ter ajudado.

Amplexos!

É possível, por exemplo, buscar os resultados apenas da última semana, ou até mesmo das últimas 24 horas!

Para isso, basta acrescentar o seguinte código à URL do Google após a busca:

&as_qdr=X

Onde está o “X” substitua por:

• d – para buscas nos resultados das últimas 24 horas
• w – para a última semana
• m – último mês
• m2 – últimos 2 meses
• m3 – últimos 3 meses
• m6 – últimos 6 meses
• y – último ano
• all – qualquer data

A URL do resultado ficará assim então:

http://www.google.com.br/search?hl=pt-BR&q=%22Silvio+Delgado%22&meta=&as_qdr=m

Espero que seja útil!

Abraços.

P.S.: publicado no UnderGoogle

O funcionamento é bem simples: o sistema gera uma imagem com um texto aleatório e uma sessão com uma chave complementar. O usuário, para poder enviar o formulário, deve digitar, num campo apropriado, o conteúdo da imagem. No lado servidor, é feita a verificação dos dados inseridos. Caso esteja OK, o formulário é enviado. Caso contrário, uma mensagem de erro é exibida.

Implementar o Captcha é relativamente simples. Cada um pode desenvolver seu próprio algoritmo ou utilizar um entre os milhares já existente pela internet. No entanto, alguns hospedeiros limitam as extensões passíveis de utilização nos seus servidores, deixando os usuários com uma grande limitação. Uma destas extensões é a biblioteca GDLib, para o PHP.

Sendo assim, como fazer então para que você possa ter a segurança de que o seu formulário não foi preenchido por um robô, mas sem utilizar o Captcha tradicional?

A solução é extremamente simples: Captcha Inverso.

Consiste em se incluir mais um campo no formulário (um input normal), mas com uma classe CSS específica para deixá-lo invisível.

A explicação para isso é que os robôs que preenchem os formulários não conseguem interpretar o CSS. Assim, este campo, que seria oculto, fica visível para aqueles.

Basta, então, verificar no servidor se este campo está preenchido. Caso negativo, os dados são legítimos e você pode dar prosseguimento no seu processamento. Em caso positivo, o formulário foi preenchido por um robô e não deve ser enviado.

Esta solução não é 100% segura (como praticamente tudo na internet), mas já é um bom começo para quem necessita de um mecanismo simples de verificação e, principalmente, não dispõe de muitos recursos disponíveis.

Obs.: mesmo com a utilização do Captcha tradicional, já existem diversos robôs que conseguem “varrer” a imagem e descobrir o seu conteúdo, burlando o esquema de segurança.

Abraços!

Siga os passos: Crie uma página que irá conter o formulário de acesso do usuário:

index.php

<form action="login.php" method="post">
Usuário <input type="text" name="TxtLogin" id="TxtLogin" size="15" /><br />
Senha <input type="password" name="TxtSenha" id="TxtSenha" size="15" /><br />
<input type="submit" name="BtnLogin" id="BtnLogin" value="Login" />
</form>

Segue abaixo a página que receberá as informações:

login.php

<?php
session_start();
if (isset($_POST['BtnLogin']))
{// testa se a página foi chamada pelo form de login
    $login = $_POST['TxtLogin'];
    $senha = $_POST['TxtSenha'];
    // se quiser, criptografe para comparar com o banco
    $conn = mysql_connect($dbhost, $dbuser, $dbpass) or die(’Erro’);
    mysql_select_db($dbname, $conn);
    $sql = “SELECT id, nome, email FROM usuarios ”
        .” WHERE login = ‘$login’ AND senha = ‘$senha’”;
    $result = mysql_query($sql, $conn);
    if (mysql_num_rows($result) > 0) // usuario existe
    {
        // pega o array de resultados
        $dados = mysql_result($result, 0);
        // grava a sessão
        $_SESSION['usuario']['id_user'] = $dados['id'];
        $_SESSION['usuario']['nome'] = $dados['nome'];
        $_SESSION['usuario']['email'] = $dados['email'];
        header(’Location: logado.php’);
    }
    else
    {
        header(’Location: index.php’);
        // falha na autenticação
    }
    mysql_close();
}
else
{
    header(’Location: index.php’);
    // caso negativo, volta para index.php
}
?>

Em todas as páginas que o usuário deva estar logado para acessar, insira o seguinte código:

logado.php
<?php
session_start();
if (!isset($_SESSION['usuario']))
{
    header(’Location: index.php’); // vai para a página de login
    exit; // é importante para não executar o restante da página
}
// restante do código da página
echo “Olá, “.$_SESSION['usuario']['nome'].”! Seja bem-vindo de volta!”;
echo “<br /><br />n”
    .”<a href=”logout.php”>Sair</a>”;
?>

Para o usuário efetuar o logout, escreva uma página como a seguir:

logout.php

<?php
session_start();
session_destroy(); // "mata" TODAS as sessões criadas
// ou
unset($_SESSION['usuario']);
// “mata” somente a sessão criada para o usuário
header(’Location: index.php’);
?>

Espero que seja útil.
Caso queira, poderá utilizar orientação a objetos para isso, inclusive com serialização de dados antes de passar à sessão. Mas isso é assunto para outro post!

Esta função acrescenta, nos textos digitados em controles Textareas, um <br /> ao final de cada linha. Com isso, auxilia na renderização de textos armazenados em banco de dados.

Porém, há poucas semanas necessitei de uma função semelhante no ASP.NET e não encontrei.
A solução que desenvolvi foi a seguinte:

public string nl2br(string texto)
{
    return texto.Replace("n", "<br />");
}


Abraços e até a próxima!

Às vezes, mesmo para se fazer uma coisa simples, é necessário um procedimento um pouco mais rebuscado. Já para fazer uma coisa complicada…

O que eu quero fazer não é complicado, mas como eu nunca trabalhei com os INNER, LEFT, RIGHT, OUTER etc., não foi tão trivial assim.

Estou desenvolvendo um pequeno sistema de cobrança (sim, em PHP mesmo!) onde, na listagem de clientes, entre outras coisas, é exibida a cidade e uf a que pertencem.

Até aí, tudo bem! Nada demais. Fiz um JOIN simples:

SELECT cli.*, cid.nome AS nome_cidade, cid.uf
FROM clientes AS cli, cidades AS cid
WHERE cid.id_cidade = cli.cidade

O problema é que, da forma como foi feita, a frase só me retorna os clientes cujo campo cidade esteja preenchido com um valor que conste na tabela cidades. Valores nulos ou inexistentes não retornam os registros.

Uma “solução” (ou seria bacalhau?? [1]) para isso seria não permitir a deleção da cidade na sua tabela, mas isso acaba nos limitando, por diversos motivos.

Eu nunca fiz um JOIN que me retornasse registros desta forma (com os correspondentes nulos ou inexistentes), mas chegara a hora de ter de fazê-lo.

Pesquisando um pouco (foi pouco mesmo!), descobri como fazer um JOIN que me retornasse o que a query acima me retorna:

SELECT * FROM clientes AS cli
INNER JOIN cidades AS cid ON cli.cidade = cid.id_cidade

Bom, até aí, tudo bem! Mas não resolveria o meu problema…

Lembrando um pouco do que eu já tinha lido sobre o tema, vi o “INNER” na frase e lembrei do seu “oposto”: “LEFT OUTER”, que mantém os registros. Logo cheguei à seguinte formulação:

SELECT * FROM clientes AS cli
LEFT OUTER JOIN cidades AS cid ON cli.cidade = cid.id_cidade

Ei-lo como qui-lo! (Ou quase…)

A sentença me retornou todos os campos da tabela de clientes, inclusive aquele registro que tinha o cídogi inválido para a cidade. Agora só faltava manipular os nomes dos campos, por causa da duplicidade (nome do cliente x nome da cidade):

SELECT cli.*, cid.nome AS nome_cidade, cid.uf
FROM clientes AS cli
LEFT OUTER JOIN cidades AS cid ON cli.cidade = cid.id_cidade

Pronto! Estava resolvido o meu problema. E espero que o seu agora também esteja.

Até a próxima!

[1] – O termo provém do antigo ditado que dizia “pra quem é, bacalhau serve”, que era um eufemismo para dizer que, para uma pessoa sem muita importância, uma coisa mal-feita já estava bom. Mas isso era no tempo em que bacalhau e manjubinha disputavam clientes no boteco…

Após alguns testes, encontrei uma solução que funcionou adequadamente. Não sei se é a melhor maneira de fazer isso e se você souber, envie para cá que eu publico.

Para as MasterPages funcionarem corretamente com uma estrutura complexa de diretórios, é necessário seguir os passos a seguir:

Estrutura básica dos diretórios de exemplo:

[Root]
|
+—{Default.aspx}
|
+—{Default2.aspx}
|
+—[Css]
|    |
|    +—{estilo.css}
|
+—[MasterPages]
|    |
|    +—{MasterPage.master}
|
+—[Images]
|    |
|    +—{imagem1.jpg}
|    |
|    +—[Img1]
|    |
|    +—{imagem2.jpg}
|
+—[Dir1]
|    |
|    +—[Dir1a]
|    |    |
|    |    +—{Default.aspx}
|    |
|    +—{Default.aspx}
|
+—[Dir2]
|
+—{Default.aspx}

Para que todas as páginas, independente do nível de diretório em que estejam, acessem o estilo corretamente, é necessário colocar no <head> da MasterPage.master:

<head runat="server">

A chamada para a folha de estilos deverá ser feita levando-se em conta a referência do arquivo CSS em relação à MasterPage.master:

<link href="../Css/estilo.css" rel="stylesheet" type="text/css" />

Note que o path é informado em HTML normal, não em ASP.NET (”~”).

Dentro da folha de estilos, as chamadas às imagens deverão ser feitas com o caminho relativo do arquivo CSS ao diretório onde as imagens estão armazenadas:

.classe1
{
background: White url('../Images/imagem1.jpg') no-repeat;
}

Dentro das páginas, caso seja necessário designar uma imagem para um ImageButton, por exemplo, basta colocar o símbolo “~” no caminho da imagem que o compilador traça o caminho corretamente:

<asp:ImageButton runat="server" ImageUrl="~/Images/Img1/imagem2.jpg" />

Caso você utilize uma imagem simples (em HTML), utilize a mesma técnica acima e acrescente o runat=”server” à tag <img>:

<img src="~/Images/imagem1.jpg" runat="server" />

Para chamar páginas com o Response.Redirect(), é necessário utilizar também o “~”:

Response.Redirect("~/Dir1/Default.aspx");

Uma solução que resolveria o problema das imagens seria, ao invés de utilizar o “~”, colocar apenas a barra e fornecer o caminho completo relativo ao domínio. No entanto, caso você mude o sistema de diretório (colocando em um subdiretório do que está no momento, por exemplo), todos os caminhos deverão ser revisados, o que enterra a produtividade.

Este sistema “joga” todos os controles para o servidor, o que compromete um pouco a performance, porém o custo x benefício vale muito a pena.

Até a próxima!

Apesar de ter feito no CorelDraw, depois que aprendi as principais ferramentas do Photoshop, descobri que é bem mais fácil fazer nesta ferramenta, aplicando camadas e máscaras.

Então, inaugurando a seção Photoshop e uma série de pequenos tutoriais, vou descrever o efeito aqui, para vocês.

Estou usando o Photoshop CS2 em inglês, então, façam seus ajustes.

Vamos a passo-a-passo:

1 – Crie um novo documento com fundo preto, tamanho 500 x 200 pixels, resolução de 72 pixels, CMYK de 8 bits e com background transparente;

2 – Escolha uma cor escura para o fundo (eu utilizei um azul com RGB = 0, 52, 113) e pinte a camada existente;

3 – Selecione a ferramenta Texto, com uma fonte de boa espessura (na dúvida, escolha Arial Black), tamanho 72, com anti-aliasing Smooth e, como cor, um azul mais claro (RGB = 2, 164, 233);

4 – Duplique a camada, segure a tecla Shift e mova essa nova camada para baixo (até ficar imediatamente abaixo da camada principal). Em seguida, vá no menu Edit -> Transform -> Flip Vertical. Neste ponto, já temos o nosso espelho, mas agora vamos adicionar os efeitos para dar um toque de realismo;

5 – Selecione a camada de cópia e adicione uma Máscara e selecione a ferramenta Gradient;

6 – Retorne as cores do pincel para preto e branco (com o branco de fundo) e selecione o gradiente “Foreground to Transparent”;

7 – Em seguida, clique na máscara criada, clique à meia altura do texto da camada de cópia e arraste até o final da mesma. Durante esta operação, segure o Shift para manter o degradê em 90°;

8 – Ajuste a opacidade desta camada para 20%;

9 – Selecione a camada de texto principal e adicione o efeito “Bevel and Emboss” (Chanfro e Entalhe). Ajuste o tamanho para 1. Adicione também o efeito “Gradient Overlay” (Sobreposição de Degradê). Agora você deve selecionar as cores que deseja para o seu texto e pode dar um efeito de luz direta. Eu utilizei as cores RGB(0, 104, 169) para a base e RGB(172, 225, 250) para o topo;

10 – O efeito está pronto! Agora só falta ajustar o tamanho final da imagem: com a camada de texto principal selecionada, segure o CTRL e clique na camada adicional (para usuários do Photoshop CS, utilize a âncora – ao lado do olho de cada camada – para agrupar camadas). Pressione CTRL + T para redimensionar o conteúdo. Com o Shift pressionado (para manter a escala), segure em uma das pontas do retângulo e altere o tamanho conforme o seu gosto. Ao terminar, pressione Enter para fixá-lo;

11 – Para dar um efeito ainda mais bonito, adicione o efeito “Drop Shadow” (Sombra Projetada) na camada de texto principal. Coloque as seguintes configurações: cor = branca, Blend Mode = Normal, Opacity = 40%, Distance = 0, Size = 20.

12 – Voilá! Está pronto seu nome com efeito de reflexo!

Veja abaixo o resultado final:

Este tutorial é bem simples, mas mostra como, em poucos passos, dá pra se conseguir um ótimo resultado com os poderosos recursos do Photoshop.

Até a próxima!

Só que nem tudo são flores quando o assunto é AJAX (Asynchronous JavaScript and XML). Principalmente se você for um programador brasileiro, como eu.
Digo isso por causa do nosso belo alfabeto, originado do latim e com seus acentos e caracteres peculiares.

Nós, brasileiros, utilizamos a codificação ISO-8859-1, enquanto que, por padrão, o AJAX trabalha com o UTF-8.
O resultado? Hieróglifos egípcios aparecem no lugar de palavras acentuadas e outros caracteres particulares do nosso idioma.

A solução?

Procurei por diversas soluções, mas nenhuma me atendia satisfatoriamente. Só uma, que posto a seguir:

header(”Content-Type: text/html; charset=ISO-8859-1″), true);

Não vou oferecer explicações a respeito da função nativa do PHP, header(). Deixo que vocês mesmos consultem o manual da linguagem para que entendam como funciona.

Existem outras alternativas, como modificar o header direto no HTML, com a tag META, mas geralmente não funcionam a contento.

Quem tiver outras soluções funcionais, postem nos comentários.

Abraços a todos.