if (mtDropDown.isSupported()) {
var ms = new mtDropDownSet(mtDropDown.direction.down, 0, 0, mtDropDown.reference.bottomLeft);
var menu1 = ms.addMenu(document.getElementById("menu1"));
menu1.addItem("About Us", "aboutus.htm");
menu1.addItem("Directors Message", "directorsmessage.htm");
menu1.addItem("FAQ", "faq.htm");
menu1.addItem("Mission Statement", "missionstatement.htm");
menu1.addItem("Company Facts", "companyfacts.htm");
menu1.addItem("Company Culture", "companyculture.htm");
menu1.addItem("Tusan Rally videos", "tuscan-rally.htm");
var menu2 = ms.addMenu(document.getElementById("menu2"));
//menu2.addItem("Tele2", "tele2.htm");
//menu2.addItem("STC ", "stc.htm");
menu2.addItem("Client Testimonials ", "clienttestimonials.htm");
var menu3 = ms.addMenu(document.getElementById("menu3"));
menu3.addItem("Deutschland", "#");
menu3.addItem("Australia ", "#");
menu3.addItem("UK & Ireland A to D", "#");
menu3.addItem("UK & Ireland E to M", "#");
menu3.addItem("UK & Ireland N to Z", "#");
var subMenu1 = menu3.addMenu(menu3.items[0]);
subMenu1.addItem("Düsseldorf", "googlemap.htm");
subMenu1.addItem("Köln", "googlemap.htm");
subMenu1.addItem("Essen", "googlemap.htm");
subMenu1.addItem("Berlin", "googlemap.htm");
subMenu1.addItem("Leipzig", "googlemap.htm");
subMenu1.addItem("Wuppertal", "googlemap.htm");
var subMenu1 = menu3.addMenu(menu3.items[1]);
subMenu1.addItem("Sydney", "googlemap.htm");
subMenu1.addItem("Brisbane", "googlemap.htm");
subMenu1.addItem("Adelaide", "googlemap.htm");
var subMenu1 = menu3.addMenu(menu3.items[2]);
subMenu1.addItem("Ayr", "googlemap.htm", "_blank");
subMenu1.addItem("Birmingham", "googlemap.htm");
subMenu1.addItem("Brighton", "googlemap.htm");
subMenu1.addItem("Bristol", "googlemap.htm");
subMenu1.addItem("Carlisle", "googlemap.htm");
subMenu1.addItem("Cardiff", "googlemap.htm");
subMenu1.addItem("Colchester", "googlemap.htm");
subMenu1.addItem("Cork", "googlemap.htm");
subMenu1.addItem("Dundee", "googlemap.htm");
subMenu1.addItem("Dublin", "googlemap.htm");
subMenu1.addItem("Derby", "googlemap.htm");
var subMenu1 = menu3.addMenu(menu3.items[3]);
subMenu1.addItem("Edinburgh", "googlemap.htm");
subMenu1.addItem("Exeter", "googlemap.htm");
subMenu1.addItem("Glasgow", "googlemap.htm");
subMenu1.addItem("Galway", "googlemap.htm");
subMenu1.addItem("Hull", "googlemap.htm");
subMenu1.addItem("Leeds", "googlemap.htm");
subMenu1.addItem("Liverpool", "googlemap.htm");
subMenu1.addItem("Lincoln", "googlemap.htm");
subMenu1.addItem("London", "googlemap.htm");
subMenu1.addItem("Manchester", "googlemap.htm");
subMenu1.addItem("Maidstone", "googlemap.htm");
var subMenu1 = menu3.addMenu(menu3.items[4]);
subMenu1.addItem("Newcastle", "googlemap.htm");
subMenu1.addItem("Nottingham", "googlemap.htm");
subMenu1.addItem("Northampton", "googlemap.htm");
subMenu1.addItem("Preston", "googlemap.htm");
subMenu1.addItem("Peterborough", "googlemap.htm");
subMenu1.addItem("Sunderland", "googlemap.htm");
subMenu1.addItem("Sheffield", "googlemap.htm");
subMenu1.addItem("Stoke On Trent", "googlemap.htm");
subMenu1.addItem("Swindon", "googlemap.htm");
subMenu1.addItem("Southampton", "googlemap.htm");
subMenu1.addItem("Telford", "googlemap.htm");
subMenu1.addItem("Wolverhampton", "googlemap.htm");
var menu4 = ms.addMenu(document.getElementById("menu4"));
menu4.addItem("Management Training Programm", "bdp.htm");
menu4.addItem("Verkaufs Programm", "salesprogramme.htm");
menu4.addItem("Bewerben", "apply.htm");
/*var menu5 = ms.addMenu(document.getElementById("menu5"));
menu5.addItem("Infopark News", "all_news.php");
menu5.addItem("ITES Habitat News", "habitat.php");
menu5.addItem("Promotional Activities", "park_news.php");*/
//==================================================================================================
// add a sub-menu
//==================================================================================================
// to add a sub menu to an existing menu object, call it's addMenu method and pass it the item from
// the parent menu which should act as it's actuator. To add a submenu to the fourth item of a menu
// called "theMenu", you would do theMenu.addMenu(theMenu.items[3])
//==================================================================================================
/*var subMenu1 = menu1.addMenu(menu1.items[2]);
subMenu1.addItem("Receivable Manager", "rblmanager.php");
subMenu1.addItem("Payable Manager", "pblmanager.php");
subMenu1.addItem("Cash Manager", "cashmanager.php");
subMenu1.addItem("Ledger Manager", "ledger.php");
subMenu1.addItem("Sales Order Manager", "sales.php");
subMenu1.addItem("Purchase Order Manager", "purchase.php");
subMenu1.addItem("Package Manager", "package.php");
subMenu1.addItem("Inventory Manager", "inventory.php");
var subMenu1 = menu1.addMenu(menu1.items[4]);
subMenu1.addItem("Hierarchy Manager", "hierarchymanager.php");
subMenu1.addItem("Authoring Manager", "authoringmanager.php");
subMenu1.addItem("Flow Manager", "flowmanager.php");
var subMenu1 = menu1.addMenu(menu1.items[5]);
subMenu1.addItem("Product Manager", "productmanager.php");
subMenu1.addItem("Inventory Manager", "inventorymanager.php");
subMenu1.addItem("Cart Manager", "cartmanager.php");
subMenu1.addItem("Bid Manager", "bidmanager.php");*/
//==================================================================================================
// write drop downs into page
//==================================================================================================
// this method writes all the HTML for the menus into the page with document.write(). It must be
// called within the body of the HTML page.
//==================================================================================================
mtDropDown.renderAll();
}
/////////////////////////////////////////////////
//Common functions for all dropdowns
/*----------------------------------------------
The Common function used for all dropdowns are:
-----------------------------------------------
-- function fnKeyDownHandler(getdropdown, e)
-- function fnLeftToRight(getdropdown)
-- function fnRightToLeft(getdropdown)
-- function fnDelete(getdropdown)
-- function FindKeyCode(e)
-- function FindKeyChar(e)
-- function fnSanityCheck(getdropdown)
--------------------------- Subrata Chakrabarty */
function fnKeyDownHandler(getdropdown, e)
{
fnSanityCheck(getdropdown);
// Press [ <- ] and [ -> ] arrow keys on the keyboard to change alignment/flow.
// ...go to Start : Press [ <- ] Arrow Key
// ...go to End : Press [ -> ] Arrow Key
// (this is useful when the edited-text content exceeds the ListBox-fixed-width)
// This works best on Internet Explorer, and not on Netscape
var vEventKeyCode = FindKeyCode(e);
// Press left/right arrow keys
if(vEventKeyCode == 37)
{
fnLeftToRight(getdropdown);
}
if(vEventKeyCode == 39)
{
fnRightToLeft(getdropdown);
}
// Delete key pressed
if(vEventKeyCode == 46)
{
fnDelete(getdropdown);
}
// backspace key pressed
if(vEventKeyCode == 8 || vEventKeyCode==127)
{
if(e.which) //Netscape
{
//e.which = ''; //this property has only a getter.
}
else //Internet Explorer
{
//To prevent backspace from activating the -Back- button of the browser
e.keyCode = '';
if(window.event.keyCode)
{
window.event.keyCode = '';
}
}
return true;
}
// Tab key pressed, use code below to reorient to Left-To-Right flow, if needed
//if(vEventKeyCode == 9)
//{
// fnLeftToRight(getdropdown);
//}
}
function fnLeftToRight(getdropdown)
{
getdropdown.style.direction = "ltr";
}
function fnRightToLeft(getdropdown)
{
getdropdown.style.direction = "rtl";
}
function fnDelete(getdropdown)
{
if(getdropdown.options.length != 0)
// if dropdown is not empty
{
if (getdropdown.options.selectedIndex == vEditableOptionIndex_A)
// if option the Editable field
{
getdropdown.options[getdropdown.options.selectedIndex].text = '';
getdropdown.options[getdropdown.options.selectedIndex].value = '';
}
}
}
/*
Since Internet Explorer and Netscape have different
ways of returning the key code, displaying keys
browser-independently is a bit harder.
However, you can create a script that displays keys
for either browser.
The following function will display each key
in the status line:
The "FindKey.." function receives the "event" object
from the event handler and stores it in the variable "e".
It checks whether the "e.which" property exists (for Netscape),
and stores it in the "keycode" variable if present.
Otherwise, it assumes the browser is Internet Explorer
and assigns to keycode the "e.keyCode" property.
*/
function FindKeyCode(e)
{
if(e.which)
{
keycode=e.which; //Netscape
}
else
{
keycode=e.keyCode; //Internet Explorer
}
//alert("FindKeyCode"+ keycode);
return keycode;
}
function FindKeyChar(e)
{
keycode = FindKeyCode(e);
if((keycode==8)||(keycode==127))
{
character="backspace"
}
else if((keycode==46))
{
character="delete"
}
else
{
character=String.fromCharCode(keycode);
}
//alert("FindKey"+ character);
return character;
}
function fnSanityCheck(getdropdown)
{
if(vEditableOptionIndex_A>(getdropdown.options.length-1))
{
alert("PROGRAMMING ERROR: The value of variable vEditableOptionIndex_... cannot be greater than (length of dropdown - 1)");
return false;
}
}
//Dropdown specific functions, which manipulate dropdown specific global variables
//for the dropdown lstDropDown_A
/*----------------------------------------------
Dropdown specific global variables are:
-----------------------------------------------
1) vEditableOptionIndex_A --> this needs to be set by Programmer!! See explanation.
2) vEditableOptionText_A --> this needs to be set by Programmer!! See explanation.
3) vPreviousSelectIndex_A
4) vSelectIndex_A
5) vSelectChange_A
--------------------------- Subrata Chakrabarty */
/*----------------------------------------------
The dropdown specific functions
(which manipulate dropdown specific global variables)
used by all dropdowns are:
-----------------------------------------------
1) function fnChangeHandler_A(getdropdown)
2) function fnKeyPressHandler_A(getdropdown, e)
3) function fnKeyUpHandler_A(getdropdown, e)
--------------------------- Subrata Chakrabarty */
/*------------------------------------------------
IMPORTANT: Global Variable required to be SET by programmer
-------------------------- Subrata Chakrabarty */
var vEditableOptionIndex_A = 0;
// Give Index of Editable option in the dropdown.
// For eg.
// if first option is editable then vEditableOptionIndex_A = 0;
// if second option is editable then vEditableOptionIndex_A = 1;
// if third option is editable then vEditableOptionIndex_A = 2;
// if last option is editable then vEditableOptionIndex_A = (length of dropdown - 1).
// Note: the value of vEditableOptionIndex_A cannot be greater than (length of dropdown - 1)
var vEditableOptionText_A = "--?--";
// Give the default text of the Editable option in the dropdown.
// For eg.
// if the editable option is ,
// then set vEditableOptionText_A = "--?--";
/*------------------------------------------------
Global Variables required for
fnChangeHandler_A(), fnKeyPressHandler_A() and fnKeyUpHandler_A()
for Editable Dropdowns
-------------------------- Subrata Chakrabarty */
var vPreviousSelectIndex_A = 0;
// Contains the Previously Selected Index, set to 0 by default
var vSelectIndex_A = 0;
// Contains the Currently Selected Index, set to 0 by default
var vSelectChange_A = 'MANUAL_CLICK';
// Indicates whether Change in dropdown selected option
// was due to a Manual Click
// or due to System properties of dropdown.
// vSelectChange_A = 'MANUAL_CLICK' indicates that
// the jump to a non-editable option in the dropdown was due
// to a Manual click (i.e.,changed on purpose by user).
// vSelectChange_A = 'AUTO_SYSTEM' indicates that
// the jump to a non-editable option was due to System properties of dropdown
// (i.e.,user did not change the option in the dropdown;
// instead an automatic jump happened due to inbuilt
// dropdown properties of browser on typing of a character )
/*------------------------------------------------
Functions required for Editable Dropdowns
-------------------------- Subrata Chakrabarty */
function fnChangeHandler_A(getdropdown)
{
fnSanityCheck(getdropdown);
vPreviousSelectIndex_A = vSelectIndex_A;
// Contains the Previously Selected Index
vSelectIndex_A = getdropdown.options.selectedIndex;
// Contains the Currently Selected Index
if ((vPreviousSelectIndex_A == (vEditableOptionIndex_A)) && (vSelectIndex_A != (vEditableOptionIndex_A))&&(vSelectChange_A != 'MANUAL_CLICK'))
// To Set value of Index variables - Subrata Chakrabarty
{
getdropdown[(vEditableOptionIndex_A)].selected=true;
vPreviousSelectIndex_A = vSelectIndex_A;
vSelectIndex_A = getdropdown.options.selectedIndex;
vSelectChange_A = 'MANUAL_CLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
}
function fnKeyPressHandler_A(getdropdown, e)
{
fnSanityCheck(getdropdown);
keycode = FindKeyCode(e);
keychar = FindKeyChar(e);
// Check for allowable Characters
// The various characters allowable for entry into Editable option..
// may be customized by minor modifications in the code (if condition below)
// (you need to know the keycode/ASCII value of the character to be allowed/disallowed.
// - Subrata Chakrabarty
if ((keycode>47 && keycode<59)||(keycode>62 && keycode<127) ||(keycode==32))
{
var vAllowableCharacter = "yes";
}
else
{
var vAllowableCharacter = "no";
}
//alert(window); alert(window.event);
if(getdropdown.options.length != 0)
// if dropdown is not empty
if (getdropdown.options.selectedIndex == (vEditableOptionIndex_A))
// if selected option the Editable option of the dropdown
{
var vEditString = getdropdown[vEditableOptionIndex_A].value;
// make Editable option Null if it is being edited for the first time
if((vAllowableCharacter == "yes")||(keychar=="backspace"))
{
if (vEditString == vEditableOptionText_A)
vEditString = "";
}
if (keychar=="backspace")
// To handle backspace - Subrata Chakrabarty
{
vEditString = vEditString.substring(0,vEditString.length-1);
// Decrease length of string by one from right
vSelectChange_A = 'MANUAL_CLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
//alert("EditString2:"+vEditString);
if (vAllowableCharacter == "yes")
// To handle addition of a character - Subrata Chakrabarty
{
vEditString+=String.fromCharCode(keycode);
// Concatenate Enter character to Editable string
// The following portion handles the "automatic Jump" bug
// The "automatic Jump" bug (Description):
// If a alphabet is entered (while editing)
// ...which is contained as a first character in one of the read-only options
// ..the focus automatically "jumps" to the read-only option
// (-- this is a common property of normal dropdowns
// ..but..is undesirable while editing).
var i=0;
var vEnteredChar = String.fromCharCode(keycode);
var vUpperCaseEnteredChar = vEnteredChar;
var vLowerCaseEnteredChar = vEnteredChar;
if(((keycode)>=97)&&((keycode)<=122))
// if vEnteredChar lowercase
vUpperCaseEnteredChar = String.fromCharCode(keycode - 32);
// This is UpperCase
if(((keycode)>=65)&&((keycode)<=90))
// if vEnteredChar is UpperCase
vLowerCaseEnteredChar = String.fromCharCode(keycode + 32);
// This is lowercase
if(e.which) //For Netscape
{
// Compare the typed character (into the editable option)
// with the first character of all the other
// options (non-editable).
// To note if the jump to the non-editable option was due
// to a Manual click (i.e.,changed on purpose by user)
// or due to System properties of dropdown
// (i.e.,user did not change the option in the dropdown;
// instead an automatic jump happened due to inbuilt
// dropdown properties of browser on typing of a character )
for (i=0;i<=(getdropdown.options.length-1);i++)
{
if(i!=vEditableOptionIndex_A)
{
var vReadOnlyString = getdropdown[i].value;
var vFirstChar = vReadOnlyString.substring(0,1);
if((vFirstChar == vUpperCaseEnteredChar)||(vFirstChar == vLowerCaseEnteredChar))
{
vSelectChange_A = 'AUTO_SYSTEM';
// Indicates that the Change in dropdown selected
// option was due to System properties of dropdown
break;
}
else
{
vSelectChange_A = 'MANUAL_CLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
}
}
}
}
// Set the new edited string into the Editable option
getdropdown.options[vEditableOptionIndex_A].text = vEditString;
getdropdown.options[vEditableOptionIndex_A].value = vEditString;
return false;
}
return true;
}
function fnKeyUpHandler_A(getdropdown, e)
{
fnSanityCheck(getdropdown);
if(e.which) // Netscape
{
if(vSelectChange_A == 'AUTO_SYSTEM')
{
// if editable dropdown option jumped while editing
// (due to typing of a character which is the first character of some other option)
// then go back to the editable option.
getdropdown[(vEditableOptionIndex_A)].selected=true;
}
var vEventKeyCode = FindKeyCode(e);
// if [ <- ] or [ -> ] arrow keys are pressed, select the editable option
if((vEventKeyCode == 37)||(vEventKeyCode == 39))
{
getdropdown[vEditableOptionIndex_A].selected=true;
}
}
}
/*-------------------------------------------------------------------------------------------- Subrata Chakrabarty */
//Dropdown specific functions, which manipulate dropdown specific global variables
//for the dropdown lstDropDown_B
/*----------------------------------------------
Dropdown specific global variables are:
-----------------------------------------------
1) vEditableOptionIndex_B --> this needs to be set by Programmer!! See explanation.
2) vEditableOptionText_B --> this needs to be set by Programmer!! See explanation.
3) vPreviousSelectIndex_B
4) vSelectIndex_B
5) vSelectChange_B
--------------------------- Subrata Chakrabarty */
/*----------------------------------------------
The dropdown specific functions
(which manipulate dropdown specific global variables)
used by all dropdowns are:
-----------------------------------------------
1) function fnChangeHandler_B(getdropdown)
2) function fnKeyPressHandler_B(getdropdown, e)
3) function fnKeyUpHandler_B(getdropdown, e)
--------------------------- Subrata Chakrabarty */
/*------------------------------------------------
IMPORTANT: Global Variable required to be SET by programmer
-------------------------- Subrata Chakrabarty */
var vEditableOptionIndex_B = 0;
// Give Index of Editable option in the dropdown.
// For eg.
// if first option is editable then vEditableOptionIndex_B = 0;
// if second option is editable then vEditableOptionIndex_B = 1;
// if third option is editable then vEditableOptionIndex_B = 2;
// if last option is editable then vEditableOptionIndex_B = (length of dropdown - 1).
// Note: the value of vEditableOptionIndex_B cannot be greater than (length of dropdown - 1)
var vEditableOptionText_B = "--?--";
// Give the default text of the Editable option in the dropdown.
// For eg.
// if the editable option is ,
// then set vEditableOptionText_B = "--?--";
/*------------------------------------------------
Global Variables required for
fnChangeHandler_B(), fnKeyPressHandler_B() and fnKeyUpHandler_B()
for Editable Dropdowns
-------------------------- Subrata Chakrabarty */
var vPreviousSelectIndex_B = 0;
// Contains the Previously Selected Index, set to 0 by default
var vSelectIndex_B = 0;
// Contains the Currently Selected Index, set to 0 by default
var vSelectChange_B = 'MANUAL_CLICK';
// Indicates whether Change in dropdown selected option
// was due to a Manual Click
// or due to System properties of dropdown.
// vSelectChange_B = 'MANUAL_CLICK' indicates that
// the jump to a non-editable option in the dropdown was due
// to a Manual click (i.e.,changed on purpose by user).
// vSelectChange_B = 'AUTO_SYSTEM' indicates that
// the jump to a non-editable option was due to System properties of dropdown
// (i.e.,user did not change the option in the dropdown;
// instead an automatic jump happened due to inbuilt
// dropdown properties of browser on typing of a character )
/*------------------------------------------------
Functions required for Editable Dropdowns
-------------------------- Subrata Chakrabarty */
function fnChangeHandler_B(getdropdown)
{
fnSanityCheck(getdropdown);
vPreviousSelectIndex_B = vSelectIndex_B;
// Contains the Previously Selected Index
vSelectIndex_B = getdropdown.options.selectedIndex;
// Contains the Currently Selected Index
if ((vPreviousSelectIndex_B == (vEditableOptionIndex_B)) && (vSelectIndex_B != (vEditableOptionIndex_B))&&(vSelectChange_B != 'MANUAL_CLICK'))
// To Set value of Index variables - Subrata Chakrabarty
{
getdropdown[(vEditableOptionIndex_B)].selected=true;
vPreviousSelectIndex_B = vSelectIndex_B;
vSelectIndex_B = getdropdown.options.selectedIndex;
vSelectChange_B = 'MANUAL_CLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
}
function fnKeyPressHandler_B(getdropdown, e)
{
fnSanityCheck(getdropdown);
keycode = FindKeyCode(e);
keychar = FindKeyChar(e);
// Check for allowable Characters
// The various characters allowable for entry into Editable option..
// may be customized by minor modifications in the code (if condition below)
// (you need to know the keycode/ASCII value of the character to be allowed/disallowed.
// - Subrata Chakrabarty
if ((keycode>47 && keycode<59)||(keycode>62 && keycode<127) ||(keycode==32))
{
var vAllowableCharacter = "yes";
}
else
{
var vAllowableCharacter = "no";
}
//alert(window); alert(window.event);
if(getdropdown.options.length != 0)
// if dropdown is not empty
if (getdropdown.options.selectedIndex == (vEditableOptionIndex_B))
// if selected option the Editable option of the dropdown
{
var vEditString = getdropdown[vEditableOptionIndex_B].value;
// make Editable option Null if it is being edited for the first time
if((vAllowableCharacter == "yes")||(keychar=="backspace"))
{
if (vEditString == vEditableOptionText_B)
vEditString = "";
}
if (keychar=="backspace")
// To handle backspace - Subrata Chakrabarty
{
vEditString = vEditString.substring(0,vEditString.length-1);
// Decrease length of string by one from right
vSelectChange_B = 'MANUAL_CLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
//alert("EditString2:"+vEditString);
if (vAllowableCharacter == "yes")
// To handle addition of a character - Subrata Chakrabarty
{
vEditString+=String.fromCharCode(keycode);
// Concatenate Enter character to Editable string
// The following portion handles the "automatic Jump" bug
// The "automatic Jump" bug (Description):
// If a alphabet is entered (while editing)
// ...which is contained as a first character in one of the read-only options
// ..the focus automatically "jumps" to the read-only option
// (-- this is a common property of normal dropdowns
// ..but..is undesirable while editing).
var i=0;
var vEnteredChar = String.fromCharCode(keycode);
var vUpperCaseEnteredChar = vEnteredChar;
var vLowerCaseEnteredChar = vEnteredChar;
if(((keycode)>=97)&&((keycode)<=122))
// if vEnteredChar lowercase
vUpperCaseEnteredChar = String.fromCharCode(keycode - 32);
// This is UpperCase
if(((keycode)>=65)&&((keycode)<=90))
// if vEnteredChar is UpperCase
vLowerCaseEnteredChar = String.fromCharCode(keycode + 32);
// This is lowercase
if(e.which) //For Netscape
{
// Compare the typed character (into the editable option)
// with the first character of all the other
// options (non-editable).
// To note if the jump to the non-editable option was due
// to a Manual click (i.e.,changed on purpose by user)
// or due to System properties of dropdown
// (i.e.,user did not change the option in the dropdown;
// instead an automatic jump happened due to inbuilt
// dropdown properties of browser on typing of a character )
for (i=0;i<=(getdropdown.options.length-1);i++)
{
if(i!=vEditableOptionIndex_B)
{
var vReadOnlyString = getdropdown[i].value;
var vFirstChar = vReadOnlyString.substring(0,1);
if((vFirstChar == vUpperCaseEnteredChar)||(vFirstChar == vLowerCaseEnteredChar))
{
vSelectChange_B = 'AUTO_SYSTEM';
// Indicates that the Change in dropdown selected
// option was due to System properties of dropdown
break;
}
else
{
vSelectChange_B = 'MANUAL_CLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
}
}
}
}
// Set the new edited string into the Editable option
getdropdown.options[vEditableOptionIndex_B].text = vEditString;
getdropdown.options[vEditableOptionIndex_B].value = vEditString;
return false;
}
return true;
}
function fnKeyUpHandler_B(getdropdown, e)
{
fnSanityCheck(getdropdown);
if(e.which) // Netscape
{
if(vSelectChange_B == 'AUTO_SYSTEM')
{
// if editable dropdown option jumped while editing
// (due to typing of a character which is the first character of some other option)
// then go back to the editable option.
getdropdown[(vEditableOptionIndex_B)].selected=true;
}
var vEventKeyCode = FindKeyCode(e);
// if [ <- ] or [ -> ] arrow keys are pressed, select the editable option
if((vEventKeyCode == 37)||(vEventKeyCode == 39))
{
getdropdown[vEditableOptionIndex_B].selected=true;
}
}
}
/*-------------------------------------------------------------------------------------------- Subrata Chakrabarty */
//Dropdown specific functions, which manipulate dropdown specific global variables
//for the dropdown lstDropDown_C
/*----------------------------------------------
Dropdown specific global variables are:
-----------------------------------------------
1) vEditableOptionIndex_C --> this needs to be set by Programmer!! See explanation.
2) vEditableOptionText_C --> this needs to be set by Programmer!! See explanation.
3) vPreviousSelectIndex_C
4) vSelectIndex_C
5) vSelectChange_C
--------------------------- Subrata Chakrabarty */
/*----------------------------------------------
The dropdown specific functions
(which manipulate dropdown specific global variables)
used by all dropdowns are:
-----------------------------------------------
1) function fnChangeHandler_C(getdropdown)
2) function fnKeyPressHandler_C(getdropdown, e)
3) function fnKeyUpHandler_C(getdropdown, e)
--------------------------- Subrata Chakrabarty */
/*------------------------------------------------
IMPORTANT: Global Variable required to be SET by programmer
-------------------------- Subrata Chakrabarty */
var vEditableOptionIndex_C = 0;
// Give Index of Editable option in the dropdown.
// For eg.
// if first option is editable then vEditableOptionIndex_C = 0;
// if second option is editable then vEditableOptionIndex_C = 1;
// if third option is editable then vEditableOptionIndex_C = 2;
// if last option is editable then vEditableOptionIndex_C = (length of dropdown - 1).
// Note: the value of vEditableOptionIndex_C cannot be greater than (length of dropdown - 1)
var vEditableOptionText_C = "--?--";
// Give the default text of the Editable option in the dropdown.
// For eg.
// if the editable option is ,
// then set vEditableOptionText_C = "--?--";
/*------------------------------------------------
Global Variables required for
fnChangeHandler_C(), fnKeyPressHandler_C() and fnKeyUpHandler_C()
for Editable Dropdowns
-------------------------- Subrata Chakrabarty */
var vPreviousSelectIndex_C = 0;
// Contains the Previously Selected Index, set to 0 by default
var vSelectIndex_C = 0;
// Contains the Currently Selected Index, set to 0 by default
var vSelectChange_C = 'MANUAL_CLICK';
// Indicates whether Change in dropdown selected option
// was due to a Manual Click
// or due to System properties of dropdown.
// vSelectChange_C = 'MANUAL_CLICK' indicates that
// the jump to a non-editable option in the dropdown was due
// to a Manual click (i.e.,changed on purpose by user).
// vSelectChange_C = 'AUTO_SYSTEM' indicates that
// the jump to a non-editable option was due to System properties of dropdown
// (i.e.,user did not change the option in the dropdown;
// instead an automatic jump happened due to inbuilt
// dropdown properties of browser on typing of a character )
/*------------------------------------------------
Functions required for Editable Dropdowns
-------------------------- Subrata Chakrabarty */
function fnChangeHandler_C(getdropdown)
{
fnSanityCheck(getdropdown);
vPreviousSelectIndex_C = vSelectIndex_C;
// Contains the Previously Selected Index
vSelectIndex_C = getdropdown.options.selectedIndex;
// Contains the Currently Selected Index
if ((vPreviousSelectIndex_C == (vEditableOptionIndex_C)) && (vSelectIndex_C != (vEditableOptionIndex_C))&&(vSelectChange_C != 'MANUAL_CLICK'))
// To Set value of Index variables - Subrata Chakrabarty
{
getdropdown[(vEditableOptionIndex_C)].selected=true;
vPreviousSelectIndex_C = vSelectIndex_C;
vSelectIndex_C = getdropdown.options.selectedIndex;
vSelectChange_C = 'MANUAL_CLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
}
function fnKeyPressHandler_C(getdropdown, e)
{
fnSanityCheck(getdropdown);
keycode = FindKeyCode(e);
keychar = FindKeyChar(e);
// Check for allowable Characters
// The various characters allowable for entry into Editable option..
// may be customized by minor modifications in the code (if condition below)
// (you need to know the keycode/ASCII value of the character to be allowed/disallowed.
// - Subrata Chakrabarty
if ((keycode>47 && keycode<59)||(keycode>62 && keycode<127) ||(keycode==32))
{
var vAllowableCharacter = "yes";
}
else
{
var vAllowableCharacter = "no";
}
//alert(window); alert(window.event);
if(getdropdown.options.length != 0)
// if dropdown is not empty
if (getdropdown.options.selectedIndex == (vEditableOptionIndex_C))
// if selected option the Editable option of the dropdown
{
var vEditString = getdropdown[vEditableOptionIndex_C].value;
// make Editable option Null if it is being edited for the first time
if((vAllowableCharacter == "yes")||(keychar=="backspace"))
{
if (vEditString == vEditableOptionText_C)
vEditString = "";
}
if (keychar=="backspace")
// To handle backspace - Subrata Chakrabarty
{
vEditString = vEditString.substring(0,vEditString.length-1);
// Decrease length of string by one from right
vSelectChange_C = 'MANUAL_CLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
//alert("EditString2:"+vEditString);
if (vAllowableCharacter == "yes")
// To handle addition of a character - Subrata Chakrabarty
{
vEditString+=String.fromCharCode(keycode);
// Concatenate Enter character to Editable string
// The following portion handles the "automatic Jump" bug
// The "automatic Jump" bug (Description):
// If a alphabet is entered (while editing)
// ...which is contained as a first character in one of the read-only options
// ..the focus automatically "jumps" to the read-only option
// (-- this is a common property of normal dropdowns
// ..but..is undesirable while editing).
var i=0;
var vEnteredChar = String.fromCharCode(keycode);
var vUpperCaseEnteredChar = vEnteredChar;
var vLowerCaseEnteredChar = vEnteredChar;
if(((keycode)>=97)&&((keycode)<=122))
// if vEnteredChar lowercase
vUpperCaseEnteredChar = String.fromCharCode(keycode - 32);
// This is UpperCase
if(((keycode)>=65)&&((keycode)<=90))
// if vEnteredChar is UpperCase
vLowerCaseEnteredChar = String.fromCharCode(keycode + 32);
// This is lowercase
if(e.which) //For Netscape
{
// Compare the typed character (into the editable option)
// with the first character of all the other
// options (non-editable).
// To note if the jump to the non-editable option was due
// to a Manual click (i.e.,changed on purpose by user)
// or due to System properties of dropdown
// (i.e.,user did not change the option in the dropdown;
// instead an automatic jump happened due to inbuilt
// dropdown properties of browser on typing of a character )
for (i=0;i<=(getdropdown.options.length-1);i++)
{
if(i!=vEditableOptionIndex_C)
{
var vReadOnlyString = getdropdown[i].value;
var vFirstChar = vReadOnlyString.substring(0,1);
if((vFirstChar == vUpperCaseEnteredChar)||(vFirstChar == vLowerCaseEnteredChar))
{
vSelectChange_C = 'AUTO_SYSTEM';
// Indicates that the Change in dropdown selected
// option was due to System properties of dropdown
break;
}
else
{
vSelectChange_C = 'MANUAL_CLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
}
}
}
}
// Set the new edited string into the Editable option
getdropdown.options[vEditableOptionIndex_C].text = vEditString;
getdropdown.options[vEditableOptionIndex_C].value = vEditString;
return false;
}
return true;
}
function fnKeyUpHandler_C(getdropdown, e)
{
fnSanityCheck(getdropdown);
if(e.which) // Netscape
{
if(vSelectChange_C == 'AUTO_SYSTEM')
{
// if editable dropdown option jumped while editing
// (due to typing of a character which is the first character of some other option)
// then go back to the editable option.
getdropdown[(vEditableOptionIndex_C)].selected=true;
}
var vEventKeyCode = FindKeyCode(e);
// if [ <- ] or [ -> ] arrow keys are pressed, select the editable option
if((vEventKeyCode == 37)||(vEventKeyCode == 39))
{
getdropdown[vEditableOptionIndex_C].selected=true;
}
}
}
/*-------------------------------------------------------------------------------------------- Subrata Chakrabarty */
//Dropdown specific functions, which manipulate dropdown specific global variables
//for the dropdown lstDropDown_D
/*----------------------------------------------
Dropdown specific global variables are:
-----------------------------------------------
1) vEditableOptionIndex_D --> this needs to be set by Programmer!! See explanation.
2) vEditableOptionText_D --> this needs to be set by Programmer!! See explanation.
3) vPreviousSelectIndex_D
4) vSelectIndex_D
5) vSelectChange_D
--------------------------- Subrata Chakrabarty */
/*----------------------------------------------
The dropdown specific functions
(which manipulate dropdown specific global variables)
used by all dropdowns are:
-----------------------------------------------
1) function fnChangeHandler_D(getdropdown)
2) function fnKeyPressHandler_D(getdropdown, e)
3) function fnKeyUpHandler_D(getdropdown, e)
--------------------------- Subrata Chakrabarty */
/*------------------------------------------------
IMPORTANT: Global Variable required to be SET by programmer
-------------------------- Subrata Chakrabarty */
var vEditableOptionIndex_D = 6;
// Give Index of Editable option in the dropdown.
// For eg.
// if first option is editable then vEditableOptionIndex_D = 0;
// if second option is editable then vEditableOptionIndex_D = 1;
// if third option is editable then vEditableOptionIndex_D = 2;
// if last option is editable then vEditableOptionIndex_D = (length of dropdown - 1).
// Note: the value of vEditableOptionIndex_D cannot be greater than (length of dropdown - 1)
var vEditableOptionText_D = "--?--";
// Give the default text of the Editable option in the dropdown.
// For eg.
// if the editable option is ,
// then set vEditableOptionText_D = "--?--";
/*------------------------------------------------
Global Variables required for
fnChangeHandler_D(), fnKeyPressHandler_D() and fnKeyUpHandler_D()
for Editable Dropdowns
-------------------------- Subrata Chakrabarty */
var vPreviousSelectIndex_D = 0;
// Contains the Previously Selected Index, set to 0 by default
var vSelectIndex_D = 0;
// Contains the Currently Selected Index, set to 0 by default
var vSelectChange_D = 'MANUAL_DLICK';
// Indicates whether Change in dropdown selected option
// was due to a Manual Click
// or due to System properties of dropdown.
// vSelectChange_D = 'MANUAL_DLICK' indicates that
// the jump to a non-editable option in the dropdown was due
// to a Manual click (i.e.,changed on purpose by user).
// vSelectChange_D = 'AUTO_SYSTEM' indicates that
// the jump to a non-editable option was due to System properties of dropdown
// (i.e.,user did not change the option in the dropdown;
// instead an automatic jump happened due to inbuilt
// dropdown properties of browser on typing of a character )
/*------------------------------------------------
Functions required for Editable Dropdowns
-------------------------- Subrata Chakrabarty */
function fnChangeHandler_D(getdropdown)
{
fnSanityCheck(getdropdown);
vPreviousSelectIndex_D = vSelectIndex_D;
// Contains the Previously Selected Index
vSelectIndex_D = getdropdown.options.selectedIndex;
// Contains the Currently Selected Index
if ((vPreviousSelectIndex_D == (vEditableOptionIndex_D)) && (vSelectIndex_D != (vEditableOptionIndex_D))&&(vSelectChange_D != 'MANUAL_DLICK'))
// To Set value of Index variables - Subrata Chakrabarty
{
getdropdown[(vEditableOptionIndex_D)].selected=true;
vPreviousSelectIndex_D = vSelectIndex_D;
vSelectIndex_D = getdropdown.options.selectedIndex;
vSelectChange_D = 'MANUAL_DLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
}
function fnKeyPressHandler_D(getdropdown, e)
{
fnSanityCheck(getdropdown);
keycode = FindKeyCode(e);
keychar = FindKeyChar(e);
// Check for allowable Characters
// The various characters allowable for entry into Editable option..
// may be customized by minor modifications in the code (if condition below)
// (you need to know the keycode/ASCII value of the character to be allowed/disallowed.
// - Subrata Chakrabarty
if ((keycode>47 && keycode<59)||(keycode>62 && keycode<127) ||(keycode==32))
{
var vAllowableCharacter = "yes";
}
else
{
var vAllowableCharacter = "no";
}
//alert(window); alert(window.event);
if(getdropdown.options.length != 0)
// if dropdown is not empty
if (getdropdown.options.selectedIndex == (vEditableOptionIndex_D))
// if selected option the Editable option of the dropdown
{
var vEditString = getdropdown[vEditableOptionIndex_D].value;
// make Editable option Null if it is being edited for the first time
if((vAllowableCharacter == "yes")||(keychar=="backspace"))
{
if (vEditString == vEditableOptionText_D)
vEditString = "";
}
if (keychar=="backspace")
// To handle backspace - Subrata Chakrabarty
{
vEditString = vEditString.substring(0,vEditString.length-1);
// Decrease length of string by one from right
vSelectChange_D = 'MANUAL_DLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
//alert("EditString2:"+vEditString);
if (vAllowableCharacter == "yes")
// To handle addition of a character - Subrata Chakrabarty
{
vEditString+=String.fromCharCode(keycode);
// Concatenate Enter character to Editable string
// The following portion handles the "automatic Jump" bug
// The "automatic Jump" bug (Description):
// If a alphabet is entered (while editing)
// ...which is contained as a first character in one of the read-only options
// ..the focus automatically "jumps" to the read-only option
// (-- this is a common property of normal dropdowns
// ..but..is undesirable while editing).
var i=0;
var vEnteredChar = String.fromCharCode(keycode);
var vUpperCaseEnteredChar = vEnteredChar;
var vLowerCaseEnteredChar = vEnteredChar;
if(((keycode)>=97)&&((keycode)<=122))
// if vEnteredChar lowercase
vUpperCaseEnteredChar = String.fromCharCode(keycode - 32);
// This is UpperCase
if(((keycode)>=65)&&((keycode)<=90))
// if vEnteredChar is UpperCase
vLowerCaseEnteredChar = String.fromCharCode(keycode + 32);
// This is lowercase
if(e.which) //For Netscape
{
// Compare the typed character (into the editable option)
// with the first character of all the other
// options (non-editable).
// To note if the jump to the non-editable option was due
// to a Manual click (i.e.,changed on purpose by user)
// or due to System properties of dropdown
// (i.e.,user did not change the option in the dropdown;
// instead an automatic jump happened due to inbuilt
// dropdown properties of browser on typing of a character )
for (i=0;i<=(getdropdown.options.length-1);i++)
{
if(i!=vEditableOptionIndex_D)
{
var vReadOnlyString = getdropdown[i].value;
var vFirstChar = vReadOnlyString.substring(0,1);
if((vFirstChar == vUpperCaseEnteredChar)||(vFirstChar == vLowerCaseEnteredChar))
{
vSelectChange_D = 'AUTO_SYSTEM';
// Indicates that the Change in dropdown selected
// option was due to System properties of dropdown
break;
}
else
{
vSelectChange_D = 'MANUAL_DLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
}
}
}
}
// Set the new edited string into the Editable option
getdropdown.options[vEditableOptionIndex_D].text = vEditString;
getdropdown.options[vEditableOptionIndex_D].value = vEditString;
return false;
}
return true;
}
function fnKeyUpHandler_D(getdropdown, e)
{
fnSanityCheck(getdropdown);
if(e.which) // Netscape
{
if(vSelectChange_D == 'AUTO_SYSTEM')
{
// if editable dropdown option jumped while editing
// (due to typing of a character which is the first character of some other option)
// then go back to the editable option.
getdropdown[(vEditableOptionIndex_D)].selected=true;
}
var vEventKeyCode = FindKeyCode(e);
// if [ <- ] or [ -> ] arrow keys are pressed, select the editable option
if((vEventKeyCode == 37)||(vEventKeyCode == 39))
{
getdropdown[vEditableOptionIndex_D].selected=true;
}
}
}
/*-------------------------------------------------------------------------------------------- Subrata Chakrabarty */
//Dropdown specific functions, which manipulate dropdown specific global variables
//for the dropdown lstDropDown_E
/*----------------------------------------------
Dropdown specific global variables are:
-----------------------------------------------
1) vEditableOptionIndex_E --> this needs to be set by Programmer!! See explanation.
2) vEditableOptionText_E --> this needs to be set by Programmer!! See explanation.
3) vPreviousSelectIndex_E
4) vSelectIndex_E
5) vSelectChange_E
--------------------------- Subrata Chakrabarty */
/*----------------------------------------------
The dropdown specific functions
(which manipulate dropdown specific global variables)
used by all dropdowns are:
-----------------------------------------------
1) function fnChangeHandler_E(getdropdown)
2) function fnKeyPressHandler_E(getdropdown, e)
3) function fnKeyUpHandler_E(getdropdown, e)
--------------------------- Subrata Chakrabarty */
/*------------------------------------------------
IMPORTANT: Global Variable required to be SET by programmer
-------------------------- Subrata Chakrabarty */
var vEditableOptionIndex_E = 6;
// Give Index of Editable option in the dropdown.
// For eg.
// if first option is editable then vEditableOptionIndex_E = 0;
// if second option is editable then vEditableOptionIndex_E = 1;
// if third option is editable then vEditableOptionIndex_E = 2;
// if last option is editable then vEditableOptionIndex_E = (length of dropdown - 1).
// Note: the value of vEditableOptionIndex_E cannot be greater than (length of dropdown - 1)
var vEditableOptionText_E = "--?--";
// Give the default text of the Editable option in the dropdown.
// For eg.
// if the editable option is ,
// then set vEditableOptionText_E = "--?--";
/*------------------------------------------------
Global Variables required for
fnChangeHandler_E(), fnKeyPressHandler_E() and fnKeyUpHandler_E()
for Editable Dropdowns
-------------------------- Subrata Chakrabarty */
var vPreviousSelectIndex_E = 0;
// Contains the Previously Selected Index, set to 0 by default
var vSelectIndex_E = 0;
// Contains the Currently Selected Index, set to 0 by default
var vSelectChange_E = 'MANUAL_ELICK';
// Indicates whether Change in dropdown selected option
// was due to a Manual Click
// or due to System properties of dropdown.
// vSelectChange_E = 'MANUAL_ELICK' indicates that
// the jump to a non-editable option in the dropdown was due
// to a Manual click (i.e.,changed on purpose by user).
// vSelectChange_E = 'AUTO_SYSTEM' indicates that
// the jump to a non-editable option was due to System properties of dropdown
// (i.e.,user did not change the option in the dropdown;
// instead an automatic jump happened due to inbuilt
// dropdown properties of browser on typing of a character )
/*------------------------------------------------
Functions required for Editable Dropdowns
-------------------------- Subrata Chakrabarty */
function fnChangeHandler_E(getdropdown)
{
fnSanityCheck(getdropdown);
vPreviousSelectIndex_E = vSelectIndex_E;
// Contains the Previously Selected Index
vSelectIndex_E = getdropdown.options.selectedIndex;
// Contains the Currently Selected Index
if ((vPreviousSelectIndex_E == (vEditableOptionIndex_E)) && (vSelectIndex_E != (vEditableOptionIndex_E))&&(vSelectChange_E != 'MANUAL_ELICK'))
// To Set value of Index variables - Subrata Chakrabarty
{
getdropdown[(vEditableOptionIndex_E)].selected=true;
vPreviousSelectIndex_E = vSelectIndex_E;
vSelectIndex_E = getdropdown.options.selectedIndex;
vSelectChange_E = 'MANUAL_ELICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
}
function fnKeyPressHandler_E(getdropdown, e)
{
fnSanityCheck(getdropdown);
keycode = FindKeyCode(e);
keychar = FindKeyChar(e);
// Check for allowable Characters
// The various characters allowable for entry into Editable option..
// may be customized by minor modifications in the code (if condition below)
// (you need to know the keycode/ASCII value of the character to be allowed/disallowed.
// - Subrata Chakrabarty
if ((keycode>47 && keycode<59)||(keycode>62 && keycode<127) ||(keycode==32))
{
var vAllowableCharacter = "yes";
}
else
{
var vAllowableCharacter = "no";
}
//alert(window); alert(window.event);
if(getdropdown.options.length != 0)
// if dropdown is not empty
if (getdropdown.options.selectedIndex == (vEditableOptionIndex_E))
// if selected option the Editable option of the dropdown
{
var vEditString = getdropdown[vEditableOptionIndex_E].value;
// make Editable option Null if it is being edited for the first time
if((vAllowableCharacter == "yes")||(keychar=="backspace"))
{
if (vEditString == vEditableOptionText_E)
vEditString = "";
}
if (keychar=="backspace")
// To handle backspace - Subrata Chakrabarty
{
vEditString = vEditString.substring(0,vEditString.length-1);
// Decrease length of string by one from right
vSelectChange_E = 'MANUAL_ELICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
//alert("EditString2:"+vEditString);
if (vAllowableCharacter == "yes")
// To handle addition of a character - Subrata Chakrabarty
{
vEditString+=String.fromCharCode(keycode);
// Concatenate Enter character to Editable string
// The following portion handles the "automatic Jump" bug
// The "automatic Jump" bug (Description):
// If a alphabet is entered (while editing)
// ...which is contained as a first character in one of the read-only options
// ..the focus automatically "jumps" to the read-only option
// (-- this is a common property of normal dropdowns
// ..but..is undesirable while editing).
var i=0;
var vEnteredChar = String.fromCharCode(keycode);
var vUpperCaseEnteredChar = vEnteredChar;
var vLowerCaseEnteredChar = vEnteredChar;
if(((keycode)>=97)&&((keycode)<=122))
// if vEnteredChar lowercase
vUpperCaseEnteredChar = String.fromCharCode(keycode - 32);
// This is UpperCase
if(((keycode)>=65)&&((keycode)<=90))
// if vEnteredChar is UpperCase
vLowerCaseEnteredChar = String.fromCharCode(keycode + 32);
// This is lowercase
if(e.which) //For Netscape
{
// Compare the typed character (into the editable option)
// with the first character of all the other
// options (non-editable).
// To note if the jump to the non-editable option was due
// to a Manual click (i.e.,changed on purpose by user)
// or due to System properties of dropdown
// (i.e.,user did not change the option in the dropdown;
// instead an automatic jump happened due to inbuilt
// dropdown properties of browser on typing of a character )
for (i=0;i<=(getdropdown.options.length-1);i++)
{
if(i!=vEditableOptionIndex_E)
{
var vReadOnlyString = getdropdown[i].value;
var vFirstChar = vReadOnlyString.substring(0,1);
if((vFirstChar == vUpperCaseEnteredChar)||(vFirstChar == vLowerCaseEnteredChar))
{
vSelectChange_E = 'AUTO_SYSTEM';
// Indicates that the Change in dropdown selected
// option was due to System properties of dropdown
break;
}
else
{
vSelectChange_E = 'MANUAL_ELICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
}
}
}
}
// Set the new edited string into the Editable option
getdropdown.options[vEditableOptionIndex_E].text = vEditString;
getdropdown.options[vEditableOptionIndex_E].value = vEditString;
return false;
}
return true;
}
function fnKeyUpHandler_E(getdropdown, e)
{
fnSanityCheck(getdropdown);
if(e.which) // Netscape
{
if(vSelectChange_E == 'AUTO_SYSTEM')
{
// if editable dropdown option jumped while editing
// (due to typing of a character which is the first character of some other option)
// then go back to the editable option.
getdropdown[(vEditableOptionIndex_E)].selected=true;
}
var vEventKeyCode = FindKeyCode(e);
// if [ <- ] or [ -> ] arrow keys are pressed, select the editable option
if((vEventKeyCode == 37)||(vEventKeyCode == 39))
{
getdropdown[vEditableOptionIndex_E].selected=true;
}
}
}
/*-------------------------------------------------------------------------------------------- Subrata Chakrabarty */
//Dropdown specific functions, which manipulate dropdown specific global variables
//for the dropdown lstDropDown_F
/*----------------------------------------------
Dropdown specific global variables are:
-----------------------------------------------
1) vEditableOptionIndex_F --> this needs to be set by Programmer!! See explanation.
2) vEditableOptionText_F --> this needs to be set by Programmer!! See explanation.
3) vPreviousSelectIndex_F
4) vSelectIndex_F
5) vSelectChange_F
--------------------------- Subrata Chakrabarty */
/*----------------------------------------------
The dropdown specific functions
(which manipulate dropdown specific global variables)
used by all dropdowns are:
-----------------------------------------------
1) function fnChangeHandler_F(getdropdown)
2) function fnKeyPressHandler_F(getdropdown, e)
3) function fnKeyUpHandler_F(getdropdown, e)
--------------------------- Subrata Chakrabarty */
/*------------------------------------------------
IMPORTANT: Global Variable required to be SET by programmer
-------------------------- Subrata Chakrabarty */
var vEditableOptionIndex_F = 6;
// Give Index of Editable option in the dropdown.
// For eg.
// if first option is editable then vEditableOptionIndex_F = 0;
// if second option is editable then vEditableOptionIndex_F = 1;
// if third option is editable then vEditableOptionIndex_F = 2;
// if last option is editable then vEditableOptionIndex_F = (length of dropdown - 1).
// Note: the value of vEditableOptionIndex_F cannot be greater than (length of dropdown - 1)
var vEditableOptionText_F = "--?--";
// Give the default text of the Editable option in the dropdown.
// For eg.
// if the editable option is ,
// then set vEditableOptionText_F = "--?--";
/*------------------------------------------------
Global Variables required for
fnChangeHandler_F(), fnKeyPressHandler_F() and fnKeyUpHandler_F()
for Editable Dropdowns
-------------------------- Subrata Chakrabarty */
var vPreviousSelectIndex_F = 0;
// Contains the Previously Selected Index, set to 0 by default
var vSelectIndex_F = 0;
// Contains the Currently Selected Index, set to 0 by default
var vSelectChange_F = 'MANUAL_FLICK';
// Indicates whether Change in dropdown selected option
// was due to a Manual Click
// or due to System properties of dropdown.
// vSelectChange_F = 'MANUAL_FLICK' indicates that
// the jump to a non-editable option in the dropdown was due
// to a Manual click (i.e.,changed on purpose by user).
// vSelectChange_F = 'AUTO_SYSTEM' indicates that
// the jump to a non-editable option was due to System properties of dropdown
// (i.e.,user did not change the option in the dropdown;
// instead an automatic jump happened due to inbuilt
// dropdown properties of browser on typing of a character )
/*------------------------------------------------
Functions required for Editable Dropdowns
-------------------------- Subrata Chakrabarty */
function fnChangeHandler_F(getdropdown)
{
fnSanityCheck(getdropdown);
vPreviousSelectIndex_F = vSelectIndex_F;
// Contains the Previously Selected Index
vSelectIndex_F = getdropdown.options.selectedIndex;
// Contains the Currently Selected Index
if ((vPreviousSelectIndex_F == (vEditableOptionIndex_F)) && (vSelectIndex_F != (vEditableOptionIndex_F))&&(vSelectChange_F != 'MANUAL_FLICK'))
// To Set value of Index variables - Subrata Chakrabarty
{
getdropdown[(vEditableOptionIndex_F)].selected=true;
vPreviousSelectIndex_F = vSelectIndex_F;
vSelectIndex_F = getdropdown.options.selectedIndex;
vSelectChange_F = 'MANUAL_FLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
}
function fnKeyPressHandler_F(getdropdown, e)
{
fnSanityCheck(getdropdown);
keycode = FindKeyCode(e);
keychar = FindKeyChar(e);
// Check for allowable Characters
// The various characters allowable for entry into Editable option..
// may be customized by minor modifications in the code (if condition below)
// (you need to know the keycode/ASCII value of the character to be allowed/disallowed.
// - Subrata Chakrabarty
if ((keycode>47 && keycode<59)||(keycode>62 && keycode<127) ||(keycode==32))
{
var vAllowableCharacter = "yes";
}
else
{
var vAllowableCharacter = "no";
}
//alert(window); alert(window.event);
if(getdropdown.options.length != 0)
// if dropdown is not empty
if (getdropdown.options.selectedIndex == (vEditableOptionIndex_F))
// if selected option the Editable option of the dropdown
{
var vEditString = getdropdown[vEditableOptionIndex_F].value;
// make Editable option Null if it is being edited for the first time
if((vAllowableCharacter == "yes")||(keychar=="backspace"))
{
if (vEditString == vEditableOptionText_F)
vEditString = "";
}
if (keychar=="backspace")
// To handle backspace - Subrata Chakrabarty
{
vEditString = vEditString.substring(0,vEditString.length-1);
// Decrease length of string by one from right
vSelectChange_F = 'MANUAL_FLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
//alert("EditString2:"+vEditString);
if (vAllowableCharacter == "yes")
// To handle addition of a character - Subrata Chakrabarty
{
vEditString+=String.fromCharCode(keycode);
// Concatenate Enter character to Editable string
// The following portion handles the "automatic Jump" bug
// The "automatic Jump" bug (Description):
// If a alphabet is entered (while editing)
// ...which is contained as a first character in one of the read-only options
// ..the focus automatically "jumps" to the read-only option
// (-- this is a common property of normal dropdowns
// ..but..is undesirable while editing).
var i=0;
var vEnteredChar = String.fromCharCode(keycode);
var vUpperCaseEnteredChar = vEnteredChar;
var vLowerCaseEnteredChar = vEnteredChar;
if(((keycode)>=97)&&((keycode)<=122))
// if vEnteredChar lowercase
vUpperCaseEnteredChar = String.fromCharCode(keycode - 32);
// This is UpperCase
if(((keycode)>=65)&&((keycode)<=90))
// if vEnteredChar is UpperCase
vLowerCaseEnteredChar = String.fromCharCode(keycode + 32);
// This is lowercase
if(e.which) //For Netscape
{
// Compare the typed character (into the editable option)
// with the first character of all the other
// options (non-editable).
// To note if the jump to the non-editable option was due
// to a Manual click (i.e.,changed on purpose by user)
// or due to System properties of dropdown
// (i.e.,user did not change the option in the dropdown;
// instead an automatic jump happened due to inbuilt
// dropdown properties of browser on typing of a character )
for (i=0;i<=(getdropdown.options.length-1);i++)
{
if(i!=vEditableOptionIndex_F)
{
var vReadOnlyString = getdropdown[i].value;
var vFirstChar = vReadOnlyString.substring(0,1);
if((vFirstChar == vUpperCaseEnteredChar)||(vFirstChar == vLowerCaseEnteredChar))
{
vSelectChange_F = 'AUTO_SYSTEM';
// Indicates that the Change in dropdown selected
// option was due to System properties of dropdown
break;
}
else
{
vSelectChange_F = 'MANUAL_FLICK';
// Indicates that the Change in dropdown selected
// option was due to a Manual Click
}
}
}
}
}
// Set the new edited string into the Editable option
getdropdown.options[vEditableOptionIndex_F].text = vEditString;
getdropdown.options[vEditableOptionIndex_F].value = vEditString;
return false;
}
return true;
}
function fnKeyUpHandler_F(getdropdown, e)
{
fnSanityCheck(getdropdown);
if(e.which) // Netscape
{
if(vSelectChange_F == 'AUTO_SYSTEM')
{
// if editable dropdown option jumped while editing
// (due to typing of a character which is the first character of some other option)
// then go back to the editable option.
getdropdown[(vEditableOptionIndex_F)].selected=true;
}
var vEventKeyCode = FindKeyCode(e);
// if [ <- ] or [ -> ] arrow keys are pressed, select the editable option
if((vEventKeyCode == 37)||(vEventKeyCode == 39))
{
getdropdown[vEditableOptionIndex_F].selected=true;
}
}
}
/*-------------------------------------------------------------------------------------------- Subrata Chakrabarty */