Normale, il y a un « else return true; » en trop.

if (listEntete.containsKey(columnMarchandisee) ){
     (...)
     return colIndex != column;
}
//else return true;
if (listEntete.containsKey(columnUtilisation) ){
     (...)
     return colIndex != column;
}
else return true;

Bonsoir 

 Vraiment il y'a pas de changement méme si je désative le "else" qui est de trop essayez au niveau de votre proramme pour voir si ça marche ce n'est pas le cas pour moi

Bonjour,

Remplacer :

return colIndex != column;

Par :

if (colIndex == column) return false;

if (listEntete.containsKey(columnMarchandisee) ){
     int column = 0;
     (....)
     if (colIndex == column) return false;
}

if (listEntete.containsKey(columnUtilisation) ){
     int column = 0;
     (....)
     if (colIndex == column) return false;
}
return true;

Ceci :

return colIndex != column;

C'est équivalent à :

if (colIndex != column) return true;
else return false;

 Bonne continuation.

-
Edité par pctronique 7 septembre 2014 à 11:45:13

Bonsoir

au niveau des messages précédentes vous avez souligné un petit probléme.

<<Cas 2 : Si je supprime seulement la colonne "prix 1", pas de soucie, j'ai ma colonne "prix 2", donc on n'est pas dans le cas 1, mais il y a un problème quand même.

Si on crée une nouvelle colonne, on aura :

|Marchandise| prix2| prix3| prix3|prix moyenne| prix public| utilisation|apréciation des prix|

Dans listEntete on a déjà "prix 3", donc la nouvelle colonne ne sera pas prise en compte par listEntete. Mais comme il a été dit, il faut que le nombre de ligne de listEntete soit égale au nombre de colonne de la Jtable.>>

Bonjour,

mada96 a écrit:

|prix4|Marchandise| prix1| prix2| prix moyenne| prix public| utilisation|apréciation des prix| 

vous voyez que la colonne "prix4" insérée occupe la premiére position dans le tableau et on a un saut de chiffre au lieu d'etre "prix3" elle s'est transformée en "prix4".Ce probleme est du au variable  <<nbPrice = 3;>> initialiser à 3.

Merci pour tous

Oui normale, mais au moment que j'ai écrit ceci, vous utilisiez la variable nbPrice. De plus, vous avez de la chance d'avoir pu ajouter "prix 4", sans avoir d'exception.

Il doit avoir une solution, peut-être en utilisent un tableau, vous pouvez le faire.

Je les fais .

public class JTableColumn extends JTable {
(...)
     
    public JTableColumn(Object[][] rowData, Object[] columnNames) {
        super();
        this.rowData = rowData;
        this.columnNames = columnNames;
        this.tableur = new  DefaultTableModel(this.rowData, this.columnNames);
        this.setModel(this.tableur);
    }
 
(...)
     
    public void placeColumn() {
        rowColumn();
    }
 
(...)
}

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Set;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;

/**
 * JTable avec le nom de colonne modifiable.
 * @author pctronique
 */
public class JTableEditHead extends JTableColumn {
    
    private HashMap<String, String> listEntete;
    
    public JTableEditHead(Object[][] rowData, String[] columnNames) {
        super(rowData, columnNames);
        listEntete = new LinkedHashMap<String, String>();
        for(String columnName : columnNames)
            listEntete.put(columnName, columnName);
        new JEditHeadColumn(this){
            public void modifName(String oldName, String newName) {
                for (String value : listEntete.keySet()) {
                    if (listEntete.get(value).equals(oldName)) listEntete.put(value, newName);
                }
            }
            
            public boolean isColumnEditable(int colIndex) {
                return isTableColumnEditable(colIndex);
            }
        };
    }
    
    /**
     * Recupere la TableColumn a partir du nom de la colonne.
     * @param identifier nom de la colonne.
     * @return 
     */
    public TableColumn getColumn(String identifier) {
        return super.getColumn(listEntete.get(identifier));
    }
    
    /**
     * Verifie que le nom appartient a un nom de colonne de la table.
     * @param name nom a verifier
     * @return true si la colonne a ete trouve
     */
    public boolean columnContains(String name) {
        return listEntete.containsKey(name);
    }
    
    /**
     * Verifie que le numero de colonne porte bien ce nom.
     * @param column le nom a verifier par le numero de colonne.
     * @param name le numero de colonne.
     * @return true si c'est bon.
     */
    public boolean isIntColumnName(int column, String name) {
        return ((String)this.getColumnModel().getColumn(column).getHeaderValue()).equals(listEntete.get(name));
    }
    
    /**
     * Avoir le numero de colonne a partir du nom.
     * @param name nom de colonne.
     * @return numero de cette colonne.
     */
    public int nmColumn(String name) {
        int column = 0;
        while(!isIntColumnName(column, name)) {
            column++;
        }
        return column;
    }
    
    /**
     * Avoir le nom de la colonne a partir du numero de colonne.
     * @param column numero de colonne.
     * @return nom de la colonne.
     */
    public String nameColumn(int column) {
        int i = 0;
        Set<String> listKey = listEntete.keySet();
        for (String value : listKey) {
            if (listEntete.get(value).equals((String)this.getColumnModel().getColumn(column).getHeaderValue())) return listEntete.get(value);
            i++;
        }
        return null;
    }
    
    /**
     * Verifie que le nom de colonne est editable.
     * @param colIndex numero de colonne.
     * @return true si editable.
     */
    public boolean isTableColumnEditable(int colIndex) {
        return true;
    }
    
    /**
     * Ajoute une colonne a la fin du tableau.
     * @param name nom de la colonne.
     */
    public void addColumn(String name) {
        listEntete.put(name, name);
        super.addColumn(name);
    }
    
    /**
     * Insert une colonne au tableau.
     * @param column numero de l'emplacement de la colonne.
     * @param name nom de la colonne.
     */
    public void insertColumn(int column, String name) {
        listEntete.put(name, name);
        super.insertColumn(column, name);
    }
    
    /**
     * Supprime une colonne du tableau.
     * @param tableColumn colonne a supprimer.
     */
    public void removeColumn(TableColumn tableColumn) {
        TableColumnModel theColumnModel = this.getColumnModel();
        String name = (String)tableColumn.getHeaderValue();
        theColumnModel.removeColumn(tableColumn);
        Set<String> listKey = listEntete.keySet();
        String efface = "";
        for (String value : listKey) {
            if (listEntete.get(value).equals(name)) efface = value;
        }
        listEntete.remove(efface);
    }
    
    /**
     * Supprime une colonne du tableau.
     * @param column numero de la colonne a supprimer.
     */
    public void removeColumn(int column) {
        TableColumnModel theColumnModel = this.getColumnModel();
        TableColumn tableColumn = theColumnModel.getColumn(column);
        this.removeColumn(tableColumn);
    }
    
    /**
     * Supprime une colonne du tableau.
     * @param columnName nom de la colonne a supprimer.
     */
    public void removeColumn(String columnName) {
        this.removeColumn(this.nmColumn(columnName));
    }
    
}

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import javax.swing.BorderFactory;
import javax.swing.DefaultCellEditor;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.TableColumn;

public class Tableur6 extends JFrame {
    
    private JTableEditHead table;
    private JButton ajout;
    private JScrollPane entete;
    
    private String columnMarchandisee;
    private String columnPoid;
    private String columnPrice;
    private String columnUtilisation;
    private int[] nbPrice;
    private JButton sup;
    private JPanel pa;
    
    /**
     * Constructeur par defaut de la classe.
     */
    public Tableur6(){
        this.initClass();
        this.setLocationRelativeTo(null);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setTitle("JTable");
        this.setSize(600, 200);
    }
    
    /**
     * Initialise les variables de la classe.
     */
    private void initVariable() {
        nbPrice = new int[]{1, 2, 3};
        columnMarchandisee = "marchandisee";
        columnPoid = "poid en kg";
        columnPrice = "prix ";
        columnUtilisation = "utilisation";
    }
    
    /**
     * Initialise les composants de la classe.
     */
    private void initComponents() {
        ajout = new JButton("Ajouter une colonne");
        sup = new JButton("Supprime une colonne");
        
        pa=new JPanel();
        pa.setPreferredSize(new Dimension (0,30));
        pa.setBorder(BorderFactory.createLineBorder(Color.CYAN));
        add(pa,BorderLayout.SOUTH);
        pa.setLayout(new GridLayout(1, 3));
        pa.add(ajout, BorderLayout.SOUTH);
        pa.add(sup, BorderLayout.SOUTH);
        
        //Les données du tableau
        Object[][] data = {
            {"rice","12","$18", "$15","$12", ""},
            {"millet","8","$20","$17", "$15", ""},
            {"corn","10", "$14","$13","$12", ""},
        };

        //Les titres des colonnes
        String[]  theTitle = {columnMarchandisee, columnPoid, columnPrice + "1", 
            columnPrice + "2", columnPrice + "3", columnUtilisation};
        
        table = new JTableEditHead(data, theTitle){
            public boolean isTableColumnEditable(int colIndex) {
                if (table.columnContains(columnMarchandisee))
                    return colIndex != table.nmColumn(columnMarchandisee);
                else return true;
            }
            
            public boolean isCellEditable(int rowIndex, int colIndex) {
                return tableIsCellEditable(rowIndex, colIndex);
            }
        };
    }
    
    /**
     * Verifie que la cellule est editable.
     * @param rowIndex numero de la ligne.
     * @param colIndex numero de la colonne.
     * @return true si on peut editer.
     */
    private boolean tableIsCellEditable(int rowIndex, int colIndex) {
        /*if (!((String)table.getColumnModel().getColumn(colIndex).getHeaderValue()).contains(columnPrice)) {
            ajout.setEnabled(true);
        } else {
            ajout.setEnabled(false);
            sup.setEnabled(false);
        }
        
        if (!table.isIntColumnName(colIndex, columnMarchandisee)) {
            sup.setEnabled(true);    
        } else {
            sup.setEnabled(false);
        }*/
        
        if(nbPrice.length==1 && 
                ((String)table.getColumnModel().getColumn(colIndex).getHeaderValue()).contains(columnPrice))
            sup.setEnabled(false);
        
        if (table.columnContains(columnMarchandisee))
            if (colIndex == table.nmColumn(columnMarchandisee)) return false;
        
        if (table.columnContains(columnUtilisation) )
            if (colIndex == table.nmColumn(columnUtilisation)) return false;
        
        return true;
    }
    
    /**
     * Les ecouteurs de la classe.
     */
    private void listenerClass() {
        ajout.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                ajoutActionPerformed(e);
            }
        });
        sup.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                supActionPerformed(e);
            }
        });
    }
    
    /**
     * Verifier que la colonne est bien une colonne de type "prix X".
     * @param colonne numero de colonne.
     * @return true si on est bien dans une colonne "prix X".
     */
    private boolean columnPrice(int colonne) {
        for (int price : nbPrice)
            if (colonne == table.nmColumn(columnPrice + price)) return true;
        return false;
    }
    
    /**
     * retrouve le numero du prix pour la colonne.
     * @param column numero de la colonne.
     * @return recupere le numero du prix.
     */
    private int intPrice(int column) {
        String name = table.nameColumn(column);
        for (int price : nbPrice)
            if (name.equals(columnPrice + price)) return price;
        return 0;
    }
    
    /**
     * Si on clique sur le bouton supprimer. (ecouteur)
     * @param e 
     */
    private void supActionPerformed(ActionEvent e) {
        if (table.getSelectedColumn() >= 0) {
            if (columnPrice(table.getSelectedColumn())) {
                delPriceColumn(intPrice(table.getSelectedColumn()));
            }
            table.removeColumn(table.getSelectedColumn());
        }
    }
    
    /**
     * Si on clique sur le bouton ajouter. (ecouteur)
     * @param e 
     */
    private void ajoutActionPerformed(ActionEvent e) {
        if (ajout.isEnabled()) { // si le bouton n'est pas active on ne peut pas faire ce qu'il suit.
            int column = 0;
            for (int j = 0; j < table.getColumnCount(); j++) {
                if (table.isIntColumnName(j, columnPrice + nbPrice[nbPrice.length-1])) column = j + 1;
            }
            addPriceColumn();
            String name= columnPrice + (nbPrice[nbPrice.length-1]);
            table.insertColumn(column, name);
        }
    }
    
    private void addPriceColumn() {
        int[] value = new int[nbPrice.length+1];
        System.arraycopy(nbPrice, 0, value, 0, nbPrice.length);
        value[nbPrice.length] = nbPrice[nbPrice.length-1] + 1;
        Arrays.sort(value);
        nbPrice = value;
    }
    
    private void delPriceColumn(int number) {
        int[] value = new int[nbPrice.length-1];
        int j = 0;
        for (int i = 0; i < nbPrice.length-1; i++) {
            if (number == nbPrice[j]) j++;
            value[i] = nbPrice[j];
            j++;
        }
        Arrays.sort(value);
        nbPrice = value;
    }
    
    /**
     * Initialise la classe.
     */
    private void initClass() {
        this.initVariable();
        this.initComponents();
        
        poid();
        entete= new JScrollPane(table);
        table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
        table.setColumnSelectionAllowed(true);
        add(entete, BorderLayout.NORTH);
        
        this.listenerClass();
    }
    
    public void poid() {
        JComboBox  jcbocoeff = new JComboBox();
        for (int i = 10; i <= 20; i++) 
            jcbocoeff.addItem(String.valueOf(i));
        TableColumn poid = table.getColumn(columnPoid);
        poid.setCellEditor(new DefaultCellEditor(jcbocoeff));
    }
    
    public static void main(String[] args){
        Tableur6 fen = new Tableur6();
        fen.setVisible(true);
    }
    
}

PS :

Vous pouvez remplacer ceci :

((String)table.getColumnModel().getColumn(colIndex).getHeaderValue()).contains(columnPrice)

par :

columnPrice(colIndex)

Si le teste est seulement pour les colonnes "prix X".

Bonne continuation.

-
Edité par pctronique 9 septembre 2014 à 11:12:09

Bonjour

Je m'excuse pour tous le temps sans connexion au niveau du forum.

on me souligne une erreur  au niveau du  mot clé << super(...)>>qui appelle le constructeur de la classe mère  dans la classe  JTableEditHead

Voici le code de l'erreur précis

    	super(rowData, columnNames);

Bonsoir,

Vous n'avez pas oublié d'ajouter dans la classe (JTableColumn) :

public JTableColumn(Object[][] rowData, Object[] columnNames) {
        super();
        this.rowData = rowData;
        this.columnNames = columnNames;
        this.tableur = new  DefaultTableModel(this.rowData, this.columnNames);
        this.setModel(this.tableur);
    }

Il dit juste, qu'il ne trouve pas le constructeur dans la classe mère.

Bonne continuation.

Bonsoir

Merci pour la resolution .Maintenant ça marche sauf que un petit soucis.vous avez reussi à désactiver le bouton "Supprimer"s'il en reste au moins un prix.Mais selectionner les 3 colonnes de "prix" puis commencer à supprimer sur les colonnes.Vous remarquerez que mème s'il en reste un seul prix le bouton "supprimer"  reste activer et on peut mème supprimer ce dernier.

Bonjour,

Je n'ai pas cherché au niveau de la suppression des colonnes, je vous laisse le faire et c'est très simple, ne cherchez pas dans du compliquer (int[] columns = table.getSelectedColumns();). Je n'ai pas cherché à désactiver le bouton c'est votre code (c'est vous qui l'avait désactivé). Vous aviez un problème sur la suppression de prix et pouvoir ajouter une nouvelle colonne prix, c'est là-dessus que je vous ai aidé. N'oubliez pas c'est un site pour apprendre à programmer et si vous avez du mal avec du code, je suis là pour vous l'expliquer, mais pas pour programmer à votre place. De plus si votre bouton supprimer est grisé, on peut quand même supprimer la colonne, vous n'avez pas pris en compte de vérifier que le bouton était désactivé. J'ai réorganisé un peu votre code, mais je ne l'ai pas modifié . Je suis là en soutient, essaye de le faire et si vraiment vous n'arrivez pas, je pourrais vous aider. Vous pouvez désactiver le bouton dans le bouton lui-même (je vous laisse trouver une solution).

Bonne continuation.

Bonsoir

donnez moi un peu de temps pour chercher bien que je le reconnait en posant cette question je n'avais rien cherché parce que je l'ai remarqué tard la nuit.Oui comme dit le proverbe "c'est en forgeant qu'on devient forgeron" Je prends du temps pour mieux voir  les choses. Et merci pour tous l'aide que vous venez de m'apporter franchement. Si j'ai des choses que je ne comprends pas je vous ferai part  pour avoir plus de clarification.

                                                                                       Merci pour le soutien.

Bonsoir

Puise avoir une explication sommaire au niveau  de ce code

 private void addPriceColumn() {
        int[] value = new int[nbPrice.length+1];
        System.arraycopy(nbPrice, 0, value, 0, nbPrice.length);
        value[nbPrice.length] = nbPrice[nbPrice.length-1] + 1;
        Arrays.sort(value);
        nbPrice = value;

Bonsoir,

private void addPriceColumn() {
        // Creation d'un tableau d'entier, qui aura pour dimension le tableau de nbPrice+1.
        int[] value = new int[nbPrice.length+1];
        // Copier le tableau nbprice dans le tableau value (en ne dépassent pas la taille 
        // du tableau nbprice et en partant de zero dans les deux tableaux).
        System.arraycopy(nbPrice, 0, value, 0, nbPrice.length);
        // Ajouter dans la dernière ligne du tableau value, la dernière valeur du tableau nbPrice en l'additionnant à 1.
        value[nbPrice.length] = nbPrice[nbPrice.length-1] + 1;
        // Trier le tableau par ordre croissant.
        Arrays.sort(value);
        // Placer le nouveau tableau dans nbprice.
        nbPrice = value;
    }

on crée un nouveau tableau int[] value = {0, 0, 0, 0}; plus grand que nbPrice.

On entre les valeurs de nbPrice dans ce nouveau tableau int[] value = {1, 2, 3, 0};

Pour finir on entre la dernière valeur en ajoutant 1 => int[] value = {1, 2, 3, 4};

On place ce nouveau tableau dans int[] nbPrice = {1, 2, 3, 4};

Il est vrai que le trie n'est pas obligatoire dans ce cas-là, mais on ne sait jamais si besoin vous savez le faire .

Le trie c'est faire qu'à partir du tableau int[] value = {4,2,3,1}; on sort le tableau suivant int[] value = {1,2,3,4};

Pour information, on ne peut pas modifier la taille d'un tableau, pour cette raison qu'il faut passer par le biais d'un autre tableau .

Bonne continuation.

Bonjour,

La méthode "nmColumn(Stringname)" se trouve déjà dans la classe JtableEditHead. Pour changer le nom des colonnes c'est aussi à partir de cette classe, c'est elle qui gère les colonnes. Vous ne connaissez pas vos classes et leur utilisation ?

Pas besoin de lire toutes les colonnes, JtableEditHead le fait.

Ne cherchez pas dans du compliquer.

Je pense que ceci pourra vous aider et vous allez voir j'ai très peu de ligne.

public class JTableEditHead extends JTableColumn {
     (...)
     public void modifName(String oldName, String newName) {
          for (String value : listEntete.keySet()) {
               if (listEntete.get(value).equals(oldName)) listEntete.put(value, newName);
          }
     }
     (...)
}

private void renameColumnPrice() {
     for (int i = 0; i < nbPrice.length; i++)
          table.modifName(columnPrice + nbPrice[i], texte.getText() + nbPrice[i]);
     columnPrice = texte.getText();
}

Ah oui, pourquoi commencer par i = 1 ? C'est un tableau on a besoin de toutes les valeurs. Vous n'avez pas compris le fonctionnement de nbPrice ? Désolé, en ce moment je n'ai pas trop le temps et je ne suis plus trop présent sur le forum.
Bonne continuation.

-
Edité par pctronique 22 septembre 2014 à 13:28:09

Bonsoir

Pour i=1 j'étais pas attentif je me suis laissé emporter par le commencement des prix 1;2; ect

Ce n'est pas necessaire de vous fatiguer sur cela. 

Oui parfois je cherche à faire  des choses compliquées.

Pour afficher une saisie au niveau de l'entéte de colonne il faut connaitre le numéro de l'entéte de colonne par la recupération de l'entéte de colonne ainsi la colonne  comme dans la classe JEditHeadColumn  par exemple.

public class JEditHeadColumn {   
 private final JTableHeader header; // initialisation
    private TableColumn column;// initialisation
(...)
 public JEditHeadColumn(JTable table) {
        header = table.getTableHeader(); // on recupére l'entéte de colonne
(...)
  }
    private void editColumnAt(Point p) {
        int columnIndex = header.columnAtPoint(p); // le numéro de l'entéte de colonne
 if (columnIndex != -1) {
if (isColumnEditable(columnIndex)) {
                column = header.getColumnModel().getColumn(columnIndex); // la colonne correspondant à l'entéte de colonne
(...)
}}}
 private void renameColumn() {
        column.setHeaderValue(text.getText());// on recupére ce qu'on'a saisi pour l'afficher 
(...)
}

Au niveau de la classe  JEditHeadColumn au recupére toute les colonnes par ce que  ça concerne tous le tableau

ce qui est  du saisi de texte pour l'afficher au niveau des entétes de colonne "prix x"  j'ai fais ceci.

 for (int i = 0; i < nbPrice.length; i++)
columnPriceEdit.setHeaderValue(texte.getText() + nbPrice[i]); 

"columnPriceEdit" je veux juste recupérer les colonnes et les entétes des colonne "Prix"comme dans la classe JEditHeadColumn (ici on recupére toutes les colonness et entétes de colonne du tableau) sauf que dans ce cas on espécifie seulement les colonnes "Prix".

J'ai fait plusieurs combinaison mais ça ne marche .Donc j'ai pensé à créer une methode qui traite seulement les entétes de colonne de "prix".

Je ne sais pas si je cherche loin mais je veux juste vous faire part de mes  idées commme ça on me comprendra mieux. 

-
Edité par mada96 23 septembre 2014 à 4:11:50

public class JTableEditHead extends JTableColumn {

    (...)
    public void modifName(String oldName, String newName) {
        JTableHeader header = this.getTableHeader();
        TableColumn column;
        for (String value : listEntete.keySet()) {
            if (listEntete.get(value).equals(oldName)) {
                int numcolumn = this.nmColumn(oldName);
                column = header.getColumnModel().getColumn(numcolumn);
                column.setHeaderValue(newName);
                listEntete.put(value, newName);
            }
        }
    }

    (...)
    public boolean isIntColumnName(int column, String name) {
        if (this.getColumnCount() <= column) return false;
        if (!listEntete.containsValue(name)) return false;
        for (String value : listEntete.keySet()) {
            if (listEntete.get(value).equals(name))
                return ((String)this.getColumnModel().getColumn(column).getHeaderValue()).equals(listEntete.get(value));
        }
        return false;
    }

    (...)
}

JTableColumn, c'est un tableau qui sert à ajouter ou insérer des colonnes. JEditHeadColumn sert à éditer les noms de colonne (d'une JTable ou de ces classes filles), mais les noms ne sont pas conservés pour du traitement. C'est juste visible au niveau du tableau, donc visuelle. JTableEditHead est un tableau avec les noms de colonne éditable, modifiable et pouvant être traité dans du code, donc c'est dans cette classe qu'il faut le faire, car il est toujours possible de changer les noms de colonne sans l'éditer. JTableEditHead utilise les deux classes (JTableColumn, JEditHeadColumn).

PS : Pour le moment vous avez ceci (j'ai supprimé les variables rowData et columnNames dans la classe JtableColumn, ils sont inutiles) :

C'est plus facile à comprendre avec un diagramme.
Ensuite, vous pouvez aussi ajouter une nouvelle classe comme ceci :

La classe ColumnNb prend en charge les colonnes suivies d'un numéro, pouvant augment par le nombre de colonne, comme les colonnes prix par exemple.
Bonne continuation.

-
Edité par pctronique 23 septembre 2014 à 18:44:13

Bonsoir 

Je crois bien qu'on ne se comprend pas. Oui j'explique mal !!!

On a ce tableau |Marchandise| prix1| prix2| prix3|prix moyenne| prix public| utilisation|apréciation des prix|

supposons juste que les entétes de colonnes des "prix"sont nom éditables en faisant une double clique.Ainsi essayons d'éditer les enététes de colonne "prix" de cette maniére en créant  au dessous du fenétre un JTextField  avec un nom comme "prix"  par défaut.Suivi d'un bouton ok comme ceci |Prix| bouton "ok"|

Maintenant voyons l'événement  que je veux créer avec le bouton "ok" suivant cette  exemple

Effaçons le nom "prix" par défaut  de notre JTextField et écrivons "achat" puis cliquons sur ok.On aura au nivveau des entétes de colonne ceci

 |Marchandise| achat 1|achat 2| achat 3|prix moyenne| prix public| utilisation|apréciation des prix|

En gros  voilà ce que je voulais expliquer au début si vous comprenez cette exemple.

Merci

Bonsoir,

Vous avez essayé la nouvelle classe JTableEditHead avec la modification des deux méthodes et ceci dans la classe tableur6 :

private void renameColumnPrice() {
     for (int i = 0; i < nbPrice.length; i++)
          table.modifName(columnPrice + nbPrice[i], texte.getText() + nbPrice[i]);
     columnPrice = texte.getText();
}

private void okPriceActionPerformed(ActionEvent e) {
     renameColumnPrice();
     table.placeColumn();
}

Remplacer "prix" par "achat" dans JTextField et appuyer sur ok, si vous voulez pour tester, mais c'est ce que fait le code . Donc j'avais bien compris .

-
Edité par pctronique 23 septembre 2014 à 20:34:43

Bonsoir

J'ai bien inséré ce code au bon endroit mais ça ne me donne pas d'effet. Je voulais savoir si ça marche au niveau de votre programme.

Merci

-
Edité par mada96 24 septembre 2014 à 18:22:30

Bonsoir,

Voici le test de ce code :

Si sa ne fonctionne pas vers vous, c'est qu'il y a un problème au niveau de votre code. Vous pouvez toujours me transmettre vos classes par message mp (pour que je regarde).

Bonne continuation.

Bonsoir

Vraiment je suis désolé .C'est juste au moment où j'ai modifié la classe JTableEditHead pour faire fonctionner les noms des entétes de colonne au niveau du code . L'ordinateur s'est éteint  alors que les modiffications n'étaient pas enregistrées .Quand je l'ai rallumé  j'avais cru faire ces modifications au niveau de cette classe alors que ce n'était pas le cas.Je m'en excuse vraiment  .C'est cette erreur qui enpéchait le code de marcher.

Au niveau de la classe "ColumnNb" il me reste à faire les instructions. Voici le code .

Est necessaire de passer par le biais d'une autre tableau  dans cette classe comme ce qu'on a fait au début.

Voici le code

/**
 * 
 * @author mada96
 *
 */
public class ColumnNb {
int [] nb;
String nameColumn;
JTableEditHead table;
/**
 * 	
 * @param naneColumn
 */
public ColumnNb(String naneColumn){
	
}
/**
 * 
 * @param nameColumn
 * @param nb
 */
public ColumnNb(String nameColumn,int [] nb){
	
}
/**
 * 
 * @param table
 */
public void table(JTableEditHead table){
}
/**
 * 
 * @return
 */
public String name(){

}
/**
 * 
 * @param nameColumn
 */
public void renameTabColumnNb(String nameColumn){
	
}
/**
 * Vérifie que la colonne est suivie de numéro
 * @param colonne la colonne
 * @return si oui : colonne numérotée
 */
public boolean isTabColumn(int colonne){
	return true;
}
/**
 * Supprime la colonne numérotée
 * @param column  colonne numérotée 
 */
public void removeTabColumn(int column){
	
}
/**
 * ajoute une colonne numérotée
 */
public void addTabColumn(){
	
}
/**
 * 
 * @return
 */
public int length(){
	
}
/**
 * 
 * @param column
 * @return
 */
public int intTabNb(int column){

/**
 * 	
 */
public void addColumn(){
	
}
/**
 * 
 * @param number
 */
public void delColumn(int number){
	
}
}
/**
 * 
 * @return
 */
public int [] arrayNb(){
	
}
/**
 * 
 * @return
 */
public String[] nameNb(){
	
}
}

-
Edité par mada96 25 septembre 2014 à 3:23:56

Bonjour,

Ce n'est pas une classe de tableau, mais une classe pour modifier les colonnes d'un tableau;).

Ensuite, non ce n'est pas obligé de le faire, mais vous travaillez à deux sur le programme (bon deux ce n'est pas beaucoup, c'est moins qu'une vingtaine de personnes ), mais faut penser au développeur final qui va assembler les codes. Si, il doit récupérer des codes un peu partout, c'est risque d'erreur et c'est une perte de temps en plus . Imaginer une vingtaine de personnes avec 400 lignes de codes chacun à récupérer (et encore 400 car je suis gentil ). Alors que si vous fournissez par exemple : mada86table-lib.jar (bibliothèque), mada86table-src.jar (la source), mada86table-doc.jar (la documentation) et mada86table-uml-classe.jpeg (le diagramme des classes). Si vous avez envie vous pourriez aussi fournir la classe "Tableur6.java" pour l'aider, ce sera plus simple. Ensuite, en développement, il y a une chose importante, un développeur c'est un fainéant (mes prof, qui me le disait ), dans le sens que lorsqu'il conçoit du code, celui-ci peut-être ré-utilisé dans d'autre programme. C'est justement le cas des classes "JTableEditHead", "JTableColumn", "JEditHeadColumn", mais aussi pour la classe "ColumnNb". Je m'explique, si un jour vous voulez faire :

|bibliothèque 1|bibliothèque 2|bibliothèque 3|tintin 1|tintin 2|tintin 3|

Les colonnes bibliothèques et tintins ressemblent fort aux colonnes prix, donc refaire le code pour les deux seraient ridicules, vu qu'il a déjà été fait pour les colonnes prix. Je ne sais pas si vous comprenez, mais je le redis, la classe "ColumnNb", n'est pas obligatoire, c'est à vous de voir.

Ensuite, vous fournissez le diagramme suivant, sans la classe "JTable" et la classe "Tableur6", qui sont seulement là pour aider, mais doit pas apparaître dans le diagramme final. Si vous laissez la classe "JTable", ce n'est pas grave dans le diagramme des classes, mais tableur6, non par contre (c'est la classe de test). Si vraiment vous n'arrivez pas ce n'est pas si grave, c'est juste une idée .

Ce n'est pas une obligation, seulement un conseil. Vous retrouvez les méthodes dans la classe "tableur6"  pour créer la classe "ColumnNb".

Bonne continuation.

Bonsoir

J'ai entendu dire qu'on peut avoir plus de 1.000 lignes de code .J'avais du mal à le croire.Peut étre un jour je pourrai dépasser 1.000 lignes

Merci pour les diagrammes.Je voit bien leurs utilités .Au par avant je ne savais pas lire ni utiliser les diagrammes.

Je crois bien que la classe  "ColumnNb" peut aider "Vieux96" à simplifier ces calculs et ça permet de reduire le nbre de ligne de code au niveau de la classe "tableur6".Au niveau des méthodes "addPriceColumn()" et "delPriceColumn()" de la classe "tableur6" on voit l'intervention de la table "nbPrice = new int[]{1, 2, 3}".Mon probléme est qu'est-il nécessaire d'intervenir la table "nbPrice" dans les méthodes "removeTabColumn(int column)";"addTabColumn";"length" et "intTabNb" de la clase "ColumnNb"  ou bien juste créer une table "nbPrice" dans la classe "ColumnNb".Par défaut il doit avoir trois colonne "prix" au niveau du tableau.

Merci

Bonjour,

Oui c'est possible, j'ai même retrouvé une de mes classes java avec 4859 lignes de code  et je crois que j'ai déjà fait pire. Là je parle de java, je ne parle même pas dans les autres langages. Et encore, il est possible de trouver des classes avec plus de 6000 lignes de code. En général mes classes ne dépassent pas 800 lignes. Mais on ne conçoit pas un programme au niveau des lignes de codes (pas vraiment), mais on le fait de la façon à pouvoir faire la maintenance derrière. Si la classe est conçue avec plus de 6000 lignes de codes et qu'on puisse faire la maintenance derrière, ce n'est pas un problème, sinon la classe et le code sont inutiles.

les méthodes removeTabColumn(int column), addTabColumn(), intTabNb(int column) de la classe ColumnNb font partie (une ligne ou la totalité) des méthodes supActionPerformed(ActionEvent e), ajoutActionPerformed(ActionEvent e), intPrice(int column) de la classe Tableur6, donc oui vous allez devoir utiliser nbPrice qui a pour nom, dans la classe ColumnNb : nb. la méthodes lenth() retourne le nombre de linge de la table nbPrice (nb). Attention la classe ColumnNb n'est pas conçut pour seulement les colonnes prix, donc pas obligé de partir avec trois. Je ne suis pas partie avec 3, mais 1, car c'est le minimum . Mais vous pouvez partir avec 3, c'est un choix, mais ne pensait pas aux colonnes prix. Pour cette raison que j'ai renommée la variable nbPrice en nb. la méthode namesNb(), c'est namesNb[i] = nameNb + nb[i].

public ColumnNb(String nameColumn) {
     this(nameColumn, new int[]{1});
}
    
public ColumnNb(String nameColumn, int[] nb) {
     this.nb = nb;
     this.nameNb = nameColumn;
}

Dans le diagramme (pour information) :

+nb: int[] (au niveau du code : public int[] nb;).

-nb: int[] (au niveau du code : private int[] nb;).

#nb: int[] (au niveau du code : protected int[] nb;).

Même chose pour les méthodes.

Bonne continuation.

Bonsoir

Merci pour la signification de ces symboles.

Il faut avoir plusieurs connaisssances pour faire ces lignes kilométriques de code.

J'esssaye depuis ce matin  de combiner les codes de la classe "Tableur6" au niveau de la classe "ColumnNb" mais je suis confronté à plusieurs  problémes.Juste puis-je  avoir les méthodes removeTabColumn(int column), addTabColumn(), intTabNb(int column) et private void addColumn()  car  la table "nbPice" au niveau  de la classe "Tableur6" me perturbe beaucoups. 

Merci

Bonsoir,

Non ça dépend surtout du programme à construire. Ca va vite pour avoir des lignes de code. Sinon c'est aussi des tonnes de classes, donc même pour construire les classes, ça fait déjà pas mal de code.

import java.util.Arrays;

/**
 * 
 * @author pctronique
 */
public class ColumnNb {
    
    public int[] nb;
    private String nameNb;
    private JTableEditHead table;
    
    public ColumnNb(String nameColumn) {
        this(nameColumn, new int[]{1});
    }
    
    public ColumnNb(String nameColumn, int[] nb) {
        this.nb = nb;
        this.nameNb = nameColumn;
    }
    
    public void table(JTableEditHead table) {
        this.table = table;
    }
    
    public String name() {
        return this.nameNb;
    }
    
    public void renameTabColumnNb(String newName) {
        for (int i = 0; i < nb.length; i++)
            table.modifName(nameNb + nb[i], newName + nb[i]);
        nameNb = newName;
    }
    
    public boolean isTabColumn(int colonne) {
        for (int price : nb)
            if (colonne == table.nmColumn(nameNb + price)) return true;
        return false;
    }
    
    public void removeTabColumn() {
        String name = nameNb + nb[nb.length - 1];
        removeTabColumn(table.nmColumn(name));
    }
    
    public void removeTabColumn(int column) {
        delColumn(intTabNb(column));
        table.removeColumn(column);
    }
    
    public void addTabColumn() {
        int column = 0;
        for (int j = 0; j < table.getColumnCount(); j++) {
            if (table.isIntColumnName(j, nameNb + nb[nb.length-1])) column = j + 1;
        }
        addColumn();
        String name= nameNb + (nb[nb.length-1]);
        table.insertColumn(column, name);
    }
    
    public int length() {
        return nb.length;
    }
    
    public int intTabNb(int column) {
        String name = table.nameColumn(column);
        for (int value : nb)
            if (name.equals(nameNb + value)) return value;
        return 0;
    }
    
    private void addColumn() {
        int[] value = new int[nb.length+1];
        System.arraycopy(nb, 0, value, 0, nb.length);
        value[nb.length] = nb[nb.length-1] + 1;
        Arrays.sort(value);
        nb = value;
    }
    
    private void delColumn(int number) {
        int[] value = new int[nb.length-1];
        int j = 0;
        for (int i = 0; i < nb.length-1; i++) {
            if (number == nb[j]) j++;
            value[i] = nb[j];
            j++;
        }
        Arrays.sort(value);
        nb = value;
    }
    
    public int[] arrayNb() {
        return this.nb;
    }
    
    public String[] namesNb() {
        String[] names = new String[nb.length];
        for (int i = 0; i < nb.length; i++)
            names[i] = nameNb + nb[i];
        return names;
    }
    
}

Je vous laisse mettre les commentaires et faire la comparaissons avec "tableur6".

Bonne continuation.

Pourtant vos profs ont raison dans le bon sens(un développeur est un fainéant) car ce n'est pas facile de laisser courir ses doight sur le clavier pendant un certain bout de temps pour saisir des milliers  de lignes  de code. Si un programmeur a plusieurs classes qui lui permet de faire des taches diverses et sait bien les manupiler ça pourra lui faciliter le travail pour concevoir une application par exemple ou faire beaucoup de choses.

La différence que j'ai notée entre la classe"ColumnNb" et "Tableur6" est seulement le remplacement de "nbPrice" par "nb"mais avec quelques rajustement au niveau de la classe "ColumnNb".ça explique le perturbement que j'avais au niveau du table "nbPrice" dans la classe "ColumnNb".

Et cette perturbation me poursuit jusqu'à la déclaration des entétes de colonne.

//Les titres des colonnes
        String[]  theTitle = {columnMarchandisee, columnPoid+  nameNb+nb[1] + columnUtilisation};

Je n'arrive pas à introduire les méthode méthodes "table";"renameTabColumn"et "addTabColumn" dans la classse "Tableur6" puisse que "nameNb" et "nb"ne ont pas dans la classe"Tableur6"

Je n'arrive pas aussi à bien commenter ceci

/**
 * 	
 * @param naneColumn
 */
public ColumnNb(String nameColumn){
	   this(nameColumn, new int[]{1});
	 }
/**
 * 
 * @param nameColumn
 * @param nb
 */
public ColumnNb(String nameColumn,int [] nb){
	 this.nb = nb;
     this.nameNb = nameColumn;	
}
/**
 * 
 * @param table
 */
public void table(JTableEditHead table){
	  this.table = table;
}
/**
 * 
 * @return
 */
public String name(){
	  return this.nameNb;
}

Merci

String[] theTitle = {columnMarchandisee, columnPoid, columnPrice + "1",
     columnPrice + "2", columnPrice + "3", columnUtilisation};

String[] theTitle = {columnMarchandisee, columnPoid+ nameNb+nb[1] + columnUtilisation};

private ColumnNb columnsPrice;

columnsPrice = new ColumnNb("prix ", new int[]{1, 2, 3});

//Les titres des colonnes
String[] namesColumnPrice = columnsPrice.namesNb();
String[]  theTitle = {columnMarchandisee, columnPoid, namesColumnPrice[0],
     namesColumnPrice[1], namesColumnPrice[2], columnUtilisation};

table = new JTableEditHead(data, theTitle){
     public boolean isTableColumnEditable(int colIndex) {
          if(columnsPrice.isTabColumn(colIndex)) return false;
          if (table.columnContains(columnMarchandisee))
               return colIndex != table.nmColumn(columnMarchandisee);
          else return true;
     }

     public boolean isCellEditable(int rowIndex, int colIndex) {
          return tableIsCellEditable(rowIndex, colIndex);
     }
};
columnsPrice.table(table);

Bonne continuation.

Bonjours

J'ai essayer de documenter la classe "ColumnNb".Ce n'est pas trés complete juste des idées incomplets.

Voici les commentaires

import java.util.Arrays;

import javax.swing.JTable;

/**
 * 
 * @author mada96
 *
 */
public class ColumnNb {
private int [] nb;
private String nameNb;
JTableEditHead table;
/**
 * 	avoir le nom de colonne
 * @param naneColumn nom de colonne
 */
public ColumnNb(String nameColumn){
	   this(nameColumn, new int[]{1});
	 }
/**
 * avoir la colonne numérotée
 * @param nameColumn nom du colonne numérotée
 * @param nb numérotation du colonne correpondante
 */
public ColumnNb(String nameColumn,int [] nb){
	 this.nb = nb;
     this.nameNb = nameColumn;	
}
/**
 * fonctionner les colonnes numérotées dans le tableau
 * @param table le tableau
 */
public void table(JTableEditHead table){
	  this.table = table;
}
/**
 * avoir le nom du colonne numérotée
 * @return recupère la colonne numérotée
 */
public String name(){
	  return this.nameNb;
}
/**
 * Renomme le nom des colonnes numérotées
 * @param newName nouveau nom remplaçant
 */
public void renameTabColumnNb(String newName){
	 for (int i = 0; i < nb.length; i++)
         table.modifName(nameNb + nb[i], newName + nb[i]);
     nameNb = newName;
	
}
/**
 * Vérifie que la colonne est suivie de numéro
 * @param colonne la colonne à vérifier
 * @return si oui : colonne numérotée
 */
public boolean isTabColumn(int colonne){
	for (int price : nb)
        if (colonne == table.nmColumn(nameNb + price)) return true;
    return false;

}
/**
 * Supprime la colonne numérotée
 * @param column  colonne numérotée 
 */
public void removeTabColumn(int column){
	 String name = nameNb + nb[nb.length - 1];
     removeTabColumn(table.nmColumn(name));
}
/**
 * insert une colonne numérotée
 */
public void addTabColumn(){
	int column = 0;
    for (int j = 0; j < table.getColumnCount(); j++) {
        if (table.isIntColumnName(j, nameNb + nb[nb.length-1])) column = j + 1;
    }
    addColumn();
    String name= nameNb + (nb[nb.length-1]);
    table.insertColumn(column, name); 
}
/**
 * avoir la numérotation
 * @return recupère le numéros
 */
public int length(){
	   return nb.length;
}
/**
 * retrouve le numéro de la colonne numérotée
 * @param column numéro de la colonne du tableau
 * @return recupère le numéro de la colonne numérotée
 */
public int intTabNb(int column){
	   String name = table.nameColumn(column);
       for (int value : nb)
           if (name.equals(nameNb + value)) return value;
       return 0;
	
}

/**
 * 	Ajoute le numéro du colonne numérotée dans le table
 */
private void addColumn(){
	 int[] value = new int[nb.length+1];
     System.arraycopy(nb, 0, value, 0, nb.length);
     value[nb.length] = nb[nb.length-1] + 1;
     Arrays.sort(value);
     nb = value;
	
}
/**
 * Supprime le numéro du colonne numérotée dans le table
 * @param number numéro des colonnes numérotées
 */
private void delColumn(int number){
	  int[] value = new int[nb.length-1];
      int j = 0;
      for (int i = 0; i < nb.length-1; i++) {
          if (number == nb[j]) j++;
          value[i] = nb[j];
          j++;
      }
}

/**
 * retrouve l'ordre des numéros
 * @return recupère l'ordre des numéros
 */
public int [] arrayNb(){
	  return this.nb;
}
/**
 * retrouve le nom du colonne numérotée
 * @return recupère le nom 
 */
public String[] namesNb(){
	  String[] names = new String[nb.length];
      for (int i = 0; i < nb.length; i++)
          names[i] = nameNb + nb[i];
      return names;

}
}

Je vous écoute pour voir les rectifications à faire.

Merci

Effectivement ce n'est pas très clair et vous avez du mal avec les méthodes définies. Si vous voulez, vous pouvez changer les noms, si ça peut vous aider. J'ai juste, repris les noms de la classe Tableur6 et juste, modifié un peu leur nom ;).

/**
 * Constructeur par référence.
 * Donner un nom de base aux colonnes numéroté.
 * Ce nom sera suivi d'un numéro pour chaque colonne créer par cette classe.
 */
public ColumnNb(String nameColumn){}
/**
 * Constructeur par référence.
 * Donner un nom de base aux colonnes numéroté.
 * Ce nom sera suivi d'un numéro pour chaque colonne créer par cette classe.
 * Définir les numéros de bases, qui sera mis après le nom.
 */
public ColumnNb(String nameColumn,int [] nb){}
/**
 * Définir le tableau où on va ajouter les colonnes numérotés et
 * faire les modifications ou ajoute de colonne numéroté.
 */
public void table(JTableEditHead table){}
/**
 * avoir le nom de la colonne numérotée sans le numéro.
 */
public String name(){}
/**
 * Renomme le nom des colonnes numérotées
 * Attention : une table doit être défini par la méthode table(JTableEditHead table).
 */
public void renameTabColumnNb(String newName){}
/**
 * Vérifie que la colonne fait bien partie d'une colonne numéroté défini par la classe.
 * Attention : une table doit être défini par la méthode table(JTableEditHead table).
 */
public boolean isTabColumn(int colonne){}
/**
 * Supprime la colonne numérotée
 * Attention : une table doit être défini par la méthode table(JTableEditHead table).
 */
public void removeTabColumn(int column){}
/**
 * insert une colonne numérotée.
 * Attention : une table doit être défini par la méthode table(JTableEditHead table).
 */
public void addTabColumn(){}
/**
 * Connaître le nombre de colonne numéroté.
 */
public int length(){}
/**
 * retrouve le numéro qui suit le nom de la colonne numérotée
 * Attention : une table doit être défini par la méthode table(JTableEditHead table).
 */
public int intTabNb(int column){}
/**
 * Crée un nouveau numéro pour la création d'une nouvelle colonne numérotée.
 */
private void addColumn(){}
/**
 * Supprime le numéro de la colonne numérotée lorsque celle-ci est supprimé de la table
 */
private void delColumn(int number){}
/**
 * retourne les numéros des colonnes numéroté.
 */
public int [] arrayNb(){}
/**
 * retourne les noms des colonnes numérotées.
 */
public String[] namesNb(){}

Par contre, je ne comprends pas trop :

import javax.swing.JTable;

On n'utilisera sûrement pas JTable, sinon faudrait revoir tout le programme. De plus, on utilise JTable par le biais de la classe JTableEditHead.
Bonne continuation.