/*
'Author : Stefan Kruger
'Date Created : 28-Jul-2005
'Last Changed by : Stefan Kruger
'Date Changed : 28-Jul-2005
'Version : 1.0.28072005
'Comments:
'Date: Desc:
'--------------------------------------------------------------------------------------------
'ToDoList:
'Date: Desc: Status:
'------------------------------------------------------------------------------------------------
'28-Jul-2005 Code update run Not done
*/
//////////////////////////////////////////////////////////////////////////////////////////////
//DEFINITIONS
//////////////////////////////////////////////////////////////////////////////////////////////
//Definitions of grid slot data
var array_of_grids = new Array();
var array_of_gridtables = new Array();
var array_of_gridnames = new Array();
var array_of_gridtitles = new Array();
var array_of_griddivs = new Array();
var array_of_gridurls = new Array();
var array_of_gridcompids = new Array();
var array_of_gridfilterdata = new Array();
var array_of_columnnames = new Array();
var array_of_fieldnames = new Array();
var array_of_colorders = new Array();
var array_of_gridfilterindices = new Array();
var grid_num = 0;
//Contant content vars
var filterwarning = "
Large amount of data present - Filtering of data may be slow
";
var searchwarning = "
Please note : Your search did not return all results. Please refine
";
//////////////////////////////////////////////////////////////////////////////////////////////
//UTILITY FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////
/*
A function to check if grid with a specififed name currently exists.
Returns the gridIndex/gridObject of the first instance of the specified gridname
or -1/null if a matching grid is not found respectively.
indexOrObject : true --> return index of grid
indexOrObject : false --> return grid object itself
*/
function getGrid(gridName,indexOrObject){
//Return index
if (indexOrObject) {
for (i = 0; i < array_of_gridnames.length; i++){
if (array_of_gridnames[i] == gridName){
return i;
}
}
return -1;
}
//Return object
else {
for (i = 0; i < array_of_gridnames.length; i++){
if (array_of_gridnames[i] == gridName){
return array_of_grids[i];
}
}
return null;
}
}
/*
A function to check if a specififed column exists in a specified grid.
Returns the column id of the first instance of the specified columnname in the grid
or -1 if a matching column is not found.
If byNameOrByField is true --> Search columnname array
If byNameOrByField is false --> Search field array
*/
function getIDForColumnName(gridID,columnName,byNameOrByField){
var columnList;
try {
if (byNameOrByField) {
columnList = array_of_columnnames[gridID]
}
else {
columnList = array_of_fieldnames[gridID];
}
}
catch (ex) {}
if (columnList) {
if (columnList.length) {
for (c = 0; c < columnList.length; c++){
if (columnList[c].toLowerCase() == columnName.toLowerCase()) {
return c;
}
}
}
}
return -1;
}
/*
Function to generate a column data structure for the grid
*/
function createGridDataStructure(componentID,gridID,isModalGrid){
//alert(componentID + "||" + gridID);
var loadGridStructure = function (oXML) {
var retvalue = oXML.responseText;
//alert(retvalue)
var split = retvalue.split(";");
if (split.length == 4){
array_of_columnnames[gridID] = eval(split[0]);
array_of_fieldnames[gridID] = eval(split[1]);
array_of_colorders[gridID] = eval(split[2]);
}
else {
//alert("Grid columns not loaded");
}
regularCursor();
oXML = null;
}
var pathchange = "";
if (isModalGrid) {
pathchange = "/"
}
hiddenSubmit(pathchange + "include/gridmoduledynamic.asp","componentid=" + componentID,loadGridStructure,0,null,false);
return;
}
/*
Function to generate a Kelvinised header for the grid page
*/
function createHeader(title,subtitle){
return "
" + title + "
"
//return "
" + title + "
";
}
/*
Fucnion to handle the loading of the add page
*/
function loadAddPage(componentid,isModalGrid){
//alert("componentid :" + componentid);
checkAction("switchtoadd",componentid,null,false,null,isModalGrid);
}
/*
Function to generate a Kelvinised search box for the grid page
*/
function createSearch(gridID,componentID,prevSearch,isModalGrid,showAdd){
var AdvancedDiv = "";
if (showAdd) {
addString = "
";
}
/*
Function to generate a filter for the grid page
*/
function createFilter(columnNames,gridName,gridID){
var filter = "
";
for (var c = 0; c < columnNames.length; c++){
//filter += "";
filter += "";
}
filter += "
";
//alert(filter);
return filter;
}
/*
Function used when setting the action to handle the contextmenu
*/
function oncontextmenu (event){
cancelAction(event);
//this.action("contextmenu");
}
function cancelAction(event) {
event.cancelBubble = true;
event.returnValue = false;
if (event.preventDefault) {
event.stopPropogation();
event.preventDefault();
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
//GRID LOADING FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////
/*
Function used to locate a grid in a slot (or create a new slot if necessary)
*/
function create_grid(divToLoadIn,gridName,componentID,globalQueryString,useSecurityDB,usesStoredProcToLoad,loadData,usesFullTextSearch,isModalGrid,componentTitle,preSearchText,showAdd) {
var grid_current_id
//Check if grid has been created previously
grid_current_id = getGrid(gridName,true);
//^ComponentTitleMarker^
if (!(componentTitle)) {
componentTitle = gridName + " - No Title Specified";
}
//If grid has been not been created, set the grid_current_id to the last available slot
//and increment the global grid counter.
if (grid_current_id == -1){
//alert("Creating new grid slot and loading grid named : " + gridName + " in it.");
grid_current_id = grid_num;
grid_num++;
//Store name only in event of new grid getting created
array_of_gridnames[grid_current_id] = gridName;
//Create header data structures for the new grid
createGridDataStructure(componentID,grid_current_id,isModalGrid);
}
//Else the returned ID is assumed to be valid and is used
else {
//alert("Loading the new grid into an existing slot for grid named : " + array_of_gridnames[grid_current_id]);
//Clear any previous data used for filtering if exists
if (array_of_gridfilterdata[grid_current_id]) {
array_of_gridfilterdata[grid_current_id] = null;
}
}
//Store latest grid related data in local arrays
array_of_griddivs[grid_current_id] = divToLoadIn;
//Add standard and gqs (relation) data to page
var loadURL = "",fulltextadd = "",storedprocadd = "",modalpathchange = "";
if (usesFullTextSearch){
fulltextadd = "usefulltext=true&"
}
if (usesStoredProcToLoad) {
storedprocadd = "usestoredprocload=true&"
}
if (isModalGrid){
modalpathchange = "/"
}
loadURL = modalpathchange + "include/getcomponentgriddata.asp?" + fulltextadd + storedprocadd + "usesecuritydb="+ useSecurityDB.toString() + "&componentid=" + componentID + "&" + globalQueryString ;
array_of_gridurls[grid_current_id] = loadURL;
array_of_gridcompids[grid_current_id] = componentID;
array_of_gridtitles[grid_current_id] = componentTitle;
if (loadData){
loadData = true;
}
else {
loadData = false;
}
var searchCol = "searchallfields";
if (!(preSearchText)) {
preSearchText = "";
}
//prompt('',loadURL)
//Do a grid load with the default URL
load_grid(grid_current_id,loadURL,preSearchText,searchCol,loadData,isModalGrid,showAdd);
}
/*
Function used to load a new grid into a specified slot
*/
function load_grid(gridID,url,searchVal,searchCol,loadData,isModalGrid,showAdd){
/////////////////////////////////////
//Creation of objects in correct slot
/////////////////////////////////////
//Create new instances of the grid and table object from scratch
var obj, table, div;
obj = array_of_grids[gridID] = new Active.Controls.Grid;
table = array_of_gridtables[gridID] = new Expert.Text.Table;
//table = array_of_gridtables[gridID] = new Active.Text.Table;
//Get the parameters of grid stored at its creation
var gridName = array_of_gridnames[gridID];
var div = array_of_griddivs[gridID];
var compID = array_of_gridcompids[gridID];
var componentTitle = array_of_gridtitles[gridID];
//Clear filter data
array_of_gridfilterdata[gridID] = null;
///////////////////////////////////
//Setup of grid specific attributes
///////////////////////////////////
//Set id of grid
obj.setId(gridName);
//Set column attributes
var columns = array_of_columnnames[gridID];
var fields = array_of_fieldnames[gridID];
var order = array_of_colorders[gridID];
if ((!(columns))||(!(fields))||(!(order))){
alert("Column load was unsuccessful");
return;
}
obj.setColumnProperty("text", function (i){return columns[i]});
obj.setColumnProperty("values", order);
//Set header's width/height parameters (semi-global)
obj.setRowHeaderWidth("29px"); //28px was the initial default, 29px is standard
obj.setColumnHeaderHeight("26px"); //52px expanded, 26px retracted, 44px Stefan
obj.setAction("onscrollmove",function (x,y) {
document.getElementById(gridName + "-filter").style.left = 0 - x;
});
//Patched refresh function that fixes losing of positioning
var _refresh = obj.refresh;
obj.refresh = function(){
var scrollbars = this.getTemplate("layout").getContent("scrollbars");
var test = false;
if (scrollbars) {
if (scrollbars.element()){
test = true;
}
}
if (test) {
var x = scrollbars.element().scrollLeft;
var y = scrollbars.element().scrollTop;
}
_refresh.call(this);
if (test){
this.element().runtimeStyle.visibility = "hidden";
var _obj = this;
window.setTimeout(function(){
try {
scrollbars.element().scrollLeft = x;
scrollbars.element().scrollTop = y;
}
catch (ex) {}
try {
_obj.element().runtimeStyle.visibility = "visible";
}
catch (ex) {}
}, 0 );
}
}
//User for checking if load of grid has completed.
var myto;
var checkGridLoad = function (){
//Get the data table
var thetable = array_of_gridtables[gridID];
if (thetable) {
try {
//Check if recordcount property is set
if (thetable.getProperty("recordCount")){
//Cancel further checking
window.clearTimeout(myto);
//Now display the needed info when needed
if (thetable.getProperty("recordCount") >= 250) {
document.getElementById(gridName + "-display").innerHTML = searchwarning;
}
//Load grid data
loadNewData(gridID);
}
//Else check again later
else {
myto = window.setTimeout(checkGridLoad,500);
}
}
catch (ex) {}
}
}
//Load the specified table into the grid object
if (loadData) {
//Double check for search breaking amp
var ampfixer = /\&+/g;
url = url.replace(ampfixer,"&");
var amptrim = /\&$/g;
url = url.replace(amptrim,"");
url = url + "&searchon=searchallfields";
if (gridName == "advancedminesearch") {
url = url + "&minename=" + searchVal;
} else {
url = url + "&searchvalue=" + searchVal;
}
//prompt('',url);
table.setURL(url);
table.request();
obj.setDataModel(table);
myto = window.setTimeout(checkGridLoad,1000);
}
//Highlight for mouse movement -- Added 12/05/2005
var row = new Active.Templates.Row;
row.setEvent("onmouseover", "mouseover(this, 'active-row-highlight')");
row.setEvent("onmouseout", "mouseout(this, 'active-row-highlight')");
obj.setRowTemplate(row);
var column = new Active.Templates.Text;
//column.setEvent("onmouseover", "mouseover(this, 'active-cell-highlight');");
//column.setEvent("onmouseout", "mouseout(this, 'active-cell-highlight');");
column.setEvent("onmouseover",function(){
//mouseover(this, 'active-cell-highlight');
var row,column;
try {
row = this.$owner.getRowProperty("index");
column = this.getColumnProperty("index");
overlib(this.$owner.$owner.getDataProperty("text",row,column));
}
catch (ex) {
//alert("Error : " + ex.message);
}
row = null;
column = null;
});
column.setEvent("onmouseout",function(){
//mouseout(this, 'active-cell-highlight');
try {
nd();
}
catch (ex){
//alert("Error : " + ex.message);
}
});
//Set base template for columns
obj.setColumnTemplate(column);
obj.setAction("startColumnResize", customEventObj);
var customEventObj = function() {
//alert("resize");
cancelAction(event);
}
var dealto;
if (gridName.toUpperCase() == "ADMINMINES" || gridName.toUpperCase() == "ADMINMINESADDRESSES" || gridName.toUpperCase() == "ADMINMINESCONTACTS") {
if (loadData) {
//First attempt at deal colors
obj.loadDealColor = function(){
//Get the data table
var thetable = array_of_gridtables[gridID];
if (thetable) {
//try {
//Check if recordcount property is set
if (thetable.getProperty("recordCount")){
//Cancel further checking
window.clearTimeout(dealto);
//Now set up the colouring based on data
var griddata = array_of_gridfilterdata[gridID];
//alert(obj.getProperty('row/count'));
for (l = 0; l < obj.getProperty('row/count'); l++){
//alert(obj.getRowTemplate(l).getProperty('item/index'));
//alert(obj.getRowTemplate(l).getProperty('row/index'));
var id;
//If filterdata exists uses filterindices for id-ing
if (array_of_gridfilterindices[gridID]){
id = array_of_gridfilterindices[gridID][l];
//alert("rowcount(pos):" + l + "\nrowid:"+ id + "\nRowData:" + griddata[id] + "\nfullarray:" + array_of_gridfilterindices[gridID]);
}
//Else assume no filtering (specifically changing of grid record count) has taken place;
else {
id = l;
}
try {
if (gridName.toUpperCase() == "ADMINMINES"){
if (griddata[id][7] == "False"){
obj.getRowTemplate(id).setStyle("color", "#E52325");
}else{
obj.getRowTemplate(id).setStyle("color", "#272727");
}
}
if (gridName.toUpperCase() == "ADMINMINESADDRESSES"){
if (griddata[id][7] == "False"){
obj.getRowTemplate(id).setStyle("color", "#E52325");
}else{
obj.getRowTemplate(id).setStyle("color", "#272727");
}
}
if (gridName.toUpperCase() == "ADMINMINESCONTACTS"){
if (griddata[id][7] == "False"){
obj.getRowTemplate(id).setStyle("color", "#E52325");
}else{
obj.getRowTemplate(id).setStyle("color", "#272727");
}
}
}
catch(ex) {}
id = null;
}
}
//Else check again later
else {
dealto = window.setTimeout(obj.loadDealColor,500);
}
//}
//catch (ex) {alert(ex);}
}
}
dealto = window.setTimeout(obj.loadDealColor,1000);
}
}
/////////////////////
//Load grid relations
/////////////////////
//Check for relations in this component and save it in an array
//Moved this into a generic function (22-Apr-2005)
var OutsideRelationList = getComponentRelations(compID,isModalGrid);
//////////////////////////////
//Setup of action click events
//////////////////////////////
if (gridName == "ownersearch" || gridName == "mineralisationsearch" || gridName == "countrysearch"){
obj.getColumnTemplate().setEvent("ondblclick", function(){this.action("myAction")});
obj.setAction("myAction", function(src){
var row = src.getRowProperty("index");
var column = src.getColumnProperty("index");
var completedGridExecuteAction = function (oXML) {
var RelationQSToSend = "";
var replaceString = "";
//Build relation string from array of relations
for (j = 0; j < OutsideRelationList.length; j++){
if (OutsideRelationList[j]){
var colid = getIDForColumnName(gridID,OutsideRelationList[j],false);
if (colid != -1) {
if (RelationQSToSend != "") {
RelationQSToSend += "|^^|";
}
RelationQSToSend += OutsideRelationList[j] + "^||^" + obj.getDataProperty("text", row, colid);
}
else {
alert("Column with name : " + OutsideRelationList[j] + " not found. May result in incomplete relationship.");
}
}
}
replaceString = "\'sendercomponent=" + compID ;
if (RelationQSToSend != "") {
//Remove single quotes from RelationQSToSend
replaceString += "&" + RelationQSToSend.replace(/'/g,"\\'");
}
replaceString += "\'";
evalstr = "executePageAction(" + oXML.responseText.replace("^RelationalID^",replaceString) + ")";
try {
//alert(evalstr);
eval(evalstr);
}
catch (ex) {
alert("Execution of an action failed.");
}
regularCursor();
oXML = null;
};
//Moved this into a generic function (22-Apr-2005)
checkAction(fields[column],compID,null,true,completedGridExecuteAction,isModalGrid);
//alert(fields[column])
//alert(compID)
//alert(completedGridExecuteAction)
//alert(isModalGrid)
nd(); // PLR 5-May-2009 Fixed bug where tooltip will be displayed even if grid has been destroyed and replaced by another component
});
} else {
//Left click - Do action associated to the clicked column
obj.setAction("click", function(src){
var row = src.getRowProperty("index");
var column = src.getColumnProperty("index");
var completedGridExecuteAction = function (oXML) {
var RelationQSToSend = "";
var replaceString = "";
//Build relation string from array of relations
for (j = 0; j < OutsideRelationList.length; j++){
if (OutsideRelationList[j]){
var colid = getIDForColumnName(gridID,OutsideRelationList[j],false);
if (colid != -1) {
if (RelationQSToSend != "") {
RelationQSToSend += "|^^|";
}
RelationQSToSend += OutsideRelationList[j] + "^||^" + obj.getDataProperty("text", row, colid);
}
else {
alert("Column with name : " + OutsideRelationList[j] + " not found. May result in incomplete relationship.");
}
}
}
replaceString = "\'sendercomponent=" + compID ;
if (RelationQSToSend != "") {
//Remove single quotes from RelationQSToSend
replaceString += "&" + RelationQSToSend.replace(/'/g,"\\'");
}
replaceString += "\'";
evalstr = "executePageAction(" + oXML.responseText.replace("^RelationalID^",replaceString) + ")";
try {
//alert(evalstr);
eval(evalstr);
}
catch (ex) {
alert("Execution of an action failed.");
}
regularCursor();
oXML = null;
};
//Moved this into a generic function (22-Apr-2005)
//alert(fields[column])
checkAction(fields[column],compID,null,true,completedGridExecuteAction,isModalGrid);
nd(); // PLR 5-May-2009 Fixed bug where tooltip will be displayed even if grid has been destroyed and replaced by another component
});
}
//////////////////////////////
//Setup of header click events
//////////////////////////////
//Set up Header and its click events
var header = new Active.Templates.Header;
header.setEvent("onmousedown", function(evt){
if (evt.button == 2 ) {
// do nothing
}
else {
this.setClass("header", "pressed");
this.timeout(function(){this.action("columnSort")});
}
});
//////////////////////
//Setup of grid layout
//////////////////////
//Set the grid header
obj.setTemplate("top/item", header);
//Make input box selectable
obj.getTemplate("top").setEvent("onselectstart", obj.getEvent("onselectstart"));
//Disable some standard events
obj.setEvent("onselectstart", null);
obj.setEvent("onkeydown", null);
///////////////
//Custom header
///////////////
//Header
//var pageHeader = '
Grid : ' + gridName + '
'
var pageHeader = createHeader(componentTitle,"");
var pageSearch = "";
if (compID == 50 || compID == 47)
{
showAdd = true;
}
pageSearch = createSearch(gridID,compID,searchVal,isModalGrid,showAdd);
var pageFilter = createFilter(eval(columns),gridName,gridID)
///////////////
//Custom footer
///////////////
//Paging footer
//var pageFooter = '
'/* + s */+ '
'
//Information footer
var infoBar = "";
var pageFooter = "" //"
";
var pageSpacer = '
'
//Set the custom info and grid to output to the div tag.
div.style.display = '';
var output = "";
//Build display according to output mode
if (loadData) {
if (isModalGrid) {
output = pageSearch + pageFilter + obj + pageFooter;
}
else {
output = pageHeader + pageSearch + pageFilter + obj + infoBar + pageFooter;
}
}
else {
output = pageHeader + pageSearch + pageFooter;
}
div.innerHTML = output;
regularCursor();
}
//////////////////////////////////////////////////////////////////////////////////////////////
//SEARCHING/FILTERING/PAGEING FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////
function checkSearch(gridID,isModalGrid,evt){
if (isEnterKey(evt)) {
searchGrid(gridID,isModalGrid);
}
}
//The database driven search function --Changed by SK on 4-Apr-2005
function searchGrid(gridID,isModalGrid){
busyCursor();
var colToBeSearched = document.getElementById("searchColumn").value;
var toSearch = document.getElementById("searchString" + gridID).value;
var searchurl = array_of_gridurls[gridID]; //+ "&searchon=" + colToBeSearched + "&searchvalue=" + toSearch;
//Load grid with needed data
//PLR 26-Jun-2009 - Override subset search and load from original dataset with new search parameters
searchurl = "include/getcomponentgriddata.asp?usestoredprocload=true&usesecuritydb=false&componentid=" + array_of_gridcompids[gridID]
load_grid(gridID,searchurl,toSearch,colToBeSearched,true,isModalGrid);
}
/*
Function to add current data to the data store for later use and reference in filtering
*/
function fetchData(gridID){
//If no data exists force load
var overrideLoad = false;
if (!(array_of_gridfilterdata[gridID])) {
overrideLoad = true;
}
if (overrideLoad){
//alert("Loading new data...");
loadNewData(gridID);
}
return array_of_gridfilterdata[gridID];
}
function loadNewData(gridID){
array_of_gridfilterdata[gridID] = extractData(gridID);
}
//Function to extract data from a grid object
function extractData(gridID){
var returnData = [];
var obj = array_of_grids[gridID];
if (obj) {
var columnIndex = obj.getColumnProperty("count");
var rowIndex = obj.getRowProperty("count");
//Generate data displayed in grid into array
for (row = 0; row < rowIndex; row++){
var rowArray = [];
for (column = 0; column < columnIndex; column++){
rowArray.push(obj.getDataProperty("text",row,column))
}
returnData.push(rowArray);
}
}
return returnData;
}
function filterGrid(gid,source,evt){
if (isEnterKey(evt)){
var obj = array_of_grids[gid];
if (obj){
busyCursor();
var myData = fetchData(gid);
var columnNames = new Array();
for (var i = 0; i < obj.getColumnProperty("values").length; i++){
columnNames.push(obj.getColumnProperty("text",i));
}
var rowidValues = new Array();
var searchvaluesaver = new Array();
var res = 0;
var remover = /\^|\||\\/g;
/*
var replacer = /\\/g;
searchtext = searchtext.replace(replacer,"\\");
*/
var dosearch = false;
for (var i = 0; i < columnNames.length; i++){
//Check if any textbox is non-empty
if (document.getElementById(columnNames[i].replace(spaceregex,"_")+"filterbox").value.toLowerCase().replace(remover,"") != ""){
dosearch = true;
}
//Save the search values in array
searchvaluesaver.push(document.getElementById(columnNames[i].replace(spaceregex,"_")+"filterbox").value);
}
//If non-empty search
//var itcount = 0;
if (dosearch){
try {
for (var x = 0; x < myData.length; x++){
var addrow = true;
//Check all columns to see if the row matches criteria
for (var i = 0; i < columnNames.length; i++){
//Set up search text from search value
var searchtext = searchvaluesaver[i].toLowerCase().replace(remover,"");
//If blank search for this column skip it
if (!(searchtext == "")){
//REGEX method
//Set up regex
var checker = new RegExp(searchtext);
//If a single criteria is not matched, don't display row.
if (!(myData[x][i].toLowerCase().match(checker))){
addrow = false;
break;
}
/*
//INDEXOF method
//If a single criteria is not matched, don't display row.
if ((myData[x][i].toLowerCase().indexOf(searchtext.toLowerCase())) < 0){
addrow = false;
break;
}
*/
}
//itcount++;
}
//Add row to display list if needed
if (addrow) {
rowidValues.push(x);
res++;
}
}
}
catch (ex) {
alert("Filter error caught");
}
}
//Else show everything
else {
for (var x = 0; x < myData.length; x++){
rowidValues.push(x);
res++;
//itcount++;
}
}
//Save sort and reset the correct sorting after loading data
var index = obj.getSortProperty("index");
var direction = obj.getSortProperty("direction");
//alert(index + ' ' + direction)
obj.setSortProperty("index",-1);
//Load the correct rows found by filter
//alert("Count:" + res + "\nRow Vals:" + rowidValues);
obj.setRowCount(res);
obj.setRowValues(rowidValues);
array_of_gridfilterindices[gid] = rowidValues;
//Do sort on new data if needed and refresh the display
if (index >= 0) {
obj.sort(index, direction);
}
//Fetch scroll properties
var scrollbars = obj.getTemplate("layout").getContent("scrollbars");
var test = false;
if (scrollbars) {
if (scrollbars.element()){
test = true;
}
}
if (test) {
var x = scrollbars.element().scrollLeft;
var y = scrollbars.element().scrollTop;
}
obj.refresh();
/*
//Reset the position after filtering to maintain position of external filter
window.setTimeout(function(){
scrollbars.element().scrollLeft = x;
scrollbars.element().scrollTop = y;
//obj.element().focus();
}, 0 );
*/
//alert(itcount);
/*
Focus attempt for embedded filter
for (var i = 0; i < columnNames.length; i++){
document.getElementById(columnNames[i].replace(spaceregex,"_")).value = searchvaluesaver[i];
}
document.getElementById(source.id).focus();
*/
regularCursor();
if (test) {
obj.action("onscrollmove",x,y);
}
}
}
}
//New and improved paging function using custom extended properties for paging info
//that was added in a custom Active.Text.Table implentation by SK -> 12-Apr-2005
function chngPage(gridID,direction,searchVal,searchCol){
//Fetch paging info
var currentpage,maxpage,recordsetsize
var table = array_of_gridtables[gridID];
if (table){
currentpage = table.getProperty("currentPage");
maxpage = table.getProperty("maxPage");
recordsetsize = table.getProperty("rowLimit");
}
//Else just fail paging call.
else {
return;
}
//If successful; Load object and process page change.
var obj = array_of_grids[gridID];
if (obj) {
var colToBeSearched = document.getElementById("searchColumn").value;
var toSearch = document.getElementById("searchString").value;
//Check if search criteria have changed and restart at page 1 if needed
var calcNextPage = true;
if ((searchVal != "") || ((searchVal == "")&&(toSearch != ""))){
if ((toSearch != searchVal) || (colToBeSearched != searchCol)) {
currentpage = 1;
//alert("Reset page for new search.")
calcNextPage = false;
}
else {
//alert("No change");
}
}
else {
//alert("searchVal is blank.");
}
//If needed calculate the next page to be loaded
if (calcNextPage){
if (direction == "next") {
if (currentpage < maxpage) {
currentpage += 1
}
else {
alert("You have already reached the last page.");
return;
}
}
else {
if (currentpage != 1){
currentpage -= 1
}
else {
alert("You have already reached the first page.");
return;
}
}
}
//The array value returns a base URL with componentID parameter already included, so add accordingly
var pageurl = array_of_gridurls[gridID] + "¤tpg=" + currentpage + "&searchon=" + colToBeSearched + "&searchvalue=" + toSearch;
//Load grid with needed data
load_grid(gridID,pageurl,toSearch,colToBeSearched,true);
}
}
![](" + pathchange + "images/help_off.gif)
![](" + pathchange + "images/search_off.gif)
