Discussion :

[ALIAS200]

Salut,
j'ai developpe un JTable et deux bouton up & down dans une interface graphique avec swing.
Je veux changer l'ordre de la ligne selectinnee de tableau en haut ou en bas selon le bouton cliquer.

J'ai cherche bien l'instruction dans la classe de JTable dans javadoc et j'ai pas trouve une instruction pour l'ordre???
est ce que il ya quelqu'un qui sait comment on peut la faire.
Merci pour vous aides

[Actarus78]

Utilise un table Model pour ta JTable qui s'occupera de faire le tri.

En voilà un made by Joshua Marinacci & Chris Adamson

Le Table Model

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
 
import javax.swing.table.*;
import javax.swing.event.*;
import java.util.*;
 
/**
 * Code source from Joshua Marinacci & Chris Adamson 
 */
 
 
public class SortableTableModel implements TableModel, TableModelListener {
 
 
    EventListenerList listenerList = new EventListenerList();
    TableModel delegatedModel;
    int[] sortedIndicies;
    int sortColumn;
    Comparator comparator;
    Comparator[] comparators;
 
    public SortableTableModel (TableModel tm) {
        delegatedModel = tm;
        delegatedModel.addTableModelListener (this);
        comparators = new Comparator [tm.getColumnCount()];
        sortedIndicies = new int [0];
        setSortColumn (0);
    }
 
 
    // listener stuff
    public void addTableModelListener (TableModelListener l) {
        listenerList.add (TableModelListener.class, l);
    }
 
    public void removeTableModelListener (TableModelListener l) {
        listenerList.remove (TableModelListener.class, l);
    }
 
    public void fireTableModelEvent (TableModelEvent e) {
        Object[] listeners = listenerList.getListenerList();
        for (int i = listeners.length-2; i>=0; i-=2) {
            if (listeners[i] == TableModelListener.class) {
                ((TableModelListener) listeners[i+1]).tableChanged(e);
            }
        }
    }
 
    // contents stuff
 
    public Class getColumnClass(int columnIndex) {
        if (delegatedModel.getRowCount() > 0)
            return delegatedModel.getValueAt(0, columnIndex).getClass();
        else
            return Object.class;
    }
 
    public int getColumnCount() {
        return delegatedModel.getColumnCount();
    }
    public String getColumnName (int index) { 
        return delegatedModel.getColumnName (index);
    }
    public int getRowCount() {
        return delegatedModel.getRowCount();
    }
    private int getDelegatedRow (int row) {
        return sortedIndicies [row];
    }
    public Object getValueAt (int rowIndex, int columnIndex) {
        return delegatedModel.getValueAt (getDelegatedRow(rowIndex),
                                          columnIndex);
    }
    public boolean isCellEditable (int rowIndex, int columnIndex) {
        return delegatedModel.isCellEditable (rowIndex, columnIndex);
    }
    public void setValueAt (Object aValue, int rowIndex, int columnIndex) {
        delegatedModel.setValueAt (aValue, rowIndex, columnIndex);
    }
 
    // internal helpers
    public void setComparatorForColumn (Comparator c, int i) {
        // range check
        if (i > comparators.length) {
            Comparator[] newComparators = new Comparator[i+1];
            System.arraycopy (comparators, 0,
                              newComparators, 0,
                              comparators.length);
            comparators = newComparators;
        }
        // add the comparator
        comparators[i] = c;
    }
 
    public void setSortColumn (int i) {
        sortColumn = i;
 
        // reset current comparator, possibly to null, which 
        // will make us use "natural ordering" for those values
        comparator = null;
        if ((comparators != null) &&
            (comparators.length > 0))
            // is there one in the list of comparators?
            comparator = comparators[sortColumn];
 
        // now do the sort
        resort();
    }
 
    public int getSortColumn () {
        return sortColumn;
    }
 
 
    /** called to rebuild the delegate-to-sortable mapping
     */
    protected void resort() {
        // does sortedIndicies need to grow or shrink?
        if (sortedIndicies.length != delegatedModel.getRowCount()) {
            sortedIndicies = new int [delegatedModel.getRowCount()];
        }
        // build up a list of SortingDelegates
        ArrayList sortMe = new ArrayList();
        for (int i=0; i<delegatedModel.getRowCount(); i++) {
            SortingDelegate sd =
                new SortingDelegate (delegatedModel.getValueAt(i, getSortColumn()),
                                     i);
            sortMe.add (sd);
        }
        // now sort him with the SortingDelegateComparator
        SortingDelegateComparator sdc =
            new SortingDelegateComparator (comparator);
        Collections.sort (sortMe, sdc);
 
        // fill sortedIndicies array
        // index -> value represents mapping from original
        // row to sorted row
        for (int i=0; i<sortMe.size(); i++) {
            sortedIndicies[i] =
                ((SortingDelegate) sortMe.get(i)).row;
        }
 
        // fire change event
        fireAllChanged();
    }
 
 
    public class SortingDelegate extends Object {
        public Object value;
        public int row;
        public SortingDelegate (Object v, int r) {
            value = v;
            row = r;
        }
    }
 
    // "pointer object" int 1 is current value and int 2 is
    // current row in table
 
    // comparator which applies current comparator's compare rule
    // to value 2 in 
    class SortingDelegateComparator extends Object implements Comparator {
        Comparator comp;
        public SortingDelegateComparator (Comparator c) {
            comp = c;
        }
        public int compare (Object o1, Object o2) {
            Object v1 = ((SortingDelegate)o1).value;
            Object v2 = ((SortingDelegate)o2).value;
            if (comp != null)
                return comp.compare (v1, v2);
            else if (v1 instanceof Comparable)
                return ((Comparable)v1).compareTo (v2);
            else 
                throw new IllegalArgumentException ("Can't compare objects "+
                                                    "for sorting");
 
        }
    }
 
 
    public void tableChanged (TableModelEvent e) {
                            switch (e.getType()) {
                            case TableModelEvent.DELETE: {
                                resort();
                                fireAllChanged();
                                break;
                            }
                            case TableModelEvent.INSERT: {
                                resort();
                                fireAllChanged();
                                break;
                            }
                            case TableModelEvent.UPDATE: {
                                resort();
                                fireAllChanged();
                                break;
                            }
 
                            }
    }
 
 
    protected void fireAllChanged() {
        TableModelEvent e = new TableModelEvent (this);
        fireTableModelEvent (e);
    }
 
 
}

L'exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
import java.awt.*;
import java.awt.event.*;
import java.awt.color.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.event.*;
import java.util.*;
 
public class TestSortableTableModel extends JPanel 
    implements ActionListener {
 
    DefaultTableModel myModel;
    SortableTableModel mySortableModel;
    JButton sort1, sort2, sort3, bonus;
 
    static Object[] headers = {
        "Letter", "Number", "Color"
    };
    static Object[][] data = {
        {"A", new Integer(2), Color.gray.darker().darker()},
        {"B", new Integer (3), Color.gray},
        {"C", new Integer (1), Color.gray.darker()},
    };
 
    static Object[] bonusData = {
        // "D", "0", Color.red  // this is the (buggy) book version
        "D", new Integer(0), Color.red
    };
 
    public TestSortableTableModel (DefaultTableModel m) {
        super (new BorderLayout());
        myModel = m;
        mySortableModel = new SortableTableModel (myModel);
        mySortableModel.setComparatorForColumn (new MyColorComparator(), 2);
        JTable table = new JTable (mySortableModel);
        table.setDefaultRenderer (java.awt.Color.class, new ColorRenderer());
        JScrollPane scroller =
            new JScrollPane (table,
                             ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS,
                             ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS);
        table.setPreferredScrollableViewportSize (new Dimension (400, 200));
        setLayout(new BorderLayout());
        add (scroller, BorderLayout.CENTER);
        // add sort buttons
        JPanel buttonPanel = new JPanel();
        sort1 = new JButton ("Sort 1");
        buttonPanel.add(sort1);
        sort1.addActionListener(this);
        sort2 = new JButton ("Sort 2");
        buttonPanel.add(sort2);
        sort2.addActionListener(this);
        sort3 = new JButton ("Sort 3");
        buttonPanel.add(sort3);
        sort3.addActionListener(this);
        bonus = new JButton ("More data");
        buttonPanel.add(bonus);
        bonus.addActionListener(this);
        add (buttonPanel, BorderLayout.SOUTH);
 
    }
 
    public void actionPerformed (ActionEvent e) {
        if (e.getSource() == sort1) {
            mySortableModel.setSortColumn (0);
        } else if (e.getSource() == sort2) {
            mySortableModel.setSortColumn (1);
        } else if (e.getSource() == sort3) {
            mySortableModel.setSortColumn (2);
        } else if (e.getSource() == bonus) {
            myModel.addRow (bonusData);
        }
 
 
    }
 
    public static void main (String[] args) {
        DefaultTableModel aModel =
            new DefaultTableModel(data, headers) ;
        JFrame frame = new JFrame ("Sortable Table");
        frame.getContentPane().add (new TestSortableTableModel(aModel),
                                    BorderLayout.CENTER);
        frame.pack();
        frame.setVisible(true);
    }
 
 
    class MyColorComparator implements Comparator {
        float[] hsb = new float[3];
        public int compare (Object o1, Object o2) {
            if ((! (o1 instanceof Color)) ||
                (! (o2 instanceof Color)))
                return 0;
            else {
                Color c1 = (Color) o1;
                Color c2 = (Color) o2;
                Color.RGBtoHSB ( c1.getRed(),
                                 c1.getGreen(),
                                 c1.getBlue(),
                                 hsb);
                float bright1 = hsb[2];
                Color.RGBtoHSB ( c2.getRed(),
                                 c2.getGreen(),
                                 c2.getBlue(),
                                 hsb);
                float bright2 = hsb[2];
                if (bright1 == bright2)
                    return 0;
                else
                    return ((bright1-bright2) < 0) ? -1 : 1;
            }
        }
        public boolean equals (Object obj) {
            return super.equals (obj);
        }
    }
 
    class ColorRenderer extends DefaultTableCellRenderer {
        public Component getTableCellRendererComponent (JTable table,
                                                        Object value,
                                                        boolean isSelected,
                                                        boolean hasFocus,
                                                        int row,
                                                        int col) {
            Component returnMe = 
                super.getTableCellRendererComponent (table, value,
                                                     isSelected,
                                                     hasFocus, row, col);
 
            // background only version
 
            if (value instanceof Color) {
                Color color = (Color) value;
                returnMe.setBackground (color);
                if (returnMe instanceof JLabel) {
                    JLabel jl = (JLabel) returnMe;
                    jl.setOpaque(true);
                    jl.setText ("");
                }
            }
            return returnMe;
        }
 
    }
 
}

[iohack]

Si c'est juste pour modifier l'ordre et non faire un tri, un simple tableau d'indexes dans le modèle devrait faire le taf ( il faudra surcharger les méthodes d'accès aux données pour qu'elles passent par le tableau d'indexes plutot que d'accéder directement au container ).

[Actarus78]

effectivement, autant pour moi, je me suis peut être précipité dans ma réponse mais l'intention y était Maintenant c'est à toi de choisir ce qui convient le mieux à ton programe.

[ALIAS200]

Merci Actarus78 pour le code mais mon probleme ,comme a expliqué iohack "c'est juste pour modifier l'ordre et non faire un tri"
C'est a dire:
je selectionne ligne 3 et je clique sur bouton up la ligne devient a la position de la ligne 2.
et si je selectionne ligne 5 et je clique sur bouton down la ligne devient a la position de la ligne 6.



J'ai pas bien compris ce que Iohack a dit:

il faudra surcharger les méthodes d'accès aux données pour qu'elles passent par le tableau d'indexes plutot que d'accéder directement au container

[ALIAS200]

Mon model:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
import java.util.Vector;
import javax.swing.table.AbstractTableModel;
 
public class Model extends AbstractTableModel {
 
		private Vector<Personne> donnees;
 
		private final String[] titres;
 
		public Model(Vector donnees, String titres[]) {
			this.donnees = donnees;
			this.titres = titres;
		}
		public int getRowCount() {
			return this.donnees.size();
		}
		public int getColumnCount() {
			return this.titres.length;
		}
		public String getColumnName(int col){
			return titres[col];
		}
		public boolean isCellEditable(int row, int col) {
			return false;
		}
		//
         public void deleteRow(int rowIndex) {
                donnees.remove(rowIndex);
                fireTableRowsDeleted(rowIndex,rowIndex); //pour notifier la suppression de la ligne à tous les composants ayant posé un listener sur le model
         }
		public Object getValueAt(int arg0, int arg1) {
			Personne  p = (Personne) donnees.get(arg0);
			   if( arg1 == 1) {
			      return p.getPrenom();
			   } else if( arg1 == 2) {
				   return p.getAdresse();
			   }
			   else if( arg1 == 0) {
				   return p.getNom();
			   }
			   else {
			      return null;
			   }
		}		
}

Classe Personne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Personne{
 
   private String nom, prenom, adresse;
 
   public Personne(){}
   public Personne(String nom,String prenom,String adresse){
	   this.nom=nom;
	   this.prenom=prenom;
	   this.adresse=adresse;
   }
 
   public String getNom(){return nom;}
   public String getPrenom(){return prenom;}
   public String getAdresse(){return adresse;}
 
   public void setNom(String nom){this.nom = nom;}
   public void setPrenom(String prenom){this.prenom = prenom;}
   public void setAdresse(String adresse){this.adresse = adresse;}
}

classe GUI:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import java.awt.event.*;
import java.util.Vector;
import javax.swing.*;
 
public class SW implements ActionListener {
 
private	JFrame cadre;
private	JPanel pane;
private	JButton bouton_up,bouton_down;
private JTable TAB;
private JScrollPane scrollpane;
 
private Vector<Personne> VP;
private String [] columns  = { "Nom", "Prenom","Adresse"};
private Personne P1,P2,P3,P4;
 
public SW()
{
	cadre = new JFrame("test");
	cadre.setSize(200,200);
	pane = new JPanel();
 
	bouton_up=new JButton("UP");
	bouton_down=new JButton("DOWN");
 
	bouton_up.addActionListener(this);
	bouton_down.addActionListener(this);
 
	VP = new Vector();
	P1 = new Personne ("AAA","aa","France");
	P2 = new Personne ("BBB","bb","France");
	P3 = new Personne ("CCC","cc","France");
	P4 = new Personne ("DDD","dd","France");
	VP.add(P1);
	VP.add(P2);
	VP.add(P3);
	VP.add(P4);
 
    Model MTable = new Model (VP,columns);
    TAB = new JTable(MTable);
 
	scrollpane= new JScrollPane(TAB,
			ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS,
			ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS);
 
	pane.add(scrollpane);
	pane.add(bouton_up);
	pane.add(bouton_down);
	cadre.getContentPane().add(pane);
	cadre.setVisible(true);
}
 
 
	public void actionPerformed(ActionEvent arg0) {
		// TODO Auto-generated method stub
		if (arg0.getSource()==bouton_up)
		{	 
			 int ligne_selec = TAB.getSelectedRow();
			 //matable.getModel().;
 
		}
		if (arg0.getSource()==bouton_down)
		{	 
			 int ligne_selec = TAB.getSelectedRow();
 
		}
 
	}
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SW T = new SW ();
	}
}

Dans ce model je dois ajouter deux methode UP et down qui modifie la position des lignes Mais j'ai pas connu quel instruction a utiliser car j'utilise un vector???

[iohack]

exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
public Object getObjectAt(int l,int c){
   Personne p=(Personne)donnees.elementAt(monTableauDIndexes[l]);
   // Je simplifie volontairement le code de la ligne suivante :
   return p.elementAt(c);
}

En fait c'est tableauDIndexes qui contiendra l'ordre des lignes du container "donnees".
Par exemple, si la cinquième ligne doit passer en première ligne, il suffira de modifier les indexes de la sorte ( je passe un container List pour l'explication qui est plus simple comme ça ) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Personne p5=(Personne)maList.get(4);
maList.remove(p5);
maList.add(0,p5);

[ALIAS200]

Salut,
c'est a dire dans mon model, je dois ajouter une methode nomme getObjectAt et je dois declaré un tableau nomme monTableauDIndexes : Vector<Personne> monTableauDIndexes;

p.elementAt(c) n'existe pas!!!

j'ai pas compris

[ALIAS200]

Salut, iohack,
j'ai teste votre code et ca ne marche pas au niveau de instruction:

Personne p=this.datas.get(this.lstIndexes.get(l).intValue());
il affiche comme exception out of range...


Alors j'ai laisse mon getValueAt tels qu'il est; j'ai ajoute une methode nomme moveUP qui deplace toujours la ligne selectionne en haut de 1.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
  public void moveUP(int l)//ligne selectione en parametre
         {
        	 if(l>0)		 
			 {
			 Personne P=(Personne)this.donnees.get(l);
			 Personne P_1=(Personne)this.donnees.get(l-1);
 
			 this.donnees.remove(P);	 
			 this.donnees.add(l-1,P);
 
			 fireTableDataChanged();
			}
         }

et ca marche
Merci pour votre aide