Como criar uma Extensão para o Google Chrome

Projeto simples, para criar uma Extensão para o Google Chrome

• O arquivo manifest.json

Todos os projetos que você criar tem que ter o arquivo manifest.json na pasta raiz do mesmo. Esse arquivo não é nada mais que um JSON, onde ficarão as informações relacionadas à sua extensão: nome da extensão, descrição, versão, permissões, etc. Tudo que você pode incluir no manifest.json, você encontra aqui nesse link.

Para nossa primeira extensão, vamos usar as seguintes informações:

As informações obrigatórias são somente o manifest_version, name e version, onde:

manifest_version: Representa a versão do manifesto que você está usando. Hoje (junho/2011), é obrigatório usar a versão 2;
name: Representa o nome da sua extensão;
version: Representa a versão da sua extensão. A versão deve ser separada por pontos.

As informações adicionais sobre nossa extensão Hello World presentes no nosso manifesto são:

description: É uma descrição para nossa extensão;
browser_action: Representa ações que executaremos no navegador. Para nosso exemplo, iremos apenas apresentar um popup quando o usuário clicar na extensão;
default_popup: Informa qual HTML o navegador deve carregar quando o usuário clicar no ícone da extensão.
icons: Representa todos os ícones que sua extensão irá utilizar.

• POPUP

Para servir de popup da extensão, use a seguinte página HTML simples abaixo, chamada index.html (ou crie uma página sua, com o mesmo nome):

Essa pagina será exibida quando o usuário clicar no ícone da nossa extensão.

• Ícone

Você pode usar qualquer ícone que desejar, no tamanho:  16 pixels. E salvar na pasta images do projeto. Se quiser usar a mesma que eu só copiar daqui: Icone. Quando você for publicar sua extensão, é recomendado que você tenha ao menos o tamanho de ícone em 128x128px. Se possível, passe todos os tamanhos pedidos (16x16, 48x48, 128x128), pois o Chrome irá selecionar o que for mais apropriado para o momento que ele precisar ser apresentado.

• CSS

Dentro da pasta CSS, você colocar o seu arquivo style.css onde você pode customizar da maneira que desejar. 

• Testando sua Extensão

Testar a extensão é bem simples, basta abrir seu Google Chrome e navegar até Menu > Mais ferramentas > Extensões.

Na página de extensões, habilite o modo desenvolvedor, clicando na caixa de seleção:

Clique em Carregar extensão expandida:

Na janela que abrir, escolha a pasta onde está seu projeto. E pronto, a extensão foi instalada! Se você reparar vai aparecer um registro novo com as informações da nossa extensão e o ícone dela já está disponível ao lado da barra de endereços.

Para testar, basta clicar no ícone da extensão:

Pronto! Agora você já pode começar a brincar e colocar mais funcionalidade na sua Extensão. O projeto completo pode ser baixado no Github: Extensão para o Google Chrome.

Criação de Excel com Java e Apache Poi

Projeto Simples para criar um arquivo Excel com Java e Apache POI

Primeiro criamos a Classe Model Usuário:

public class User {
	private int id;
	private String name;
	private String email;
	private String password;
	private String adress;
	private int telefone; //getters e setter

 

Agora vamos criar a Classe que vai criar o Excel, com um método main que vai executar nosso programa e gerar o Excel. 

public class CreateExcel {
	private static final String fileName = "C:/apachepoi/usuarios.xls";
	public static void main(String[] args) throws IOException {} }

Dentro da Pasta C:/apachepoi vamos adicionar um arquivo .xls que será o nosso arquivo modelo, do qual podemos configurar como desejarmos colocar um template, logo, titulo das informações que serão adicionadas, etc. No caso estamos usando o usuarios.xls. 

Dentro desse método vamos adicionar as informações do usuário em memoria, para podermos ter informações reais para gerar o relatório,  

public static void main(String[] args) throws IOException {

	List<User> lisUsers = new ArrayList<User>(); lisUsers.add(new User(1, "Bruno", "bruno@gmail.com","senha", 9876525, "Aclimacao, 155"));
	lisUsers.add(new User(1, "Eduardo", "eduardo@gmail.com","senha", 9876525, "Santana, 520"));
	lisUsers.add(new User(1, "Carol", "carol@gmail.com","senha", 9876525, "Itaquera, 302"));
	lisUsers.add(new User(1, "Marcia", "marcia@gmail.com","senha", 9876525, "Sapopemba, 49"));
	lisUsers.add(new User(1, "Gustavo", "gustavo@gmail.com","senha", 9876525, "Vila Prudente, 155"));
	lisUsers.add(new User(1, "Rafael", "eduardo@gmail.com","senha", 9876525, "Vila Ema, 275"));

}

A Apache POI contém classes e métodos para trabalhar em todos os documentos do MS-Office. Vamos usar um desses componentes da Biblioteca o HSSF (Horrible formato de planilha): Ele é usado para ler e escrever formato .xls de arquivos MS-Excel, que o que precisamos, então vamos acionar dentro do nosso metodo main:

	HSSFWorkbook workbook = new HSSFWorkbook(); HSSFSheet sheetUsers = workbook.createSheet("Usuarios");

Em seguida vamos informar em que linha os dados vão começar a ser inseridos. Por exemplo se você criar um template, e tiver adicionado na primeira linha do seu arquivo o titulo das informações que serão inseridas, você vai gerar o arquivo a partir da linha 1 (a contagem é feita a partir da linha 0 que é equivalente a primeira linha), se você não for colocar nenhum titulo então iniciara na linha 0.

int rownum = 0;

Agora vamos criar um for, que vai percorrer pela nossa lista de usuários que criamos com as informações e adicionar no arquivo.

	for (User user : lisUsers) { Row row = sheetUsers.createRow(rownum++);
	int cellnum = 0;
	Cell cellId = row.createCell(cellnum++);
	cellId.setCellValue(user.getId());
	Cell cellNome = row.createCell(cellnum++);
	cellNome.setCellValue(user.getName());
	Cell cellEmail = row.createCell(cellnum++);
	cellEmail.setCellValue(user.getEmail());
	Cell cellSenha = row.createCell(cellnum++);
	cellSenha.setCellValue(user.getPassword());
	Cell cellTelefone = row.createCell(cellnum++);
	cellTelefone.setCellValue(user.getTelefone());
	Cell cellAdress = row.createCell(cellnum++);
	cellAdress.setCellValue(user.getAdress());
	}

Em seguida criamos o arquivo

	try { FileOutputStream out = new FileOutputStream(new File(CreateExcel.fileName));
	workbook.write(out);
	out.close();
	System.out.println("Arquivo Excel criado com sucesso!");

E tratamos os eventuais erros:

	} catch (FileNotFoundException e) {
	System.out.println("Arquivo não encontrado!");
	} catch (IOException e) {
	System.out.println("Erro na edição do arquivo!");
	}
	}
	}

Agora basta executar o método main e a mágica estará feita. O projeto completo pode ser baixado no Github: Projeto Simples Aplache POI 

Melissa Lobo.

Apache POI

Apache POI é uma API popular que permite aos programadores criar, modificar e exibir arquivos do Microsoft-Office usando programas Java. É uma biblioteca de código aberto desenvolvido e distribuído pela Apache Software Foundation. Ele contém classes e métodos para decodificar os dados de entrada do usuário ou um arquivo para documentos do Microsoft Office.

Componentes do Apache POI
Apache POI contém classes e métodos para trabalhar em todos os documentos OLE2 compostos de MS-Office. A lista de componentes deste API é dado abaixo:

• POIFS (Pobre Obfuscation Implementação do Sistema de Arquivos): Este componente é o fator básico de todos os outros elementos de POI. Ele é usado para ler arquivos diferentes explicitamente.
• HSSF (Horrible formato de planilha): Ele é usado para ler e escrever formato .xls de arquivos MS-Excel.
• XSSF (XML SpreadSheet Format): É usado para o formato de arquivo .xlsx do MS-Excel.
• HPSF (Horrible Property Set Format): É usado para extrair conjuntos de propriedades dos arquivos do MS-Office.
• HWPF (Horrible formato Word Processor): Ele é usado para ler e escrever arquivos de extensão .doc do MS-Word.
• XWPF (XML formato Word Processor): Ele é usado para ler e escrever arquivos de extensão docx do MS-Word.
• HSLF (Horrible Deslize layout Format): É usado para ler, criar e editar apresentações de PowerPoint.
• HDGF (Horrible formato de diagrama): Contém classes e métodos para arquivos binários MS-Visio.
• HPBF (Horrible formato do Publisher): Ele é usado para ler e gravar arquivos MS-Publisher.

Instalação Apache POI Biblioteca

Baixe a versão mais recente do Apache POI a partir http://poi.apache.org/download.html e descompacte seu conteúdo para uma pasta de onde as bibliotecas necessárias podem ser ligados ao seu programa Java. 

E depois adicionar os jars ao projeto.

1) Clique com o botão direito do mouse em cima do projeto
2) Vá em propriedades
3) Biibliotecas
4) Adicionar Jar/Pasta

O que escrever no README.md do seu projeto no Github

Antes de sitar os tópicos, é boa pratica criar a descrição do seu projeto no README.md em inglês, pois as chances de pessoas de outros países verem seu projeto é grande, e não queremos que eles não entendam o que o nosso projeto faz, não é mesmo? Então sempre que possível escreva a descrição em inglês. 

Sinopse/Synopsis
Na parte superior do arquivo deve haver uma breve introdução e / ou visão geral que explica o que é o projeto. Esta descrição deve corresponder descrições adicionados para os gestores de pacotes (gemspec, package.json, etc.)

Exemplo de código/Code Example
Os desenvolvedores devem ser capazes de descobrir como seu projeto resolve o seu problema, olhando para o exemplo de código. Verifique se a API que você está mostrando é óbvio, e que o código é curto e conciso.

Motivação/Motivation
Uma breve descrição da motivação por trás da criação e manutenção do projeto. Isso deve explicar por que existe o projeto.

Instalação/Installation
Fornecer exemplos de código e explicações sobre como obter o projeto.

Referência API/API Reference
Dependendo do tamanho do projeto, se for pequena e simples o suficiente para os documentos de referência pode ser adicionado ao README. Para o tamanho médio a grandes projectos é importante, pelo menos, fornecer um link para onde os documentos de referência API viver.

Testes/Tests
Descrever e mostrar como executar os testes com exemplos de código.

Contribuintes/Contributors
Que as pessoas saibam como eles podem mergulhar no projeto, incluem links importantes para coisas como rastreadores de problemas, irc, contas de Twitter, se aplicáveis.

Licença/License
Um trecho curto descrevendo a licença (MIT, Apache, etc.)

Escrevendo em Markdown

Agora vamos praticar, e escrever em Markdown, para visualizar os exemplos é só abrir: Exemplos do Tutorial e ir acompanhando como fica cada coisa. 


Títulos

Para marcar um título, você vai usar # a quantidade de vezes que irá representar o nível do título. Exemplo:

1 2 3 4 5 6

# Título nível 1 ## Título nível 2 ### Título nível 3 #### Título nível 4 ##### Título nível 5 ###### Título nível 6

view

Parágrafos e quebras de linha

Para gerar parágrafos, basta você escrever o texto em uma linha:

1 2 3 4 5

Título de nível 1 ================== Título de nível 2 ------------------

 view

Parágrafos e quebras de linha
Para gerar parágrafos, basta você escrever o texto em uma linha:

1 2 3

Este é um parágrafo. Este é outro parágrafo.

view

Mas a documentação do Markdown diz que, para quebras de linha, você precisa deixar dois espaços no final da linha:

1 2	Primeira linha do parágrafo. [espaço][espaço] Segunda linha do parágrafo.

Coloquei o [espaço] no final da primeira linha somente para facilitar a visualização. Você deve substituir por dois espaços em branco.

Links 

Para gerar links, você usa [](). Dentro dos colchetes você coloca o texto do link, e dentro dos parênteses, você coloca a URL:

1	[Blog da Mel](http://melissalobo.blogspot.com.br)

view

Links automáticos

Se o texto do seu link é o próprio link, você pode envolvê-lo entre < link >, que o link será gerado automaticamente:

1	<https://www.google.com.br>

view

Listas

Para listas não ordenadas, você pode usar *, + ou -. Veja:

1 2 3 4 5 6 7 8 9 10 11

* Item 1 * Item 2 * Item 3 + Item 1 + Item 2 + Item 3 - Item 1 - Item 2 - Item 3

view

E para listas ordenadas, você usa o número, seguido de ponto:

1 2 3

1. Item 1 2. Item 2 3. Item 3

view

Imagens

Geração de imagens é bem parecido com a geração de links: você só precisa adicionar uma ! no início. E o texto que você coloca entre os colchetes, é usado como alt na imagem:

1	

view

Backslash scapes

Para escapar caracteres que são parseados pelo Markdown, você pode usar a barra invertida \, seguida do caractere, para imprimi-lo literalmente. O escape funciona para os caracteres listados abaixo:

1 2 3 4 5 6 7 8 9 10 11 12

\ backslash (barra invertida) ` backtick (crase) * asterisk (asterisco) _ underscore {} curly braces (chaves) [] square brackets (colchetes) () parentheses (parênteses) # hash mark (sustenido / hash / jogo da velha) + plus sign (sinal de "mais" ou somar) - minus sign (hyphen) (sinal de menos ou hífen) . dot (ponto) ! exclamation mark (ponto de exclamação)

view

Para saber mais sobre Markdown, recomendo a leitura da documentação oficial:

http://daringfireball.net/projects/markdown/

E alguns links de como o Github usa Markdown, que foi onde eu descobri tudo isso que postei:
https://help.github.com/articles/markdown-basics | https://help.github.com/articles/github-flavored-markdown/