Intelecto Livre!

Como Melhorar Nitidez do Firefox no Ubuntu

2010-02-22T21:35:00.002-03:00

Por muito tempo desejei que numa atualiazação ou outra o Firefox ficasse tão nítido no Ubuntu como é no Windows. As fontes ficam embaçadas, cansativas para leitura. E assim que minha preguiça acabou (achei que fosse mais complicado fazer isso), resolvi pesquisar como melhorar a nitidez do firefox no Ubuntu. Agora compartilho como consegui o feito.

Basta digitar no nosso fiel terminal (ou console, como queira) os seguintes comandos:

$ cd /etc/fonts/
$ sudo mv conf.d/10-hinting-slight.conf .
$ sudo ln -s conf.avail/10-hinting-slight.conf conf.d/
$ sudo mv conf.d/10-hinting.conf .
$ sudo ln -s conf.avail/10-hinting.conf conf.d/
$ sudo dpkg-reconfigure fontconfig

Esse "." (ponto) no final do segundo e do quarto comando é obrigatório mesmo, separado por espaço.

Prontinho! Se digitou certinho ou usou CTRL+C/CTRL+V, tem que ter funcionado. Reinicie seu firefox e sinta o alívio!

Lindoélio Lázaro

Recuperando GRUB 2 no Ubuntu 9.10

2010-01-12T21:07:00.003-02:00

Não consigo me convencer de que a nova versão do Grub, totalmente diferente da anterior, era mesmo necessária. Afinal, em time que está ganhando se mexe? E precisa mexer tanto assim? Bom, acho que o pessoal da Canonical não pensa como eu e adicionou o Grub 2 como padrão na instalação do Ubuntu 9.10.

Dentre os vários problemas que poderia citar desse novo Grub em relação ao antigo (que nem era antigo), é que ao instalar uma distribuição que use o Grub 1, as entradas configuradas no Grub 2 não são reconhecidas, ou seja, lá vai o pobre "human beings" tentar recuperar o Grub 2 para não ter que reinstalar o seu multimídia Ubuntu 9.10. E o mesmo ocorre quando se instala o SO janelinha.

Abaixo, descrevo a forma que encontrei de resolver esse probleminha que já deve ter feito muita gente reinstalar seu novo, nem tão novo assim, Ubuntu, afim de compartilhar com quem queira:

Você só vai precisar de um LiveCD do Ubuntu 9.10 (Ainda tem ele, não tem? Se não tem, serve um LiveUSB) e uma xícara de café.

Então, vamos lá...

Encontre seu LiveCD ou LiveUSB do Ubuntu 9.10 e inicie o Sistema pelo LiveCD/LiveUSB normalmente...

Abra o terminal de comandos, disponível em "Aplicativos >> Acessórios >> Terminal" e digite os seguintes comandos (só o que vem depois dos símbolos $ ou #, por favor):

Para listar os HD's e suas respectivas partições...
$ sudo fdisk -l

Descubra em qual das partições listadas está instalado o seu Ubuntu 9.10 e monte-a na pasta /mnt, assim:
$ sudo mount /dev/sdaX /mnt
(troque esse sdaX pela identificação da sua partição)

Caso você tenha o /boot em outra partição (e só nesse caso), monte-a também:

$ sudo mount /dev/sda6 /mnt/boot

Em seguida, execute:
$ sudo mount --bind /dev /mnt/dev

Mude a raiz para o novo ponto de montagem, dessa forma:
$ sudo chroot /mnt

Agora os comandos serão executados como root e não vai mais precisar que você digite o sudo.
E então o comando "mágico" que lhe voltará ao Grub 2:
# grub-install /dev/sda

Pronto!
Desmonte o que montou, pegue sua xícara de café, reinicie a máquina (tirando o LiveCD/LiveUSB) e corra para um lugar seguro pra ver se vai explodir! Mas não há motivo pra pânico, porque se você não digitou os símbolos $ ou # com os espaços depois deles, então vai dar tudo certo...
# exit
$ umount /mnt/dev
$ umount /mnt
$ sudo shutdown -r now

Se quiser se aprofundar sobre os detalhos desse novo Grub, acesse esse ótimo artigo: http://gnulinuxbr.wordpress.com/2009/11/16/grub2/

Lindoélio Lázaro

Sincronizando Arquivos no Ubuntu

2008-08-15T10:26:00.010-03:00

Minha busca por um aplicativo que fizesse sincronia de arquivos bilateralmente entre dispositivos móveis de armazenamento (pendrive, cartões de memória, etc) e o computador, no Ubuntu, ou até mesmo entre dois desses dispositivos, ou ainda entre dois diretórios numa mesma máquina, ou mesmo em dois locais de rede, e por aí vai, rsrsrs, acabou quando encontrei o Grsync. Esse software é, na verdade, uma interface visual em GTK+2 para o utilitário Rsync (que opera por comandos, em modo texto), com capacidades avançadas de sincronia e backup.
Para instalar o Grsync no Ubuntu, acesse no menu: "Aplicações > Adicionar/Remover", pesquise por Grsync e marque para instalação imediata. Se preferir, entre no terminal e digite o comando # sudo apt-get install grsync para instalá-lo. Lembrando que, para tal, você deverá estar logado na Internet.

Após a instalação execute-o. No meu Ubuntu (Hardy Heron) o atalho para o programa foi parar no menu "Aplicações > Internet". Pode ser que contigo seja assim também. Para executá-lo do terminal digite # grsync.

Com o Grsync aberto é só definir os diretórios ou dispositivos de armazenamento a serem sincronizados e estabelecer algumas regras marcando as opções disponíveis na interface. Se desejar algum recurso "extra", que não tenha sido implementado na interface, antes ou depois de executar a sincronia, você pode inserir isso em forma de comandos pela aba "Extra Options" nos campos respectivos.

No primeiro botão Browse (source), informe o diretório ou drive que será copiado para o destino que será definido no segundo botão Browse, onde você informará o local onde a cópia será salva.
Se você quiser sincronizar os dois locais, afim de que tenham o mesmo conteúdo, clique no botão Switch logo após o os botões Browse's; isso fará com que o destino passe a ser a fonte e a fonte passe a ser o destino.
Relaciono as opções de sincronia mais úteis, a saber:

Delete on destination - apaga todo o conteúdo no local de destino que não tiver cópia no local de origem, ou seja, garante que os dois locais terão, absolutamente, o mesmo conteúdo.

Skip newer - faz com que os arquivos mais antigos contidos no local de origem não sobrescrevam os arquivos mais novos contidos no local de destino.

Windows compatibility - evita erros de escrita nos arquivos e pastas que serão copiados entre partição Linux para uma partição Windows (NTFS, Fat32, Fat16), aumentando assim, a compatibilidade entre os sistemas de arquivos. A maioria dos pendrives, por exemplo, utiliza Fat32 como sistema de arquivos.

Compress file data - comprime o conteúdo a ser copiado afim de compactá-lo. Mais útil quando a intenção é manter cópias de segurança, para evitar despêndios de espaço em disco.
Only update existing files - apenas atualiza os arquivos do local de destino com as versões mais novas dos mesmos arquivos no local de origem.
Escolha as opções que lhe aprouver e clique em Executar para realizar a sincronia ou backup.
Caso queira definir mais de um esquema de sincronia você poderá criar novas "sessions", logo no topo da interface.

Sincronize sua mente com o que há de melhor no mundo livre!

RMVB no Linux com Real Player 11 GOLD

2008-08-05T10:16:00.006-03:00

Pois bem, para abrir aqueles vídeos todos de animes que você baixou ou outros alheios de conteúdo diverso, geralmente todos em RMVB, você precisará fazer algumas configurações e ajustes em qualquer Sistema Operacional para rodar satisfatoriamente. Apresento aqui a forma mais simples de se poder assistir seus RMVB's no seu Linux sem dor de cabeça.
Muitos usam o Kaffeine ou Xine para abrir esse tipo de arquivo, mas para isso é preciso algumas configurações bem minuciosas e com algumas diferenças entre as distribuições, por isso eu gosto de usar mesmo é o Real Player 11, específico para tal. Dessa forma, é só instalar o Real Player e assistir seus vídeos, em qualquer distribuição Linux.
Para baixar o Real Player (que está na versão 11), entre na página de download do site da Real para Linux e baixe o executável binário (.bin) clicando no botão de download ou o pacote RPM, se sua distribuição for extendida de Red Hat (aconselhável baixar sempre a versão binária, para poder instalar em qualquer distribuição Linux).
Para o pacote RPM não tem segredos, é só clicar duas vezes sobre o executável e instalar normalmente, mas para o pacote binário (.bin) vamos discorrer sobre sua execução...
Mova o binário que você baixou para a pasta principal do usuário que iniciou a sessão (exemplo, /home/lindoelio/ - isso, porque em algumas distros o binário não se executa estando dentro de um esquema de diretório mais longo). Abra o terminal de comandos (pressionando ALT+F2 e digitando XTerm, uma opção) e inicie sessão como superusuário digitando sudo su ou sudo -s e informando corretamente a senha. Estando agora como root, dentro do diretório para onde moveu o binário dê permissão de execução a ele, fazendo:
# chmod +x RealPlayer11GOLD.bin
E, então execute-o:
# ./RealPlayer11GOLD.bin
O processo vai correr e lhe será perguntado o diretório de instalação (eu prefiro sempre confirmar a instalação no diretório /opt que o instalador sugere), confirme com ENTER e depois com F e ENTER.
Pronto! RealPlayer11 instaldo no seu Linux. Agora vá até o menu de aplicações e procure o atalho de menu para o RealPlayer, execute e prossiga o assistente de configuração avançando as telas até a conclusão (bem rápida, por sinal).

Prestigie livremente seus vídeos preferidos!

Convertendo Vídeos para AMV (mp4) no Linux

2008-07-18T09:05:00.009-03:00

Comprei um aparelho mp4 pela Internet para me deliciar com músicas e vídeos num mesmo aparelho enquanto viajo para a faculdade todos os dias... Porém, na minha ignorância, tive um choque quando percebi que nenhum formato de vídeo (os mais famosos) rodavam no bichinho, apenas um tal de AMV, que eu nunca tinha escutado sobre ele... Então peguei o CD que o acampanhara, mas o software disponível (AMVConvert) só roda no Windows (como toda porcaria) e nem com o Wine não quis funcionar... Digitei algumas linhas de comando aqui e outras alí mas não obtive sucesso na conversão dos vídeos, até descobrir um modesto programinha open-source para Linux, em GTK+2, que usa o ffmpeg para converter diversos formatos, inclusive o FLV (para quem gosta de baixar vídeos do youtube e afins), coisa que o concorrente que só roda no Windows não faz (pelo menos na versão que veio junto ao aparelho), e se chama Bytessence...
Atualmente, o projeto foi dividido e podemos encontrar o Bytessence AMV Converter e o Bytessence MPx Converter. Aliás, pelo o que a equipe desenvolvedora recomenda, a versão Bytessence AMV Converter foi descontinuada e portanto o Bytessence MPx Converter seria a melhor opção. Mas, particularmente não gostei do MPx porque não consegui grandes resultados, não entendi o porque, e ainda uso o Bytessence AMV Converter...
Então a dica é: teste os dois!
O primeiro passo é garantir de que você possui o ffmpeg instalado corretamente no seu sistema, pois ele é pre-requisito para que os conversores funcionem (uma vez que esses são apenas interfaces para o ffmpeg)...
Para baixar gratuitamente o Bytessence AMV Converter e o Bytessence MPx Converter, acesse o site http://www.bytessence.com ou clique nos links de download:
- AMV: http://www.bytessence.com/download /bamvc/BAMVC_LIN_1.1.zip
- MPx: http://www.bytessence.com/download/bmpxconverter/MPxConverter_L.tar.gz

Com o download concluído, basta descompactar o pacote e acessar a pasta para executar o Bytessence; não é necessário instalar. Sendo assim, mova essa pasta para um lugar seguro (recomendo o diretório /opt) e então crie um link para acessar o executável. Lembrando que você deverá dar permissão de execução para esse como programa. No Ubuntu, basta clicar sobre o executável e na guia Permissões marcar a permissão de execução como programa. Se quiser fazer pelo terminal é só digitar # sudo chmod +x e o nome do arquivo, desde que se esteja dentro do diretório do mesmo e então, para executar, # ./amv_ou_mpx...

No blog Virus_cg tem disponível um pacote .deb para instalação do Bytessence AMV Converter, porém, necessita-se criar também o link para acessar o programa instalado, mas aí está o link para download: http://www.adrive.com/public/d6e553e343eff78b89bac14231fc80be3e2b355be023e81cc15a0fb263d5f1e3.html

Veja os screenshots...

Bytessence AMV Converter 1.1

Bytessence MPx Converter 1.0

Exibindo, Gravando e Recuperando Imagens em Banco de Dados com JAVA

2008-07-14T10:21:00.006-03:00

Após quase três dias de tentativas consegui realizar o que o título deste post promete com total equilibrio... E só então, depois de pronto, percebi o quanto é facil fazer isso, rsrsrsrs (se tivesse descoberto antes, talves tivesse dado menos patadas nas pessoas e teria ajudado alguns idosos a atravessarem a rua ao invés de empurrá-los, rsrsrs, brincadeira)...
Neste post, usando swing, para aplicações desktop, vamos aprender a selecionar um arquivo de imagem alocado numa pasta do sistema, com iteração do JFileChooser (responsável por obter o path do arquivo no filesystem), visualiza-lo num JPanel adicionado no formulário, trasformar essa imagem num array de bytes, jogar esse array de bytes num campo do banco de dados do tipo BLOB ou LONGBLOB (ou ByteA, caso esteja usando PostgreSQL) e então recuperar o array de bytes transformando-o em imagem novamente para a visualização quando requerida...
Primeiro, criamos uma classe para subscrever o método paitComponet() do JPanel setando a imagem a ser pintada (essa classe foi contribuição do amigo ViniGodoy do fórum do GUJ. Apenas acrescentei duas funcionalidades, criando um cálculo para redimensionamento da imagem, respeitando o aspect ratio da mesma, comparado às dimensões do JPanel)...

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.TexturePaint;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class ImagePanel extends JPanel {
private BufferedImage image = null;
// Abaixo você define como a imagem será pintada no JPanel...
// Nesse caso, o padrão é o redimensionamento da imagem calculando
// o ASPECT RATIO da mesma e centralizando-a no JPanel...
private FillType fillType = FillType.ASPECT_RATIO_CENTER;

public ImagePanel(BufferedImage img) {
setImage(img);
}

public ImagePanel(File imgSrc) throws IOException {
this(ImageIO.read(imgSrc));
}

public ImagePanel(String fileName) throws IOException {
this(new File(fileName));
}

public final void setImage(BufferedImage img) {
if (img == null) JOptionPane.showMessageDialog(null,
"Sem imagem para processar!");
this.image = img;
invalidate();
}

public void setImage(File img) throws IOException {
setImage(ImageIO.read(img));
}

public void setImage(String fileName) throws IOException {
setImage(new File(fileName));
}

public BufferedImage getImage() {
return image;
}

protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D) g.create();
fillType.drawImage(this, g2d, image);
g2d.dispose();
}

public FillType getFillType() {
return fillType;
}

public void setFillType(FillType fillType) {
if (fillType == null) JOptionPane.showMessageDialog(null,"Saída inválida!");
this.fillType = fillType;
invalidate();
}

public static enum FillType {
// redimensiona a imagem para a dimensão do JPanel...
RESIZE {
public void drawImage(
JPanel panel, Graphics2D g2d, BufferedImage image) {
g2d.drawImage(image, 0, 0, panel.getWidth(), panel.getHeight(), null);
}
},
// mantém o tamanho natural da imagem e a centraliza no JPanel...
CENTER {
public void drawImage(
JPanel panel, Graphics2D g2d, BufferedImage image) {
int left = (panel.getHeight() - image.getHeight()) / 2;
int top = (panel.getWidth() - image.getWidth()) / 2;
g2d.drawImage(image, top, left, null);
}
},
// caso a imagem seja menor que o JPanel, a coloca lado a lado...
SIDE_BY_SIDE {
public void drawImage(
JPanel panel, Graphics2D g2d, BufferedImage image) {
Paint p = new TexturePaint(
image, new Rectangle2D.Float(
0, 0, image.getWidth(), image.getHeight()));
g2d.setPaint(p);
g2d.fillRect(0, 0, panel.getWidth(), panel.getHeight());
}
},
// calcula o aspect ratio da imagem e a pinta no JPanel no eixo (0,0)...
ASPECT_RATIO {
public void drawImage(
JPanel panel, Graphics2D g2d, BufferedImage image) {
int larguraImg = image.getWidth();
int alturaImg = image.getHeight();
int largura = 0, altura = 0;
double aspectoImg =
(double) larguraImg / (double) alturaImg;
double aspectoPanel =
(double) panel.getWidth() / (double) panel.getHeight();

if (larguraImg > panel.getWidth() || alturaImg > panel.getHeight()) {
if (aspectoImg == aspectoPanel) {
largura = panel.getWidth();
altura = panel.getHeight();
}
if (aspectoImg > aspectoPanel) {
largura = panel.getWidth();
altura = (largura * alturaImg) / larguraImg;
}
if (aspectoImg <> altura = panel.getHeight();
largura = (altura * larguraImg) / alturaImg;
}
}
else {
largura = image.getWidth();
altura = image.getHeight();
}
g2d.drawImage(image, 0, 0, largura, altura, null);
}
},
// calcula o aspect ratio da imagem e a pinta no JPanel, centralizando-a...
ASPECT_RATIO_CENTER {
public void drawImage(
JPanel panel, Graphics2D g2d, BufferedImage image) {
int larguraImg = image.getWidth();
int alturaImg = image.getHeight();
int largura = 0, altura = 0;
double aspectoImg =
(double) larguraImg / (double) alturaImg;
double aspectoPanel =
(double) panel.getWidth() / (double) panel.getHeight();

if (larguraImg > panel.getWidth() || alturaImg > panel.getHeight()) {
if (aspectoImg == aspectoPanel) {
largura = panel.getWidth();
altura = panel.getHeight();
}
if (aspectoImg > aspectoPanel) {
largura = panel.getWidth();
altura = (largura * alturaImg) / larguraImg;
}
if (aspectoImg <> altura = panel.getHeight();
largura = (altura * larguraImg) / alturaImg;
}
}
else {
largura = image.getWidth();
altura = image.getHeight();
}
int left = (panel.getHeight() - altura) / 2;
int top = (panel.getWidth() - largura) / 2;

g2d.drawImage(image, top, left, largura, altura, null);
}
};

public abstract void drawImage(
JPanel panel, Graphics2D g2d, BufferedImage image);
}
}

Agora vamos implementar o procura do arquivo de imagem no filesystem e a visualização no JPanel. Para isso, vamos usar o JFileChooser (com a dica de como eu adicionei um preview ao JFileChooser para pré-visualizar as imagens enquanto procura a desejada, facilitando a procura).
Criaremos uma classe responsável por pré-visualizar os arquivos de imagem dentro do JFileChooser, a saber...

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JFileChooser;

public class ImageFileChooser extends JComponent implements
PropertyChangeListener {
ImageIcon painelImagem = null;
File arquivo = null;

public ImageFileChooser(JFileChooser fc) {
setPreferredSize(new Dimension(170,230));
fc.addPropertyChangeListener(this);
}

public void loadImage() {
if (arquivo == null) {
painelImagem = null;
return;
}
ImageIcon img = new ImageIcon(arquivo.getPath());
if (img != null) {
if (img.getIconWidth() > 170) {
painelImagem = new ImageIcon(
img.getImage().getScaledInstance(170, -1, Image.SCALE_DEFAULT));
}
else painelImagem = img;
}
}

public void propertyChange(PropertyChangeEvent e) {
boolean atualizar = false;
String propriedades = e.getPropertyName();
if (JFileChooser.DIRECTORY_CHANGED_PROPERTY.equals(propriedades)) {
arquivo = null;
atualizar = true;
}
else if (JFileChooser.SELECTED_FILE_CHANGED_PROPERTY.equals(propriedades)) {
arquiv0 = (File) e.getNewValue();
atualizar = true;
}
if (atualizar) {
painelImagem = null;
if (isShowing()) {
loadImage();
repaint();
}
}
}

protected void paintComponent(Graphics g) {
if (painelImagem == null) loadImage();
else {
int x = getWidth()/2 - painelImagem.getIconWidth()/2;
int y = getHeight()/2 - painelImagem.getIconHeight()/2;
if (y < y =" 0; }
}
}

No evento ActionPerformed do botão de "procurar" a imgem, inicie o JFileChooser...

// instancie os seguintes tipos depois de importar as bibliotecas...
private ImageFileChooser imagePrev = null;
private JFileChooser fc = new JFileChooser();
private ImagePanel quadroImagem = null;
private BufferedImage img;
//(...)
private void btnProcurarActionPerformed(java.awt.event.ActionEvent evt) {
if (imagePrev == null) imagePrev = new ImageFileChooser(fc);
// adiciona a nova funcionalidade de preview...
fc.setAccessory(imagePrev);
if (fc.showOpenDialog(this) == JFileChooser.CANCEL_OPTION) return;
try{
// cria um objeto do tipo BufferedImage do arquivo selecionado...
img = ImageIO.read(new File(fc.getSelectedFile().getAbsolutePath()));
// inicia o processo para reescrever o método paintComponent do JPanel...
if (quadroImagem == null) quadroImagem = new ImagePanel(img);
quadroImagem.setImage(img);
painelImagem.add(quadroImagem);
painelImagem.repaint();
painelImagem.validate();
}
catch (IOException e) {
JOptionPane.showMessageDialog(this, "Não foi possível ler a imagem!");
}
}

Pronto! Imagem visualizada no JPanel com sucesso!
E então vamos transformar essa imagem selecionada em um array de bytes (um monte de bytes que compõe o arquivo) e gravá-lo no banco de dados, implementando um método de persistência com PreparedStatement...

private void incluirRegistro() {
try {
conexao.conectar();
PreparedSatement pstmt = conexao.con.prepareStatement(
"Insert into Imagens (Imagem_Img) Values (?)");
// já temos a imagem transformada numa BufferedImage, então é só convertê-la
// em array de bytes (tipo JPG)...
ByteArrayOutputStream bytesImg = new ByteArrayOutputStream();
ImageIO.write((BufferedImage)img, "jpg", bytesImg);
bytesImg.flush();
byte[] byteArray = bytesImg.toByteArray();
bytesImg.close();
// agora é só jogar no banco de dados...
pstmt.setBytes(1, byteArray);
pstmt.executeUpdate();
pstmt.close();
}
catch (IOException ex) {
Logger.getLogger(Logomarcas.class.getName()).log(Level.SEVERE, null, ex);
JOptionPane.showMessageDialog(this, "Não foi possível processar a imagem!");
}
catch (SQLException e) {
e.printStackTrace();
JOptionPane.showMessageDialog(this, "Falha na inclusão do registro!");
}
finally {
conexao.desconectar();
}
}

Ótimo! Já que geramos uma BufferedImage para trabalharmos com a imagem selecionada do filesystem então vamos gerar outra para visualizarmos a imagem selecionada no banco de dados (gravada como array de bytes)...

private void visualizarRegistroSelecionado() {
// você pode implementar qualquer forma para identificar o registro na tabela,
// porém vamos simplificar aqui fixando o ID 20, considerando ID como
// chave primária da tabela de imagens...
try {
conexao.conectar();
Statement stmt = conexao.con.createStatement();
ResultSet rs = stmt.executeQuery("Select * from Imagens where ID = 20");
if (rs.next()) {
// recuperamos o array de bytes convertendo-o numa BufferedImage (img)...
img = ImageIO.read(new ByteArrayInputStream(rs.getBytes("Imagem_Img")));
// e então adicionamos essa BufferedImage para ser pintada no JPanel de visualização...
if (quadroImagem == null) quadroImagem = new ImagePanel(img);
quadroImagem.setImage(img);
painelImagem.add(quadroImagem);
painelImagem.repaint();
painelImagem.validate();
}
rs.close();
stmt.close();
}
catch (IOException ex) {
Logger.getLogger(Logomarcas.class.getName()).log(Level.SEVERE, null, ex);
}
catch (SQLException e){
e.printStackTrace();
}
finally {
conexao.desconectar();
}
}

Abrindo arquivos .cdr (Corel Draw) no Inkscape

2008-07-11T09:04:00.005-03:00

Preciso confessar um pecado...
"Sempre praguejei o linux por não abrir arquivos .cdr, nativos do Corel Draw!"
Foi aí, então, que resolvi fazer uma última tentativa de abrir um arquivo .cdr o qual precisava muito ao menos visualizar... Dei uma googlada, como costume de todos os internautas, e achei uma notícia maravilhosa! A nova versão do Inkscape (programa livre para desenhos vetoriais, no estilo Corel Draw) pode abrir arquivos .cdr e trabalhar com eles como formato nativo, ou seja, você não vai precisar importar nem exportar para que o Corel Draw volte a reconhecer o arquivo nativamente... Tudo isso graças a um novo utilitário chamado UniConvertor, capaz de integrar ao Inkscape as funcionalidades necessárias para editar diversos tipos de arquivos extendidos do Corel Draw desde a versão 7 até a recente X4, e ainda abrirá arquivos do Adobe Illustrator com base PostScript...
Então vamos instalar!
Primeiro certifique-se de que seu Inkscape esteja devidamente instalado... Caso não esteja, existem pacotes do Inkscape em praticamente todos os tipos de pacote linux, e você poderá ainda encontrá-lo facilmente nos repositórios das principais distros...
E então baixe o UniConvertor do site do projeto clicando aqui, com preferência para a última versão, e instale-o normalmente... Enquanto escrevo este post ele se encontra na versão 1.1.2, com pacotes de instalação em RPM e .EXE (para a versão do Inkscape for Windows)...
Depois da instalação não notará qualquer mudança expressiva no sistema, porém agora seu Inkscape poderá abrir arquivos .cdr e outros proprietários nativamente! Sem maior segredo! Só iniciar o Inkscape e trabalhar com a nova gama de arquivos!
Usem e abusem!

Instalando e configurando o PostgreSQL no Ubuntu

2008-06-27T09:33:00.010-03:00

Todos nós sabemos que o Ubuntu Linux é um Sistema Operacional perfeitamente adaptável além de uma das melhores opções para desenvolvedores de software de qualquer nível. E, novamente, todos nós sabemos que o PostgreSQL é um dos melhores SGBD's de código livre da atualidade, principalmente, na minha opinião, por se basear na plataforma Unix.
Por muito apanhar até conseguir instalar e configurar corretamente o PostgreSQL no meu Ubuntu, disponho agora um breve guia de instalação e configuração para permissões de acesso em ferramentas de modelagem, bem como para acessos remotos em rede baseada no protocolo TCP/IP.
Vamos considerar que o Ubuntu já esteja instalado e em sua versão 8.04 (deverá funcionar da mesma forma em versões anteriores)...
O PostgreSQL já se encontra nos repositórios oficiais da distro nas versões 8.2 e 8.3, bem como num metapacote preparado pela equipe da Canonical.
Não temos muitas ferramentas de administração totalmente voltadas para PostgreSQL, talvez devido à Orientação a Objetos na modelagem, porém, dentre as poucas, o PGAdminIII (ou PGAdmin3) se destaca com uma interface simples, customizável e competente ao que se destina. Sendo assim, a instalação e configuração da mesma entra no nosso guia.
Mãos à obra!

Desde já, abra um terminal de comandos e inicie sessão em modo superusuario (sudo su) ...
Vamos instalar a última versão do PostgreSQL (8.3), que vem corrigida em muitos detalhes em relação à versão anterior (8.2)...
Abra o Gerenciador de Pacotes Synaptic com o comando...
# synaptic

Procure e marque para instalação os seguintes pacotes, aceitando as indicações de dependências...

pgadmin3
postgresql-8.3
postgresql-client-8.3
postgresql-client-common
postgresql-common
postgresql-contrib-8.3

Pronto! PostgreSQL instalado! Viva o apt-get!

Agora vamos à etapa de configuração...
Só a título de teste (se você quiser), abra o PGAdmin3 e tente adicionar uma instância de servidor com qualquer nome na máquina localhost... Paradoxalmente, se tudo ocorrer bem abrirá uma mensagem de erro como essa:
Isso acontece porque ainda não permitimos ao usuário "postgres" se conectar no banco através da ferramenta de administração, sendo que o mesmo, por padrão, não possui senha...
Então vamos alterar alguns arquivos de configuração do PostgreSQL, a saber: pg_hba.conf e postgresql.conf... No Ubuntu o sistema de diretório desses arquivos fica: /etc/postgresql/8.3/main/, então basta entrar na pasta "main" e acessar os arquivos para edição com os comandos...
# cd /etc/postgresql/8.3/main

Dentro da pasta "main" abra o arquivo "pg_hba.conf"...
# gedit pg_hba.conf

Para permitir a administração por usuários além do padrão "postgres", bem como a autenticação para tal, procure as linhas:
# Database administrative login by UNIX sockets
local all postgres ident sameuser
... E substitua a linha não comentada (sem #) por:
local all all trust

Para liberar a conexão para seus usuários, procure as linhas:
# "local" is for Unix domain socket connections only
local all all ident sameuser
... E mude a autenticação, substituindo a linha não comentada (sem #) por:
local all all trust

Para permitir conexões remotas por usuários numa rede com tunelagem IPv4, sem distinção de host's, procure as linhas:
# IPv4 local connections:
host all all 127.0.0.1/32 md5
... E libere todos os host's, atribuindo-lhes autenticação por senha, substituindo a linha não comentada (sem #) por:
host all all 0.0.0.0/0 trust
ou
host all all 0.0.0.0 0.0.0.0 trust

Salve o arquivo e feche o editor de texto...

Agora, para liberar essas configurações vamos editar o arquivo "postgresql.conf", também na pasta "main"...
# gedit postgresql.conf

Para liberar as conexões por IP na rede, procure a linha comentada:
# listen_addresses = 'localhost'
... Retire o comentario e altere a autenticação para qualquer máquina, ficando assim:
listen_addresses = '*'

Procure também a linha ssl = true só para garantir que está ativado...

Salve o arquivo e feche o editor de textos.

Precisamos, então, reiniciar o servidor do postgresql para que as alterações tenham efeito:
# /etc/init.d/postgresql-8.3 restart
... Aguarde o status de [OK] e então pode fechar o terminal.

Pronto! PostgreSQL configurado! Viva os neurônios torrados pra editar arquivos de texto!!!

Agora abra novamente o PGAdmin3 e adicione um servidor, preenchendo da seguinte forma os campos:
Ao clicar em OK, se você seguiu corretamente os passos, o PGAdmin3 criará uma nova instância do servidor conectado ao banco de dados padrão "postgres" pelo usuário padrão "postgres"...
Assim, você pode criar novas roles (usuários), dar permissões, fazer backup's, criar novos bancos, etc...
Lembrando que você pode alterar antes a senha do usuário "postgres" pelo terminal de comandos, se quiser. Para isso, inicie sessão no terminal com o usuário "postgres" e abra o psql (ferramenta de administração do PostgreSQL por comandos)...
# sudo su postgres -c psql postgres
Com o psql preparado digite o comando:
# ALTER USER postgres WITH PASSWORD 'novasenha';

Se você tem um rede configurada pode testar a conexão através do IP de um servidor, ou ainda, pode limitar, lá no arquivo pg_hba.conf, quais IP's ou máscaras poderão se autenticar, etc...

Chegamos ao fim... Divirta-se!