segunda-feira, 14 de outubro de 2013

Remover B1 org search spyware do Internet Explorer

Acesse as Ferramentas no Menu superior do IE


Selecione Gerenciar Complementos


Selecione os indesejáveis, e clique no botão desabilitar.


O problema do "sempre falho" Internet Explorer é não permitir a exclusão. Tal operação precisa ser feita no Painel de Desinstalação de Programas ou no registro do Windows.


sexta-feira, 13 de setembro de 2013

Renderizando uma tabela (table) com jquery template - Funcionando

Foram dias e dias pesquisando exemplos do plugin jquery template. Só conseguimos encontrar pseudo-exemplos, que precisavam recorrer a JSON, ou chamadas jquery. Nada que fosse o legítimo e puro uso do jquery template.

Então mergulhamos em um exemplo de tabela de 2 colunas (o resto vem por consequência). O resultado esperado é:



Os detalhes apresentados ajudarão na compreensão dos parâmetros envolvidos no loop de uma template.

O arranjo

Os conteúdos apresentados vem da tabela javascript mostrada abaixo:

// Cria o arranjo com as informações
        var books = [
{ abre: "1", ind: "esq", title: "A - Lista variáveis", link: "listavars6.php" },
{ ind: "dir", title: "1 - Parte 1", link: "Ato01.php", fecha: "1" },
{ abre: "1",ind: "esq", title: "2 - Parte 2", link: "Ato02.php" },
{ ind: "dir", title: "3 - Parte 3", link: "Ato03.php", fecha: "1" },
{ abre: "1",ind: "esq", title: "4 - Parte 4", link: "UsaFrase1_a.php" },
{ ind: "dir", title: "5 - Parte 5", link: "UsaFrase1_b.php", fecha: "1" }
        ];

Repare que, em se tratando de uma tabela com duas colunas, e que vamos percorrer coluna a coluna dos registros, a cada dois registros colocamos o campo "abre" com um valor qualquer (poderia ser "sim", "x", etc). E ao fim dos segundo registro do par, colocamos o campo "fecha", também com qualquer valor.

Também não existe problema em um par ficar incompleto, pois a nossa template "milagrosa" vai dar um jeito nisto.

A template milagrosa

<script id="bookTemplate" type="text/x-jQuery-tmpl" >
{{each(x,y) $data}}
<{{if x=="abre"}}tr{{else}}v{{/if}}>
{{if x=="link"}}
<td>${$index} _ ${x}|${y}=&gt;${ind}-${$index}<A href="${y}"> ${title} </a></td>
{{/if}}
<{{if x=="fecha"}}/tr{{else}}v{{/if}}>
{{/each}}
</script>

Os comandos de tag do jquery template estão destacados em cor preta, para facilitar a sua identificação. Para começo de conversa, os comandos de tag SÓ FUNCIONAM DENTRO DOS SINAIS "<" E ">", coisa que não está explicada pelos "papas" do assunto na Internet, e que nos custou muito sangue para descobrir.

Abertura de uma linha

Para abrir uma linha, é preciso enviar a tag "<tr>". Já vimos que os sinais "<" e ">" precisam ficar do lado de fora da expressão, pois do contrário a interpretação das tags de jquery template apresenta o erro de "nodo não existe". Quando é feito o teste do "abre", a expressão acrescenta "tr" aos sinais citados. Mas quando o teste dá falso, aparecem os incômodos pares "<>" na tela, sem um nome de tag. A solução é acrescentar a tag "v", que não existe no HTML. Se a script é do tipo PHP, a tag "<v>" é ignorada na interpretação, pois não existe no DOM.

Se a tag "<v>" aparecer, acrescentamos nos estilos a definição:

V { color: white;}

que impede que o conteúdo dela seja visível, e o problema estará resolvido.

Por isto reproduzimos o teste de abre em tamanho grande a seguir:

<{{if x=="abre"}}tr{{else}}v{{/if}}>

Fechamento de uma linha

Para fechar uma linha, é preciso enviar a tag "</tr>". Já vimos que os sinais "<" e ">" precisam ficar do lado de fora da expressão, pois do contrário a interpretação das tags de jquery template apresenta o erro de "nodo não existe". Quando é feito o teste do "fecha", a expressão acrescenta "/tr" aos sinais citados. Mas quando o teste dá falso, aparecem os incômodos pares "<>" na tela, sem um nome de tag. A solução é a mesma citada no item anterior:

.<{{if x=="fecha"}}/tr{{else}}v{{/if}}>

Código completo da página

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<script type="text/javascript" src="jquery-1.9.1.js"></script>
<script src="jquery.tmpl.js" type="text/javascript" charset="utf-8"></script>
<style>
V {color:white;}
</style>
</head>
<body>
<div id="pageContent">
<table border=1><tbody id="relat"></tbody></table>
</div>
<!-- $y é o valor lido no momento -->
<script id="bookTemplate" type="text/x-jQuery-tmpl" >
{{each(x,y) $data}}
<{{if x=="abre"}}tr{{else}}v{{/if}}>
{{if x=="link"}}
<td>${$index} _ ${x}|${y}=&gt;${ind}-${$index}<A href="${y}"> ${title} </a></td>
{{/if}}
<{{if x=="fecha"}}/tr{{else}}v{{/if}}>
{{/each}}
</script>
<script type="text/javascript">
// Cria o arranjo com as informações
        var books = [
{ abre: "1", ind: "esq", title: "A - Lista variáveis", link: "listavars6.php" },
{ ind: "dir", title: "1 - Parte 1", link: "Ato01.php", fecha: "1" },
{ abre: "1",ind: "esq", title: "2 - Parte 2", link: "Ato02.php" },
{ ind: "dir", title: "3 - Parte 3", link: "Ato03.php", fecha: "1" },
{ abre: "1",ind: "esq", title: "4 - Parte 4", link: "UsaFrase1_a.php" },
{ ind: "dir", title: "5 - Parte 5", link: "UsaFrase1_b.php", fecha: "1" }
        ];
        // Renderiza as linhas
        $("#bookTemplate").tmpl(books).appendTo("#relat");
</script>
</body>
</html>










sexta-feira, 23 de agosto de 2013

Renderizando tabelas com jquery template

Se o jquery foi uma revolução no javascript e Ajax, o jquery template é uma revolução dentro da revolução.

A linguagem HTML é muito limpa e independente para formatação, efeitos e usabilidade. O jquery leva esta usabilidade e formatação ao extremo. Agora, o jquery template se propõe a dividir, na apresentação, a camada de dados do aspecto visual. Isto possibilita a produção de templates com locais definidos para o programador e para o designer.

A template de tabela

Todo mundo conhece a tabela em HTML, mecanismo básico e estruturado de apresentação de dados. Dentro do TBODY, o grupo que se repete, para uma tabela com somente uma coluna é:

<tr><td>Conteúdo</td></tr>

Se o conteúdo é o link com seu texto de apresentação, o grupo fica:

<tr><td><a href="address">title</a></td></tr>

Vamos supor, em uma nova linguagem, que pudéssemos ter a sintaxe:

<tr><td><a href="${address}">${title}</a></td></tr>

E que pudéssemos ter uma template em forma de script envolvendo esta linha:

<script id="linkTemplate" type="text/x-jQuery-tmpl" >
<tr><td><a href="${address}"> ${title} </a>  </td></tr>
</script>

Pois saiba que isto foi concebido como sintaxe do plugin jquery template (text/x-jQuery-tmpl).

Os dados

Os dados a serem apresentados na template acima (que estabelece um loop, fique bem claro) ficam num arranjo (array), apresentado a seguir:

<script type="text/javascript">
        var links = [
            { title: "Google", address: "http://www.google.com/"},
            { title: "Copasa", address: "http://www.copasa.com.br/"},
            { title: "Intranet", address: "http://intranet/" }
        ];
</script>

A estrutura de conteúdo da página

Toda a página realmente será renderizada em uma DIV, cujo nome obrigatório é pageContent:

<div id="pageContent">
<table border=1><tbody id="relat"></tbody></table>
</div>

Juntando todas as peças:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<script type="text/javascript" src="jquery-1.7.1.min.js"></script>
<script src="jquery.tmpl.js" type="text/javascript" charset="utf-8"></script>
</head>
<body>
<!-- 1 - A DIV pageContent é a padrão para TODO o conteúdo da página, conteúdo "templatizado" -->
<div id="pageContent">
<table border=1><tbody id="relat"></tbody></table>
</div>
<!-- 2 - SEÇÃO DE TEMPLATES QUE GERAM HTML -->
<script id="linkTemplate" type="text/x-jQuery-tmpl" >
<tr><td><a href="${address}"> ${title} </a>  </td></tr>
</script>
<!-- 3 - SEÇÃO DE DADOS A SEREM APRESENTADOS -->
<script type="text/javascript">
// Cria um array de links
        var links = [
            { title: "Google", address: "http://www.google.com/"},
            { title: "Copasa", address: "http://www.copasa.com.br/"},
            { title: "Intranet", address: "http://intranet/" }
        ];
        // 4 - EXECUTA AS TEMPLATES CONTRA OS DADOS E INJETA NA DIV pageContent
        $("#linkTemplate").tmpl(links).appendTo("#relat");
</script>
</body>
</html>

Agora leia e compreenda este código. Veja que as bibliotecas jQuery e o seu plugin jQuery template precisam ser carregadas. Elas se encontram no site do jquery, facilmente localizado pelo Google.




terça-feira, 20 de agosto de 2013

Como fazer uma extensão para o Chrome - Atalho - Chamada para um site (URL)

Crie uma pasta para a extensão Chrome

Crie um diretório com o nome da extensão, onde colocaremos os arquivos que seguem.

Crie o icone

Capture uma figura e redimensione seu tamanho para 128 px X 128 px, e grave no formato PNG na pasta criada anteriormente.

Crie o arquivo manifest.json

Com um editor de texto em formato só texto (bloco de notas, Kate, Scite), crie o seguinte arquivo (o exemplo usa o site baixaki) na pasta criada anteriormente:


{
  "name": "Baixaki",
  "description": "Todos os softwasres necessários",
  "manifest_version": 2,
  "version": "1.0",
  "icons": {
    "128": "128.png"
    },
  "app": {
    "urls": [
      "http://www.baixaki.com.br/"
      ],
    "launch": {
      "web_url": "http://www.baixaki.com.br/"
      }
    },
  "permissions": [
  "unlimitedStorage",
  "notifications"
  ]
}

Para criar chamadas para outros sites, substitua os valores em vermelho e rosa.

Gerenciador de extensões

No Chrome, acione o menu de utilkitários (à direita na barra de endereços), depois Ferramentas, depois Extensões.

Marque a opção "Modo do desenvolvedor". Pressione o botão "Carregar Extensão Expandida". Aponte para a pasta que você criou para os arquivos de ícone e manifest.json.

Está pronto. Confira criando uma nova aba.

A melhor solução para linguagem Script e banco de dados para Web – Parte II

Uma linguagem Web deve ter características de alta produtividade, que se revelam nos seguintes aspectos:


  • Acesso nativo a bancos de dados ou por ODBC;
  • Acesso nativo às variáveis GET e POST do protocolo HTTP;
  • Conexões e queries a bancos de dados através de instruções bem simples;
  • Criação simplificada de classes;
  • Disponibilidade de literatura na Web;
  • Eventos centrados nas tags;
  • Facilidade para desenvolvimento de plugins;
  • Funções sem excessiva tipagem;
  • Funções nativas para leitura de arquivos no servidor (texto);
  • Funções nativas para manipulação de arquivos comprimidos (ZIP);
  • Funções nativas para manipulação de arquivos PDF;
  • Manipulação simplificada de arrays;
  • Manipulação simplificada de datas;
  • Manipulação nativa de expressões relacionais (para check e parsing);
  • Query Return by array;
  • Tratamento nativo do protocolo de e-mail;
  • Tratamento nativo do protocolo de transferência de arquivos (FTP);
  • Treinamento rápido;


Acesso nativo a bancos de dados ou por ODBC

As aplicações Web, geralmente, envolvem a leitura de bancos de dados. Isto ocorre pelo fato de que nos últimos anos a Internet vem sendo usada para finalidades comerciais e empresariais bem exigentes. Até a alguns anos atrás, era preciso instalar módulos complementares com conectores e objetos de acesso a dados, e algumas linguagens conservam estes resquícios, como o ASP e o Java.

A linguagem ASP, alias VBScript com objetos complementares, precisa do suporte dos módulos OLEDB, ADODB e MSDTC instalados no servidor IIS. O IIS não possui versões para todos os sistemas operacionais, mas tão somente para o Windows. Os módulos de apoio residem em DLLs cujos ponteiros ficam constantemente na memória. A interferência de novos objetos ou de DLLs criadas (pois isto é estimulado pelas suites RAD do mercado) pelos desenvolvedores podem simplesmente embaralhar o espaço de memória destas DLLs, levando o servidor ao travamento.

Existem vários produtos necessários para o IIS, como o ASPemail, códigos de barras e gráficos, que  precisam ser instalados. Este pacotes possuem várias DLLs que precisam ser registradas no IIS, para executarem como serviços, bem como serem configuradas. A linguagem PHP já possui o suporte nativo para:


  • Email
  • FTP
  • Mysql
  • ODBC
  • Postgres (banco de dados)
  • SQLite


Não é preciso fazer a cansativa e onerosa instanciação de objetos específicos, e nem se preocupar se os mesmos vão travar o servidor. Apenas é preciso se certificar de que os serviços correspondentes no servidor alvo estão em execução, é claro.

Acesso nativo às variáveis GET e POST do protocolo HTTP

A linguagem Java possui objetos encapsulados em classes específicas que possibilitam o acesso às variáveis GET e POST das requisições HTTP. Mas isto se dá com o servidor Tomcat executando. Se utilizarmos somente o JDK, testando programas no console, não conseguimos testar as requisições HTTP. O Java, para ambiente Web, precisa de um servidor Tomcat, cuja compreensão não é tão óbvia, ou Websphere, cuja compreensão é ainda mais longínqua, ambos programados seguindo a filosofia de servlets, pois senão as entradas e saídas padrão não são entendidas.

Entende-se disto que o Java tem servidor específico. A correta abordagem seria que ele fosse um módulo do IIS ou Apache, para fins de aplicações Web. Ao invés disto, ele tem que rodar no seu próprio servidor.

O ASP precisa instanciar seus objetos específicos.

No caso do servidor Apache, é possível se implementar o acesso diretamente pelos seus módulos, sem a utilização de linguagens. Mas como isto tem uma vertente muito grande de complexidade, as linguagens que rodam debaixo dele tem esta característica nativa. As linguagens PHP, Perl, Python e outras tem esta funcionalidade implementada na forma de um simples arranjo para cada finalidade:

$_GET – para os parâmetros GET;
$_POST – para os parâmetros POST;

Conexões aos bancos de dados através de instruções simples

O ASP precisa instanciar seus objetos específicos e, pior ainda, um para conexão e outro para os recordsets (datasets):

ADODB.Connection – para as conexões;
ADODB.Recordset – para os recordsets.

Do Java nem se fale. É preciso instanciar a classe de conexão com uma string de acesso difícil de se memorizar, preparar a sentença SQL, e depois executar.

Criação simplificada de classes

No início do verdadeiro “boom” do conceito da programação orientada a objetos, os analistas e programadores achavam que esta seria a solução de todos os programas. Os objetos, excessivamente estruturados, tornavam o programa auto-documentado, pois as instruções revelavam claramente suas intenções.

A evolução dos objetos, no entanto, transformou-se numa busca obsessiva do minimalismo. Método para “extração de vírgula”, método para “enxugar gelo”, a ponto de se precisar de especialista para cada classe. Hoje, as linguagens Web estão evoluindo para produtividade. Faz-se método para o que é realmente necessário. Não se perde mais tempo fazendo todos os métodos possíveis para depois se utilizar apenas 10 % deles (se muito).

No início desta forma de abordagem, está o Java, que possui classes, e dentro delas métodos para tudo. No final, mais prático está o PHP. E como uma aberração está o ASP, onde não se tem métodos para grande parte das características desejáveis. Os arrays em ASP (insumo básico para qualquer linguagem) são os mais fracos de qualquer linguagem Web disponível. É preferível se ter uma linha de valores separados por vírgulas do que um arranjo em ASP.

As classes em Java criam um ambiente de excessiva, cansativa e improdutiva tipagem de variáveis. Dificilmente, após alguns meses de criação de uma classe, o programador se lembra de como utilizar os métodos de uma classe que ele fez.

Disponibilidade de literatura na Web

Neste requisito, as linguagens que estão no rol do software livre oferecem uma literatura mais vasta (como o PHP e JAVA). Isto porque a comunidade de desenvolvedores e de usuários se ajuda mutuamente. Existe uma infinidade de fóruns a respeito destas linguagens. Já às proprietárias (como ASP e ASP.NET) não interessa revelar aquilo que se chama “internals”, ou seja, características que são macetes de manipulação de comandos. O interesse dos fornecedores destas últimas é formar especialistas que serão suportes PAGOS, e que vão zelar pela permanência dos softwares nas empresas. Nisto vemos mais uma relação de interesse do fornecedor do que do cliente.

Qualquer dúvida a respeito do software livre é resolvida em pouco tempo pela numerosa comunidade de usuários de uma linguagem na Internet, atuando como uma grande rede neural de pessoas, ou um CÉREBRO COLETIVO.

Eventos centrados em tags

As aplicações e sistemas para Web se baseiam em “design dirigido para execução”. Por isso o design é tão importante neste universo. O analista do negócio orienta o programador quanto às regras do negócio, e o designer quanto às direções obrigatórias da aplicação. Em outras palavras, o designer só torna visível à medida em que o usuário avança nos caminhos da aplicação (telas e links) aquilo que é necessário até o ponto em que o usuário está. Isto é mais que programação a eventos. É programação dirigida.

E dentro deste conceito de programação dirigida, os campos e controles correspondem às tags de HTML. Tudo o que é visível e operacional em telas Web é definido por meio das tags. Estas tem os eventos específicos, ligados às ferramentas operacionais de que o hardware de um computador cliente possui, ou seja, teclado e mouse. Recentemente se acrescentou o “touch screen”, mas no final ele se traduz nos eventos comuns de mouse (click, over e out).

Mas na busca por vezes obsessiva de abranger tudo, alguns fabricantes resolveram “customizar” suas tags (tags proprietárias), lotando-as de atributos, afastando-se da programação a objeto e corrompendo o padrão W3C. A desvantagem é a não portabilidade e a dependência de um servidor específico. Este é o caso da plataforma .NET e Cold Fusion. O conhecido site superdownloads, que disponibiliza softwares para os usuários e profissionais de informática abandonou o Cold Fusion, justamente porque ele é um padrão proprietário, baseado em tags. Também as aplicações em .NET, se migradas para outra plataforma, tem que ser totalmente refeitas, pois parte de sua “inteligência” está em tags.

Facilidade para o desenvolvimento de plugins

Depois dos objetos, surgiu o conceito de plugin. O plugin se agrega a um software como sua parte integrante, obedecendo à engine interna deste software. O Java não utiliza este conceito, como tampouco o ASP ou o .NET. Já o PHP possibilita tal coisa. Para se fazer coisa semelhante em Java, você desenvolve uma classe, e faz com que ela partcipe do ambiente do sistema em questão. No ASP e ASP.NET você tem que recorrer ao Delphi (Embarcadero) ou VBScript para fazer uma DLL e enfrentar os complicados procedimentos de registro desta DLL, coisa possível somente para um suporte capacitado.

Tudo pode ser contornado em programação, mas existe o custo do tempo necessário.

Funções sem excessiva tipagem

Se já é trabalhoso conceber as regras de negócio de um sistema ou aplicação, mais ainda é ter que observar os tipos das variáveis de retorno dos métodos e extrair os seus elementos. Temos os dois extremos. De um lado está o ASP e o PHP, que não exigem conhecimento de tipos, e do outro está o Java, em que temos que “tropeçar” a todo momento em mensagens de tipos não correspondentes (type mismatch).

Alguns minutos de teste de algumas linhas de programa em Java podem enervar um programador a ponto de ele se arrepender da linguagem escolhida. A simples definição de uma classe exige o planejamento dos tipos de entrada e tipos de saída. Existem vários níveis de intermediários para um resultado nesta linguagem.

Hoje, com as exigências de prazos tão apertadas, ninguém pode se dar ao luxo de planejar com tanta rigidez os tipos dos diversos parâmetros exigidos e retornados. Para documentação é ótimo, mas para produtividade é sofrível.

Funções nativas para leitura de arquivos no servidor (texto)

Algumas vezes precisamos armazenar informações temporárias no servidor. Os cookies foram concebidos para isto. Mas, pela paranoia dominante da segurança, eles tem seus efeitos bloqueados por default nas regras de segurança da maioria dos Firewalls do mercado. Sempre passamos pela situação de necessidade de armazenamento ou de objetos completos ou de arranjos temporariamente numa aplicação Web robusta. A solução são os arquivos temporários. Eles são importantíssimos na comunicação de duas aplicações Web que não compartilham nem o espaço de uma Sessão e nem de Aplicação.

O Java permite tal coisa, mas é preciso configurar a segurança do servidor em relação à linguagem. O ASP permite também, mas o IIS precisa ser configurado. O PHP proporciona comandos dos mais simples para esta finalidade, inclusive o armazenamento de objetos inteiros. A segurança necessária é configurada simplesmente pelas autorizações de arquivos (permissões).

Funções nativas para manipulação de arquivos comprimidos (ZIP)

Hoje temos servidores com alta capacidade de armazenamento de arquivos. O tamanho não deveria ser preocupação. Mas em se tratando de Web, com várias requisições, ter o arquivo comprimido é uma vantagem. A única linguagem que possui esta característica é o PHP. Em Java é preciso baixar um pacote na Internet. ASP ou ASP.NET não possuem, e dependem de chamadas ao sistema operacional.

Funções nativas para manipulação de arquivos PDF

O formato PDF tornou-se realmente um padrão, a ponto de se exigir, em certos sistemas, que os relatórios já saiam neste formato, pois se presta a proteger o resultado e também poder ser salvo em seu formato original.

A primeira biblioteca para este fim (FPDF) surgiu para o PHP, e depois a funcionalidade foi incorporada na forma de funções nativas. Para o ASP e Java, é preciso baixar um pacote e instanciar na forma de objetos, para depois se usar.

 Manipulação simplificada de arrays

Quando se obtém um recordset (dataset) produto de uma query ao banco de dados, é altamente desejável extrair os resultados como se fossem itens de um arranjo. Quando se quer armazenar valores como se fossem uma estrutura, mesmo sem o auxílio de tabelas, o arranjo é a melhor solução. Por vezes o arranjo atua como um registro de banco de dados.

Em Java, esta manipulação fica na dependência de algo chamado serialização, de difícil compreensão e manuseio. Em ASP, os recursos para se fazê-lo são praticamente nulos. Em PHP esta manipulação é extremamente facilitada por instruções nativas.

Manipulação simplificada de datas

O formato de data se tornou extremamente importante, pois tudo, hoje em dia, envolve prazos, datas limite e outras características do registro de informações. Esta é uma característica que se refere mais aos bancos de dados, e não à linguagem. Como o banco de dados que registra a data em termos mais inteligíveis (ano, mês e dia) e inteligentes é o Mysql, e a linguagem que mais se preocupa com o acesso a este banco é o PHP, este último procurou se adequar ao máximo a este formato, e proporciona um conjunto de funções para acessar mais eficientemente este formato.

A linguagem em que o custo programacional para recuperação de datas é maior é a linguagem Java. Esta se preocupa com tantos aspectos que uma data pode assumir, que o programador fica confuso. Ela peca realmente pelo excesso. Também o processo de “deprecação” de funções data nesta linguagem é muito frequente. Uma função para extrair determinada parte da data muda inesperadamente quando se lança uma nova versão, deixando o programador abandonado.

Manipulação nativa de expressões relacionais (para check e parsing)

A linguagem Java possui recursos para isto, em vista de sua abordagem minimalista de programação. Em ASP é preciso instanciar o objeto Regexp. Em PHP existe uma instrução nativa para fazê-lo, além da facilidade provida pelo retorno deste teste em um arranjo.

Query Return by array

Esta expressão significa “Retorno do resultado das queries em arranjos estruturados da linguagem e não em objetos”. Isto se justifica pelo fato de que as operações complexas são melhor executadas pelo conceito de métodos e propriedades dos objetos. Mas o retorno, para uso imediato, deve se enquadrar nos conceitos mais comuns das linguagens mais comuns, em uma forma fácil de se manipular. E a forma mais fácil de se manipular um retorno estruturado como é o retorno de uma query é o arranjo.

O Java oferece um caminho tortuoso para manipular o retorno da query, pois se você já armazenou o conteúdo em uma estrutura tipada, porque ter que novamente reconhecer o tipo de variável campo a campo. O ASP retorna os valores facilmente em um objeto, mas a data precisa ser tipada. O PHP simplesmente retorna todos os valores num arranjo, proporcionando o uso de cada um sem trabalho.

Tratamento nativo do protocolo de e-mail

Os sistemas da atualidade, como explicamos no critério “Manipulação simplificada de datas” dependem de prazos. É preciso, frequentemente (quase diariamente) dar satisfação a fornecedores, clientes e gerentes. Então, a integração com a ferramenta de e-mail é extremamente necessária. Em Java, obter um canal com o servidor SMTP ou POP3 é uma verdadeira novela, e provavelmente é melhor fazê-lo baixando alguma classe na Internet, sujeita a bugs. Em ASP, é preciso baixar um objeto (geralmente o ASPemail). Em PHP, a manipulação dos protocolos de e-mail é nativa, ainda oferecendo a possibilidade de se registrar em bancos de dados os parâmetros de envio (datas, nomes dos anexos e até o texto do e-mail). Basta dizer que o serviço de e-mail “horde” é baseado em PHP.

Em todos os casos, é preciso ter um servidor com este serviço em execução.

Tratamento nativo do protocolo de transferência de arquivos (FTP)

O envio de arquivos por FTP é algo muito desejável, pois o tamanho dos anexos de e-mail tem limite por provedor. Em Java e ASP é preciso baixar pacotes para se poder fazer isto em suas scripts. Já em PHP, esta característica é preenchida por funções nativas.

Em todos os casos, é preciso ter um servidor com este serviço em execução.

Treinamento rápido

Seja qual for a linguagem, ambiente ou tipo de sistema, Web ou não, a curva de aprendizado e domínio da linguagem precisa ser bem satisfatória. Ao treinar uma equipe, é preciso ter em mente o “retreinamento”, ou seja, se um membro arranja outro emprego, um novato precisa ser treinado rapidamente.

A linguagem cuja curva e prazo de aprendizado é maior é, sem dúvida, o Java. Em seguida vem o .NET, com sua série de tipos de abordagens (C#, J# e ASP.NET). Depois vem o ASP clássico. E com a curva de aprendizado menor vem o PHP, pois a criação de objetos se resume a igualdades. O acesso a banco de dados se resume a funções, sem as instanciações do ASP ou ASP.NET.

A melhor solução para linguagem Script e banco de dados para Web – Parte I

A particularidade do ambiente Web

O ambiente Web fornece um aspecto que muitos profissionais que utilizaram as três camadas de aplicação se esqueceram: a aplicação tem um só usuário (anônimo) que é chamado muitas vezes. A identidade de acesso é única, a autenticação é necessária e a fila de atendimento é enorme. Portanto, a escolha do banco de dados se pauta mais pela disponibilidade de conectores e classes de acesso do que pelo porte do banco. Daí se poder utilizar bancos desde o Microsoft Access até Oracle.

Antes do banco de dados dar sinais de fadiga, o software servidor (IIS, Apache e outros) pode dar sinal de fadiga ou incapacidade.

Critérios de escolha

A escolha de uma solução Web se pauta nos seguintes critérios:

- Confiabilidade dos fornecedores;
- Portabilidade;
- Custo;
- Rapidez no desenvolvimento/simplicidade de acesso a características esperadas (conexões, arranjos);
- Infra-estrutura exigida;
- Complexidade de instalação/manutenção;
- Variedade de Sistemas/Aplicações conhecidas que os utilizam;
- Coerência no versionamento (versões);
- Facilidade de resolução de dúvidas pela Internet ou Credibilidade frente aos usuários;
- Rotatividade por remuneração dos técnicos.

Confiabilidade dos Fornecedores

Os fornecedores de softwares precisam atender os seguintes requisitos:

- Conhecer e disponibilizar ferramentas e literatura de suporte suficiente para produzir o conforto dos profissionais de suporte e desenvolvimento, através de sites próprios e fóruns na Internet. O teste deste requisito equivale a responder a pergunta: “Quanto tenho uma dúvida, eu acho a solução rapidamente ?”

- Lançar novas versões num prazo de 6 a 12 meses, ou mais rapidamente quando surge um problema;

- Atender pequenas e grandes aplicações sem diferença muito grande de desempenho;

- Preocupar-se com a diversidade de sistemas operacionais, linguagens do mercado e processadores;

- Proporcionar conectores para os diversos bancos de dados;

- Ter alguma espécie de preocupação com a comunidade que desenvolve software livre;

Como complemento a este requisito, entra uma quase paradoxal independência do fornecedor, ou seja, é preciso adotar uma solução cujo futuro esteja garantido pela comunidade que a utiliza. Adotar um produto de um fornecedor que hoje aparece dominando o mercado não é garantia, pois em uma fusão o controlador pode simplesmente descartá-lo ou impor um prazo para abandoná-lo. Esta independência só pode ser obtida com a credibilidade de tendência, ou seja, a comunidade que utiliza o produto o acha bom e digno de ser continuado. Os exemplos são o pacote Staroffice (da Sun) que hoje tem suas marcas como Openoffice, BrOffice e Libreoffice , entre outros. Um outro aspecto é o interesse gerado pela solução, que a faz ser comprada por um fornecedor de credibilidade e destaque no mercado, como o foi do Mysql em relação à Oracle (a Oracle comprou os direitos do banco Mysql).

Portabilidade

As versões lançadas precisam atender os diversos sistemas operacionais existentes, com o mesmo leque de características. Além desta portabilidade ortodoxa, existe a portabilidade de conceitos. Uma linguagem não pode oferecer conceitos tão diversos das linguagens já existentes, com excesso de instanciações, produtos paralelos, tags proprietárias, objetos intermediários, etc.

Custo

Na composição de custo entram os seguintes fatores:

- Custo da plataforma de hardware necessária, para desenvolvimento e produção (dois serviços de software ou dois itens de hardware);

- Custo de treinamento para suporte;

- Custo de treinamento para desenvolvimento;

- Custo de treinamento para usuários;

- Custo de instalação;

- Custo de manutenção;

- Custo de versionamento;

- Custo de licenciamento;

Quanto ao custo de versionamento, hoje ninguém negocia atualizações periódicas no contrato inicial. Este item acaba aparecendo quando um problema exige que se atualize a versão.

Rapidez no desenvolvimento/simplicidade …

No desenvolvimento, é comum a preocupação com a IDE da linguagem de acesso. Os desenvolvedores querem escrever o código com os tradicionais assistentes. Hoje, com a proliferação e diversidade de fóruns disponíveis, um aplicativo inteiro pode ser baixado e modificado. As IDEs podem ter um uso classificado na categoria de “reinvento da roda”. Quando a linguagem é simples e objetiva, apenas algumas instruções podem resolver o problema. Tags proprietárias, com uma infinidade de atributos dificultam tanto a compreensão do código como a sua natureza procedural local.

A palavra-chave é “proprietárias”. Em termos de tags, deve-se sempre esperar que elas já estejam especificadas no padrão W3C, se atendo mais à formatação do que ao acesso a dados. Isto possibilita dividir o trabalho Web em:

- Programador do banco;
- Programador da interface;
- Programador da engine (parte funcional) da aplicação.

A excessiva colocação de acesso a dados em tags de formatação provoca a dificuldade na identificação da engine da aplicação, onde estão seus conceitos e regras. Espera-se que o programador de interface seja mais um designer visual do que um misto de design e programador de  acessos a banco. A interface de um ambiente Web deve ser o mais puro HTML, no máximo conjugado à consolidada linguagem javascript. A plataforma .NET é um exemplo de confusão entre os dois terrenos de programação, misturando formatação com acesso a bancos de dados.

Infra-estrutura exigida

Bancos de dados são notórios neste requisito. O banco Oracle exige máquina dedicada. Já os bancos menores podem conviver com o serviço de disponibilização de páginas do protocolo HTTP. Quando se compra uma solução Web, o hardware necessário conta e muito. Devemos nos perguntar se o banco de dados poderá ser instalado em servidor já existente. Uma resposta negativa implica na compra de servidor, e ser refém de especificações do fornecedor do banco.

Coisa parecida vale para o servidor de páginas. Temos os servidores que rodam até em servidor tipo DOS (Apache), e que consomem um mínimo de recursos, até os que exigem pelo menos um servidor separado (como o IIS).

Complexidade da instalação/manutenção

Em um mundo em que as aplicações Web atingiram o nível da banalidade quanto ao uso, espera-se que a instalação de um software, mesmo servidor, não exija a leitura de manuais, um grande conhecimento e um grande esforço. O cliente quer, geralmente, sua aplicação instalada rapidamente, ou ainda reinstalada quando da perda de um servidor ou problema na instalação. A complexidade de instalação justifica também a alta remuneração dos técnicos, e portanto o aumento no custo da solução.

O tempo de instalação e configuração nunca deve ultrapassar 6 horas, pois o cliente Web não pode ficar sem a sua aplicação no ar.

Variedade de Sistemas/Aplicações conhecidas que …

Quanto mais Sistemas e aplicações existirem com a solução escolhida, maior é o grau de confiabilidade da solução. Em termos do Java e Oracle, por exemplo, não existem muitos produtos prontos e comuns conhecidos. Existe o grande produto SAP, mas ele se aplica tão somente a clientes de vulto, como grandes empresas e bancos. Já o híbrido Mysql/PHP possui muitas aplicações disponibilizadas gratuitamente para download nos diversos sites, sob a licença GPL. Estes produtos podem ser baixados, estudados, modificados e utilizados.

Alguns produtos, como o Joomla (Mysql/PHP/Apache) possui tanta credibilidade, que são desenvolvidas extensões para ele.

Coerência no versionamento

Existem versões de produtos de software que quebram constantemente os seus conceitos de uma versão para a outra. Os produtos Microsoft fazem isto frequentemente, pelo acordo com fornecedores de hardware. Chega-se ao absurdo de um SDK trabalhar completamente diferente de uma versão para a outra, com retirada de características anteriores, modificação do número de parâmetros fornecidos na chama e outros aspectos.

No caso de bancos de dados, muitas vezes é preciso fazer procedimentos detalhados para se exportar o banco para novas versões, inclusive com a presença de técnicos de empresas especializadas, gerando custo. Bancos do tipo ISAM, como o Mysql, possuem uma coerência muito grande entre as versões. A nova engine reconhece os formatos anteriores.

Facilidade na resolução de dúvidas pela Internet

Geralmente, quanto maior o custo da solução, menor será o volume de informação que se achará na Internet sobre suas características e problemas. Um fornecedor que trabalha com uma solução cara não vai querer divulgar as características de sua engine, e nem admitir os erros que ela apresenta. Já as soluções que envolvem software livre e uma grande comunidade de usuários, possuem farta literatura para utilização e solução de problemas advindos de sua utilização.

A literatura em torno de soluções caras como as do banco Oracle ou produtos IBM é escrita em tom formal, e sem detalhes de sua estrutura. Já as soluções livres apresentam farta quantidade de manuais e tutoriais, muitos deles escritos pelos usuários, em linguagem coloquial, fácil de se entender.

Rotatividade por remuneração dos técnicos

Profissionais que trabalham com produtos caros, dando suporte ou desenvolvendo para grandes clientes, procuram sempre uma remuneração maior, e a oferta é tanto maior quanto mais raro o técnico. Um analista que trabalha com banco de dados Oracle facilmente encontra um alto salário em uma grande corporação. Profissionais que trabalham com software livre não encontram esta facilidade, pois a comunidade que utiliza um produto desta natureza é muito numerosa. Por isto a comunidade livre prefere os serviços rápidos de customização.

Conclusão

Na busca pela melhor solução, submeta os critérios aos técnicos cuja história na empresa seja a mais longa. Eles, com a sua experiência, irão decidir o caminho compatível com o seu perfil, porém não se esquecendo de alinhar a diretriz com o mercado. Não adianta adotar o muito mais seguro e formal, se o mercado estiver tendendo para outro lado.

sábado, 17 de agosto de 2013

Instalando o Xampp com outro Mysql e PHPMyAdmin

O pacote Xampp vem com a versão customizada do Mysql para ele, mas que pode não ser a última da Oracle, que tem o Workbench e outras utilidades. Então, vamos arriscar.

Instalando o Mysql

Baixe o pacote Mysql CE (Community Edition). Lembre-se que, ao usar o Mysql acessado por ferramentas de licença GPL, como Apache, PHP, Perl ou Python (ou o que vier depois), ele continua Free. Se acessar pelo ASP ou .NET, aí a licença é paga.

Instalando o Xampp

O pacote Xampp é mais um "Triade", ou seja, Mysql, Apache e PHP no mesmo instalador. Instale-o sem o Mysql. Ao final, é claro, ele vai dar um erro de escrita em mysql.ini, pois o Mysql não veio dele,

Criando o banco pma

O banco de dados phpmyadmin é o que armazena as informações do configurador PHPMyAdmin. Procure as scripts no Google, mas se estiver com preguiça, copie o texto abaixo num arquivo texto e salve com o nome phpmyadmin.sql:

-- --------------------------------------------------------
-- SQL Commands to set up the pmadb as described in Documentation.html.
-- 
-- This file is meant for use with MySQL 5 and above!
-- 
-- This script expects the user pma to already be existing. If we would put a
-- line here to create him too many users might just use this script and end
-- up with having the same password for the controluser.
--                                                     
-- This user "pma" must be defined in config.inc.php (controluser/controlpass)                         
--                                                  
-- Please don't forget to set up the tablenames in config.inc.php                                 
-- 

-- --------------------------------------------------------

-- 
-- Database : `phpmyadmin`
-- 
CREATE DATABASE IF NOT EXISTS `phpmyadmin`
  DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;
USE phpmyadmin;

-- --------------------------------------------------------

-- 
-- Privileges
-- 
-- (activate this statement if necessary)
-- GRANT SELECT, INSERT, DELETE, UPDATE ON `phpmyadmin`.* TO
--    'pma'@localhost;

-- --------------------------------------------------------

-- 
-- Table structure for table `pma_bookmark`
-- 

CREATE TABLE IF NOT EXISTS `pma_bookmark` (
  `id` int(11) NOT NULL auto_increment,
  `dbase` varchar(255) NOT NULL default '',
  `user` varchar(255) NOT NULL default '',
  `label` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL default '',
  `query` text NOT NULL,
  PRIMARY KEY  (`id`)
)
  ENGINE=MyISAM COMMENT='Bookmarks'
  DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;

-- --------------------------------------------------------

-- 
-- Table structure for table `pma_column_info`
-- 

CREATE TABLE IF NOT EXISTS `pma_column_info` (
  `id` int(5) unsigned NOT NULL auto_increment,
  `db_name` varchar(64) NOT NULL default '',
  `table_name` varchar(64) NOT NULL default '',
  `column_name` varchar(64) NOT NULL default '',
  `comment` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL default '',
  `mimetype` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL default '',
  `transformation` varchar(255) NOT NULL default '',
  `transformation_options` varchar(255) NOT NULL default '',
  PRIMARY KEY  (`id`),
  UNIQUE KEY `db_name` (`db_name`,`table_name`,`column_name`)
)
  ENGINE=MyISAM COMMENT='Column information for phpMyAdmin'
  DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;

-- --------------------------------------------------------

-- 
-- Table structure for table `pma_history`
-- 

CREATE TABLE IF NOT EXISTS `pma_history` (
  `id` bigint(20) unsigned NOT NULL auto_increment,
  `username` varchar(64) NOT NULL default '',
  `db` varchar(64) NOT NULL default '',
  `table` varchar(64) NOT NULL default '',
  `timevalue` timestamp NOT NULL,
  `sqlquery` text NOT NULL,
  PRIMARY KEY  (`id`),
  KEY `username` (`username`,`db`,`table`,`timevalue`)
)
  ENGINE=MyISAM COMMENT='SQL history for phpMyAdmin'
  DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;

-- --------------------------------------------------------

-- 
-- Table structure for table `pma_pdf_pages`
-- 

CREATE TABLE IF NOT EXISTS `pma_pdf_pages` (
  `db_name` varchar(64) NOT NULL default '',
  `page_nr` int(10) unsigned NOT NULL auto_increment,
  `page_descr` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL default '',
  PRIMARY KEY  (`page_nr`),
  KEY `db_name` (`db_name`)
)
  ENGINE=MyISAM COMMENT='PDF relation pages for phpMyAdmin'
  DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;

-- --------------------------------------------------------

-- 
-- Table structure for table `pma_relation`
-- 

CREATE TABLE IF NOT EXISTS `pma_relation` (
  `master_db` varchar(64) NOT NULL default '',
  `master_table` varchar(64) NOT NULL default '',
  `master_field` varchar(64) NOT NULL default '',
  `foreign_db` varchar(64) NOT NULL default '',
  `foreign_table` varchar(64) NOT NULL default '',
  `foreign_field` varchar(64) NOT NULL default '',
  PRIMARY KEY  (`master_db`,`master_table`,`master_field`),
  KEY `foreign_field` (`foreign_db`,`foreign_table`)
)
  ENGINE=MyISAM COMMENT='Relation table'
  DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;

-- --------------------------------------------------------

-- 
-- Table structure for table `pma_table_coords`
-- 

CREATE TABLE IF NOT EXISTS `pma_table_coords` (
  `db_name` varchar(64) NOT NULL default '',
  `table_name` varchar(64) NOT NULL default '',
  `pdf_page_number` int(11) NOT NULL default '0',
  `x` float unsigned NOT NULL default '0',
  `y` float unsigned NOT NULL default '0',
  PRIMARY KEY  (`db_name`,`table_name`,`pdf_page_number`)
)
  ENGINE=MyISAM COMMENT='Table coordinates for phpMyAdmin PDF output'
  DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;

-- --------------------------------------------------------

-- 
-- Table structure for table `pma_table_info`
-- 

CREATE TABLE IF NOT EXISTS `pma_table_info` (
  `db_name` varchar(64) NOT NULL default '',
  `table_name` varchar(64) NOT NULL default '',
  `display_field` varchar(64) NOT NULL default '',
  PRIMARY KEY  (`db_name`,`table_name`)
)
  ENGINE=MyISAM COMMENT='Table information for phpMyAdmin'
  DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;

-- --------------------------------------------------------

-- 
-- Table structure for table `pma_designer_coords`
-- 

CREATE TABLE IF NOT EXISTS `pma_designer_coords` (
  `db_name` varchar(64) NOT NULL default '',
  `table_name` varchar(64) NOT NULL default '',
  `x` INT,
  `y` INT,
  `v` TINYINT,
  `h` TINYINT,
  PRIMARY KEY (`db_name`,`table_name`)
)
  ENGINE=MyISAM COMMENT='Table coordinates for Designer'
  DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;

-- --------------------------------------------------------

-- 
-- Table structure for table `pma_tracking`
-- 

CREATE TABLE IF NOT EXISTS `pma_tracking` (
  `db_name` varchar(64) collate utf8_bin NOT NULL,
  `table_name` varchar(64) collate utf8_bin NOT NULL,
  `version` int(10) unsigned NOT NULL,
  `date_created` datetime NOT NULL,
  `date_updated` datetime NOT NULL,
  `schema_snapshot` text collate utf8_bin NOT NULL,
  `schema_sql` text collate utf8_bin,
  `data_sql` longtext collate utf8_bin,
  `tracking` set('UPDATE','REPLACE','INSERT','DELETE','TRUNCATE','CREATE DATABASE','ALTER DATABASE','DROP DATABASE','CREATE TABLE','ALTER TABLE','RENAME TABLE','DROP TABLE','CREATE INDEX','DROP INDEX','CREATE VIEW','ALTER VIEW','DROP VIEW') collate utf8_bin default NULL,
  `tracking_active` int(1) unsigned NOT NULL default '1',
  PRIMARY KEY  (`db_name`,`table_name`,`version`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_bin ROW_FORMAT=COMPACT;

-- --------------------------------------------------------

--
-- Table structure for table `pma_userconfig`
--

CREATE TABLE IF NOT EXISTS `pma_userconfig` (
  `username` varchar(64) NOT NULL,
  `timevalue` timestamp NOT NULL,
  `config_data` text NOT NULL,
  PRIMARY KEY  (`username`)
)
  ENGINE=MyISAM COMMENT='User preferences storage for phpMyAdmin'
  DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;

Abra uma ferramenta como o MysqlFront ou Workbench (do pacote Oracle), e use a função importar SQL para criar o banco, importando este arquivo sql.

Criando um diretório config

Debaixo do diretório C:\xampp\phpMyAdmin, crie o diretório config, onde o phpmyadmin vais armazenar alguns arquivos temporários de configuração.

Configurando o config.inc.php

No Xampp, este arquivo fica no caminho C:\xampp\phpMyAdmin. Comente as linhas $cfg de tabelas que não estiverem no banco phpmyadmin, para poder utilizá-lo sem que apareçam erros:

No nosso caso, veja as linhas comentadas:

<?php
/*
 * This is needed for cookie based authentication to encrypt password in
 * cookie
 */
$cfg['blowfish_secret'] = 'xampp'; /* YOU SHOULD CHANGE THIS FOR A MORE SECURE COOKIE AUTH! */

/*
 * Servers configuration
 */
$i = 0;

/*
 * First server
 */
$i++;

/* Authentication type and info */
$cfg['Servers'][$i]['auth_type'] = 'config';
$cfg['Servers'][$i]['user'] = 'root';
$cfg['Servers'][$i]['password'] = 'marina';
$cfg['Servers'][$i]['extension'] = 'mysqli';
$cfg['Servers'][$i]['AllowNoPassword'] = true;
$cfg['Lang'] = '';

/* Bind to the localhost ipv4 address and tcp */
$cfg['Servers'][$i]['host'] = '127.0.0.1';
$cfg['Servers'][$i]['connect_type'] = 'tcp';

/* User for advanced features */
$cfg['Servers'][$i]['controluser'] = 'pma';
$cfg['Servers'][$i]['controlpass'] = '';

/* Advanced phpMyAdmin features */
$cfg['Servers'][$i]['pmadb'] = 'phpmyadmin';
$cfg['Servers'][$i]['bookmarktable'] = 'pma_bookmark';
$cfg['Servers'][$i]['relation'] = 'pma_relation';
$cfg['Servers'][$i]['table_info'] = 'pma_table_info';
$cfg['Servers'][$i]['table_coords'] = 'pma_table_coords';
$cfg['Servers'][$i]['pdf_pages'] = 'pma_pdf_pages';
$cfg['Servers'][$i]['column_info'] = 'pma_column_info';
$cfg['Servers'][$i]['history'] = 'pma_history';
$cfg['Servers'][$i]['designer_coords'] = 'pma_designer_coords';
$cfg['Servers'][$i]['tracking'] = 'pma_tracking';
$cfg['Servers'][$i]['userconfig'] = 'pma_userconfig';
// $cfg['Servers'][$i]['recent'] = 'pma_recent';
//$cfg['Servers'][$i]['table_uiprefs'] = 'pma_table_uiprefs';

/*
 * End of servers configuration
 */

?>

As tabelas pma_recent e pma_table_uiprefs não estavam na script sql que baixamos, e então, friamente, eliminamos as mesmas.

Agora, divirta-se.





quinta-feira, 15 de agosto de 2013

Qual é o melhor editor para PHP ?

O ambiente IDE mais difundido e completo (porém complexo), é o Eclipse.

A sua versão standard vem pronta para programação em Java, pois esta linguagem se tornou a panacéia para todo tipo de desenvolvimento, seja em console, tablets, smartphones ou em janelas.

Mas se você quer uma IDE enxuta, apropriada para a excelente linguagem PHP, baixe uma ferramenta completa e dedicada:

O Zend Eclipse for PHP Developers

Até esta data, o link para fazê-lo é:

http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/kepler/R/eclipse-standard-kepler-R-win32-x86_64.zip&mirror_id=576

O servidor é brasileiro, e a versão é para Windows.

quinta-feira, 8 de agosto de 2013

Menu com Jquery, HTML5, CSS3 com PIE.htc para compatibilidade com Internet Explorer

Um dos problemas dos grupos que desenvolvem softwares para a Web se refere aos browsers do mercado. A palavra é compatibilidade. Não se preocupem, pois ao final do artigo daremos o código completo do exemplo em HTML.

São 3 os principais browsers utilizados:


  • Google Chrome;
  • Firefox;
  • Internet Explorer.


O último é uma praga que se recusa a acompanhar os padrões vigentes ao tempo em que são disponibilizados, principalmente a especificação HTML5. Isto pode ser contornado utilizando-se uma biblioteca javascript de nome HTML5.js, disponível no repositório da Google neste endereço. Para outras compatibilidades com o padrão CSS3, é preciso incluir também a biblioteca PIE.htc, disponível neste endereço.

Cabeçalho do HTML (HEAD)

Conforme dito, o corpo do HEAD do HTML fica assim:

<script src="js/html5.js"></script>
<link rel="stylesheet" href="MenuMeyer.css">
<script src="js/jquery-1.9.1.js"></script>
<script>window.jQuery || document.write('<script src="js/jquery-1.9.1.js"><\/script>')</script>

A folha de estilo padrão CSS3

A folha de estilo mencionada (MenuMeyer.css) fica da seguinte forma:

UL.xmenu LI {
list-style-type: none;
font-family: Verdana;
font-size: 14px;
}
UL.xmenu.horizontal LI {
float: left;
}
UL.xmenu.horizontal LI.ultimo {
float: none;
}
UL.xmenu LI A {
border-style: solid; 
border-width: 1px; 
border-color: gray; 
border-radius: 6px;
behavior: url(PIE.htc);
text-decoration: none;
}
UL.xmenu LI A SPAN {
font-weight: normal;
color: royalblue;
background-color:gold;
}
UL.xmenu LI A SPAN.active {
font-weight: bold;
color: gold;
background-color: royalblue;
}

Ou seja, a tag ou sequência de tags que precisar de compatibilidade (como UL nesta folha de estilos) deverá ter a inclusão da cláusula "behavior" típica do Internet Explorer, pois muitas de suas versões tem dificuldade para lidar com o padrão CSS3.

Os menus utilizando as tags UL e LI

Os menus podem ser horizontais ou verticais.

Menu horizontal

   <ul class="xmenu horizontal">
<li><a href="#"><i class="xicone"></i><span>Opção 1</span></a></li>
<li><a href="#"><i class="xicone"></i><span name="Op12">Opção 2</span></a></li>
<li class="ultimo"><a href="#"><i class="xicone"></i><span name="Op13">Opção 3</span></a></li>
   </ul>

Menu Vertical

   <ul class="xmenu vertical">
<li><a href="#"><i class="xicone"></i><span name="Op21">Opção 1</span></a></li>
<li class="active"><a href="#"><i class="xicone"></i><span name="Op22">Opção 2</span></a></li>
<li><a class="ultimo" href="#"><i class="xicone"></i><span name="Op23">Opção 3</span></a></li>
   </ul>

Basicamente, a diferença entre um e outro é o atributo "float". Este atributo é configurado pelo uso da classe xmenu, subclasses horizontal e vertical.

Código de inicialização javascript

Por se tratar de um HTML baseado em jquery (pois a palavra chave aqui é compatibilidade), fazemos a seguinte definição quando o documento está totalmente carregado:

// Ativação
$( document ).ready(function() {
$("i.xicone").html('<img border=0 src="img/estrela.gif">');
$("UL.xmenu>LI>A>SPAN").bind({
"mouseover": function() {
$(this).addClass("active");
},
"mouseout": function() {
$(this).removeClass("active");
},
"click": function(){
bmyClickOption(this);
}
});
});

O evento "onclick" aponta para a função bmyClickOption(). Esta faz uma associação entre o elemento do modelo DOM do HTML carregado que provocou o evento e a função correspondente cujo nome é o nome do elemento (do atributo name) concatenado com a string "Click".

// Manipulação do Click
function bmyClickOption(pElem){
var nomeElem = $(pElem).attr("name");
if( nomeElem == null ){
alert('Sem função específica para manipulação deste evento.');
} else {
var funcao = nomeElem + "Click()";
eval(funcao);
}
}


 Daí termos o seguinte código javascript para manipular os eventos dos elementos nas tags SPAN:

// Biblioteca de eventos click - INICIO
function Op11Click(){
alert("Opção 11");
}
function Op12Click(){
alert("Opção 12");
}
function Op13Click(){
alert("Opção 13");
}
function Op21Click(){
alert("Opção 21");
}
function Op22Click(){
alert("Opção 22");
}
function Op23Click(){
alert("Opção 23");
}

Código completo

<html>
<head>
<script src="js/html5.js"></script>
<link rel="stylesheet" href="MenuMeyer.css">
<script src="js/jquery-1.9.1.js"></script>
<script>window.jQuery || document.write('<script src="js/jquery-1.9.1.js"><\/script>')</script>
<script type="text/javascript">
// Biblioteca de eventos click - INICIO
function Op11Click(){
alert("Opção 11");
}
function Op12Click(){
alert("Opção 12");
}
function Op13Click(){
alert("Opção 13");
}
function Op21Click(){
alert("Opção 21");
}
function Op22Click(){
alert("Opção 22");
}
function Op23Click(){
alert("Opção 23");
}
// Biblioteca de eventos click - FIM
// Manipulação do Click
function bmyClickOption(pElem){
var nomeElem = $(pElem).attr("name");
if( nomeElem == null ){
alert('Sem função específica para manipulação deste evento.');
} else {
var funcao = nomeElem + "Click()";
eval(funcao);
}
}
// Ativação
$( document ).ready(function() {
$("i.xicone").html('<img border=0 src="img/estrela.gif">');
$("UL.xmenu>LI>A>SPAN").bind({
"mouseover": function() {
$(this).addClass("active");
},
"mouseout": function() {
$(this).removeClass("active");
},
"click": function(){
bmyClickOption(this);
}
});
});
</script>
</head>
<body>
<h2>Menu Horizontal</h2>
   <div>
   <ul class="xmenu horizontal">
<li><a href="#"><i class="xicone"></i><span>Opção 1</span></a></li>
<li><a href="#"><i class="xicone"></i><span name="Op12">Opção 2</span></a></li>
<li class="ultimo"><a href="#"><i class="xicone"></i><span name="Op13">Opção 3</span></a></li>
   </ul>
   </div>
   <h2>Menu Vertical</h2>
   <div>
   <ul class="xmenu vertical">
<li><a href="#"><i class="xicone"></i><span name="Op21">Opção 1</span></a></li>
<li class="active"><a href="#"><i class="xicone"></i><span name="Op22">Opção 2</span></a></li>
<li><a class="ultimo" href="#"><i class="xicone"></i><span name="Op23">Opção 3</span></a></li>
   </ul>
   </div>
<body>
</html>