SortableTable Widget for GWT : Table « GWT « Java

Home
Java
1.2D Graphics GUI
2.3D
3.Advanced Graphics
4.Ant
5.Apache Common
6.Chart
7.Class
8.Collections Data Structure
9.Data Type
10.Database SQL JDBC
11.Design Pattern
12.Development Class
13.EJB3
14.Email
15.Event
16.File Input Output
17.Game
18.Generics
19.GWT
20.Hibernate
21.I18N
22.J2EE
23.J2ME
24.JDK 6
25.JNDI LDAP
26.JPA
27.JSP
28.JSTL
29.Language Basics
30.Network Protocol
31.PDF RTF
32.Reflection
33.Regular Expressions
34.Scripting
35.Security
36.Servlets
37.Spring
38.Swing Components
39.Swing JFC
40.SWT JFace Eclipse
41.Threads
42.Tiny Application
43.Velocity
44.Web Services SOA
45.XML
Java Tutorial
Java Source Code / Java Documentation
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Java » GWT » TableScreenshots 
SortableTable Widget for GWT
  


/*
 * SortableTable Widget for GWT library of Google, Inc.
 
 * Copyright (c) 2006 Parvinder Thapar
 * http://psthapar.googlepages.com/
 
 * This library is free software; you can redistribute 
 * it and/or modify it under the terms of the GNU Lesser 
 * General Public License as published by the Free Software 
 * Foundation; either version 2.1 of the License, or 
 * (at your option) any later version. This library is 
 * distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNULesser General Public License for more details. 
 * You should have received a copy of the GNU Lesser General 
 * PublicLicense along with this library; if not, write to the 
 * Free Software Foundation, Inc.,  
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA  
 */
package com.java2s.gwt.client;

import java.util.ArrayList;
import java.util.List;
import java.util.Collections;
import java.util.Iterator;
import java.util.Date;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.HasHorizontalAlignment;
import com.google.gwt.user.client.ui.HasVerticalAlignment;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.Widget;
import com.google.gwt.user.client.ui.HTMLTable.CellFormatter;
import com.google.gwt.user.client.ui.HTMLTable.RowFormatter;

import com.google.gwt.user.client.ui.FlexTable;
import com.google.gwt.user.client.ui.SourcesTableEvents;
import com.google.gwt.user.client.ui.TableListener;
public class GWTClient implements EntryPoint{

    /**
     * This is the entry point method.
     */
    public void onModuleLoad() {
      
        final SortableTable sortableTable = new SortableTable();
        
        sortableTable.setWidth(500 "px");
        sortableTable.setStyleName("sortableTable");
        sortableTable.setBorderWidth(1);
        sortableTable.setCellPadding(4);
        sortableTable.setCellSpacing(1);

        sortableTable.addColumnHeader("Employee",  0);
        sortableTable.addColumnHeader("Days"1);
        sortableTable.addColumnHeader("Hire Date"2);
        sortableTable.addColumnHeader("Bonus"3);
        
      // The rowIndex should begin with 1 as rowIndex 0 is for the Header
      // Any row with index == 0 will not be displayed.
        sortableTable.setValue(10"Parvinder Thapar");
        sortableTable.setValue(11new Integer(28));
        sortableTable.setValue(12new SimpleDate(20051025));
        sortableTable.setValue(13new Float("125.27"));

        sortableTable.setValue(20"David Brooks");
        sortableTable.setValue(21new Integer(32));
        sortableTable.setValue(22new SimpleDate(200041));
        sortableTable.setValue(23new Float("105.78"));

        sortableTable.setValue(30"Raj Rajendran");
        sortableTable.setValue(31new Integer(30));
        sortableTable.setValue(32new SimpleDate(2001129));
        sortableTable.setValue(33new Float("236.82"));

        sortableTable.setValue(40"Brian Foley");
        sortableTable.setValue(41new Integer(38));
        sortableTable.setValue(42new SimpleDate(2003224));
        sortableTable.setValue(43new Float("489.29"));

        sortableTable.setValue(50"Visala Dhara");
        sortableTable.setValue(51new Integer(30));
        sortableTable.setValue(52new SimpleDate(2001423));
        sortableTable.setValue(53new Float("892.72"));

        sortableTable.setValue(60"Wasim Khan");
        sortableTable.setValue(61new Integer(35));
        sortableTable.setValue(62new SimpleDate(1999710));
        sortableTable.setValue(63new Float("1242.89"));

        sortableTable.setValue(70"Bob Hammel");
        sortableTable.setValue(71new Integer(56));
        sortableTable.setValue(72new SimpleDate(1995214));
        sortableTable.setValue(73new Float("107.21"));

        sortableTable.setValue(80"Jeanie Sa-ville");
        sortableTable.setValue(81new Integer(58));
        sortableTable.setValue(82new SimpleDate(198961));
        sortableTable.setValue(83new Float("2372.42"));

        sortableTable.setValue(90"Scott Loyet");
        sortableTable.setValue(91new Integer(42));
        sortableTable.setValue(92new SimpleDate(1992229));
        sortableTable.setValue(93new Float("896.74"));

        sortableTable.setValue(100"Dennis Twiss");
        sortableTable.setValue(101new Integer(59));
        sortableTable.setValue(102new SimpleDate(1990415));
        sortableTable.setValue(103new Float("1896.74"));
        
        sortableTable.setValue(110"Mike McIntosh");
        sortableTable.setValue(111new Integer(76));
        sortableTable.setValue(112new SimpleDate(1982525));
        sortableTable.setValue(113new Float("689.77"));
        
        sortableTable.setValue(120"Andrews Andy");
        sortableTable.setValue(121new Integer(62));
        sortableTable.setValue(122new SimpleDate(1994115));
        sortableTable.setValue(123new Float("829.24"));

        sortableTable.setValue(130"Bob Regent");
        sortableTable.setValue(131new Integer(29));
        sortableTable.setValue(132new SimpleDate(1996312));
        sortableTable.setValue(133new Float("621.52"));
        
        sortableTable.setValue(140"Chris Chalmers");
        sortableTable.setValue(141new Integer(32));
        sortableTable.setValue(142new SimpleDate(199741));
        sortableTable.setValue(143new Float("804.26"));
        
        sortableTable.setValue(150"Christopher Mathrusse");
        sortableTable.setValue(151new Integer(64));
        sortableTable.setValue(152new SimpleDate(2005910));
        sortableTable.setValue(153new Float("761.25"));
        
        sortableTable.setValue(160"John Smith");
        sortableTable.setValue(161new Integer(56));
        sortableTable.setValue(162new SimpleDate(1992316));
        sortableTable.setValue(163new Float("789.29"));
        
        sortableTable.setValue(170"Jane Smith");
        sortableTable.setValue(171new Integer(45));
        sortableTable.setValue(172new SimpleDate(1989725));
        sortableTable.setValue(173new Float("2254.87"));
        
        sortableTable.setValue(180"Jason Chen");
        sortableTable.setValue(181new Integer(37));
        sortableTable.setValue(182new SimpleDate(1995824));
        sortableTable.setValue(183new Float("978.32"));
        
        sortableTable.setValue(190"Tina Matt");
        sortableTable.setValue(191new Integer(49));
        sortableTable.setValue(192new SimpleDate(1998915));
        sortableTable.setValue(193new Float("189.64"));
        
        sortableTable.setValue(200"Roxanne Rocks");
        sortableTable.setValue(201new Integer(43));
        sortableTable.setValue(202new SimpleDate(19921112));
        sortableTable.setValue(203new Float("1209.73"));
        
      // In your application code, the following should be part 
        // of the looop that adds the data to the Table.
        // Since we have some hard-coded data here, this is done 
        // separately down here....
        // Please note that this is totally optional. This has nothing
        // to do with the Sorting capabilities of the widget.
        // This is just the cosmetics injection to the table.
        
        // Set Style Name for the header
      RowFormatter rowFormatter = sortableTable.getRowFormatter();
      rowFormatter.setStyleName(0"tableHeader");
      
      // Set the Styles for the Data Rows and Columns
      CellFormatter cellFormatter = sortableTable.getCellFormatter();
      // Set the styles for the headers
      for (int colIndex=0; colIndex<4; colIndex++){
        cellFormatter.setStyleName(0, colIndex, "headerStyle");
        cellFormatter.setAlignment(0, colIndex, HasHorizontalAlignment.ALIGN_CENTER, HasVerticalAlignment.ALIGN_MIDDLE);
      }

      for(int rowIndex=1; rowIndex<21; rowIndex++){
        if(rowIndex%== 0){
          rowFormatter.setStyleName(rowIndex, "customRowStyle");
        }else{
          rowFormatter.setStyleName(rowIndex, "tableRow");
        }
        for (int colIndex=0; colIndex<4; colIndex++){
          cellFormatter.setStyleName(rowIndex, colIndex, "customFont");
          if(colIndex == || colIndex == 3){
            cellFormatter.setAlignment(rowIndex, colIndex, HasHorizontalAlignment.ALIGN_RIGHT, HasVerticalAlignment.ALIGN_MIDDLE);
          }else if(colIndex == 0){
            cellFormatter.setAlignment(rowIndex, colIndex, HasHorizontalAlignment.ALIGN_LEFT, HasVerticalAlignment.ALIGN_MIDDLE);
          }if(colIndex == 2){
            cellFormatter.setAlignment(rowIndex, colIndex, HasHorizontalAlignment.ALIGN_CENTER, HasVerticalAlignment.ALIGN_MIDDLE);
          }
        }
      }
        
        // Add the table to the doc
      RootPanel.get("slot1").add(sortableTable);
    }
}



 class SimpleDate extends Date {

  public SimpleDate(){
    super();
  }
  
  public SimpleDate(int year, int month, int date){
    super(year-1900, month-1, date);
  }
  
  public int compareTo(Object other) {
    Date otherDate = (Date)other;
    return super.compareTo(otherDate);
  }
  
  public String toString(){
    return this.formatDate_DDMONYYYY(this);
  }

  /*
   * formatDate_DDMONYYYY
   
   * Formats the date in DDMONYYYY format
   
   * @param (Date to be formatted)
   * @return String
   */
  private String formatDate_DDMONYYYY(Date date){
    String[] MONTHS = {
      "Jan",
      "Feb",
      "Mar",
      "Apr",
      "May",
      "Jun",
      "Jul",
      "Aug",
      "Sep",
      "Oct",
      "Nov",
      "Dec"
    };    
    StringBuffer dateStr = new StringBuffer();
    if(date.getDate() 10){
      dateStr.append("0");
    }
    dateStr.append(date.getDate());
    dateStr.append(" ");
    
    dateStr.append(MONTHS[date.getMonth()]);
    dateStr.append(" ");
    
    dateStr.append((date.getYear()+1900));
    return dateStr.toString();
  }      
  
  /*
   * formatDate_MMDDYYYY
   
   * Formats the date in MMDDYYYY format
   
   * @param (Date to be formatted)
   * @return String
   */
  private String formatDate_MMDDYYYY (Date date){
    StringBuffer strDate = new StringBuffer();
    if(this.getMonth() 9){
      strDate.append("0");
    }
    strDate.append(this.getMonth()+1);
    strDate.append("/");
    if(this.getDate() 10){
      strDate.append("0");
    }
    strDate.append(this.getDate());
    strDate.append("/");
    strDate.append((this.getYear()+1900));
    
    return strDate.toString();
  }
}


/*
 * SortableTable Widget for GWT library of Google, Inc.
 
 * Copyright (c) 2006 Parvinder Thapar
 * http://psthapar.googlepages.com/
 
 * This library is free software; you can redistribute 
 * it and/or modify it under the terms of the GNU Lesser 
 * General Public License as published by the Free Software 
 * Foundation; either version 2.1 of the License, or 
 * (at your option) any later version. This library is 
 * distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNULesser General Public License for more details. 
 * You should have received a copy of the GNU Lesser General 
 * PublicLicense along with this library; if not, write to the 
 * Free Software Foundation, Inc.,  
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA  
 */


/*
 * RowData defines one row in a Sortable Table
 */
 class RowData implements Comparable {
  
  // Maintains the list of the columns in the table
  List columnValues = new ArrayList();
  
  // Keeps the current column index being sorted
  int sortColIndex = 0;

  /*
   * addColumnValue
   
   * Adds the Comparable Value in the List of columns
   
   * @param Comparable
   */
  public void addColumnValue(Comparable value){
    this.columnValues.add(value);
  }
  
  /*
   * addColumnValue
   
   * Adds the Comparable Value in the specific index in the
   * List of columns
   
   * @param colIndex (int)
   * @param Comparable
   */
  public void addColumnValue(int index, Comparable value){
    if(index >= this.columnValues.size()){
      addNullColumns(index);
    }
    this.columnValues.set(index, value);
  }  

  /*
   * getColumnValue
   
   * Retrieves the Comparable Object from the List of columns
   
   * @param colIndex (int)
   * @return Object
   */
  public Object getColumnValue(int index){
    return this.columnValues.get(index);
  }  
  
  /*
   * addColumnValues
   
   * Retrieves the list of column values
   
   * @return List
   */
  public List getColumnValues() {
    return columnValues;
  }

  /*
   * setColumnValues
   
   * Sets the List to the List of column values
   
   * @param List
   */
  public void setColumnValues(List columnValues) {
    this.columnValues = columnValues;
  }

  /*
   * getSortColIndex
   
   * Returns the current column index being sorted
   
   * @return colIndex (int)
   */
  public int getSortColIndex() {
    return sortColIndex;
  }

  /*
   * setSortColIndex
   
   * Sets the current column index being sorted
   
   * @param colIndex (int)
   */
  public void setSortColIndex(int sortColIndex) {
    this.sortColIndex = sortColIndex;
  }

  /*
   * compareTo
   
   * Implementation of Interface Comparable 
   * Returns the compare result to another RowData object
   
   * @param colIndex (int)
   */
  public int compareTo(Object other) {
    if(null == other){
      return -1;
    }
    RowData otherRow = (RowData)other;
    Comparable obj1 = (Comparable)this.getColumnValue(this.sortColIndex);
    Comparable obj2 = (Comparable)otherRow.getColumnValue(this.sortColIndex);
    return obj1.compareTo(obj2);
  }
  
  /*
   * addNullColumns
   
   * Adds the Null columns in the table row
   *  
   * @param colIndex (int)
   * @deprecated
   */
  private void addNullColumns(int index){
    for(int nullIndex=this.columnValues.size(); nullIndex<=index; nullIndex++){
      columnValues.add(null);
    }
  }
}

/*
 * SortableTable Widget for GWT library of Google, Inc.
 
 * Copyright (c) 2006 Parvinder Thapar
 * http://psthapar.googlepages.com/
 
 * This library is free software; you can redistribute 
 * it and/or modify it under the terms of the GNU Lesser 
 * General Public License as published by the Free Software 
 * Foundation; either version 2.1 of the License, or 
 * (at your option) any later version. This library is 
 * distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNULesser General Public License for more details. 
 * You should have received a copy of the GNU Lesser General 
 * PublicLicense along with this library; if not, write to the 
 * Free Software Foundation, Inc.,  
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA  
 */

/*
 * Sortable Interface defines the signatures and the 
 * constants for the sortable table
 */
interface Sortable {
  // Constants defining the current direction of the 
  // sort on a column
  public static int SORT_ASC = 0;
  public static int SORT_DESC = 1;
  
  /*
   * sort
   
   * Defines what happens when the column is sorted
   
   * @param columnIndex to be sorted (int)
   */
  public void sort(int columnIndex);
}

/*
 * SortableTable Widget for GWT library of Google, Inc.
 
 * Copyright (c) 2006 Parvinder Thapar
 * http://psthapar.googlepages.com/
 
 * This library is free software; you can redistribute 
 * it and/or modify it under the terms of the GNU Lesser 
 * General Public License as published by the Free Software 
 * Foundation; either version 2.1 of the License, or 
 * (at your option) any later version. This library is 
 * distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNULesser General Public License for more details. 
 * You should have received a copy of the GNU Lesser General 
 * PublicLicense along with this library; if not, write to the 
 * Free Software Foundation, Inc.,  
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA  
 */




/*
 * SortableTable is a type of FlexTable which allows Sorting
 * on its column. Sorting is done totally on the client side.
 * No server side call is made in this table.
 
 * Current implementation of Sortable Table needs <code>Comparable</code>
 * Object in its column values to be able to sort them correctly
 
 * The objects being set in the column values must implement the interface
 * <code>Comparable</code> and implement methods: compareTo() and 
 * toString()
 *  
 * {@link com.google.gwt.user.client.ui.FlexTable}
 * {@link java.lang.Comparable}
 */
class SortableTable extends FlexTable implements Sortable, TableListener {
  
  // Holds the current column being sorted
  private int sortColIndex    =  -1;
  
  // Holds the current direction of sort: Asc/ Desc
  private int sortDirection    =  -1;
  
  // The default image to show acending order arrow
  private String sortAscImage   = "images/asc.gif";
  
  //The default image to show descending order arrow
  private String sortDescImage  = "images/desc.gif";
  
  // The default image to show the blank image
  // This is needed to paint the columns other than
  // the one which is being sorted.
  // Should be same length and width as the asc/ desc
  // images.
  private String blankImage    = "images/blank.gif";

  // Holds the data rows of the table
  // This is a list of RowData Object
  private List tableRows       = new ArrayList();
  
  // Holds the data for the column headers
  private List tableHeader     = new ArrayList();
  
  /*
   * Default Constructor
   
   * Calls the super class constructor
   * and adds a TableListener object
   */
  public SortableTable(){
    super();
    this.addTableListener(this);
  }

  /*
   * addColumnHeader
   
   * Adds the Column Header to the table
   * Uses the rowIndex 0 to add the header names.
   * Renders the name and the asc/desc/blank gif 
   * to the column
   
   * @param columnName (String)
   * @param columnIndex (int)
   */
  public void addColumnHeader(String name, int index){
    tableHeader.add(index, name);
    this.renderTableHeader(name, index);
  }
  
  /*
   * setValue
   
   * Sets the values in specifed row/column
   * Expects a Comparable Object for sorting
   *  
   * @param rowIndex (int)
   * @param columnIndex (int)
   * @param Value (Comparable)
   */
  public void setValue(int rowIndex, int colIndex, Comparable value){
    // The rowIndex should begin with 1 as rowIndex 0 is for the Header
    // Any row with index == 0 will not be displayed.
    if(rowIndex == 0){
      return;
    }
    
    if((rowIndex-1>= this.tableRows.size() || null == tableRows.get(rowIndex-1)){
      tableRows.add(rowIndex-1new RowData());
    }
    
    RowData rowData = (RowData)this.tableRows.get(rowIndex-1)
    rowData.addColumnValue(colIndex, value);
    this.setHTML(rowIndex, colIndex, "" + value.toString()"");
  }
  
  /*
   * sort
   
   * Implementation of Sortable Interface, this
   * method decribes how to sort the specified
   * column. It checks the current sort direction
   * and flips it
   *  
   * @param columnIndex (int)
   */
  public void sort(int columnIndex){
    Collections.sort(this.tableRows);
    if(this.sortColIndex != columnIndex){
      // New Column Header clicked
      // Reset the sortDirection to ASC
      this.sortDirection = SORT_ASC;
    }else{
      // Same Column Header clicked
      // Reverse the sortDirection
      this.sortDirection = (this.sortDirection == SORT_ASC)? SORT_DESC:SORT_ASC; 
    }
    this.sortColIndex = columnIndex;
  }
  
  /*
   * onCellClicked
   
   * Implementation of Table Listener Interface, this
   * method decribes what to do when a cell is clicked
   * It checks for the header row and calls the sort 
   * method to sort the table
   *  
   * @param sender (SourcesTableEvents)
   * @param rowIndex (int)
   * @param colIndex (int)
   */
  public void onCellClicked(SourcesTableEvents sender, int row, int col) {
    if(row != 0){
      return;
    }
    this.setSortColIndex(col);
    this.sort(col);
    this.drawTable();
  }  

  /*
   * getSortAscImage
   
   * Getter for Sort Ascending Image
   
   * @return String
   */
  public String getSortAscImage() {
    return sortAscImage;
  }

  /*
   * setSortAscImage
   
   * Setter for Sort Ascending Image
   
   * @param relative path + image name (String)
   * e.g. images/asc.gif
   */
  public void setSortAscImage(String sortAscImage) {
    this.sortAscImage = sortAscImage;
  }

  /*
   * getSortDescImage
   
   * Getter for Sort Descending Image
   
   * @return String
   */
  public String getSortDescImage() {
    return sortDescImage;
  }

  /*
   * setSortDescImgage
   
   * Setter for Sort Descending Image
   
   * @param relative path + image name (String)
   * e.g. images/desc.gif
   */
  public void setSortDescImgage(String sortDescImgage) {
    this.sortDescImage = sortDescImgage;
  }
  
  /*
   * getBlankImage
   
   * Getter for blank Image
   
   * @return String
   */
  public String getBlankImage() {
    return blankImage;
  }

  /*
   * setBlankImage
   
   * Setter for the blank Image
   
   * @param relative path + image name (String)
   * e.g. images/blank.gif
   */
  public void setBlankImage(String blankImage) {
    this.blankImage = blankImage;
  }
  
  /*
   * drawTable
   
   * Renders the header as well as the body 
   * of the table
   */
  protected void drawTable(){
    this.displayTableHeader();
    this.displayTableBody();
  }
  
  /*
   * displayTableHeader
   
   * Renders only the table header
   */
  private void displayTableHeader(){
    int colIndex=0;
    for(Iterator colHeaderIter = this.tableHeader.iterator(); colHeaderIter.hasNext();){
      String colHeader = (String)colHeaderIter.next();
      this.renderTableHeader(colHeader, colIndex++);
    }
  }
  
  /*
   * displayTableBody
   
   * Renders the body or the remaining rows of the table
   * except the header.
   * It checks the sort direction and displays the rows 
   * accordingly
   */
  private void displayTableBody(){
    if(this.sortDirection == SORT_ASC || this.sortDirection == -1){
      // Ascending order and Default Display
      for(int rowIndex=0; rowIndex<tableRows.size(); rowIndex++){
        RowData columns = (RowData)tableRows.get(rowIndex);
        for(int colIndex=0; colIndex<columns.getColumnValues().size(); colIndex++){
          Object value = columns.getColumnValue(colIndex);
          if(null != value){
            this.setHTML(rowIndex+1, colIndex, value.toString());
          }
        }
      }
    }else{
      // Descending Order Display
      for(int rowIndex=tableRows.size()-1, rowNum = 1; rowIndex>=0; rowIndex--, rowNum++){
        RowData columns = (RowData)tableRows.get(rowIndex);
        for(int colIndex=0; colIndex<columns.getColumnValues().size(); colIndex++){
          Object value = columns.getColumnValue(colIndex);
          if(null != value){
            this.setHTML(rowNum, colIndex, value.toString());
          }
        }
      }
    }
  }
  
  /*
   * setSortColIndex
   
   * Sets the current column index being sorted
   
   * @param column index being sorted (int)
   */
  private void setSortColIndex(int sortIndex){
    for(int rowIndex=0; rowIndex<tableRows.size(); rowIndex++){
      RowData row = (RowData)tableRows.get(rowIndex);
      row.setSortColIndex(sortIndex);
    }
  }
  
  /*
   * renderTableHeader
   * Renders a particular column in the Table Header
   
   * @param Column Name (String)
   * @param Column Index (int) 
   */
  private void renderTableHeader(String name, int index){
    StringBuffer headerText = new StringBuffer();
    headerText.append(name);
    headerText.append("&nbsp;<img border='0' src=");
    if(this.sortColIndex == index){
      if(this.sortDirection == SORT_ASC){
        headerText.append("'" this.sortAscImage + "' alt='Ascending' ");  
      }else{
        headerText.append("'" this.sortDescImage + "' alt='Descending' ");
      }
    }else{
      headerText.append("'" this.blankImage + "'");
    }
    headerText.append("/>");

    this.setHTML(0, index, headerText.toString());
  }
}

           
         
    
  
GWT-SortableTable.zip( 9 k)
Related examples in the same category
1.Absolute Table
2.Dynamic Table
3.Set up drag and drop between ListGrids (Smart GWT)Set up drag and drop between ListGrids (Smart GWT)
4.Adding Selection listener to ListGrid (Smart GWT)Adding Selection listener to ListGrid (Smart GWT)
5.Menus support all the drag and drop behaviors supported by grids (Smart GWT)Menus support all the drag and drop behaviors supported by grids (Smart GWT)
6.Single column ListGrid (Smart GWT)Single column ListGrid (Smart GWT)
7.extends ListGridRecord to create Record for ListGrid (Smart GWT)extends ListGridRecord to create Record for ListGrid (Smart GWT)
8.Grid Form Add Sample (Smart GWT)Grid Form Add Sample (Smart GWT)
9.Grid Form Update Sample (Smart GWT)Grid Form Update Sample (Smart GWT)
10.Nested Form in a Grid Sample (Smart GWT)Nested Form in a Grid Sample (Smart GWT)
11.Grid Simple Freeze Sample (Smart GWT)Grid Simple Freeze Sample (Smart GWT)
12.Grid Dynamic Freeze Sample (Smart GWT)Grid Dynamic Freeze Sample (Smart GWT)
13.Table Autofit Filter Sample (Smart GWT)Table Autofit Filter Sample (Smart GWT)
14.Table selection event (Smart GWT)Table selection event (Smart GWT)
15.Table Header Hover Tips Sample (Smart GWT)Table Header Hover Tips Sample (Smart GWT)
16.Table with Multiple Selection Sample (Smart GWT)Table with Multiple Selection Sample (Smart GWT)
17.Table record clicked event (Smart GWT)Table record clicked event (Smart GWT)
18.Table record double-clicked event (Smart GWT)Table record double-clicked event (Smart GWT)
19.Table row context click handler (Smart GWT)Table row context click handler (Smart GWT)
20.Table mouse hover event (Smart GWT)Table mouse hover event (Smart GWT)
21.Table columns are sorted as date, number, and calculated number values, respectively (Smart GWT)Table columns are sorted as date, number, and calculated number values, respectively (Smart GWT)
22.Table cell hover tooltip (Smart GWT)Table cell hover tooltip (Smart GWT)
23.Show/hide table header (Smart GWT)Show/hide table header (Smart GWT)
24.extends ListGrid (Smart GWT)extends ListGrid (Smart GWT)
25.Drag to reorder table rows (Smart GWT)Drag to reorder table rows (Smart GWT)
26.Add to / clear ListGrid (Smart GWT)Add to / clear ListGrid (Smart GWT)
27.Grid Dependent Selects Sample (Smart GWT)Grid Dependent Selects Sample (Smart GWT)
28.Table Single Select Sample (Smart GWT)Table Single Select Sample (Smart GWT)
29.Nested Grid in another Grid cell Sample (Smart GWT)Nested Grid in another Grid cell Sample (Smart GWT)
30.Formula Summary Builder Sample (Smart GWT)Formula Summary Builder Sample (Smart GWT)
31.Add paging support for a local collection of models (Ext GWT)Add paging support for a local collection of models (Ext GWT)
32.Total summary table (Ext GWT)Total summary table (Ext GWT)
33.Load from Php and add to table with LiveGridView (Ext GWT)Load from Php and add to table with LiveGridView (Ext GWT)
34.Using BufferView to create buffered grid (Ext GWT)Using BufferView to create buffered grid (Ext GWT)
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.