FAQ Java GUIConsultez toutes les FAQ

1
2
3
4
5
6
7
public boolean isCellEditable (int row, int column) { 
        if ( celluleEstEditable ) { 
                return ( true ); 
        } else { 
                return ( false ); 
        }  
}

1
2
3
4
5
6
int rows = 10;  
int cols = 2;  
  
JTable table = new JTable(rows, cols);  
table.getColumnModel().getColumn(0).setPreferredWidth(36); 
table.getColumnModel().getColumn(1).setPreferredWidth(100);

1
2
3
4
5
6
7
8
9
int rows = 10; 
int cols = 5; 
  
JTable table = new JTable(rows, cols); 
JTableHeader header = table.getTableHeader(); 
  
JPanel container = new JPanel(new BorderLayout()); 
container.add(header, BorderLayout.NORTH); 
container.add(table, BorderLayout.CENTER);

1
2
3
4
int colonne, ligne; 
Point p = e.getPoint (); 
colonne = jtable.columnAtPoint (p); 
ligne = jtable.rowAtPoint (p);

maJTable.getTableHeader().setReorderingAllowed(false);

1
2
myJTable.getSelectionModel().addSelectionInterval(2,2);  
myJTable.getSelectionModel().addSelectionInterval(4,5);

1
2
3
4
5
public void changeSelection( 
  int rowIndex,  
  int columnIndex,  
  boolean toggle,  
  boolean extend)

1
2
3
4
5
6
public class CenterTableCellRenderer extends DefaultTableCellRenderer { 
    public CenterTableCellRenderer() { 
        setHorizontalAlignment(CENTER); 
        setVerticalAlignment(CENTER); 
    } 
}

1
2
3
JTable table = new JTable(); 
 // on applique le renderer à la table 
table.setDefaultRenderer(Object.class, new CenterTableCellRenderer());

1
2
// on applique le renderer à la colonne d'indice 0 
table.getColumnModel().getColumn(0).setCellRenderer(new CenterTableCellRenderer());

1
2
3
// on applique le renderer sur tous les headers de la table 
TableCellRenderer headerRenderer = table.getTableHeader().getDefaultRenderer()); 
((DefaultTableCellRenderer) headerRenderer).setHorizontalAlignment(DefaultTableCellRenderer.CENTER);

1
2
3
// on applique le renderer sur le header de la colonne d'indice 0 
TableCellRenderer headerRenderer = table.getColumnModel().getColumn(0).getHeaderRenderer(); 
((DefaultTableCellRenderer) headerRenderer).setHorizontalAlignment(DefaultTableCellRenderer.CENTER);

DefaultTreeModel myModel = ...;JTree myTree = new JTree(myModel);

1
2
DefaultMutableTreeNode myRoot = ...; 
DefaultTreeModel myModel = new DefaultTreeModel(myRoot);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Construction du nœud racine. 
DefaultMutableTreeNode myRoot = new DefaultMutableTreeNode("Manuel"); 
  
// Construction des différents nœuds de l'arbre. 
DefaultMutableTreeNode chap = new DefaultMutableTreeNode("Chapitre1"); 
myRoot.add(chap); 
DefaultMutableTreeNode page = new DefaultMutableTreeNode("Page1"); 
chap.add(page); 
page = new DefaultMutableTreeNode("Page2"); 
chap.add(page); 
chap = new DefaultMutableTreeNode("Chapitre2"); 
myRoot.add(chap); 
page = new DefaultMutableTreeNode("Page3"); 
chap.add(page); 
  
// Construction du modèle de l'arbre. 
DefaultTreeModel myModel = new DefaultTreeModel(myRoot); 
  
// Construction de l'arbre. 
JTree myTree = new JTree(myModel);

myTree.setShowsRootHandles(true);

myTree.setRootVisible(false);

1
2
3
4
5
6
7
8
9
10
11
12
// Construction d'un afficheur par défaut. 
DefaultTreeCellRenderer myRenderer = new DefaultTreeCellRenderer(); 
  
// Changement de l'icône pour les feuilles de l'arbre. 
myRenderer.setLeafIcon(new ImageIcon("pageIcon.png")); 
// Changement de l'icône pour les nœuds fermés. 
myRenderer.setClosedIcon(new ImageIcon("closedBookIcon.png")); 
// Changement de l'icône pour les nœuds ouverts. 
myRenderer.setOpenIcon(new ImageIcon("openBookIcon.png")); 
  
// Application de l'afficheur à l'arbre. 
myTree.setCellRenderer(myRenderer);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Ajoute un événement de sélection à l'arbre. 
myTree.addTreeSelectionListener(new TreeSelectionListener() 
{ 
   // Appelé lorsque la valeur de la sélection change. 
   public void valueChanged(TreeSelectionEvent event) 
   { 
      // Récupère le chemin dans l'arbre. 
      TreePath myPath = myTree.getSelectionPath(); 
      if(myPath == null) return; 
      // Récupère l'objet utilisateur correspondant. 
      DefaultMutableTreeNode myNode = (DefaultMutableTreeNode) myPath.getLastPathComponent(); 
      Page myPage = (Page) myNode.getUserObject(); 
      myEditorPane().setPage(myPage.getUrl()); 
   } 
});

myTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);

1
2
3
4
5
6
7
8
9
jtree.addTreeWillExpandListener(new TreeWillExpandListener(){ 
	@Override 
	public void treeWillExpand(TreeExpansionEvent event) throws ExpandVetoException {} 
	@Override 
	public void treeWillCollapse(TreeExpansionEvent event) throws ExpandVetoException{ 
		// On n'enroule pas le contenu du neoud quand on double-clique dessus 
		throw new ExpandVetoException(event); 
	} 
});

1
2
((BasicTreeUI) ihmArbre.getUI()).setExpandedIcon(null); 
((BasicTreeUI) ihmArbre.getUI()).setCollapsedIcon(null);

1
2
((BasicTreeUI) jTree.getUI()).setRightChildIndent(0); 
((BasicTreeUI) jTree.getUI()).setLeftChildIndent(0);

1
2
3
4
5
jTree.setUI(new BasicTreeUI(){ 
	protected void paintHorizontalPartOfLeg(Graphics g, Rectangle clipBounds, Insets insets, Rectangle bounds, 
		    TreePath path, int row, boolean isExpanded, boolean hasBeenExpanded, boolean isLeaf)  { } 
	protected void paintVerticalPartOfLeg(Graphics g, Rectangle clipBounds, Insets insets, TreePath path)  { } 
});