Colonne déplacée événement [terminé] dans JTable

Question

Comment dois-je détecter que l'action déplacée par colonne est terminée dans JTable? J'ai ajouté columnModeListener à mon modèle de colonne, mais le problème est que la méthode columnMoved est appelée chaque fois qu'une colonne se déplace (par certains pixels). Je ne veux pas de ce comportement. Je veux juste détecter quand le déplacement de la colonne est terminé.

columnModel.addColumnModelListener(new TableColumnModelListener() { 

      public void columnAdded(TableColumnModelEvent e) { 
      } 

      public void columnRemoved(TableColumnModelEvent e) { 
      } 

      public void columnMoved(TableColumnModelEvent e) { 
       //this is called so many times 
       //I don't want this, but something like column moved finished event 
       System.out.println("Moved "+e.getFromIndex()+", "+e.getToIndex()); 
      } 

      public void columnMarginChanged(ChangeEvent e) { 
      } 

      public void columnSelectionChanged(ListSelectionEvent e) { 
      } 
     }); 

J'espère que ce que je cherche est clair. Merci.

Answer 1

C'est ce que j'ai fini par faire. Je sais qu'il est sale, mais il convient pour ce que je suis à la recherche:

boolean dragComplete = false; 
     apTable.getTableHeader().addMouseListener(new MouseAdapter() { 
      @Override 
      public void mouseReleased(MouseEvent e) { 
       if (dragComplete) { 
        System.out.println("Drag completed"); 
       } 
       dragComplete = false; 
      } 
     }); 
     columnModel.addColumnModelListener(new TableColumnModelListener() { 

      public void columnAdded(TableColumnModelEvent e) { 
      } 

      public void columnRemoved(TableColumnModelEvent e) { 
      } 

      public void columnMoved(TableColumnModelEvent e) { 
       dragComplete = true; 
      } 

      public void columnMarginChanged(ChangeEvent e) { 
      } 

      public void columnSelectionChanged(ListSelectionEvent e) { 
      } 
     }); 

Answer 2

Si je vous comprends bien, peut-être que vous voulez regarder les écouteurs de la souris. Peut-être l'événement MOUSE_RELEASED?

Answer 3

Voici une classe interne que j'utilise pour déterminer quand l'ordre des colonnes a changé. Notez que l'utilisateur n'a peut-être pas lâché la souris à ce stade, donc le glissement peut continuer plus loin.

private class ColumnUpdateListener implements TableColumnModelListener { 

    int lastFrom = 0; 
    int lastTo = 0; 

    private void verifyChange(int from, int to) { 
     if (from != lastFrom || to != lastTo) { 
     lastFrom = from; 
     lastTo = to; 

     /////////////////////////////////////// 
     // Column order has changed! Do something here 
     /////////////////////////////////////// 
     } 
    } 

    public void columnMoved(TableColumnModelEvent e) { 
     verifyChange(e.getFromIndex(), e.getToIndex()); 
    } 

    public void columnAdded(TableColumnModelEvent e) { 
     verifyChange(e.getFromIndex(), e.getToIndex()); 
    } 

    public void columnRemoved(TableColumnModelEvent e) { 
     verifyChange(e.getFromIndex(), e.getToIndex()); 
    } 

    public void columnMarginChanged(ChangeEvent e) {} 
    public void columnSelectionChanged(ListSelectionEvent e) {} 

}

Il a bien fonctionné pour moi.

Answer 4

Cela pourrait être une meilleure approche:

table.setTableHeader(new JTableHeader(table.getColumnModel()) { 

     @Override 
     public void setDraggedColumn(TableColumn column) { 
     boolean finished = draggedColumn != null && column == null; 
     super.setDraggedColumn(column); 
     if (finished) { 
      onColumnChange(table); // Handle the event here... 
     } 
     } 
    }); 

Answer 5

C'est ce qui fonctionne pour moi (les deux mouvements de la colonne et redimensionne de marge):

Je tends la table et passer outre les columnMoved et columnMarginChanged méthodes de la façon suivante:

... d'abord ajouter s les variables ertains pour l'état garder

private int lastMovementDistance = 0; 
private boolean bigMove = false; 
private boolean resizeBegan = false; 

...

@Override 
public void columnMarginChanged(ChangeEvent e) { 
    super.columnMarginChanged(e); 
    if (isShowing()){ 
     resizeBegan = true; 
    } 
} 

@Override 
public void columnMoved(TableColumnModelEvent e) { 
    super.columnMoved(e); 

    //this will be set to 0 when the column is dragged 
    //to where it should begin if released  
    lastMovementDistance = Math.abs(getTableHeader().getDraggedDistance()); 


    if (e.getFromIndex() != e.getToIndex()){ 
    //note, this does not guarantee that the columns will be eventually 
    //swapped - the user may move the column back. 
    //but it prevents us from reacting to movements where 
    //the user hasn't even moved the column further then its nearby region. 
    //Works for me, because I don't care if the columns stay the same 
    //I only need the updates to be infrequent and don't want to miss 
    //changes to the column order 
bigMove = true; 
    } 
} 

... puis dans le constructeur de ma table je fais ceci:

public MyTable(){ 

    ... 

getTableHeader().addMouseListener(new MouseAdapter(){ 

    public void mouseReleased(MouseEvent evt) { 
     if (bigMove && lastMovementDistance == 0){ 
     //react! the tables have possibly switched! 
     } 

      else if (resizeBegan){ 
    //react! columns resized 
     } 

     resizeBegan = false; 
     bigMove = false; 
} 
}); 
    ... 
} 

Il est un peu comme un hack, Mais cela fonctionne pour moi.

Answer 6

Toutes les réponses échouent à un cas d'utilisation: si la table est dans une disposition remplissant toute la fenêtre, le redimensionnement de la fenêtre redimensionne la table et donc ses colonnes. En observant les événements de la souris sur les en-têtes de colonne, nous ne recevons pas l'événement lorsque l'utilisateur redimensionne la fenêtre.

J'ai regardé le code source JTable & et la méthode columnMarginChanged() est toujours appelée dans une sous-sous-sous-fonction ... appelée par JTable.doLayout(). Ensuite, ma solution est de surveiller les appels à doLayout() qui déclenchent au moins un columnMarginChanged().

En fait, columnMarginChanged() est appelé pour chaque colonne.

Voici ma solution:

private class ResizableJTable extends JTable { 

    private TableColumnModelListener columnModelListener; 

    private boolean columnsWereResized; 

    @Override 
    public void setColumnModel(TableColumnModel columnModel) { 
     if (getColumnModel() != null) { 
      getColumnModel().removeColumnModelListener(columnModelListener); 
      columnModelListener = null; 
     } 

     if (columnModel != null) { 
      columnModelListener = new TableColumnModelListener() { 

       public void columnSelectionChanged(ListSelectionEvent e) { 
        // Nothing to do 
       } 

       public void columnRemoved(TableColumnModelEvent e) { 
        // Nothing to do 
       } 

       public void columnMoved(TableColumnModelEvent e) { 
        // Nothing to do 
       } 

       public void columnMarginChanged(ChangeEvent e) { 
        columnsWereResized = true; 
       } 

       public void columnAdded(TableColumnModelEvent e) { 
        // Nothing to do 
       } 
      }; 

      columnModel.addColumnModelListener(columnModelListener); 
     } 

     super.setColumnModel(columnModel); 
    } 

    @Override 
    public void doLayout() { 
     columnsWereResized = false; 
     super.doLayout(); 
     if (columnsWereResized) { 
      onColumnsResized(); 
     } 
    } 

    /** 
    * Sub-classes can override this method to 
    * get the columns-were-resized event. 
    * By default this method must be empty, 
    * but here we added debug code. 
    */ 
    protected void onColumnsResized() { 
     int[] columnSizes = getColumnSizes(); 
     String sizes = ""; 
     for (int i : columnSizes) { 
      sizes += i + " "; 
     } 
     System.out.println("COLUMNS RESIZED: [ " + sizes + "]"); 
    } 

    protected int[] getColumnSizes() { 
     TableColumnModel columnModel = getTableHeader().getColumnModel(); 
     int columnCount = columnModel.getColumnCount(); 
     int[] columnSizes = new int[columnCount]; 

     for(int i = 0; i < columnCount; i++) { 
      TableColumn column = columnModel.getColumn(i); 
      columnSizes[i] = column.getWidth(); 
     } 

     return columnSizes; 
    } 
} 

Answer 7

Belle réponse sur votre question ashokgelal. Juste un peu d'amélioration je pense. Votre code se déclenche également en un seul clic sur l'en-tête. En utilisant un drapeau supplémentaire, vous pouvez empêcher le déclencheur 'dragComplete' quand la colonne n'a pas vraiment changé. Code modifié:

boolean mDraggingColumn = false; 
    boolean mColumnCHangedIndex = false; 

    tblObjects.getTableHeader().addMouseListener(new MouseAdapter() { 
     @Override 
     public void mouseReleased(MouseEvent e) { 
      if (mDraggingColumn && mColumnCHangedIndex) { 
       System.out.println("Column changed"); 
      } 
      mDraggingColumn = false; 
      mColumnCHangedIndex = false; 
     } 
    }); 
    tblObjects.getColumnModel().addColumnModelListener(new TableColumnModelListener() { 
     @Override 
     public void columnAdded(TableColumnModelEvent e) {} 
     @Override 
     public void columnRemoved(TableColumnModelEvent e) {} 
     @Override 
     public void columnMoved(TableColumnModelEvent e) { 
      mDraggingColumn = true; 
      if (e.getFromIndex() != e.getToIndex()) { 
       mColumnCHangedIndex = true; 
      } 
     } 
     @Override 
     public void columnMarginChanged(ChangeEvent e) {} 
     @Override 
     public void columnSelectionChanged(ListSelectionEvent e) {} 
    });