:?:Oi pessoal eu tenho uma tabela e quero deixa-la transaparente, antes da consulta no banco de dados, para podeer visualizar totalmente o fundo que eu coloquei no meu panel, alguem ai sabe me dizer como que eu posso fazer isso?
eu tambem quero saber
Simplesmente deixá-la invisível não resolve?
// supondo que seu JTable chame-se tabela
// use isso na criação
tabela.setVisible(false);
// e isso quando houverem dados
tabela.setVisible(true);mas isso ai vai fazer ela desaparecer e aparecer certo?
eu queria que fosse transparente, aparessece um pouco da tabela em cima
Componentes translúcidos… essa eu não conheço. É possível criar uma classe que estende JTable e alterar seu método paint dando efeito de tranparência, mas uma classe já pronta que faz isso acho que não tem (só tem pra janelas, a classe AWTUtilities, que eu conheça).
valew, eu sou novo em java,vo procurar mais sobre isso
Gente ninguem descubriu como deixar o fundo de Jtable ficar transparente, eu ja procurei na internt no forum, ja tentei tabela.setOpaque(false), ja tentei tudo e naum consegui se alguem encontrar a solução posta ai por favor!
como nosso amigo marcobiscaro2112 falou, não existe um método direto que faça isso…tu vai ter que subir para as classes pai, avo, bisavo de jtable e verificar se é possível tu sobrescrever o método que pinta o background de table…Uma outra forma, eu acho, é verificar como são customizados os Look And Feel e verificar se é possível através de um, fazer o que voce quer.
Fernando
O método para fazer isso é realmente o setOpaque(). Mas não adianta usar direto na table. As células que formam a tabela são, na verdade, JLabels que são implementadas pelo TableCellRenderer.
Eu tentei fazer o mesmo e consegui, mas tive que criar mais duas classes.
O código que o Luiz Gustavo publica num tópico aqui no guj me ajudou bastante. Dá uma olhadinha: http://www.guj.com.br/posts/list/30793.java#165564
Eu criei uma classe que extende o DefaultTableCellRenderer e implementei o método getTableCellRendererComponent(). Ali eu mexi nas propriedades do JLabel usado para ele poder ou não receber o setOpaque():
public class NewTableCellRenderer extends DefaultTableCellRenderer {
private boolean tranparente = false;
public NewTableCellRenderer() {
super();
} // Fim do construtor
public void setTranparencia(boolean tranparente) {
this.tranparente = tranparente;
}
public Component getTableCellRendererComponent(JTable tabela,
Object valor, boolean estaSelecionado, boolean temFoco,
int linha, int coluna) {
JLabel label = (JLabel) super.getTableCellRendererComponent(
tabela, valor, estaSelecionado, temFoco, linha, coluna);
// Exibe o fundo da tabela ou o do próprio label
label.setOpaque(!this.tranparente);
// Centraliza o label
if (coluna != 0)
label.setHorizontalAlignment(JLabel.CENTER);
return label; // Retorna o label formatado
} // Fim do método getTableCellRendererComponent
} // Fim da classe NewTableCellRendererDepois criei outra classe que extende um DefaultTableColumnModel que recebe esse NewTableCellRenderer que eu fiz. Depois só foi chamar o ColumnModel na tabela usando o método setColumnModel().
Agora estou tentado criar um JLabel diferente (com cantos arredondados) para colocar nesse modelo. Só não sei como eu mantenho o fundo transparente do JLabel, pois quando eu sobrescrevo o método paintComponent() ele perde esta propriedade. Se alguém puder me ajudar eu fico grato.
[quote=mrsmylle]Algo assim:
http://www.javalobby.org/articles/ultimate-image/[/quote]
Na mosca! Valeu pela dica. Para aqueles que ainda quiserem a JTable tranparente, vejam essa classe que criei (aceito sugestões de melhoria 
):
import java.awt.AlphaComposite;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JComponent;
import javax.swing.JTable;
/**
* TODO javadoc me!
*
* @author Marco Biscaro
*/
public class JTransparentTable extends JTable {
private static final long serialVersionUID = 1L;
private float alpha;
/**
* Creates a new instance of JTransparentTable, setting the
* <code>alpha</code> value as <code>0.5f</code>.
*/
public JTransparentTable() {
super();
alpha = 0.5f;
}
/**
* Sets the component opaque or transparent. If the parameter is
* <code>true</code>, the code has the same effect than: <br>
* <code>
* <pre>
* setAlpha(1.0f);
* </pre>
* </code>
*/
@Override
public void setOpaque(boolean isOpaque) {
if (isOpaque) {
alpha = 1.0f;
}
}
/**
* @return true if the alpha value is 1.0f. False otherwise.
*/
@Override
public boolean isOpaque() {
return alpha == 1f;
}
/**
* The getter for alpha.
*
* @return the alpha value.
*/
public float getAlpha() {
return alpha;
}
/**
* The setter for alpha.
*
* @param alpha
*/
public void setAlpha(float alpha) {
this.alpha = alpha;
}
/**
* Overrides the same method in {@linkplain JComponent} class. This
* implementation allows the transparent effect.
*/
@Override
public void paintComponent(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
alpha));
super.paintComponent(g2d);
}
}Para usar, basta criar uma instância e usar normalmente, como qualquer JTable. A única diferença é que essa classe tem o método setAlpha (cujos valores podem variar de zero a um, sendo zero totalmente transparente e um totalmente opaca). Exemplo de uso:
TableModel jTransparentTable1Model = new DefaultTableModel(new String[][] { { "One", "Two" }, { "Three", "Four" } }, new String[] { "Column 1", "Column 2" });
jTransparentTable1 = new JTransparentTable();
jTransparentTable1.setModel(jTransparentTable1Model);
jTransparentTable1.setAlpha(0.3f);
add(jTransparentTable1);E pronto. Depois, para torná-la opaca, use o método setOpaque(true) ou setAlpha(1.0f).