Moderator: JIDE Support
protected void initTable() {
            super.initTable();
            setSortTableHeaderRenderer();
         }
         
         protected JTableHeader createDefaultTableHeader() {
               return new JTableHeader(columnModel);
           }
}
        _sortableTable.getTableHeader().setPreferredSize(new Dimension(_sortableTable.getTableHeader().getPreferredSize().width, 40));
/*
 * @(#)SortableTableDemo.java
 *
 * Copyright 2002 - 2003 JIDE Software Inc. All rights reserved.
 */
import com.jidesoft.converter.ConverterContext;
import com.jidesoft.converter.DoubleConverter;
import com.jidesoft.converter.ObjectConverterManager;
import com.jidesoft.grid.*;
import com.jidesoft.hssf.HssfTableUtils;
import com.jidesoft.icons.JideIconsFactory;
import com.jidesoft.plaf.LookAndFeelFactory;
import com.jidesoft.swing.JideBoxLayout;
import com.jidesoft.swing.JideTabbedPane;
import javax.swing.*;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.io.File;
import java.io.IOException;
import java.text.DecimalFormat;
import java.util.Calendar;
import java.util.Date;
/**
 * Demoed Component: {@link SortableTable} <br> Required jar files: jide-common.jar, jide-grids.jar <br> Required L&F:
 * any L&F
 */
public class SortableTableDemo extends AbstractDemo {
    protected SortableTable _sortableTable;
    protected String _lastDirectory = ".";
    private static final long serialVersionUID = -5373007282200581748L;
    public SortableTableDemo() {
        ObjectConverterManager.initDefaultConverter();
        DecimalFormat format = new DecimalFormat();
        format.setMinimumFractionDigits(2);
        format.setMaximumFractionDigits(10);
        DoubleConverter converter = new DoubleConverter(format);
        ObjectConverterManager.registerConverter(Double.class, converter);
    }
    public String getName() {
        return "SortableTable Demo";
    }
    public String getProduct() {
        return PRODUCT_NAME_GRIDS;
    }
    @Override
    public int getAttributes() {
        return Demo.ATTRIBUTE_UPDATED;
    }
    @Override
    public String getDescription() {
        return "This is a demo of SortableTable. \n" +
                "\nClick once on the header to sort ascending, click twice to sort descending, a third time to unsort. Hold CTRL key (or Command key on Mac OS X) then click on several headers to see mulitple columns sorting.\n" +
                "\n" +
                "Demoed classes:\n" +
                "com.jidesoft.grid.SortableTable";
    }
    @Override
    public Component getOptionsPanel() {
        JPanel panel = new JPanel();
        panel.setLayout(new JideBoxLayout(panel, JideBoxLayout.Y_AXIS));
        panel.add(new JLabel("Maximum sorted columns: "));
        DefaultComboBoxModel model = new DefaultComboBoxModel();
        model.addElement("No maximum (default)");
        for (int i = 0; i < _sortableTable.getColumnCount(); i++) {
            model.addElement(new Integer(i + 1));
        }
        panel.add(Box.createVerticalStrut(3));
        final JComboBox maxComboBox = new JComboBox(model);
        maxComboBox.addActionListener(new AbstractAction() {
            private static final long serialVersionUID = -6480174819379988040L;
            public void actionPerformed(ActionEvent e) {
                int maxCount = maxComboBox.getSelectedIndex();
                if (maxCount == 0) {
                    ((ISortableTableModel) _sortableTable.getModel()).setMaximumSortColumns(-1);
                }
                else {
                    ((ISortableTableModel) _sortableTable.getModel()).setMaximumSortColumns(maxCount);
                }
            }
        });
        panel.add(maxComboBox);
        panel.add(Box.createVerticalStrut(6));
        panel.add(new JLabel("Sort priority: "));
        model = new DefaultComboBoxModel();
        model.addElement("FILO (Default)");
        model.addElement("FIFO");
        panel.add(Box.createVerticalStrut(3));
        final JComboBox priorityComboBox = new JComboBox(model);
        priorityComboBox.addActionListener(new AbstractAction() {
            private static final long serialVersionUID = 3712678830602409607L;
            public void actionPerformed(ActionEvent e) {
                int priority = priorityComboBox.getSelectedIndex();
                ((ISortableTableModel) _sortableTable.getModel()).setSortPriority(priority);
            }
        });
        panel.add(priorityComboBox);
        panel.add(Box.createVerticalStrut(12));
        JCheckBox sortingEnabled = new JCheckBox("Allow user to sort table");
        sortingEnabled.setSelected(_sortableTable.isSortingEnabled());
        sortingEnabled.addItemListener(new ItemListener() {
            public void itemStateChanged(ItemEvent e) {
                _sortableTable.setSortingEnabled(e.getStateChange() == ItemEvent.SELECTED);
            }
        });
        panel.add(sortingEnabled);
        JCheckBox showSortOrder = new JCheckBox("Always show sort order");
        showSortOrder.setSelected(_sortableTable.isShowSortOrderNumber());
        showSortOrder.addItemListener(new ItemListener() {
            public void itemStateChanged(ItemEvent e) {
                _sortableTable.setShowSortOrderNumber(e.getStateChange() == ItemEvent.SELECTED);
            }
        });
        panel.add(showSortOrder);
        final JCheckBox sortIconCheckBox = new JCheckBox("Use Look&Feel Default Sort Icon");
        sortIconCheckBox.addItemListener(new ItemListener() {
            public void itemStateChanged(ItemEvent e) {
                _sortableTable.setUseLnfDefaultSortIcon(e.getStateChange() == ItemEvent.SELECTED);
            }
        });
        sortIconCheckBox.setSelected(_sortableTable.isUseLnfDefaultSortIcon());
        panel.add(sortIconCheckBox);
        panel.add(Box.createVerticalStrut(12));
        panel.add(new JButton(new AbstractAction("Export to Excel") {
            private static final long serialVersionUID = -3816637828684822007L;
            public void actionPerformed(ActionEvent e) {
                if (!HssfTableUtils.isHssfInstalled()) {
                    JOptionPane.showMessageDialog((Component) e.getSource(), "Export to Excel feature is disabled in the webstart demo because hssf.jar is not in the classpath.");
                    return;
                }
                JFileChooser chooser = new JFileChooser() {
                    @Override
                    protected JDialog createDialog(Component parent) throws HeadlessException {
                        JDialog dialog = super.createDialog(parent);
                        dialog.setTitle("Export the content to an \".xls\" file");
                        return dialog;
                    }
                };
                chooser.setCurrentDirectory(new File(_lastDirectory));
                int result = chooser.showDialog(((JButton) e.getSource()).getTopLevelAncestor(), "Export");
                if (result == JFileChooser.APPROVE_OPTION) {
                    _lastDirectory = chooser.getCurrentDirectory().getAbsolutePath();
                    try {
                        HssfTableUtils.export(_sortableTable, chooser.getSelectedFile().getAbsolutePath(), "SortableTable", false, true, new HssfTableUtils.DefaultCellValueConverter() {
                            @Override
                            public int getDataFormat(JTable table, Object value, int rowIndex, int columnIndex) {
                                if (value instanceof Double) {
                                    return 2; // use 0.00 format
                                }
                                else if (value instanceof Date) {
                                    return 0xe; // use "m/d/yy" format
                                }
                                return super.getDataFormat(table, value, rowIndex, columnIndex);
                            }
                        });
                    }
                    catch (IOException e1) {
                        e1.printStackTrace();
                    }
                }
            }
        }));
        return panel;
    }
    public Component getDemoPanel() {
        TableModel model = new SampleTableModel();
        _sortableTable = new SortableTable(model);
        AutoFilterTableHeader header = new AutoFilterTableHeader(_sortableTable);
        header.setAutoFilterEnabled(true);
        _sortableTable.setTableHeader(header);
        _sortableTable.getTableHeader().setPreferredSize(new Dimension(_sortableTable.getTableHeader().getPreferredSize().width, 40));
        JTable normalTable = new JTable(model);
        JideTabbedPane tabbedPane = new JideTabbedPane();
        tabbedPane.setTabShape(JideTabbedPane.SHAPE_BOX);
        tabbedPane.addTab("SortableTable", new JScrollPane(_sortableTable));
        tabbedPane.addTab("JTable (for comparison)", new JScrollPane(normalTable));
        tabbedPane.setPreferredSize(new Dimension(550, 400));
        return tabbedPane;
    }
    static class SampleTableModel extends AbstractTableModel implements ContextSensitiveTableModel, ToolTipSupport {
        private static final long serialVersionUID = 8798261997256893224L;
        public int getColumnCount() {
            return 6;
        }
        public int getRowCount() {
            return 8;
        }
        @Override
        public boolean isCellEditable(int rowIndex, int columnIndex) {
            return false;
        }
        public ConverterContext getConverterContextAt(int row, int column) {
            return null;
        }
        public EditorContext getEditorContextAt(int row, int column) {
            return null;
        }
        public Class<?> getCellClassAt(int row, int column) {
            return getColumnClass(column);
        }
        @Override
        public String getColumnName(int column) {
            switch (column) {
                case 0:
                    return "int column";
                case 1:
                    return "<html>double<br>column</html>";
                case 2:
                    return "boolean column";
                case 3:
                    return "string column";
                case 4:
                    return "icon column";
                case 5:
                    return "date column";
            }
            return "";
        }
        @Override
        public Class<?> getColumnClass(int column) {
            switch (column) {
                case 0:
                    return Integer.class;
                case 1:
                    return Double.class;
                case 2:
                    return Boolean.class;
                case 3:
                    return String.class;
                case 4:
                    return Icon.class;
                case 5:
                    return Date.class;
            }
            return Object.class;
        }
        public Object getValueAt(int row, int column) {
            switch (column) {
                case 0:
                    if (row > 4) {
                        return 2;
                    }
                    else {
                        return row;
                    }
                case 1:
                    return row * 2.333333;
                case 2:
                    if (row % 2 == 0)
                        return Boolean.TRUE;
                    return Boolean.FALSE;
                case 3:
                    return "row " + (getRowCount() - row);
                case 4:
                    if (row % 2 == 0)
                        return JideIconsFactory.getImageIcon(JideIconsFactory.FileType.HTML);
                    else
                        return JideIconsFactory.getImageIcon(JideIconsFactory.FileType.JAVA);
                case 5:
                    Calendar calendar = Calendar.getInstance();
                    calendar.roll(Calendar.DAY_OF_YEAR, row);
                    return calendar.getTime();
            }
            return null;
        }
        public String getToolTipText(int columnIndex) {
            return "Click to sort this " + getColumnName(columnIndex);
        }
    }
    @Override
    public String getDemoFolder() {
        return "G2.SortableTable";
    }
    static public void main(String[] s) {
        LookAndFeelFactory.installDefaultLookAndFeelAndExtension();
        showAsFrame(new SortableTableDemo());
    }
}
import javax.swing.Icon;
import javax.swing.JTable;
import javax.swing.table.TableModel;
import java.util.Comparator;
import com.jidesoft.grid.AutoFilterBox;
import com.jidesoft.grid.AutoFilterTableHeader;
import com.jidesoft.grid.FilterableTableModel;
import com.jidesoft.grid.FilterableTableModelEvent;
import com.jidesoft.grid.FilterableTreeTableModel;
import com.jidesoft.grid.IFilterableTableModel;
import com.jidesoft.grid.SortableTable;
import com.jidesoft.grid.TreeTable;
public class CNAutoFilterTableHeader extends AutoFilterTableHeader
{
   private JTable _table = null;
   private CNTablePanel _nTable = null;
   
   public CNAutoFilterTableHeader(CNTablePanel nTable)
   {
      super(nTable.getTable());
      _table = nTable.getTable();
      _nTable = nTable;
      
   }
   
   
   
   @Override
    protected IFilterableTableModel createFilterableTableModel(TableModel model) {
      if (_table instanceof TreeTable)
      {
           return new FilterableTableModel(model) {
               @Override
               public boolean isColumnAutoFilterable(int column) {
                   return true;
               }
               @Override
            public Object[] getPossibleValues(int column, Comparator comparator) {
                   return super.getPossibleValues(column, new Comparator(){
                  public int compare(Object firstObj, Object secondObj) {
                           try {
                              if (firstObj instanceof Comparable && secondObj instanceof Comparable)
                              {
                                 return ((Comparable)firstObj).compareTo(secondObj);
                              }
                                else {
                                   String str1 = firstObj.toString();
                                   String str2 = secondObj.toString();
                                   return (str1.compareToIgnoreCase(str2));
                               }
                           } catch (Exception e) {
                               e.printStackTrace();
                               return -1;
                           }
                       }
                   });
               }
               @Override
            protected boolean shouldPossibleValueBeIncluded(Object value,int columnIndex)
            {
               if (value == null)
                  return false;
               
               return !(value.toString().equals(""));
            }
               
              
               
           };
      }
      else
      {
          return new FilterableTreeTableModel(model) {
                  @Override
                  public boolean isColumnAutoFilterable(int column) {
                      return true;
                  }
                  @Override
               public Object[] getPossibleValues(int column, Comparator comparator) {
                      return super.getPossibleValues(column, new Comparator(){
                     public int compare(Object firstObj, Object secondObj) {
                              try {
                                 if (firstObj instanceof Comparable && secondObj instanceof Comparable)
                                 {
                                    return ((Comparable)firstObj).compareTo(secondObj);
                                 }
                                   else {
                                      String str1 = firstObj.toString();
                                      String str2 = secondObj.toString();
                                      return (str1.compareToIgnoreCase(str2));
                                  }
                              } catch (Exception e) {
                                  e.printStackTrace();
                                  return -1;
                              }
                          }
                     
                      });
                  }
                  @Override
               protected boolean shouldPossibleValueBeIncluded(Object value,int columnIndex)
               {
                  if (value == null)
                     return false;
                  
                  if (value instanceof JobStatus )
                  {
                     String str = ((JobStatus)value).toString();
                     if (str.equals(StringBank.UNKNOWN))
                        return false;
                     else
                        return!(str.equals(""));
                  }
                     
                  return !(value.toString().equals(""));
               }
                  
              };
      }
    }
   
    @Override
     public void filterableTableModelChanged(FilterableTableModelEvent event)
     {
       super.filterableTableModelChanged(event);
       _nTable.setPreferredWidthOfColumns();
     }
   
   protected void customizeAutoFilterBox(AutoFilterBox autoFilterBox) {
      autoFilterBox.setBackground(Utilities.COLOR_LIGHT_LIGHT_GREY);
      if (autoFilterBox.getFilterTitleFormatter() ==null) {                
         autoFilterBox.setFilterTitleFormatter(new Formatter());
      }
      super.customizeAutoFilterBox(autoFilterBox);
      autoFilterBox.setShowFilterName(true);     
      
   }
   
   protected Icon createSortIcon(SortableTable table, boolean ascending)
     {
        if (ascending)
           return RuntimeContext.upIcon;
        else 
           return RuntimeContext.downIcon;
     }
   
   class Formatter implements  AutoFilterBox.FilterTitleFormatter
    {
       String filter = "";
       public String formatColumnTitle(String columnName, com.jidesoft.filter.Filter[] filters) {
          filter = "";
         if (filters !=null && filters.length > 0)
         {
            if ( filters[0].getName().equals("All") == false)
               filter = ":" + filters[0].getName();
         }
            
      //   System.out.println("formatColumnTitle:: " + columnName + ", filter: " + filter);
         return "<html><body><b>" + columnName + filter +  "</b></body></html>";
      }
       
       public String getFilterName()
       {
          return filter;
       }
       public void clearFilter()
       {
          filter="";
       }
    }
          
}
  public static class CNTableHeaderRenderer extends DefaultTableCellRenderer
    {
        GradientPanel panel = null;
       int maxHeight = 0;  
       int pady = 10;
         
       public CNTableHeaderRenderer(boolean darkHeader)
       {
          if (darkHeader)
             panel = new GradientPanel(new GridBagLayout(),  Utilities.COLOR_GRADIENT1_DARKER, Utilities.COLOR_GRADIENT2, GradientPanel.VERTICAL);
          else
             panel = new GradientPanel(new GridBagLayout(), Utilities.COLOR_GRADIENT2, GradientPanel.VERTICAL);
       }
        
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
          Component actualRenderer = super.getTableCellRendererComponent(table,value,isSelected,hasFocus,row,column);
          
           if (table != null) {
               JTableHeader header = table.getTableHeader();
               if (header != null) {
                   actualRenderer.setForeground(header.getForeground());
                    actualRenderer.setBackground(header.getBackground());
                   actualRenderer.setFont(header.getFont().deriveFont(Font.BOLD));
                   }
            }
           
            Component headerComponent = null;
            String stringValue = (value == null) ? "" : value.toString();
            GridBagConstraints constraints = new GridBagConstraints();
             if (stringValue.indexOf('\n') != -1)
            {
                
               JPanel cellPanel =new JPanel(new GridBagLayout());
               cellPanel.setOpaque(false);
                constraints = new GridBagConstraints();
                String totalString = stringValue;
                JLabel tempLabel = null;
                int rows =0;
                while(totalString.indexOf('\n') != -1)
                {
                    String partString = totalString.substring(0, totalString.indexOf('\n'));
                    tempLabel = new JLabel(partString);
                    tempLabel.setHorizontalAlignment(JLabel.CENTER);
                    tempLabel.setOpaque(false);
                    tempLabel.setFont(actualRenderer.getFont());
                    cellPanel.add(tempLabel, Utilities.getConstraints(constraints, GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE, GridBagConstraints.REMAINDER, 1, 1, 0, GridBagConstraints.NORTH, GridBagConstraints.HORIZONTAL));
                    totalString = totalString.substring(totalString.indexOf('\n')+1);
                    rows++;
                }
                tempLabel = new JLabel(totalString );
                tempLabel.setHorizontalAlignment(JLabel.CENTER);
                tempLabel.setFont(actualRenderer.getFont());
                cellPanel.add(tempLabel, Utilities.getConstraints(constraints, GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE, GridBagConstraints.REMAINDER, GridBagConstraints.REMAINDER, 1, 1, GridBagConstraints.NORTH, GridBagConstraints.HORIZONTAL, new Insets(0,0,3,0)));
                
                headerComponent = cellPanel;
                panel.removeAll();
                panel.add(headerComponent, Utilities.getConstraints(constraints,
                                            GridBagConstraints.RELATIVE,
                                            GridBagConstraints.RELATIVE,
                                            GridBagConstraints.RELATIVE,
                                            GridBagConstraints.REMAINDER,
                                            1,
                                            1,
                                            GridBagConstraints.NORTH,
                                            GridBagConstraints.BOTH,
                                            new Insets(3,3,3,3)));
                int h = (tempLabel.getFontMetrics(tempLabel.getFont()).getHeight() + 10) * rows; //headerComponent.getPreferredSize().height ;
                if (h > maxHeight)
                {
                   maxHeight = h;
                }
            }
            else 
            {
                JLabel label = (JLabel) actualRenderer;
                label.setText((value == null) ? "" : value.toString() );
                label.setHorizontalAlignment(JLabel.CENTER);
                label.setVerticalAlignment(JLabel.NORTH);
                label.setOpaque(false);
                
                headerComponent = label;
                panel.removeAll();
                panel.add(headerComponent, Utilities.getConstraints(constraints,
                                            GridBagConstraints.RELATIVE,
                                            GridBagConstraints.RELATIVE,
                                            GridBagConstraints.RELATIVE,
                                            GridBagConstraints.REMAINDER,
                                            1,
                                            1,
                                            GridBagConstraints.NORTH,
                                            GridBagConstraints.NONE,
                                            new Insets(3,3,3,3)));
               
                int h = headerComponent.getPreferredSize().height ;
                if (h > maxHeight)
                {
                   maxHeight = h;
                }
            }
             
             panel.setPreferredSize(new Dimension((int)headerComponent.getPreferredSize().getWidth() + 30,maxHeight + pady));
             
             return panel;
        }
       
    }    
    protected TableCellEditor createDefaultEditor() {
        if (isAutoFilterEnabled()) {
            return new AutoFilterTableHeaderEditor() {
                @Override
                protected void customizeAutoFilterBox(AutoFilterBox autoFilterBox) {
                    autoFilterBox.applyComponentOrientation(AutoFilterTableHeader.this.getComponentOrientation());
                    super.customizeAutoFilterBox(autoFilterBox);
                    AutoFilterTableHeader.this.customizeAutoFilterBox(autoFilterBox);
                }
            };
        }
        else {
            return null;
        }
    }
      myTable = new SortableTable(myModel) {
            protected JTableHeader createDefaultTableHeader() {
                return new MultilineTableHeader(columnModel);
            }
        };
  /**
     * BUG: Default JTable header renderer does not properly calculate
     * preferred height when any of the columns has a multiline column name.
     * This is a fix proposed on the sun website.
     * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4292511
     */    
    private static class MultilineTableHeader extends SortableTableHeader {
        private int preferrredHeight = -1;
        public MultilineTableHeader(TableColumnModel cm) {
            super(cm);
        }
        private Component getHeaderRenderer(int columnIndex) {
            TableColumn aColumn = getColumnModel().getColumn(columnIndex);
            TableCellRenderer renderer = aColumn.getHeaderRenderer();
            if (renderer == null) {
                renderer = getDefaultRenderer();
            }
            return renderer.getTableCellRendererComponent(getTable(), aColumn.getHeaderValue(), false, false, -1, columnIndex);
        }
        private int getPreferredHeight() {
            if (preferrredHeight == -1) {
                preferrredHeight = 0;
                TableColumnModel columnModel = getColumnModel();
                for (int column = 0; column < columnModel.getColumnCount(); column++) {
                    Component comp = getHeaderRenderer(column);
                    int rendererHeight = comp.getPreferredSize().height;
                    preferrredHeight = Math.max(preferrredHeight, rendererHeight);
                }
            }
            return preferrredHeight;
        }
        @Override
        public Dimension getPreferredSize() {
            return new Dimension(super.getPreferredSize().width, getPreferredHeight());
        }
        @Override
        public void columnAdded(TableColumnModelEvent e) {
            preferrredHeight = -1;
            super.columnAdded(e);
        }
        @Override
        public void columnRemoved(TableColumnModelEvent e) {
            preferrredHeight = -1;
            super.columnRemoved(e);
        }
    }Users browsing this forum: No registered users and 242 guests