Win a copy of Head First Android this week in the Android forum!
  • Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other Pie Elite all forums
this forum made possible by our volunteer staff, including ...
Marshals:
  • Tim Cooke
  • Campbell Ritchie
  • Paul Clapham
  • Ron McLeod
  • Liutauras Vilda
Sheriffs:
  • Jeanne Boyarsky
  • Rob Spoor
  • Bear Bibeault
Saloon Keepers:
  • Jesse Silverman
  • Tim Moores
  • Stephan van Hulst
  • Tim Holloway
  • Carey Brown
Bartenders:
  • Piet Souris
  • Al Hobbs
  • salvin francis

Struts 2 and auto population of HTML tables

 
Ranch Hand
Posts: 95
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Hi,

I am working away on a site using struts 2 and tiles 2. This is all new to me but I am making steady progress. Struts 2 and tiles 2 are great to work with.

Now I am wondering does anyone know of a tutorial that shows how to populate a table dynamically and sort dynamically using struts 2, JSON, Dojo.
I know nothing about JSON or DOJO so I need a tutorial/WAR with every import and show you every jar you need.

Im pretty certain I can just have a table in a JSP like so


and have dojo, json populate the table through annotating a java class. I know very little about annotations aswell.
This is why I need a tutorial/War with all the bells and whistles.

This is the best I could find but cant get it working
http://www.javaworld.com/javaworld/jw-08-2007/jw-08-ajaxtables.html?page=1

Thanks
Alan

 
Ranch Hand
Posts: 185
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
can you look into ajaxTags and Display tag.
 
Ally Cavs
Ranch Hand
Posts: 95
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
OK will Thanks very much for your reply
 
Greenhorn
Posts: 15
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
If you are using javascript


//*****************************************************************************
// Filename: sortTable.js
// Description: This javascript file can be applied to convert record tables
// in a HTML file to be client-side sortable by associating title columns with
// sort events.
//
// COPYRIGHT (C) 2002 HAN J. YU
// THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY IT
// UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY THE FREE
// SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR (AT YOUR OPTION)
// ANY LATER VERSION. THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE
// USEFUL, BUT WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
// MERCHANTABILITY OF FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU GENERAL
// PUBLIC LICENSE FOR MORE DETAILS.
//
// YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE ALONG
// WITH THIS PROGRAM; IF NOT, WRITE TO:
//
// THE FREE SOFTWARE FOUNDATION, INC.,
// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
//
// Bugs/Comments: han@velocityhsi.com
//
// Change History:
//
// 11-26-01:
// o Made a few more settings configurable (i.e. data delimiter etc).
// o Added a check for the browser type/version (>= IE 5.0 allowed).
// 11-27-01:
// o Used document.getElementById method to retrieve object
// o Now supports both IE 5.0 or greater and Netscape 6.0 or greater
// 11-28-01:
// o Fixed the status display for Netscape.
// o Fixed the cursor shape for Netscape. Used pointer instead of hand.
// 11-29-01:
// o Fixed a cursor bug for IE 5.5
// 12-03-01:
// o Uses delete/insert cell when doing the sort.
// o Uses delete/insert cell for the title.
// 12-04-01:
// o Created redrawTitle function to tidy things up a bit.
// 12-09-01:
// o Used the innerMost cell's nodeValue to display title name.
// 12-10-01:
// o Now preserves the align property of the title cell.
// o Allows to have multiple child nodes inside the title cell.
// o Simulates <TH> by centeing and bold-facing title cell contents.
// 01-21-02: (Thanks to Ric Shumack ...)
// o Added one more condition for table init call (table.tainted == false)
// o Used the preferred method for checking the browser version
// 03-01-02: (Recommendation from Dan ...)
// o Default sorting will be applied to all tables upon loading
// 03-12-02:
// o Changed parseInt to parseFloat in compare function
// 03-13-02:
// o Ignores THEAD, TFOOT in the data row list
// 03-18-02:
// o Compare as numbers only if both inputs are number
// 03-19-02:
// o Now compares IETF recognized date string inputs
// 03-29-02: (Recommendation from Ashley ...)
// o New global settings for up/down images and title font face
// 03-31-02:
// o Retains various cell properties
// o align, vAlign, bgColor, noWrap, width, height
// o borderColor, borderColorLight, borderColorDark
// o Bug fix in isDate method.
// 04-04-02: (Thanks to Steen ...)
// o Can have separate table for titles
// 04-06-02: (Thanks to Steen ...)
// o CSS properties are preserved
// o Bug fix (  removed)
// o Title cell events applied to cells
// 04-08-02:
// o Used eval to simplify the code
// 04-24-02:
// o Removes HTML tags when comparing cell content
// 05-07-02:
// o Handles Euro date format
// 05-15-02:
// o Fixed up/down replacement reg exp
// 06-13-02:
// o Title column hints (via TITLE) added
// 07-12-02:
// o Changed up/down char to up/down arrows
// o Up/down arrows get displayed if doSortUponLoad is set
// 07-15-02:
// o Added a new feature to allow skipping columns when sorting
// o This requires 2nd parameter to specify which columns to skip
// 07/19-02:
// o Title cells can be highlighted (bgcolor chaged) onMouseOver ...
// 09-04-02:
// o Bug fix in cell highlighting functionality
// 09-06-02:
// o Mouse pointer becomes hourglass while sorting
// 09-21-02:
// o Sorting is mistakenly done twice if doSortUponLoad is set
// o Mouse pointer to hourglass while sorting ... (bug fixes)
// o Use "" as default in cursor settings
// o DOES NOT WORK WITH NETSCAPE ... TO BE FIXED SOON !!!
// 09-22-02:
// o Made it work with Netscape
// 09-23-02:
// o Fixed error if doSortUponLoad is NOT set
// o Sort direction alternates even between tables
//*****************************************************************************

//*****************************************************************************
// sortTable.js
//
// This script contains useful functions that can be used to convert ordinary
// tables into sortable tables by modifying the HTML sources.
//
// Here is how one can do that. The following assumptions are required
// for the tables to be sorted.
//
// 1. All the record columns must be the same lengh. Otherwise (i.e. the ones
// that contain colspan) the rows will be ignored.
//
// 2. Row spans can not happen in the record rows though column spans
// can be one of the record rows.
//
// 3. Row-spanned single column will be considered as title.
//
// To enable the sorting, simply include this javascript source file and
// add an onLoad event to the <body> like below:
//
// <body onLoad='initTable("table1");initTable("table2");' ...>
//
// Note that all the tables that need to be sorted MUST contain ID tag.
// So, if they do not exist, you must create one for each table that
// needs to be sorted. Also, the table names/ids MUST BE UNIQUE.
//*****************************************************************************
// Global variables
var table; // Table object
var ttable; // Title Table object
var tableId; // Current Table ID
var ttableId; // Current Title Table ID
var tableIdArray = new Array(); // Holds Tabld IDs
var sortDirArray = new Array(); // Holds sort direction (descending)
var tableCount = 0; // Total table count
var rowArray = new Array(); // Data row array
var rowIdArray = new Array(); // Data row ID array
var rowPropArray = new Array(); // Data row property array
var titleRowArray = new Array(); // Contains row pointer for titles
var titleInnerHTMLArray = new Array(); // Contains innerHTML for title cells
var titleSpanCountArray = new Array(); // Contains the row-span count
var titleRowCellArray = new Array(); // Dynamically constructed title cells
var titleSpanCellArray = new Array(); // Title elelments from row-spanned
var colSpanArray = new Array(); // Rows col-spanned
var colTitleFilled = new Array(); // Indicates whether title is filled
var sortIndex; // Selected index for sort
var nRow, actualNRow, maxNCol; // Various table stats
var origColor; // Holds original default color
var isIE; // True if IE
var separateTitle = false; // Has separate title table
var linkEventString = // What's insider <a> tag
'onMouseOver=\'setCursor(this);' +
'setColor(this,"selected");\' ' +
'onMouseOut=\'setColor(this,"default");\' ' +
'onClick="setCursorWait(this);setTimeout(\'sortTable(';
var cellPropArray = new Array( // Cell properties to preserve
"align", "vAlign", "bgColor",
"noWrap", "width", "height",
"borderColor",
"borderColorLight",
"borderColorDark");
var colsToIgnoreArray; // Col indexes to ignore (Array)
var colsToIgnore; // Col indexes to ignore

// Configurable constants
var useImg = false; // Uses images if true
var ascChrFile = "up.gif"; // Image for ascending sort
var desChrFile = "down.gif"; // Image for descending sort
var ascChr = "↑"; // Symbol for ascending sort
var desChr = "↓"; // Symbol for descending sort
var useCustomTitleFont = false; // Uses custom fonts for titles
var titleFont = "Trebuchet MS"; // Title Font
var selectedColor = "blue"; // Color for sort focus
var defaultColor = "black"; // Default color for sort off-focus
var recDelimiter = '|'; // Char used as a record separator
var cellPropDelimiter = ","; // Char used as a cell prop separator
var updownColor = 'gray'; // Specified the color for up/downs
var doSortUponLoad = true; // Do the sort upon page load
var defaultSortColumn = 0; // Indicates the default sort column index
var useEuroDate = false; // Set if Euro Date format is used
var highlightSelCell = false; // Set if selected cell needs to be highlighted
var cellHighlightColor = "red"; // Color for cell highlight

//*****************************************************************************
// Main function. This is to be associated with onLoad event in <BODY>.
//
// IMPORTANT: This is the only function that needs to be included in the pages
// to be sorted. The rest of the functions are simply called by this
// function.
//*****************************************************************************
function initTable(obj,ignore)
{
var tIndex;

// Check whether it's viewed by IE 5.0 or greater
if (! checkBrowser()) return;

// Cols to ignore
colsToIgnore = ignore;
if (colsToIgnore != null)
colsToIgnoreArray = ignore.split(",");
else
colsToIgnore = null;

// Local variables
var countCol;
var currentCell;
var nColSpan, nRowSpannedTitleCol, colPos;
var titleFound = false;
var skipRow = false;
var rNRowSpan, rNColSpan, parentNodeName;
var cCellContent, cCellSetting;
var sObj;
var ctable;
var doneftable = false;
var cmd;
var tableLoaded = false;

// Initializing global table object variable
if (obj.tagName == "TABLE")
{
// Assumes that the obj is THE OBJECT
table = obj;
}
else
{
table = document.getElementById(obj);
sObj = obj.id + "title";
ttable = document.getElementById(sObj);
}

// Check whether it's an object
if (table == null) return;

// Check whether it's a table
if (table.tagName != "TABLE") return;

if (ttable != null && ttable.tagName == "TABLE")
separateTitle = true;

// No need to re-init if it's already done
if (tableId == table.id && table.tainted == false) return;

// Setting table id
tableId = table.id;

if (separateTitle) ttableId = ttable.id;

// Initializing the max col number with the size of last data row
maxNCol = table.rows[table.rows.length-1].cells.length;

// Initializing arrays
rowArray = new Array();
rowIdArray = new Array();
rowPropArray = new Array();
colSpanArray = new Array();
colTitleFilled = new Array();
titleRowArray = new Array();
titleInnerHTMLArray = new Array();
titleSpanCountArray = new Array();
titleRowCellArray = new Array();

for (var i=0; i<maxNCol; i++)
{
if (i == 0) continue;
colTitleFilled[i] = false;
}

// Setting the number of rows
nRow = table.rows.length;

// Should have at least 1 row
if (nRow < 1) return;

// Initialization of local variables
actualNRow = 0; // Number of actual data rows
rNRowSpan = 0; // Remaining rows in the row span
rNColSpan = 0; // Remaining cols in the col span
nRowSpannedTitleCol = 0; // Number of title cols from row span

// Loop through rows
for (var i=0; i<nRow; i++)
{
if (! separateTitle)
{
ctable = table;
}
else if (i == 0 && separateTitle && titleFound == false)
{
ctable = ttable;
nRow = ttable.rows.length + 1;
}

if (! doneftable && separateTitle && titleFound)
{
ctable = table;
nRow = table.rows.length;
i = 0;
doneftable = true;
}

skipRow = false;
// Skip if it's THEAD, TFOOT
if (ctable.rows[i].parentNode != null)
{
parentNodeName = ctable.rows[i].parentNode.nodeName;
parentNodeName.toUpperCase();
if (parentNodeName == 'THEAD' ||
parentNodeName == 'TFOOT')
{
skipRow = true;
}
}
nColSpan = 1, colPos = 0;
// Loop through columns
// Initializing
for (var j=0; j<ctable.rows[i].cells.length; j++)
{
// Do this iff title has not been found
if (titleFound == false)
{
if (ctable.rows[i].cells[j].rowSpan > 1)
{
if (ctable.rows[i].cells[j].colSpan < 2)
{
titleSpanCellArray[colPos] =
ctable.rows[i].cells[j];
titleRowArray[colPos] =
ctable.rows[i];
colTitleFilled[colPos] = true;
nRowSpannedTitleCol++;
}
if (ctable.rows[i].cells[j].rowSpan - 1
> rNRowSpan)
{
rNRowSpan =
ctable.
rows[i].cells[j].
rowSpan - 1;

if (ctable.rows[i].
cells[j].colSpan > 1)
rNColSpan =
rNRowSpan + 1;
}
}
}
if (ctable.rows[i].cells[j].colSpan > 1 &&
rNColSpan == 0)
{
nColSpan = ctable.rows[i].cells[j].colSpan;
colPos += nColSpan;
}
else
{
colPos++;
}
}

// Setting up the title cells
if (titleFound == false && nColSpan == 1 &&
rNRowSpan == 0 && rNColSpan == 0)
{
colSpanArray[i] = true;
titleFound = true;

// Using indivisual cell as an array element
countCol = 0;
for (var j=0;
j<ctable.rows[i].cells.length
+ nRowSpannedTitleCol; j++)
{
if (colTitleFilled[j] != true)
{
titleRowCellArray[j] =
ctable.rows[i].cells[countCol];
titleRowArray[j] =
ctable.rows[i];
countCol++;
}
else
{
titleRowCellArray[j] =
titleSpanCellArray[j];

}
titleInnerHTMLArray[j] =
String(titleRowCellArray[j].innerHTML);
titleSpanCountArray[j] =
titleRowCellArray[j].rowSpan;
}
}
// Setting up the data rows
else if (titleFound == true && nColSpan == 1 &&
rNRowSpan == 0 && !skipRow)
{
for (var j=0; j<ctable.rows[i].cells.length; j++)
{
// Can't have row span in record rows ...
if (ctable.rows[i].cells[j].rowSpan > 1) return;

currentCell = ctable.rows[i].cells[j];
cCellContent = String(currentCell.innerHTML);
for (var k=0; k<cellPropArray.length; k++)
{
if (k == 0)
cmd = "cCellSetting=" +
"String(currentCell." +
cellPropArray[k] + ");"
else
cmd = "cCellSetting+=" +
"cellPropDelimiter+" +
"String(currentCell." +
cellPropArray[k] + ");"
eval(cmd);
}

if (j == 0)
{
rowArray[actualNRow] = cCellContent;
rowPropArray[actualNRow] = cCellSetting;
}
else
{
rowArray[actualNRow] += recDelimiter +
cCellContent;
rowPropArray[actualNRow] +=
recDelimiter + cCellSetting;
}
if (j == ctable.rows[i].cells.length-1)
rowArray[actualNRow] += recDelimiter +
String(actualNRow);
}
// Inconsistent col lengh for data rows
if (ctable.rows[i].cells.length > maxNCol)
return;
actualNRow++;
colSpanArray[i] = false;
}
else if (nColSpan == 1 && rNRowSpan == 0 &&
rNColSpan == 0 && titleFound == false && !skipRow)
{
colSpanArray[i] = false;
}
else
{
colSpanArray[i] = true;
}

// Counters for row/column spans
if (rNRowSpan > 0) rNRowSpan--;
if (rNColSpan > 0) rNColSpan--;
}

// If the row number is < 1, no need to do anything ...
if (actualNRow < 1) return;

// Sorting upon loading the page
tIndex = findTableIndex(table.id);
if (tIndex >= 0) tableLoaded = true;
if (!tableLoaded)
{
tableIdArray[tableCount] = table.id;
sortDirArray[tableCount] = false;
tIndex = tableCount;
tableCount++;
}

// Re-drawing the title row
redrawTitle(false);

// Sort if doSortUponLoad is set
if (doSortUponLoad)
{
sortTable(defaultSortColumn, table.id, 0);
if (!tableLoaded) sortDirArray[tIndex] = true;
}
}

//*****************************************************************************
// Function called to re-draw title row
//*****************************************************************************
function redrawTitle(isSort)
{
var currentRow, innerHTML, newInnerHTML, cellIndex;
var reAnchor, reUpDown, reLabel, cellAlign, makeBold;
var cellOnmouseover, cellOnmouseout;
var cellClass;
var cmd;
var cCellPropArray = new Array();
var tIndex;

cellAlign = "";
makeBold = false;
reAnchor = / *\<a[^\>]*\>(.*) *\<\/a\>/i;
reUpDown = /\<font[^\>]* *id=.*updown.*[^\>]*\>.*\<\/font\>/i;
reLabel = /\>([^\<]*)\</g;

tIndex = findTableIndex(table.id);

// Re-drawing the title row
for (var j=0; j<maxNCol; j++)
{
currentRow = titleRowArray[j];
innerHTML = String(titleInnerHTMLArray[j]);
cellIndex = titleRowCellArray[j].cellIndex;

// Skips the columns if set to ignore
if (colsToIgnore != null)
if (indexExist(colsToIgnoreArray,cellIndex)) continue;

// Recording cell settings
for (var k=0; k<cellPropArray.length; k++)
{
cmd = "cCellPropArray[" + k +
"]=titleRowCellArray[j]." +
cellPropArray[k] + ";";
eval(cmd);
}
cellClass = titleRowCellArray[j].getAttribute('className');

currentRow.deleteCell(cellIndex);
currentRow.insertCell(cellIndex);

// Setting the font type for the title
if (cellAlign != "")
currentRow.cells[cellIndex].align =
cellAlign;
if (titleRowCellArray[j].tagName == "TH")
{
makeBold = true;
}

// Restoring cell settings
for (var k=0; k<cellPropArray.length; k++)
{
cmd = "currentRow.cells[cellIndex]." +
cellPropArray[k] +
"=cCellPropArray[" + k + "];";
eval(cmd);
}

currentRow.cells[cellIndex].setAttribute(
'className', cellClass, 0);

if (titleSpanCountArray[j] > 1)
currentRow.cells[cellIndex].rowSpan =
titleSpanCountArray[j];
newTitle = '';
if (j == sortIndex && isSort)
{
newTitle = '<font id=updown color=' +
updownColor + '> ';
if (sortDirArray[tIndex])
if (useImg)
newTitle += '<img src="' +
desChrFile + '" alt="' +
desChr + '">';
else
newTitle += desChr;
else
if (useImg)
newTitle += '<img src="' +
ascChrFile + '" alt="' +
ascChr + '">';
else
newTitle += ascChr;
newTitle += '</font>';
}
// Remove carriage return, linefeed, and tab
innerHTML = innerHTML.replace(/\r|\n|\t/g, "");
if (makeBold)
{
if (innerHTML.match(reLabel))
innerHTML =
innerHTML.replace(reLabel, "<b>$1</b>");
else
innerHTML =
innerHTML.replace(
/(^.*$)/, "<b>$1</b>");
}
innerHTML = innerHTML.replace(reUpDown, "");
innerHTML = innerHTML.replace(reAnchor, "$1");
newInnerHTML =
'<a ' + linkEventString + j + ',' +
tIndex + ',' + 1 + ',' + 1 + ')\', 1);">';
if (useCustomTitleFont)
newInnerHTML += '<font face="' + titleFont + '">' +
+ innerHTML + '</font>';
else
newInnerHTML += innerHTML;
newInnerHTML += '</a>' + newTitle;

currentRow.cells[cellIndex].innerHTML = newInnerHTML;
titleRowCellArray[j] = currentRow.cells[cellIndex];
}
}

//*****************************************************************************
// Function called when user clicks on a title to sort
//*****************************************************************************
function sortTable(index,tobj,doInit,isIndex)
{
var obj, tIndex;
if (isIndex != null)
if (isIndex)
{
tIndex = tobj;
// Look up the table object
obj = tableIdArray[tobj];
}
else
{
tIndex = findTableIndex(tobj.id);
obj = tobj;
}

// Re-inializing the table object
if (doInit)
{
if (colsToIgnore != null)
initTable(obj,colsToIgnore);
else
initTable(obj);
}

// Local variables
var rowContent, rowProp, cellProp;
var rowCount;
var rowIndex;
var cellClass, cellOnClick, cellMouseOver, cellMouseOut;
var cmd;

// Can't sort past the max allowed column size
if (index < 0 || index >= maxNCol) return;

// Assignment of sort index
sortIndex = index;
// Doing the sort using JavaScript generic function for an Array
rowArray.sort(compare);

// Re-drawing the title row
if (doInit || doSortUponLoad) redrawTitle(true);

// Re-drawing the table
rowCount = 0;
for (var i=0; i<nRow; i++)
{
if (! colSpanArray[i])
{
for (var j=0; j<maxNCol; j++)
{
// Skips the columns if set to ignore
if (colsToIgnore != null)
if (indexExist(colsToIgnoreArray,j))
continue;
rowContent = rowArray[rowCount].
split(recDelimiter);
rowIndex = rowContent[maxNCol];
rowProp = rowPropArray[rowIndex].
split(recDelimiter);
cellProp = rowProp[j].split(cellPropDelimiter);
cellClass =
table.rows[i].cells[j].getAttribute(
'className');
cellOnClick = table.rows[i].cells[j].onclick;
cellMouseOver =
table.rows[i].cells[j].onmouseover;
cellMouseOut =
table.rows[i].cells[j].onmouseout;

table.rows[i].deleteCell(j);
table.rows[i].insertCell(j);

// Restoring cell properties
for (var k=0; k<cellPropArray.length; k++)
{
cmd = "table.rows[i].cells[j]." +
cellPropArray[k] +
"=cellProp[" + k + "];";
eval(cmd);
}

table.rows[i].cells[j].innerHTML =
rowContent[j];
table.rows[i].cells[j].setAttribute(
'className', cellClass, 0);
table.rows[i].cells[j].onclick = cellOnClick;
table.rows[i].cells[j].onmouseover =
cellMouseOver;
table.rows[i].cells[j].onmouseout =
cellMouseOut;
}
rowCount++;
}
}

// Switching btw descending/ascending sort
if (doInit)
{
if (sortDirArray[tIndex])
sortDirArray[tIndex] = false;
else
sortDirArray[tIndex] = true;
}
setCursorDefault();
}

//*****************************************************************************
// Function to be used for Array sorting
//*****************************************************************************
function compare(a, b)
{
// Getting the table index
var tIndex;
tIndex = findTableIndex(table.id);

// Getting the element array for inputs (a,b)
var aRowContent = a.split(recDelimiter);
var bRowContent = b.split(recDelimiter);

// Needed in case the data conversion is necessary
var aToBeCompared, bToBeCompared;

// Remove HTML tags
reRowText = /(\< *[^\>]*\>|\ \;)/g;
aRowContent[sortIndex] = aRowContent[sortIndex].replace(reRowText, "");
bRowContent[sortIndex] = bRowContent[sortIndex].replace(reRowText, "");

// Euro Date format
if (useEuroDate)
{
aRowContent[sortIndex] =
convertEuroDate(aRowContent[sortIndex]);
bRowContent[sortIndex] =
convertEuroDate(bRowContent[sortIndex]);
}

if (isDate(aRowContent[sortIndex]) && isDate(bRowContent[sortIndex]))
{
aToBeCompared = new Date(aRowContent[sortIndex]);
bToBeCompared = new Date(bRowContent[sortIndex]);
}
else if (! isNaN(aRowContent[sortIndex]) &&
! isNaN(bRowContent[sortIndex]))
{
aToBeCompared = parseFloat(aRowContent[sortIndex], 10);
bToBeCompared = parseFloat(bRowContent[sortIndex], 10);
}
else
{
aToBeCompared = aRowContent[sortIndex];
bToBeCompared = bRowContent[sortIndex];
}

if (aToBeCompared < bToBeCompared)
if (!sortDirArray[tIndex])
{
return -1;
}
else
{
return 1;
}
if (aToBeCompared > bToBeCompared)
if (!sortDirArray[tIndex])
{
return 1;
}
else
{
return -1;
}
return 0;
}

//*****************************************************************************
// Function to determine whether it's a IETF recognized date string
//*****************************************************************************
function isDate(x)
{
var xDate;
xDate = new Date(x);
if (xDate.toString() == 'NaN' ||
xDate.toString() == 'Invalid Date')
return false;
else
return true;
}

//*****************************************************************************
// Function to convert EURO date
//*****************************************************************************
function convertEuroDate(x)
{
var reExp = /^ *(\d{2})\-(\d{2})\-(\d{4}) *$/g;
var dArray;
if (x.match(reExp))
x = x.replace(reExp, "$2\/$1\/$3");
return(x);
}

//*****************************************************************************
// Functions to set the cursor
//*****************************************************************************
function setCursor(obj)
{
var rowText, reRowText;

reRowText = /(\< *[^\>]*\>|\ \;)/g;
// Show hint text at the browser status bar
rowText = String(obj.innerHTML);

// Remove up/down
rowText = rowText.replace(/\<font id\=updown.*\<\/font\>/ig, "");
// Remove HTML tags and  
rowText = rowText.replace(reRowText, "");
// Remove carriage return, linefeed, and tab
rowText = rowText.replace(/\r|\n|\t/g, "");

// Setting window's status bar
window.status = "Click to sort by " + String(rowText);

// Setting title
obj.title = "Click to sort by " + String(rowText);

// Change the mouse cursor to pointer or hand
if (isIE)
obj.style.cursor = "hand";
else
obj.style.cursor = "pointer";
}

function setCursorWait(obj)
{
if (isIE && document.all)
for (var i=0;i<document.all.length;i++)
document.all(i).style.cursor = 'wait';
else
{
obj.style.cursor = 'wait';
document.body.style.cursor = 'wait';
}
}

function setCursorDefault()
{
if (isIE && document.all)
for (var i=0;i<document.all.length;i++)
document.all(i).style.cursor = '';
else
document.body.style.cursor = '';
}

//*****************************************************************************
// Function to set the title color
//*****************************************************************************
function setColor(obj,mode)
{
if (mode == "selected")
{
// Remember the original color
if (obj.style.color != selectedColor)
defaultColor = obj.style.color;
obj.style.color = selectedColor;

if (highlightSelCell)
obj.bgColor = cellHighlightColor;
}
else
{
// Restoring original color and re-setting the status bar
obj.style.color = defaultColor;
if (highlightSelCell) obj.bgColor = defaultColor;
window.status = '';
}
}

//*****************************************************************************
// Function to check browser type/version
//*****************************************************************************
function checkBrowser()
{
if (navigator.appName == "Microsoft Internet Explorer"
&& parseInt(navigator.appVersion) >= 4)
{
isIE = true;
return true;
}
// For some reason, appVersion returns 5 for Netscape 6.2 ...
else if (navigator.appName == "Netscape"
&& navigator.appVersion.indexOf("5.") >= 0)
{
isIE = false;
return true;
}
else
return false;
}

//*****************************************************************************
// Function to check whether index exists in array
//*****************************************************************************
function indexExist(x, index)
{
var found = false;
for (var i=0; i<x.length; i++)
{
if (index == x[i])
{
found = true;
break;
}
}
return found;
}

//*****************************************************************************
// Function to return table index given table id
//*****************************************************************************
function findTableIndex(id)
{
for (var i=0; i<tableCount; i++)
if (tableIdArray[i] == id)
return(i);
return(-1);
}
 
With a little knowledge, a cast iron skillet is non-stick and lasts a lifetime.
reply
    Bookmark Topic Watch Topic
  • New Topic