@Override public void rebuildTableModel() { SortKey sortKey = this.getSortKey(); columnTitles.clear(); columnTitles.add(DEFAULT_TIME_COLUMN_TITLE); // Remember the current width of the table columns Vector<Integer> columnWidths = this.getColumnWidths(); // Rebuild the table model this.tableModelDataVector = new TableModelDataVector(TimeSeries.class.getSimpleName(), this.tableModelDataVector.isActivateRowNumber(), this.tableModelDataVector.getKeyColumnIndex()); List chartDataSeries = this.parentDataModel.getOntologyModel().getChartData(); for (int i = 0; i < chartDataSeries.size(); i++) { DataSeries chartData = (DataSeries) chartDataSeries.get(i); this.addSeries(chartData, false); } // Set the width of the columns like before this.setColumnWidths(columnWidths); this.setSortKey(sortKey); }
/** * Overloaded to return an icon suitable to the primary sorted column, or * null if the column is not the primary sort key. * * @param table the <code>JTable</code>. * @param column the column index. * @return the sort icon, or null if the column is unsorted. */ protected Icon getIcon(JTable table, int column) { SortKey sortKey = getSortKey(table, column); if (sortKey != null && table.convertColumnIndexToView(sortKey.getColumn()) == column) { switch (sortKey.getSortOrder()) { case ASCENDING: return UIManager.getIcon("Table.ascendingSortIcon"); case DESCENDING: return UIManager.getIcon("Table.descendingSortIcon"); default: // Just to remove unmatched case warning } } return null; }
public void setSelectedAccount(Account account) { if (this.selectedAccount == null || ! this.selectedAccount.getId().equals(account.getId())) { this.selectedAccount = account; setTitle(account); transactionTable.getModel().removeTableModelListener(tableModelListener); transactionTable.getModel().removePropertyChangeListener(TransactionTableModel.NEW_TRANSACTION_PAYEE_PROPERTY, payeeChangeListener); TransactionTableModel newModel = transactionModelCache.getModel(account); transactionTable.setModel(newModel); transactionTable.getRowSorter().setSortKeys(Collections.singletonList(new SortKey(0, SortOrder.ASCENDING))); newModel.addTableModelListener(tableModelListener); newModel.addPropertyChangeListener(TransactionTableModel.NEW_TRANSACTION_PAYEE_PROPERTY, payeeChangeListener); ComponentBinder.bind(newModel, TransactionTableModel.CLEARED_BALANCE_PROPERTY, newModel.getClearedBalance(), clearedBalance, currencyFormat); if (transactionTable.getModel().getBeans().isEmpty()) { refreshAction.actionPerformed(new ActionEvent(this, RefreshAction.INITIAL_LOAD_ACTION_ID, null)); } else { transactionTable.selectLastTransaction(); } firePropertyChange(ACCOUNT_PROPERTY, null, selectedAccount); } }
public AccountSecuritiesPanel(ServiceLocator serviceLocator, DomainEventPublisher domainEventPublisher, Iterable<SecurityTableExtension> tableExtensions, FinanceTableFactory tableFactory, WindowEventPublisher<WindowType> windowEventPublisher) { this.assetOperations = serviceLocator.getAssetOperations(); this.windowEventPublisher = windowEventPublisher; AccountSecurityTableModel tableModel = new AccountSecurityTableModel(domainEventPublisher, tableExtensions); table = tableFactory.createTable(tableModel); SectionTableRowSorter<SecuritySummary, AccountSecurityTableModel> sorter = new SectionTableRowSorter<>(table); sorter.setRowFilter(SecuritySummary::isNotEmpty); sorter.setSortKeys(Lists.newArrayList(new SortKey(AccountSecurityTableModel.NAME_INDEX, SortOrder.ASCENDING))); table.setRowSorter(sorter); reloadAction = new ReloadActionHandler(); setLayout(new BorderLayout()); add(BorderLayout.CENTER, new JScrollPane(table)); // for (SecurityTableExtension extension : tableExtensions) { // if (extension instanceof TableSummary) { // addSummaries((TableSummary) extension); // } // } reloadHandler = new ReloadEventHandler<>(this, RELOAD_MESSAGE_KEY, assetOperations::getSecuritySummariesByAccount, this::getTableModel, SecuritySummary::isSameIds); domainEventPublisher.register(SecuritySummary.class, reloadHandler); }
@Test public void newTransactionAlwaysLast() throws Exception { TransactionTableModel model = new TransactionTableModel(new Account(1L)); TransactionTable table = new TransactionTable(model); model.addBean(newTransaction(1L)); model.addBean(newTransaction(null)); model.addBean(newTransaction(2L)); TransactionTableRowSorter sorter = new TransactionTableRowSorter(table); sorter.setSortKeys(Collections.singletonList(new SortKey(1, SortOrder.ASCENDING))); assertThat(sorter.convertRowIndexToView(0)).isEqualTo(0); assertThat(sorter.convertRowIndexToView(1)).isEqualTo(1); assertThat(sorter.convertRowIndexToView(4)).isEqualTo(2); assertThat(sorter.convertRowIndexToView(5)).isEqualTo(3); assertThat(sorter.convertRowIndexToView(2)).isEqualTo(4); assertThat(sorter.convertRowIndexToView(3)).isEqualTo(5); sorter.toggleSortOrder(1); assertThat(sorter.convertRowIndexToView(0)).isEqualTo(2); assertThat(sorter.convertRowIndexToView(1)).isEqualTo(3); assertThat(sorter.convertRowIndexToView(4)).isEqualTo(0); assertThat(sorter.convertRowIndexToView(5)).isEqualTo(1); assertThat(sorter.convertRowIndexToView(2)).isEqualTo(4); assertThat(sorter.convertRowIndexToView(3)).isEqualTo(5); }
@Override public JComponent createPageComp() { final BorderPanel p = new BorderPanel(); final XTable table = new XTable(); final Vector< Vector< Object > > data = new Vector<>(); final Properties props = System.getProperties(); // Use name enumeration which properly returns names from the default properties of a property // (while HashTable.entrySet() does not!). final Enumeration< ? > nameEnum = props.propertyNames(); while ( nameEnum.hasMoreElements() ) { final Object name = nameEnum.nextElement(); data.add( Utils.vector( name, props.getProperty( name.toString() ) ) ); } table.getXTableModel().setDataVector( data, Utils.vector( "Property name", "Property value" ) ); table.getRowSorter().setSortKeys( Arrays.asList( new SortKey( 0, SortOrder.ASCENDING ) ) ); table.packColumnsExceptLast(); p.addCenter( table.createWrapperBox( true, table.createToolBarParams( p ) ) ); return p; }
private void updateClusterTable() { int index = annotationSetCombo.getSelectedIndex(); AnnotationSet annotationSet = annotationSetCombo.getItemAt(index).getValue(); ClusterTableModel clusterModel = new ClusterTableModel(annotationSet); int widths[] = getColumnWidths(clusterTable); clusterTable.setModel(clusterModel); setColumnWidths(clusterTable, widths); TableColumn collapsedColumn = clusterTable.getColumnModel().getColumn(ClusterTableModel.COLLAPSED_COLUMN_INDEX); collapsedColumn.setCellRenderer(new ClusterTableCollapsedCellRenderer(iconManager)); // sort TableRowSorter<TableModel> sorter = new TableRowSorter<>(clusterTable.getModel()); clusterTable.setRowSorter(sorter); List<SortKey> sortKeys = new ArrayList<>(2); sortKeys.add(new RowSorter.SortKey(ClusterTableModel.NODES_COLUMN_INDEX, SortOrder.DESCENDING)); sortKeys.add(new RowSorter.SortKey(ClusterTableModel.CLUSTER_COLUMN_INDEX, SortOrder.ASCENDING)); sorter.setSortKeys(sortKeys); sorter.sort(); }
/** * Returns the primary sort column, or null if nothing sorted or no sortKey * corresponds to a TableColumn currently contained in the TableColumnModel. * * @return the currently interactively sorted TableColumn or null if there * is not sorter active or if the sorted column index does not * correspond to any column in the TableColumnModel. */ public TableColumn getSortedColumn() { // bloody hack: get primary SortKey and // check if there's a column with it available RowSorter<?> controller = getRowSorter(); if (controller != null) { // PENDING JW: must use RowSorter? SortKey sortKey = SortUtils.getFirstSortingKey(controller .getSortKeys()); if (sortKey != null) { int sorterColumn = sortKey.getColumn(); List<TableColumn> columns = getColumns(true); for (Iterator<TableColumn> iter = columns.iterator(); iter .hasNext();) { TableColumn column = iter.next(); if (column.getModelIndex() == sorterColumn) { return column; } } } } return null; }
public Object getSessionState(Component c) { checkComponent(c); JXTable table = (JXTable) c; List<ColumnState> columnStates = new ArrayList<ColumnState>(); List<TableColumn> columns = table.getColumns(true); List<TableColumn> visibleColumns = table.getColumns(); for (TableColumn column : columns) { columnStates.add(new ColumnState((TableColumnExt) column, visibleColumns.indexOf(column))); } XTableState tableState = new XTableState(columnStates.toArray(new ColumnState[columnStates.size()])); tableState.setHorizontalScrollEnabled(table.isHorizontalScrollEnabled()); List<? extends SortKey> sortKeys = null; if (table.getRowSorter() != null) { sortKeys = table.getRowSorter().getSortKeys(); } // PENDING: store all! if ((sortKeys != null) && (sortKeys.size() >0)) { tableState.setSortKey(sortKeys.get(0)); } return tableState; }
@Override public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) { Component c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column); c.setBackground(Constants.DS_BACK); DefaultTableCellRenderer r = ((DefaultTableCellRenderer) c); r.setText("<html><b>" + r.getText() + "</b></html>"); try { List<? extends SortKey> sortKeys = table.getRowSorter().getSortKeys(); SortKey key = sortKeys.get(0); if (column == key.getColumn()) { r.setIcon(key.getSortOrder() == SortOrder.ASCENDING ? ascIcon : descIcon); } else { r.setIcon(null); } } catch (Exception e) { r.setIcon(null); } return r; }
public List<SortKey> getSortKeys() { if (sortIndexes2Direction.isEmpty()) { return Collections.emptyList(); } final List<SortKey> sortKeys = new ArrayList<>(sortIndexes2Direction.size()); for (final Map.Entry<Integer, Boolean> e : sortIndexes2Direction.entrySet()) { final int modelColumnIndex = e.getKey(); final SortOrder sortOrder = getSortOrderOfBooleanAscendingFlag(e.getValue()); final SortKey sortKey = new SortKey(modelColumnIndex, sortOrder); sortKeys.add(sortKey); } return sortKeys; }
public final void setSortKeys(final List<? extends SortKey> sortKeys) { sortIndexes2Direction.clear(); if (sortKeys == null || sortKeys.isEmpty()) { return; } for (final SortKey sortKey : sortKeys) { final int modelColumnIndex = sortKey.getColumn(); final Boolean isSortAscending = getSortAscendingFlagOfSortOrder(sortKey.getSortOrder()); if (isSortAscending == null) { continue; } sortIndexes2Direction.put(modelColumnIndex, isSortAscending); } }
@Override public void sorterChanged(RowSorterEvent e) { if (e.getType() == Type.SORT_ORDER_CHANGED) { @SuppressWarnings("unchecked") List<? extends SortKey> sortKeys = e.getSource().getSortKeys(); Object[] keys = new Object[sortKeys.size()]; boolean[] directions = new boolean[sortKeys.size()]; int index = 0; for (SortKey s : sortKeys) { keys[index] = SwingTable.this.keys[s.getColumn()]; directions[index] = s.getSortOrder() == SortOrder.ASCENDING; index++; } if (list instanceof Sortable) { ((Sortable) list).sort(keys, directions); } setOffset(0); } }
public int compareRows(int row1, int row2) { int order = 0; for (int i = 0; i < criteria.size(); i++) { SortKey key = criteria.get(i); if (key.getSortOrder() != SortOrder.UNSORTED) { Object o1 = model.getValueAt(row1, key.getColumn()); Object o2 = model.getValueAt(row2, key.getColumn()); if (o1 instanceof Comparable<?> && o2 instanceof Comparable<?>) { Comparable<Object> c1 = (Comparable<Object>) o1; Comparable<Object> c2 = (Comparable<Object>) o2; order = c1.compareTo(c2); } else if (o1 == null && o2 != null) { order = 1; } else if (o1 != null && o2 == null) { order = -1; } order = key.getSortOrder() == SortOrder.DESCENDING ? -order : order; if (order != 0) { break; } } } return order; }
@Test public void sortByFirstModelColumnTest() throws Exception { int fixedRows = 2; int fixedCols = 3; LinearInset rowsInset = new LinearInset(1, 1); LinearInset columnsInset = new LinearInset(1, 1); ConfResult conf = beginSortedVisual(fixedRows, fixedCols, rowsInset, columnsInset); for (int i = 1; i < conf.tlTable.getRowCount(); i++) { assertEquals(new Long(i), (Long)conf.tlTable.getValueAt(i, 1)); } for (int i = 0; i < conf.blTable.getRowCount() - 1; i++) { assertEquals(new Long(i + conf.tlTable.getRowCount()), (Long)conf.blTable.getValueAt(i, 1)); } SortKey sk = new SortKey(0/*in terms of the model, not the view*/, SortOrder.DESCENDING); List<SortKey> keys = new ArrayList<>(); keys.add(sk); conf.tlTable.getRowSorter().setSortKeys(keys); Long k = 7l; for (int i = 1; i < conf.tlTable.getRowCount(); i++) { assertEquals(k--, (Long)conf.tlTable.getValueAt(i, 1)); } for (int i = 0; i < conf.blTable.getRowCount() - 1; i++) { assertEquals(k--, (Long)conf.blTable.getValueAt(i, 1)); } endVisual(); }
private void initialSort() { @SuppressWarnings("unchecked") TableRowSorter<ClipTableModel> sorter = ((TableRowSorter<ClipTableModel>)table.getRowSorter()); List<SortKey> list = new ArrayList<>(); switch (CCProperties.getInstance().PROP_VIEW_DB_START_SORT.getValue()) { case LOCALID: //DO nothing return; case TITLE: list.add( new RowSorter.SortKey(ClipTableModel.COLUMN_TITLE, SortOrder.ASCENDING) ); break; case ADDDATE: list.add( new RowSorter.SortKey(ClipTableModel.COLUMN_DATE, SortOrder.DESCENDING) ); break; } sorter.setSortKeys(list); sorter.sort(); }
private void finalizeGUI() { if (! LookAndFeelManager.isSubstance()) { edName.setBackground(Color.WHITE); } if (! LookAndFeelManager.isSubstance()) { edTyp.setBackground(Color.WHITE); } lsModel = new SettingsTableModel(properties); // $hide$ rowsorter = new TableRowSorter<>(); rowsorter.setModel(lsModel); List<SortKey> sk = new ArrayList<>(); sk.add( new RowSorter.SortKey(0, SortOrder.ASCENDING) ); rowsorter.setSortKeys(sk); rowsorter.sort(); tabSettings.setModel(lsModel); tabSettings.setRowSorter(rowsorter); tabSettings.getColumnModel().getColumn(0).setPreferredWidth(getWidth()*2/3); tabSettings.getColumnModel().getColumn(1).setPreferredWidth(getWidth()*1/3); tabSettings.getSelectionModel().addListSelectionListener(this); tabSettings.getColumnModel().getColumn(1).setCellEditor(lsEditor = new SettingsTableEditor(properties)); }
private void btnColumnsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnColumnsActionPerformed List<SortKey> sortKeys = (List<SortKey>) tblInstanceSeed.getRowSorter().getSortKeys(); List<String> columnNames = new ArrayList<String>(); for (SortKey sk : sortKeys) { columnNames.add(tblInstanceSeed.getColumnName(tblInstanceSeed.convertColumnIndexToView(sk.getColumn()))); } EDACCInstanceColumnSelection dialog = new EDACCInstanceColumnSelection(EDACCApp.getApplication().getMainFrame(), true, selector, InstanceTableModel.COL_PROP + 1); dialog.setLocationRelativeTo(EDACCApp.getApplication().getMainFrame()); dialog.setVisible(true); List<SortKey> newSortKeys = new ArrayList<SortKey>(); for (int k = 0; k < columnNames.size(); k++) { String col = columnNames.get(k); for (int i = 0; i < tblInstanceSeed.getColumnCount(); i++) { if (tblInstanceSeed.getColumnName(i).equals(col)) { newSortKeys.add(new SortKey(tblInstanceSeed.convertColumnIndexToModel(i), sortKeys.get(k).getSortOrder())); } } } tblInstanceSeed.getRowSorter().setSortKeys(newSortKeys); edacc.experiment.Util.updateTableColumnWidth(tblInstanceSeed); }
private void btnBrowserColumnSelectionActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnBrowserColumnSelectionActionPerformed List<SortKey> sortKeys = (List<SortKey>) tblJobs.getRowSorter().getSortKeys(); List<String> columnNames = new ArrayList<String>(); for (SortKey sk : sortKeys) { columnNames.add(tblJobs.getColumnName(tblJobs.convertColumnIndexToView(sk.getColumn()))); } EDACCResultsBrowserColumnSelection dialog = new EDACCResultsBrowserColumnSelection(EDACCApp.getApplication().getMainFrame(), true, jobsColumnSelector, jobsTableModel); dialog.setLocationRelativeTo(EDACCApp.getApplication().getMainFrame()); dialog.setVisible(true); List<SortKey> newSortKeys = new ArrayList<SortKey>(); for (int k = 0; k < columnNames.size(); k++) { String col = columnNames.get(k); for (int i = 0; i < tblJobs.getColumnCount(); i++) { if (tblJobs.getColumnName(i).equals(col)) { newSortKeys.add(new SortKey(tblJobs.convertColumnIndexToModel(i), sortKeys.get(k).getSortOrder())); } } } tblJobs.getRowSorter().setSortKeys(newSortKeys); Util.updateTableColumnWidth(tblJobs); }
private void btnSelectInstanceColumnsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnSelectInstanceColumnsActionPerformed instanceTableModel.updateProperties(); List<SortKey> sortKeys = (List<SortKey>) tableInstances.getRowSorter().getSortKeys(); List<String> columnNames = new ArrayList<String>(); for (SortKey sk : sortKeys) { columnNames.add(tableInstances.getColumnName(tableInstances.convertColumnIndexToView(sk.getColumn()))); } EDACCManageInstanceColumnSelection dialog = new EDACCManageInstanceColumnSelection(EDACCApp.getApplication().getMainFrame(), true, instanceTableModel); dialog.setLocationRelativeTo(EDACCApp.getApplication().getMainFrame()); dialog.setVisible(true); List<SortKey> newSortKeys = new ArrayList<SortKey>(); for (int k = 0; k < columnNames.size(); k++) { String col = columnNames.get(k); for (int i = 0; i < tableInstances.getColumnCount(); i++) { if (tableInstances.getColumnName(i).equals(col)) { newSortKeys.add(new SortKey(tableInstances.convertColumnIndexToModel(i), sortKeys.get(k).getSortOrder())); } } } tableInstances.getRowSorter().setSortKeys(newSortKeys); edacc.experiment.Util.updateTableColumnWidth(tableInstances); instanceTableModel.fireTableDataChanged(); instanceTableModel.updateProperties(); tableInstances.updateUI(); }
private void btnBrowserColumnSelectionActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnBrowserColumnSelectionActionPerformed updateJobBrowserProperties(); List<SortKey> sortKeys = (List<SortKey>) tableJobs.getRowSorter().getSortKeys(); List<String> columnNames = new ArrayList<String>(); for (SortKey sk : sortKeys) { columnNames.add(tableJobs.getColumnName(tableJobs.convertColumnIndexToView(sk.getColumn()))); } EDACCResultsBrowserColumnSelection dialog = new EDACCResultsBrowserColumnSelection(EDACCApp.getApplication().getMainFrame(), true, jobsColumnSelector, jobsTableModel); dialog.setLocationRelativeTo(EDACCApp.getApplication().getMainFrame()); dialog.setVisible(true); List<SortKey> newSortKeys = new ArrayList<SortKey>(); for (int k = 0; k < columnNames.size(); k++) { String col = columnNames.get(k); for (int i = 0; i < tableJobs.getColumnCount(); i++) { if (tableJobs.getColumnName(i).equals(col)) { newSortKeys.add(new SortKey(tableJobs.convertColumnIndexToModel(i), sortKeys.get(k).getSortOrder())); } } } tableJobs.getRowSorter().setSortKeys(newSortKeys); Util.updateTableColumnWidth(tableJobs); }
/** * Configure sort and order in page from sorter */ private void configurePage() { Page.Order order = Page.Order.ASC; String sortPropertyName = null; List<? extends SortKey> keys = sorter.getSortKeys(); // If sorting, get values to set in page if (keys.size() > 0) { RowSorter.SortKey key = sorter.getSortKeys().get(0); if (tableModel.isPropertyColumn(key.getColumn())) { sortPropertyName = tableModel.getSortPropertyName(key.getColumn()); order = converSortOrder(key); } } page.setSortName(sortPropertyName); page.setOrder(order); }
private boolean isSameSorter(List<? extends SortKey> sortKeys1, List<? extends SortKey> sortKeys2) { int size1 = (sortKeys1 == null) ? 0 : sortKeys1.size(); int size2 = (sortKeys2 == null) ? 0 : sortKeys2.size(); if ((size1 == 0) && (size2 == 0)) { return true; } if ((sortKeys1 == null) && (sortKeys2 == null)) return true; if ((sortKeys1 == null) || (sortKeys2 == null)) return false; if (size1 != size2) return false; for (int i = 0; i < size1; i++) { SortKey sortKey1 = sortKeys1.get(i); SortKey sortKey2 = sortKeys2.get(i); if ((sortKey1.getColumn() != sortKey2.getColumn()) || (sortKey1.getSortOrder() != sortKey2.getSortOrder())) { return false; } } return true; }
@SuppressWarnings("unchecked") public void valueChanged(final ListSelectionEvent e) { // fix for issue 478 - no animations when sorter has changed List<? extends SortKey> sortKeys = (table.getRowSorter() == null) ? null : table.getRowSorter().getSortKeys(); boolean isDifferentSorter = !isSameSorter(sortKeys, oldSortKeys); if (e.getValueIsAdjusting() && isDifferentSorter) return; if (sortKeys == null) { oldSortKeys = null; } else { oldSortKeys = new ArrayList<SortKey>(); for (SortKey sortKey : sortKeys) { SortKey copy = new SortKey(sortKey.getColumn(), sortKey.getSortOrder()); oldSortKeys.add(copy); } } syncSelection(isDifferentSorter); }
/** * Removes a time series from the table model * @param seriesIndex The index of the series to be removed * @throws NoSuchSeriesException Will be thrown if there is no series with the specified index */ public void removeSeries(int seriesIndex) throws NoSuchSeriesException { SortKey sortKey = this.getSortKey(); if (this.getColumnCount()==2) { // --- The last series has to be removed ------ this.initilizeTabelModel(); } else { int column2remove = seriesIndex+1; // Column 0 contains the time stamps if(column2remove <= this.getColumnCount()){ columnTitles.remove(column2remove); java.util.Iterator<Vector<Number>> rows = tableModelDataVector.iterator(); while(rows.hasNext()){ rows.next().remove(column2remove); } } // else{ // throw new NoSuchSeriesException(); // } } fireTableStructureChanged(); if(this.getColumnCount() > 0){ this.setSortKey(sortKey); } }
private void setSortKey(SortKey sortKey){ if(sortKey != null){ Vector<SortKey> keyVector = new Vector<SortKey>(); keyVector.addElement(sortKey); myJTable.getRowSorter().setSortKeys(keyVector); } }
@Override public Icon getIcon() { int modelCol = header.getTable().convertColumnIndexToModel(curCol); TableModel model = header.getTable().getModel(); if (model instanceof ExtendedJTableSorterModel) { ExtendedJTableSorterModel sortModel = (ExtendedJTableSorterModel) model; switch (sortModel.getSortingStatus(modelCol)) { case ExtendedJTableSorterModel.ASCENDING: return UIManager.getIcon("Table.ascendingSortIcon"); case ExtendedJTableSorterModel.DESCENDING: return UIManager.getIcon("Table.descendingSortIcon"); case ExtendedJTableSorterModel.NOT_SORTED: default: return null; } } else { SortKey sortKey = getSortKey(header.getTable().getRowSorter(), modelCol); SortOrder sortOrder = sortKey != null ? sortKey.getSortOrder() : SortOrder.UNSORTED; switch (sortOrder) { case ASCENDING: return UIManager.getIcon("Table.ascendingSortIcon"); case DESCENDING: return UIManager.getIcon("Table.descendingSortIcon"); case UNSORTED: default: return null; } } }
/** * Tries to return the sort key for the given column. * * @param sorter * @param column * @return the sort key or {@code null} */ private SortKey getSortKey(RowSorter<? extends TableModel> sorter, int column) { if (sorter == null) { return null; } for (Object sortObj : sorter.getSortKeys()) { SortKey key = (SortKey) sortObj; if (key.getColumn() == column) { return key; } } return null; }
/** * Returns the current sort key, or null if the column is unsorted. * * @param table the table * @param column the column index * @return the SortKey, or null if the column is unsorted */ @SuppressWarnings("rawtypes") protected SortKey getSortKey(JTable table, int column) { RowSorter rowSorter = table.getRowSorter(); if (rowSorter == null) { return null; } List sortedColumns = rowSorter.getSortKeys(); if (!sortedColumns.isEmpty()) { return (SortKey) sortedColumns.get(0); } return null; }
/** * Rebuilds the table. */ private void rebuildTable() { table.saveSelection( classColIdx ); final XTableModel model = table.getXTableModel(); model.getDataVector().clear(); model.fireTableDataChanged(); for ( final Class< ? extends IColumn< ? > > colClass : RepListColumnRegistry.COLUMN_LIST ) { final boolean isCustom = BaseCustomColumn.class.isAssignableFrom( colClass ); // Only show custom columns if skill level is met if ( isCustom && Settings.REP_LIST_CUST_COL_1_NAME.skillLevel.isBelow() ) continue; final IColumn< ? > column = RepListColumnRegistry.getColumnInstance( colClass ); if ( column == null ) continue; final int pos = rlcBean.getColumnClassList().indexOf( colClass ) + 1; final Vector< Object > row = Utils.< Object > asNewVector( colClass, pos > 0 ? pos : -1, column.getRicon(), column.getDisplayName(), pos > 0, isCustom, column.getDescription() ); model.addRow( row ); } table.getRowSorter().setSortKeys( Arrays.asList( new SortKey( posColIdx, SortOrder.ASCENDING ) ) ); // Pack all columns except the last Description column for ( int i = table.getColumnCount() - 1; i >= 0; i-- ) if ( i != table.convertColumnIndexToView( descColIdx ) ) table.packColumns( i ); table.restoreSelection( classColIdx ); }
private void rowSorterChanged() { List<? extends SortKey> list = getRowSorter().getSortKeys(); if(list.isEmpty()) return; SortKey k = list.get(0); int i = k.getColumn() + 1; if(k.getSortOrder() == SortOrder.UNSORTED) return; if(k.getSortOrder() == SortOrder.DESCENDING) i *= -1; preferences().setIntProperty(tablePrefix + "sortOrder", i); }
/** * Aktualizacja modelu tabeli w zwiazku ze zmianami filtrow */ private void doUpdate() { Map<String, String> params = getParams(); // zachowanie kluczy sortowania List<? extends SortKey> sortKeys = objTable.getRowSorter().getSortKeys(); // zmiana modelu objTable.setModel(tablePanel.getNewTableModel(params)); // przywrocenie szerokosci kolumn i kluczy sortowania tablePanel.afterModelChange(); objTable.getRowSorter().setSortKeys(sortKeys); }
/** * Overloaded to return an icon suitable to the primary sorted column, or null if * the column is not the primary sort key. * * @param table the <code>JTable</code>. * @param column the column index. * @return the sort icon, or null if the column is unsorted. */ protected Icon getIcon(JTable table, int column) { SortKey sortKey = getSortKey(table, column); if (sortKey != null && table.convertColumnIndexToView(sortKey.getColumn()) == column) { switch (sortKey.getSortOrder()) { case ASCENDING: return UIManager.getIcon("Table.ascendingSortIcon"); case DESCENDING: return UIManager.getIcon("Table.descendingSortIcon"); } } return null; }
/** * Returns the current sort key, or null if the column is unsorted. * * @param table the table * @param column the column index * @return the SortKey, or null if the column is unsorted */ protected SortKey getSortKey(JTable table, int column) { RowSorter rowSorter = table.getRowSorter(); if (rowSorter == null) { return null; } List sortedColumns = rowSorter.getSortKeys(); if (sortedColumns.size() > 0) { return (SortKey) sortedColumns.get(0); } return null; }
/** * Returns the view column index of the primary sort column. * * @return the view column index of the primary sort column or -1 if nothing * sorted or the primary sort column not visible. */ public int getSortedColumnIndex() { RowSorter<?> controller = getRowSorter(); if (controller != null) { SortKey sortKey = SortUtils.getFirstSortingKey(controller.getSortKeys()); if (sortKey != null) { return convertColumnIndexToView(sortKey.getColumn()); } } return -1; }
/** * For comparison ... * * Issue #1132-swingx: JXTable - define and implement behaviour on remove column */ @Test public void testSortStateAfterRemoveColumn() { JTable table = new JTable(); table.setAutoCreateRowSorter(true); table.setModel(new AncientSwingTeam()); table.getRowSorter().toggleSortOrder(0); List<? extends SortKey> sortKeys = table.getRowSorter().getSortKeys(); table.removeColumn(table.getColumnModel().getColumn(0)); assertEquals(sortKeys, table.getRowSorter().getSortKeys()); }
/** * Issue #1156-swingx: sorter must use comparable if available * ListSortController */ @Test public void testComparableComparatorList() { ListModel model = new DefaultComboBoxModel(new Integer[] {10, 2}); ListSortController<ListModel> sorter = new ListSortController<ListModel>(model); List<SortKey> keys = new ArrayList<SortKey>(); keys.add(new SortKey(0, SortOrder.ASCENDING)); sorter.setSortKeys(keys); assertEquals(0, sorter.convertRowIndexToModel(1)); }
/** * Test that resetSortOrders doesn't change sorts at all if controller is not sortable. * Does nothing if columnCount < 2. */ @Test public void testResetSortOrdersIfSortableFalse() { if (getColumnCount() < 2) return; controller.toggleSortOrder(0); controller.toggleSortOrder(1); controller.setSortable(false); List<? extends SortKey> keys = controller.getSortKeys(); assertEquals(2, keys.size()); controller.resetSortOrders(); assertEquals("resetSortOrders must not touch unsortable columns", keys, controller.getSortKeys()); }