[Java - Swing] Problema con righe lunghe nella JTable

[rai-p]

Salve a tutti! Sto implementando un progetto e mi trovo in una situazione particolare.
Ho una JTable dove vengono caricate delle descrizioni di lavori disponibili. Queste descrizioni sono lunghe in media 20 25 parole e quindi non entrano tutte nello spazio della colonna (mi escono le prime e poi ci sono i puntini "....") . Vorrei sapere se è possibile espandere questo testo su più righe (della stessa riga) e se qualcuno sa come posso farlo ??

Nella foto si nota che risultato ho ora. Vorrei appunto continuare il testo andando a capo e quindi evitando il troncamento del testo.


grazie a tutti anticipatamente!

[rai-p]

nessuno mi può aiutare ? anche con soluzioni alternative...vi prego!

[isAlreadyInUse]

Scusa non ti basta settare la dimensione della colonna?

[rai-p]

Originariamente inviato da isAlreadyInUse

Scusa non ti basta settare la dimensione della colonna?

poi dovrei usare lo scroll orizzontale per leggerla tutta...come ultima ipotesi sicuramente farò così!
probabilmente però quello che vorrei fare io non si può fare

[isAlreadyInUse]

metti una textArea nella cella

[rai-p]

Originariamente inviato da isAlreadyInUse

metti una textArea nella cella

oh mamma...non c'avevo pensato!!!appena posso provo
grazie!!

[PGI-Bis]

E' possibile e abbastanza semplice. Puoi definire un tuo TableCellRenderer che, avvalendosi di alcuni strumenti precotti in swing/awt, disegni il testo distribuendolo su più linee avendo come riferimento la larghezza della colonna.

Incollo un esempio commentato di questo TableCellRenderer.

package it.tukano.tprenderer;

import javax.swing.*;
import java.awt.*;
import java.awt.font.*;
import java.awt.geom.*;
import java.text.*;
import javax.swing.table.*;
import java.util.*;

public class MultiLineTableCellRenderer extends JPanel implements TableCellRenderer {
	private Map<Point, Integer> heightMap = new HashMap<Point, Integer>();
	private ArrayList<TextLayout> textLayoutList = new ArrayList<TextLayout>();
	private String text;
	
	public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
		/* Azzera il "buffer" dei TextLayout */
		textLayoutList.clear();
		
		/* Ricava la larghezza della colonna corrente */
		TableColumnModel tableColumnModel = table.getColumnModel();
		TableColumn tableColumn = tableColumnModel.getColumn(column);
		int columnWidth = tableColumn.getWidth();
		
		/* Se il valore è null usiamo come testo un carattere di spaziatura. Altrimenti occorre
		ammazzarsi di if perchè AttributedCharacterIterator e TextLayout non vanno d'accordo con null o
		con stringhe di lunghezza inferiore a 1 carattere. */
		text = value == null ? " " : (text = String.valueOf(value)).length() == 0 ? " " : text;
		
		/* Separiamo il testo in linee e calcoliamo nel contempo quale dev'essere l'altezza della
		riga per mostrare queste linee. */
		AttributedCharacterIterator styledText = new AttributedString(text).getIterator();
		FontRenderContext fontRenderContext = getFontRenderContext(table);
		
		/* Senza un FontRenderContext siamo in braghe di tela. */
		if(fontRenderContext != null) {
			
			/* LineBreakMeasurer è lo strumento che spezza il testo in linee usando una o
			più larghezze come limiti per la separazione dei caratteri. */
			LineBreakMeasurer lineBreakMeasurer = new LineBreakMeasurer(styledText, fontRenderContext);
			
			/* In questo "newHeight" sommeremo l'altezza delle linee di testo e, al termine del
			ciclo, verificheremo se sia diverso dall'altezza corrente della riga row. In caso
			affermativo useremo newHeight come valore di altezza per la riga row. */
			float newHeight = 0;
			
			/* LineBreakMeasurer funziona come un iteratore: man mano che gli si chiede di
			calcolare quanto testo possa essere disegnato in una certa larghezza avanza di
			carattere in carattere. */
			while(lineBreakMeasurer.getPosition() < text.length()) {
				
				/* La linea di testo che lineBreakMeasurer riesce ad "infilare" in un
				certo spazio viene restituita come TextLayout. Per disegnare effettivamente il testo
				occorre applicare questo TextLaout ad un Graphics. Noi salviamo la linea di testo
				nel buffer "textLayoutList" perchè il momento del disegno è successivo rispetto
				all'invocazione del metodo in cui ci troviamo (e passa per paintComponent). */
				TextLayout layout = lineBreakMeasurer.nextLayout(columnWidth);
				textLayoutList.add(layout);
				
				/* Sommiamo l'altezza della riga appena computata da LineBreakMeasurer all'altezza
				totale fin qui ottenuta. Alla fine newHeight sarà la somma delle altezze di tutte
				le righe computate da LineBreakMeasurer e ci dirà quanto deva essere alta la riga
				della tabella che stiamo esaminando. */
				newHeight += layout.getAscent() + layout.getDescent() + layout.getLeading();
			}
			
			/* Se l'altezza totale delle linee di testo è maggiore dall'altezza della riga corrente
			della tabella allora chiediamo alla tabella di cambiarla. L'invocazione di setRowHeight
			causa una nuova richiesta di aggiornamento grafico delle celle contenute in quella riga e,
			quindi, una seconda invocazione di questo nostro getTableCellRendererComponent. Probabilmente
			qui c'è lo spazio per una qualche ottimizzazione.*/
			int rowHeight = table.getRowHeight(row);
			if((int)newHeight > rowHeight) {
				int h = Math.round(newHeight);
				
				/* Salviamo l'altezza della riga nella mappa delle altezze. Useremo poi questa mappa
				per determinare quale sia l'altezza della riga nel caso in cui una cella perda 
				il primato di altezza. */
				heightMap.put(new Point(column, row), h);
				table.setRowHeight(row, h);
			}
			
			/* Se l'altezza è minore allora la faccenda si fa più complicata. Questa cella non è più
			quella più alta. Dobbiamo determinare quale tra le altre celle contenute nella stessa riga
			sia la nuova più alta. */
			else if((int)newHeight < rowHeight) {
				Point cell = new Point();
				cell.y = row;
				int maxHeight = table.getRowHeight();
				for(cell.x = 0; cell.x < table.getColumnCount(); cell.x++) {
					if(cell.x == column) {
						heightMap.put(cell, (int)newHeight);
					}
					Integer cellHeight = heightMap.get(cell);
					if(cellHeight == null) cellHeight = table.getRowHeight();
					maxHeight = Math.max(cellHeight, maxHeight);
				}
				if(maxHeight != rowHeight) {
					table.setRowHeight(row, maxHeight);
				}
			}
			
			/* Queste righe impostano i colori del componente MultiLineTableCellRenderer in modo
			che risulti omogeneo rispetto a quello delle altre celle di table. */
			setForeground(isSelected ? table.getSelectionForeground() : table.getForeground());
			setBackground(isSelected ? table.getSelectionBackground() : table.getBackground());
		}
		return this;
	}
	
	/* Metodo d'appoggio, estrae un FontRenderContext da un JComponent. La precondizione per
	la riuscita dell'operazione è che il componente sia proiettabile (displayable) */
	private FontRenderContext getFontRenderContext(JComponent c) {
		Graphics2D g = (Graphics2D)c.getGraphics();
		return g == null ? null : g.getFontRenderContext();
	}
	
	/* Questo è il metodo che viene invocato per disegnare concretamente il testo nella
	nostra cella. Qui noi usiamo i valori precomputati nel metodo getTableCellRendererComponent. */
	protected void paintComponent(Graphics graphics) {
		Graphics2D g = (Graphics2D)graphics;
		/* Disegna uno sfondo opaco */
		g.setPaint(getBackground());
		g.fillRect(0, 0, getWidth(), getHeight());
		
		if(text != null) {
			drawText(text, g);
		}
	}
	
	private void drawText(String vaue, Graphics2D g) {
		g.setPaint(getForeground());
		
		/* Ogni TextLayout contenuto in textLayoutList rappresenta una linea di
		testo "creata" dal LineBreakMeasurer nel metodo getTableCellRendererComponent. Qui
		disegnamo quelle linee una sotto l'altra. */
		Point2D.Float pen = new Point2D.Float();
		for(TextLayout layout : textLayoutList) {
			pen.y += layout.getAscent();
			layout.draw(g, pen.x, pen.y);
			pen.y += layout.getDescent() + layout.getLeading();
		}
	}
}

Puoi provare l'effetto con:

package it.tukano.tprenderer;

import java.awt.*;
import javax.swing.table.*;
import javax.swing.*;

public class Main implements Runnable {

	public static void main(String[] args) {
		EventQueue.invokeLater(new Main());
	}
	
	public void run() {
		DefaultTableModel tableModel = new DefaultTableModel(10, 5);
		JTable table = new JTable() {
			private MultiLineTableCellRenderer multiLineRenderer = new MultiLineTableCellRenderer();
			public TableCellRenderer getCellRenderer(int row, int column) {
				return multiLineRenderer;
			}
		};
		table.setModel(tableModel);
		
		JScrollPane scroller = new JScrollPane(table);
		JFrame window = new JFrame("MultiLineRenderer Test");
		window.add(scroller, BorderLayout.CENTER);
		window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		window.pack();
		window.setVisible(true);
	}
}

La mappa delle altezze dovrebbe essere aggiornata quando la tabella subisce una mutazione strutturale tale da invalidare un indice precedente - ad esempio l'inserimento di una colonna. Nel caso in cui tu voglia usare altri renderer personalizzati - ad esempio per disegnare un thumbnail senza tagliarlo - devi coordinare la gestione delle altezze di riga.