:thumbup:
Editado: Tá tudo funcionando 100%.
Grande
Tenho uma jTable que consegui imprimi-la direto na impressora, mas gostaria de ter um cabeçalho em cada pagina, e configurar 20 linhas por pagina. Pode me ajudar. Segue código quando abro a Tabela, e quando imprimo.
[code]
package Relatorio;
import java.awt.event.ActionListener;
import java.awt.print.PrinterException;
import java.sql.SQLException;
import java.text.MessageFormat;
import java.util.Date;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.* ;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.DefaultTableModel;
import utilitarios.conexao;
import javax.swing.text.MaskFormatter;
public class RelaContas extends javax.swing.JFrame
{
private static class jTable {
public jTable() {
}
}
MaskFormatter formatodatacada;
private MaskFormatter formatodata;
private MaskFormatter formatocep;
private MaskFormatter formatocnpj;
private MaskFormatter formatoie;
private MaskFormatter formatoccm;
private MaskFormatter formatoddi;
private MaskFormatter formatotelefone;
//COMANDA PRIMEIRO, PROXIMO, ANTERIOR, ULTIMO
int navega = 0 ;
//ORDENA PELO CÓDIGO
String ordenacao =“codigo”;
//ORDENA PELA DATA DE VENCIMENTO
String ordenacao1 =“datavencimento”;
String novo = “n”;
conexao contas;
private ActionListener ActionListener;
public RelaContas()
{
initComponents();
contas = new conexao();
contas.conecta();
contas.executeSQL("select * from Contas order by "+ordenacao1);
try
{
contas.executeSQL(“select * from Contas order by posicaoconta”);
preencher_jtable();
contas.executeSQL(“select * from Contas order by codigo”);
contas.resultset.last();
mostrardados();
}
catch(SQLException erro)
{
JOptionPane.showMessageDialog(null,“BANCO DE DADOS NÃO ENCONTRADO, VERIFIQUE O ERRO”);
}
}
public void mostrardados()
{
//try
{
//MOSTRA DATA NO FORMULÁRIO
Date data = new Date();
String dia = “” + data.getDate();
String mes = “” + String.valueOf(data.getMonth()+1);
String ano = “” + (1900 + data.getYear());
if (Integer.parseInt(dia)<=9)
dia = “0” + dia;
if (Integer.parseInt(mes)<=9)
mes = “0” + mes;
datacada.setText(dia+"/"+mes+"/"+ano);
datacada.setEditable(false);
//MOSTRA HORA NO FORMULÁRIO
Date hora = new Date();
String thora ="" + data.getHours();
String tminuto=""+ data.getMinutes();
String tsegundo=""+ data.getSeconds();
if (Integer.parseInt(tminuto)<=9)
tminuto = “0” + tminuto;
if (Integer.parseInt(tsegundo)<=9)
tsegundo = “0” + tsegundo;
horacada.setText(thora+":"+tminuto+":"+tsegundo);
horacada.setEditable(false);
//DESABILITA O X NO FORMULÁRIO
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
}
}
public void preencher_jtable()
{
DefaultTableCellRenderer esquerda = new DefaultTableCellRenderer();
DefaultTableCellRenderer centro = new DefaultTableCellRenderer();
DefaultTableCellRenderer direita = new DefaultTableCellRenderer();
esquerda.setHorizontalAlignment(SwingConstants.LEFT);
centro.setHorizontalAlignment(SwingConstants.CENTER);
direita.setHorizontalAlignment(SwingConstants.RIGHT);
//CODIGO
jTable.getColumnModel().getColumn(0).setCellRenderer(centro);
//DATAVENCIMENTO
jTable.getColumnModel().getColumn(1).setCellRenderer(centro);
//FORNECEDOR
jTable.getColumnModel().getColumn(2).setCellRenderer(esquerda);
//VALOR
jTable.getColumnModel().getColumn(3).setCellRenderer(direita);
//PISIÇÃO CONTA
jTable.getColumnModel().getColumn(4).setCellRenderer(esquerda);
//CODIGO DE BARRAS
jTable.getColumnModel().getColumn(5).setCellRenderer(esquerda);
//CODIGO
jTable.getColumnModel().getColumn(0).setPreferredWidth(10);
//DATA VENCIMENTO
jTable.getColumnModel().getColumn(1).setPreferredWidth(15);
//FORNECEDOR
jTable.getColumnModel().getColumn(2).setPreferredWidth(200);
//VALOR
jTable.getColumnModel().getColumn(3).setPreferredWidth(30);
//POSIÇÃO CONTA
jTable.getColumnModel().getColumn(4).setPreferredWidth(20);
//CODIGO DE BARRAS
jTable.getColumnModel().getColumn(5).setPreferredWidth(220);
DefaultTableModel modelo = (DefaultTableModel)jTable.getModel();
modelo.setNumRows(0);
try
{
while(contas.resultset.next())
{
modelo.addRow(new Object[]
{
contas.resultset.getString(“codigo”),
contas.resultset.getString(“datavencimento”),
contas.resultset.getString(“fornecedor”),
contas.resultset.getString(“valor”),
contas.resultset.getString(“posicaoconta”),
contas.resultset.getString(“codigobarras”),
}
);
}
}
catch(SQLException erro)
{
}
}
private void btsairActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
//if(javax.swing.JOptionPane.showConfirmDialog(null,“DESEJA FECHAR ESTE FORMULÁRIO ?”,“SAIR”,javax.swing.JOptionPane.YES_NO_OPTION )==0)
//this.dispose();
//new Cadastro.CadastroDeContas().show();
Object[] options =
{
“Sim”, “Não”
};
int i = JOptionPane.showOptionDialog(null,
“DESEJA FECHAR ESTE FORMULÁRIO ?”,“SAIR”,
JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null,
options, options[0]);
if (i == JOptionPane.YES_OPTION)
{
//System.exit(0);
this.dispose();
new Cadastro.CadastroDeContas().show();
}
}
private void btimprimirActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
{
try
{
jTable.print();
}
catch (PrinterException ex)
{
Logger.getLogger(RelaContas.class.getName()).log(Level.SEVERE, null, ex);
}
}
DefaultTableModel modelo = (DefaultTableModel)jTable.getModel();
modelo.setNumRows(0);
try
{
while(contas.resultset.next())
{
modelo.addRow(new Object[]
{
contas.resultset.getString(“codigo”),
contas.resultset.getString(“datavencimento”),
contas.resultset.getString(“fornecedor”),
contas.resultset.getString(“valor”),
contas.resultset.getString(“posicaoconta”),
contas.resultset.getString(“codigobarras”),
}
);
}
}
catch(SQLException erro)
{
}
this.dispose();
new Relatorio.RelaContas().show();
}
[quote=Luiz_Gustavo]Nesse trecho:
se você sabe a quantidade certa de colunas (rsmd.getColumnCount() te dá a quantidade de colunas), e a ordem em que elas serão apresentadas, você pode montar um array manualmente e passar para o model de sua tabela:[/quote]
Eu preciso saber como faço para não permitir que o usuário altere a ordem das colunas. Alguém aí faz ideia de como se faz isso?
[quote=Gustavo Zub][quote=Luiz_Gustavo]Nesse trecho:
se você sabe a quantidade certa de colunas (rsmd.getColumnCount() te dá a quantidade de colunas), e a ordem em que elas serão apresentadas, você pode montar um array manualmente e passar para o model de sua tabela:[/quote]
Eu preciso saber como faço para não permitir que o usuário altere a ordem das colunas. Alguém aí faz ideia de como se faz isso?[/quote]
Opa, já descobri…
jTable.getTableHeader().setReorderingAllowed(false); Boa noite a todos, nao conheco muito de java e estou trabalhando com uma jtable, estou com o seguinte problema.
Preciso alterar a largura das colunas da tabela, nao pode ser no geral para cada classe vai ser uma tabela diferente. Ex tabela cliente codigo (20), nome(50), cidade (50), telefone(50).
ja a tabela pecas codigo(20), descrição(50), quantidade(20), valor(20).
Como posso fazer isso???
desde ja agradeço pela atenção.
ja posto os codigos.
codigos da tabela.
package Extra;
import java.util.Vector;
import java.util.Comparator;
import java.util.Collections;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableColumnModel;
import javax.swing.table.JTableHeader;
import javax.swing.event.TableModelEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.InputEvent;
import javax.swing.JTable;
public class TablePrincipalModel extends DefaultTableModel implements Comparator{
protected int currCol;
protected Vector ascendCol; // this vector stores the state (ascending or descending) of each column
protected Integer one = new Integer(1);
protected Integer minusOne = new Integer(-1);
protected Vector colEditable = new Vector() ;
protected Vector cellLocked = new Vector();
public TablePrincipalModel() {
super();
ascendCol = new Vector();
}
public TablePrincipalModel(Object[][] data, Object[] titles) {
super(data,titles);
ascendCol = new Vector();
for (int i = 0; i < titles.length; i++)
colEditable.add(new Boolean(false));
}
public Class getColumnClass(int c) {
//return getValueAt(0, c).getClass();
//Para evitar erro de null, procurando em todos as linhas
for (int i=0; i < this.getRowCount(); i++) {
if (getValueAt(i, c) != null)
return getValueAt(i, c).getClass();
}
//Se todas estao vazias, retornar como tipo String
String ret = "";
return ret.getClass();
}
public void limpaVectorCellNotEditable(){
cellLocked.removeAllElements();
}
public void setColEditable(int col, boolean editable) { //Anderson criou
colEditable.set(col, new Boolean(editable));
}
public void setCellNotEditable(int col, int row) { //FT criou
cellLocked.add(new Cell(row,col));
}
/*
* Don't need to implement this method unless your table's
* editable.
*/
public boolean isCellEditable(int row, int col) {
if (cellLocked.size() > 0) {
Cell cellTest;
for (int i=0; i < cellLocked.size(); i ++) {
cellTest =(Cell)cellLocked.get(i);
if (cellTest.row == row && cellTest.col == col)
return false;
}
}
return ((Boolean)colEditable.get(col)).booleanValue();
}
/*******************************************************************
* addColumn methods are inherited from the DefaultTableModel class.
*******************************************************************/
public void addColumn(Object columnName) {
super.addColumn(columnName);
ascendCol.add(one);
colEditable.add(new Boolean(false));
}
public void addColumn(Object columnName, Object[] columnData) {
super.addColumn(columnName, columnData);
ascendCol.add(one);
}
public void addColumn(Object columnName, Vector columnData) {
super.addColumn(columnName, columnData);
ascendCol.add(one);
}
/*****************************************************************
* This method is the implementation of the Comparator interface.
* It is used for sorting the rows
*****************************************************************/
public int compare(Object v1, Object v2) {
// the comparison is between 2 vectors, each representing a row
// the comparison is done between 2 objects from the different rows that are in the column that is being sorted
int ascending = ((Integer) ascendCol.get(currCol)).intValue();
if (v1 == null && v2 == null) {
return 0;
} else if (v2 == null) { // Define null less than everything.
return 1 * ascending;
} else if (v1 == null) {
return -1 * ascending;
}
Object o1 = ((Vector) v1).get(currCol);
Object o2 = ((Vector) v2).get(currCol);
// If both values are null, return 0.
if (o1 == null && o2 == null) {
return 0;
} else if (o2 == null) { // Define null less than everything.
return 1 * ascending;
} else if (o1 == null) {
return -1 * ascending;
}
if (o1 instanceof Number && o2 instanceof Number) {
Number n1 = (Number) o1;
double d1 = n1.doubleValue();
Number n2 = (Number) o2;
double d2 = n2.doubleValue();
if (d1 == d2) {
return 0;
} else if (d1 > d2) {
return 1 * ascending;
} else {
return -1 * ascending;
}
} else if (o1 instanceof Boolean && o2 instanceof Boolean) {
Boolean bool1 = (Boolean) o1;
boolean b1 = bool1.booleanValue();
Boolean bool2 = (Boolean) o2;
boolean b2 = bool2.booleanValue();
if (b1 == b2) {
return 0;
} else if (b1) {
return 1 * ascending;
} else {
return -1 * ascending;
}
} else {
// default case
if (o1 instanceof Comparable && o2 instanceof Comparable) {
Comparable c1 = (Comparable) o1;
Comparable c2 = (Comparable) o2; // superflous cast, no need for it!
try {
return c1.compareTo(c2) * ascending;
} catch (ClassCastException cce) {
// forget it... we'll deal with them like 2 normal objects below.
}
}
String s1 = o1.toString();
String s2 = o2.toString();
return s1.compareTo(s2) * ascending;
}
}
/***************************************************************************
* This method sorts the rows using Java's Collections class.
* After sorting, it changes the state of the column -
* if the column was ascending, its new state is descending, and vice versa.
***************************************************************************/
public void sort() {
Collections.sort(dataVector, this);
Integer val = (Integer) ascendCol.get(currCol);
ascendCol.remove(currCol);
if(val.equals(one)) // change the state of the column
ascendCol.add(currCol, minusOne);
else
ascendCol.add(currCol, one);
}
public void sortByColumn(int column) {
this.currCol = column;
sort();
fireTableChanged(new TableModelEvent(this));
}
// Add a mouse listener to the Table to trigger a table sort
// when a column heading is clicked in the JTable.
public void addMouseListenerToHeaderInTable(JTable table) {
final TablePrincipalModel sorter = this;
final JTable tableView = table;
tableView.setColumnSelectionAllowed(false);
MouseAdapter listMouseListener = new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
TableColumnModel columnModel = tableView.getColumnModel();
int viewColumn = columnModel.getColumnIndexAtX(e.getX());
int column = tableView.convertColumnIndexToModel(viewColumn);
if (e.getClickCount() == 1 && column != -1) {
int shiftPressed = e.getModifiers()&InputEvent.SHIFT_MASK;
boolean ascending = (shiftPressed == 0);
//sorter.sortByColumn(column);
sorter.sortByColumn(column);
}
}
};
JTableHeader th = tableView.getTableHeader();
th.addMouseListener(listMouseListener);
}
}
class Cell {
int row;
int col;
public Cell(int i_row, int i_col) {
row = i_row;
col = i_col;
}
}
Aqui eu chamo a tabela…
public class Cliente extends javax.swing.JFrame {
TablePrincipalModel tmCliente = new TablePrincipalModel(null, new String[]{"Código","Nome","Cidade","Telefone Residencial"});
// DefaultTableModel tmCliente = new DefaultTableModel(null, new String[]{“Código”,“Nome”,“Cidade”,“Telefone Residencial”});
ListSelectionModel lsmCliente;
List<Cliente_Bean> clientes;
List<Cidade_Bean> cidade;
String tipoCadastro;
private String tipo_consulta