Discussion :

[opensource]

bsr,
je travail avec jtreetable,
mon probleme est comment rendre les cellules de jtable editable??
Merci pour votre aide?

[tchoukapi]

Avec la methode : isCellEditable (int, int); de la classe DefaultTableModel dont tu fais heriter le TableMOdel de ta JTable

[xixi31]

tout dépend de l'implémentation de JTreeTable que tu utilises.

[opensource]

ce que j'ai fait est de modifier au niveau de AbstracttreetableModel de tel façon que mes cellules seront tjrs editable,
je veux pas a chaque fois recuperer la cellule est mettre iseditable....
voila mon code de abstractModel

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
 
 
public abstract class AbstractTreeTableModel implements TreeTableModel {
 
    protected Object root;
    protected EventListenerList listenerList = new EventListenerList();
.............
............
 
/** By default, make the column with the Tree in it the only editable one.
    *  Making this column editable causes the JTable to forward mouse
    *  and keyboard events in the Tree column to the underlying JTree.
    */
 
    public boolean isCellEditable(Object node, int column) {
 
      // return getColumnClass(column) == TreeTableModel.class;
       //!!!!!!!!!!!!!!!!!!!!! @Abdellah !!!!!!!!!!!!!!!!
       /* boolean pass=false;
        pass=getColumnClass(column) == TreeTableModel.class;
        System.out.print("valeur pass :"+ pass +"\n");
        return pass;*/
        return false;
       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
    }

Merci je suis clair

[tchoukapi]

Si tu les veux tjours editable c'est "true" qu'il faut retourner .

[opensource]

je veux essayer et je vous rend le resultat dans un petit instant
attendez moi...............

[opensource]

j'ai testé avec true mais aucune resultat pour le moment, d'apres vous quelle est la solution?
Merci pour votre aide

[tchoukapi]

Bah perso je ne use pas les Jtree mais dans les Jtable c'est la meme implementation et si tu set le table model qui herite de DefaultTableModel a ta Jtable :

jTablexxx.setmodel(tonmodel);

et que dans ton model la methode isCellEditable retourne true tes cellules seront editables.

[opensource]

franchement je les rend true mais je n'obtient pas les resultats attendues,
je veux reessayer et chercher a surdefinir les fonctions de jtable dans la classe jtreetable pour tenter la chance encore.

[opensource]

rebonsoir,
j'ai essayé mais aucune resultat pour l'instant, pouvez m'aider?

[opensource]

Monsieur XX dit

Code :

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

tout dépend de l'implémentation de JTreeTable que tu utilises.

voila l'implementation de mon JTreeTable

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
package jtreeTable;
 
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Graphics;
 
import javax.swing.ImageIcon;
import javax.swing.JTable;
import javax.swing.JTree;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeSelectionModel;
import javax.swing.tree.TreeModel;
 
public class JTreeTable extends JTable {
 
    private static final long serialVersionUID = 1L;
    public TreeTableCellRenderer tree;
    public JTreeTable(TreeTableModel treeTableModel) {
        super();
        // Create the tree. It will be used as a renderer and editor.
        tree = new TreeTableCellRenderer(treeTableModel);
 
        // Install a tableModel representing the visible rows in the tree.
        super.setModel(new TreeTableModelAdapter(treeTableModel, tree));
 
        // Force the JTable and JTree to share their row selection models.
        tree.setSelectionModel(new DefaultTreeSelectionModel() {
                    // Extend the implementation of the constructor, as if:
                    /* public this() */ {
                        setSelectionModel(listSelectionModel);
                    }
                });
        // Make the tree and table row heights the same.
        tree.setRowHeight(getRowHeight());
        setRenderer(); // private method
 
        // Install the tree editor renderer and editor.
        setDefaultRenderer(TreeTableModel.class, tree);
        setDefaultEditor(TreeTableModel.class, new TreeTableCellEditor());
 
        setShowGrid(false);
        setIntercellSpacing(new Dimension(1, 1));
        //setGridColor(Color.blue);
        getColumnModel().getColumn(0).setPreferredWidth(100);
        //************
    }
 
    public void setModel(TreeTableModel treeTableModel) {
        tree.setModel(treeTableModel);
        super.setModel(new TreeTableModelAdapter(treeTableModel, tree));
        tree.setSelectionModel(new DefaultTreeSelectionModel() {
                    {
                        setSelectionModel(listSelectionModel);
                    }
                });
        tree.setRowHeight(getRowHeight());
        tree.setRootVisible(false);
 
    }
 
    /*
	 * Workaround for BasicTableUI anomaly. Make sure the UI never tries to
	 * paint the editor. The UI currently uses different techniques to paint the
	 * renderers and editors and overriding setBounds() below is not the right
	 * thing to do for an editor. Returning -1 for the editing row in this case,
	 * ensures the editor is never painted.
	 */
 
    public int getEditingRow() {
        return (getColumnClass(editingColumn) == TreeTableModel.class) ? -1 : 
               editingRow;
    }
 
    public JTree getTree() {
        return tree;
    }
 
 
    // 
    // The renderer used to display the tree nodes, a JTree.
    //
 
    public class TreeTableCellRenderer extends JTree implements TableCellRenderer {
 
        /**
         * 
         */
        private static final long serialVersionUID = 1L;
 
        protected int visibleRow;
 
        public TreeTableCellRenderer(TreeModel model) {
            super(model);
        }
 
        public void setBounds(int x, int y, int w, int h) {
            super.setBounds(x, 0, w, JTreeTable.this.getHeight());
        }
 
        public void paint(Graphics g) {
            g.translate(0, -visibleRow * getRowHeight());
            super.paint(g);
        }
 
        public Component getTableCellRendererComponent(JTable table, 
                                                       Object value, 
                                                       boolean isSelected, 
                                                       boolean hasFocus, 
                                                       int row, int column) {
 
            if (isSelected)
                setBackground(table.getSelectionBackground());
            else
                setBackground(table.getBackground());
 
            visibleRow = row;
            return this;
        }
    }
    // 
    // The editor used to interact with tree nodes, a JTree.
    //
 
    public class TreeTableCellEditor extends AbstractCellEditor implements TableCellEditor {
        public Component getTableCellEditorComponent(JTable table, 
                                                     Object value, 
                                                     boolean isSelected, int r, 
                                                     int c) {
            return tree;
        }
    }
 
 
    public void setRenderer() {
        DefaultTreeCellRenderer renderer = 
            (DefaultTreeCellRenderer)tree.getCellRenderer();
        java.net.URL url;
        url = getClass().getResource("/oms/icons/toc_closed.gif");
        if (url != null) {
            renderer.setClosedIcon(new ImageIcon(url));
        }
        url = getClass().getResource("/oms/icons/toc_opened.gif");
        if (url!= null) {
            renderer.setOpenIcon(new ImageIcon(url));
        }
        url = getClass().getResource("/oms/icons/topic.gif");
        if (url != null) {
            renderer.setLeafIcon(new ImageIcon(url));
        }
    }
    public boolean isCellEditable(int rowIndex, int columnIndex) {
              return true;
             }
 
}

voila voila voila

[xixi31]

a priori, tu dois passer par la méthode editCellAt dans ta JTable ( vérifier par une petite surcharge peut-être...).

voilà ce qu'elle fait dans la JTable :

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
 
    public boolean editCellAt(int row, int column, EventObject e){
        if (cellEditor != null && !cellEditor.stopCellEditing()) {
            return false;
        }
 
    if (row < 0 || row >= getRowCount() ||
        column < 0 || column >= getColumnCount()) {
        return false;
    }
 
        if (!isCellEditable(row, column))
            return false;
 
        if (editorRemover == null) {
            KeyboardFocusManager fm =
                KeyboardFocusManager.getCurrentKeyboardFocusManager();
            editorRemover = new CellEditorRemover(fm);
            fm.addPropertyChangeListener("permanentFocusOwner", editorRemover);
        }
 
        TableCellEditor editor = getCellEditor(row, column);
        if (editor != null && editor.isCellEditable(e)) {
        editorComp = prepareEditor(editor, row, column);
        if (editorComp == null) {
        removeEditor();
        return false;
        }
        editorComp.setBounds(getCellRect(row, column, false));
        add(editorComp);
        editorComp.validate();
 
        setCellEditor(editor);
        setEditingRow(row);
        setEditingColumn(column);
        editor.addCellEditorListener(this);
 
        return true;
        }
        return false;
    }

donc, comme ta surcharge de isCellEditable retourne toujours true, peut-être que l'éditeur que la table essaie de créer considère qu'il n'est pas éditable...
tu as vérifié que ta surcharge de isCellEditable était rééllement appelée?