/*
 *
 * IBM Confidential
 *
 * OCO Source Materials
 *
 * 5724-M19
 *
 * (C) COPYRIGHT IBM CORP. 2006
 *
 * The source code for this program is not published or otherwise
 * divested of its trade secrets, irrespective of what has been
 * deposited with the U.S. Copyright Office.
 *
 */
 
/*
 *
 * MRO Software Confidential
 *
 * (C) COPYRIGHT MRO Software, Inc. 2001-2006
 *
 * The source code for this program is not published or otherwise
 * divested of its trade secrets, irrespective of what has been
 * deposited with the U.S. Copyright Office.
 *
 */

/**************** BEGIN Standard functions for appbar**********************/
	
	function appbar_onclick(ctrlInst)
	{
		var eventElement = library_getElementHavingEvent(ctrlInst,event.srcElement);
		appbar_handleEvent(ctrlInst,eventElement);  
	}
	
	function appbar_onkeypress(ctrlInst)
	{		
		var eventElement = library_getElementHavingEvent(ctrlInst, event.srcElement);
		var keyCode =  event.keyCode;
		switch(keyCode)
		{
			case KEYCODE_ENTER:
				appbar_handleEvent(ctrlInst,eventElement); 
				break;
			default: break;
		}
	}
	
	function appbar_handleEvent(ctrlInst,eventElement)
	{
		var mxevents = library_getMxEvents(ctrlInst,eventElement);
		for(var i=0; i<mxevents.length; i++)
		{
			var mxevent = mxevents[i];
			switch(mxevent)
			{
				case "changeapp": 
				case "loadlink": 
					var appid = eventElement.getAttribute("appid");
					var toappid = eventElement.getAttribute("toappid");
					if(!undef(ctrlInst,appid) && !undef(ctrlInst,toappid))
					{
						sendEvent(mxevent, appid, toappid);
					}
					break; 
			}
		}
	}
/**************** END Standard functions for appbar**********************/

/**************** Begin Standard functions for attachments**********************/

	function attachments_onclick(ctrlInst)
	{
		el = event.srcElement;
		part = el.mxpart;
		switch(part)
		{
			case "label":
				if(ctrlInst.isempty=="false")
					sendEvent("viewattachments", ctrlInst.id);
				break;
			case "img":
				x=event.clientX-event.offsetX-2;
				y=event.clientY-event.offsetY-2;
				getMenu(ctrlInst.id, x, y);
				break;
		}
	}

	function attachments_onactivate(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "label":
				setfocusField(getPart(ctrlInst,"label"));
				break;
			case "img":
				setfocusField(getPart(ctrlInst,"img"));
				break;
		}
	}

/**************** END Standard functions for attachments**********************/

/**************** BEGIN Standard functions for bboardpopup**********************/

	 function bboardpopup_popupDisplayMessage(ctrlInst,bbindex,msgstate,bboardid,controlId,doc)
	 {	
	 	mainCtrl = getControl(ctrlInst);
		var msg = document.getElementById(mainCtrl.id+'_popupmessagerow_'+bbindex);
		var msgboxdiv = document.getElementById(mainCtrl.id+'_popupbbmessagemain_'+bbindex);
		var hiddenmsgdiv = document.getElementById(mainCtrl.id+'_popuphiddenmsg_'+bbindex);
		var msgdiv = document.getElementById (mainCtrl.id+'_popupbbmessage_'+bbindex);
		
		if(msgstate == 'close')
		{
			msgboxdiv.style.display = 'none';			
			return;
		}

		if(msgboxdiv.style.display == 'none')
		{	
			msg.className = "popupmessagelineOpened";		
			msgboxdiv.style.display = 'inline';
			if(mainCtrl.expandOnlyOne=="true")
			{
			 	var oldOpened = mainCtrl.selectedMsgIndex;
				var oldmsg = document.getElementById(mainCtrl.id+'_popupmessagerow_'+oldOpened);
				var oldmsgboxdiv = document.getElementById(mainCtrl.id+'_popupbbmessagemain_'+oldOpened);
				if( oldmsgboxdiv)
				{
					oldmsgboxdiv.style.display='none';
					if(oldmsg)
						oldmsg.className="popupmessagelineClosed";
				}
			}
			mainCtrl.selectedMsgIndex = bbindex;
	 	}
	 	else
	 	{	
	 		msg.className = "popupmessagelineClosed";
			msgboxdiv.style.display = 'none';
	 		mainCtrl.selectedMsgIndex = "-1";
	 	}
	 }
	 
	 		
	function bboardpopup_refreshPopup(ctrlInst)
	{
		parent.sendEvent("redrawbboard","showbboard",null);
	}
/**************** END Standard functions for bboardpopup**********************/

/**************** BEGIN Standard functions for calendar**********************/

	function calendar_oncontentready(ctrlInst)
	{
		ctrlInst.dateArray = new Array();
		ctrlInst.dateArray = ctrlInst.datevalue.split(",");

		ctrlInst.month=ctrlInst.dateArray[0];
		calendar_handleMonth(ctrlInst, ctrlInst.month);

		ctrlInst.day=ctrlInst.dateArray[1];

		ctrlInst.year=ctrlInst.dateArray[2];
		calendar_handleYear(ctrlInst, ctrlInst.year);
						
		hms = new Array();
		hms = ctrlInst.dateArray[3].split(":");

		ctrlInst.hour=hms[0];
		calendar_handleHour(ctrlInst, ctrlInst.hour);
		
		ctrlInst.minute=hms[1];
		calendar_handleMinutes(ctrlInst, ctrlInst.minute);
		
		ctrlInst.second=hms[2];
		calendar_handleSeconds(ctrlInst, ctrlInst.second);
		
		part = getPart(ctrlInst, "calendarampm");
		calendar_handleAMPM(ctrlInst, ctrlInst.am_pm);
		
		ctrlInst.displaytype = ctrlInst.getAttribute("displaytype");
		ctrlInst.currenttimefocus = "calendarhour";
		calendar_renderCalendar(ctrlInst);
		ctrlInst.init=1;
	}
	
	function calendar_onkeyup(ctrlInst)
	{
	}

	function calendar_onkeydown(ctrlInst)
	{
		var eventElement = event.srcElement;
		var keyCode =  event.keyCode;
		ctrlInst = library_getControlByType(ctrlInst, "calendar");
		switch(keyCode)
		{
			case KEYCODE_ENTER:
				if(!undef(eventElement)){
					eventElement.click();
					event.cancelBubble=true;
				}
				break;
			case KEYCODE_UP_ARROW:
			case KEYCODE_DOWN_ARROW:
				if(event.ctrlKey)
				{
					var interval = (keyCode==KEYCODE_UP_ARROW)?1:-1;
					var part = null;
					switch(eventElement.mxpart)
					{
						case "yearstring":
							prop="year";
							part = getPart(ctrlInst, eventElement.mxpart);
							ctrlInst.year = calendar_handleYear(ctrlInst, part.value, interval);
							part.setAttribute("changed", "true");
							part.focus();
							part.select();
							break;
						case "monthstring":
							prop="month";
							part = getPart(ctrlInst, eventElement.mxpart);
							ctrlInst.month = calendar_handleMonth(ctrlInst, ctrlInst.month, interval);
							part.setAttribute("changed", "true");
							part.focus();
							part.select();
							break;
						case "calendarhour": 
							prop = "hour"; 
							part = getPart(ctrlInst, eventElement.mxpart);
							ctrlInst.hour = calendar_handleHour(ctrlInst, part.value, interval);
							part.setAttribute("changed", "true");
							part.focus();
							part.select();
							break;
						case "calendarminute": 
							prop = "minute"; 
							part = getPart(ctrlInst, eventElement.mxpart);
							ctrlInst.minute = calendar_handleMinutes(ctrlInst, part.value, interval);
							part.setAttribute("changed", "true");
							part.focus();
							part.select();
							break;
						case "calendarsecond": 
							prop = "second"; 
							part = getPart(ctrlInst, eventElement.mxpart);
							ctrlInst.second = calendar_handleSeconds(ctrlInst, part.value, interval);
							part.setAttribute("changed", "true");
							part.focus();
							part.select();
							break;
						case "calendarampm": 
							prop = "am_pm"; 
							part = getPart(ctrlInst, eventElement.mxpart);
							ctrlInst.am_pm = calendar_handleAMPM(ctrlInst, (ctrlInst.am_pm=="0") ? "1" : "0");
							part.setAttribute("changed", "true");
							part.focus();
							part.select();
							break;
					}
				}
				break;
			default: break;
		}
	}

	function calendar_onkeypress(ctrlInst)
	{
	
	}

	function calendar_onactivate(ctrlInst)
	{
		el = event.srcElement
		switch (el.mxpart)
	  	{
	  		case "yearstring": 
	   		case "monthstring":   
	   		case "calendarhour":
	   		case "calendarminute":
	   		case "calendarsecond":
	   		case "calendarampm":
	    		ctrlInst.currenttimefocus=el.mxpart;
	    		break;
	   		case "first": 
	   		case "last":
	    		//Loop back to the first element on the calendar control.
	    		var focuselementid = el.getAttribute("focuselementid");
	    		if(!undef(focuselementid))
	    		{
	     			var focusElement = document.getElementById(focuselementid);
	     			if(!undef(focusElement))
	     			{
	      				focusElement.focus();
	      				focusElement.select();
	     			}
	    		}
	    		break;
	  		}
	 }

 	function calendar_ondeactivate(part)
 	{
 		var mxevent="changedate";
 		var prop = "";
 		var propvalue = "";
 		var ctrlInst = library_getControlByType(part, "calendar");
 		var changed = (part.getAttribute("changed")=="true");
		switch (part.mxpart)
		{
			case "yearstring":
				prop = "year";
				propvalue = calendar_handleYear(ctrlInst, part.value);
				if(ctrlInst.year!=propvalue){changed = true;}
				break;
			case "monthstring": 
				prop = "month"; 
				propvalue = calendar_handleMonth(ctrlInst, ctrlInst.month);
				propvalue = (propvalue.indexOf("0")==0)?propvalue.replace("0",""):propvalue;
				if(ctrlInst.month!=propvalue){changed = true;}
				break;
			case "calendarhour":
				prop = "hour"; 
				propvalue = calendar_handleHour(ctrlInst, part.value);
				propvalue = (propvalue.indexOf("0")==0)?propvalue.replace("0",""):propvalue;
				if(ctrlInst.hour!=propvalue){changed = true;}
				break;
			case "calendarminute": 
				prop = "minute"; 
				propvalue = calendar_handleMinutes(ctrlInst, part.value);
				propvalue = (propvalue.indexOf("0")==0)?propvalue.replace("0",""):propvalue;
				if(ctrlInst.minute!=propvalue){changed = true;}
				break;
			case "calendarsecond": 
				prop = "second"; 
				propvalue = calendar_handleSeconds(ctrlInst, part.value);
				propvalue = (propvalue.indexOf("0")==0)?propvalue.replace("0",""):propvalue;
				if(ctrlInst.second!=propvalue){changed = true;}
				break;
			case "calendarampm":
				prop = "am_pm"; 
				propvalue = calendar_handleAMPM(ctrlInst, ctrlInst.am_pm);
				if(ctrlInst.am_pm!=propvalue){changed = true;}
				break;
		}
		if(!undef(prop) && !undef(propvalue) && changed)
		{
			sendEvent(mxevent, ctrlInst.id, prop + ":" + propvalue);
			part.removeAttribute("changed");
			event.returnValue = false;
		}
		return false;
 	}

	function calendar_onclick(ctrlInst)
	{
		var el = event.srcElement
		var prop="";
		var propvalue="";
		var mxevent = el.mxevent;
		switch (el.mxpart)
		{
			case "day":
			case "today":
			case "current":
				prop="day";
				propvalue = el.mxvalue;
				break;
			case "previousyear":
				prop="year";
				propvalue = calendar_handleYear(ctrlInst, ctrlInst.year, -1);
				break;
			case "nextyear":
				prop="year";
				propvalue = calendar_handleYear(ctrlInst, ctrlInst.year, 1);
				break;
			case "previousmonth":
				prop="month";
				propvalue = calendar_handleMonth(ctrlInst, ctrlInst.month, -1);
				break;
			case "nextmonth":
				prop="month";
				propvalue = calendar_handleMonth(ctrlInst, ctrlInst.month, 1);
				break;
			case "timeup":
			case "timedown":
				var interval = (el.mxpart=="timeup")?1:-1;
				var part = getPart(ctrlInst, ctrlInst.currenttimefocus);
				var mxpart = part.mxpart;
				switch(mxpart)
				{
					case "calendarhour": 
						prop = "hour"; 
						propvalue = calendar_handleHour(ctrlInst, part.value, interval);
						break;
					case "calendarminute": 
						prop = "minute"; 
						propvalue = calendar_handleMinutes(ctrlInst, part.value, interval);
						break;
					case "calendarsecond": 
						prop = "second"; 
						propvalue = calendar_handleSeconds(ctrlInst, part.value, interval);
						break;
					case "calendarampm": 
						prop = "am_pm"; 
						propvalue = calendar_handleAMPM(ctrlInst, (ctrlInst.am_pm=="0") ? "1" : "0");
						break;
				}
				break;
		}
		if(undef(mxevent)){mxevent="changedate";}
		if(!undef(prop) && !undef(propvalue))
		{
			sendEvent(mxevent, ctrlInst.id, prop + ":" + propvalue);
		}	
		event.returnValue=false;
		return false;
	}

	function calendar_onmouseout(ctrlInst)
	{
		var el = event.srcElement;
		if(!undef(el))
		{
			var part = el.mxpart;
			var elmClass =  el.className;
			if(undef(part))
				return;
			if(undef(elmClass) || elmClass.indexOf("currentdateval") != -1)
				return;
			switch (part)
			{
				case "day":
				case "today":
					el.className="day validday";
					break;
			}
		}	
	}	
	
	function calendar_setDate(ctrlInst, prop, propValue)
	{
		if(ctrlInst.init==1 || ctrlInst.init=="1")
		{
			var mxevent = "changedate";
			if(ctrlInst.displaytype=="DATE")
			{
				mxevent = "selectdate";
			}
			sendEvent(mxevent, ctrlInst.id, prop + ":" + propValue);
		}
	}

	function calendar_renderCalendar(ctrlInst)
	{
		container = getPart(ctrlInst, "graphical");
		if(!container)
		{
			alert("no container")
			return;
		}
		container.innerHTML="";	
		//window.status = ctrlInst.dateValue;
		graphicalTable = document.createElement("<table mxpart='monthcal' class='innercal' cellspacing='0' cellpadding='0' border='0'></table>");
		actualDay = 0;
		dayTitleRow = graphicalTable.insertRow();

		if(undef(ctrlInst.shortdays))
		{
			ctrlInst.shortdays = ctrlInst.getAttribute("shortdaysstring").split(",");
		}
		for(a=0; a<=ctrlInst.shortdays.length; a++)
		{
			actualDay=parseInt(a);
			if(!undef(ctrlInst.shortdays[actualDay]))
			{
				dayTitleCell = dayTitleRow.insertCell();
				dayTitleCell.className = "day daytitle";
				dayTitleCell.align="center";
				dayTitleCell.innerHTML = ctrlInst.shortdays[actualDay];
			}
		}

		todaysDate = ctrlInst.today;
		if(!undef(todaysDate))
		{
			todaysDate = todaysDate.split(",");
			currentMonth = parseInt(todaysDate[0]);
			currentDate = parseInt(todaysDate[1]);
			currentYear = parseInt(todaysDate[2]);
		}

		for(i=0; i<6;i++)
		{	
			daysRow = graphicalTable.insertRow();
			for(j=0; j<7;j++)
			{
				dayPart="";
				dayStyle="";
				dayClass="day";
				dayVal="";
				dayCell = daysRow.insertCell();
				dayCell.id = "calday_row"+i+"_col_"+j;
				if(i==0 && j<(ctrlInst.startDay))
				{
					dayClass = "day validday";
				}
				else
				{
					dayNum = 0;
					dayNum = ((i*7)+j-parseInt(ctrlInst.startDay))+1;
					if(parseInt(dayNum)<=parseInt(ctrlInst.daysInMonth))
					{
						dayVal = parseInt(dayNum);
						dayCell.mxevent = (ctrlInst.displaytype=="DATE_TIME")?"changedate":"selectdate";
						dayCell.mxvalue = dayVal;
						dayClass="day validday";
						dayPart = "day";
						if(dayNum==currentDate && ctrlInst.year==currentYear && ctrlInst.month==currentMonth)
						{
							dayClass="day validday today";
							dayPart="today";
						}
						else if(dayNum==ctrlInst.day)
						{
							dayClass+=" currentdateval";
							dayPart="current";
						}
						dayStyle.style="text-align:left";
						dayCell.tabindex="0";
					}
				}
				dayCell.className = dayClass; 
				dayCell.mxpart = dayPart;
				dayCell.innerHTML = (undef(dayVal))? "&nbsp;" : dayVal;
			}
		}
		fc = container.firstChild;
		if(fc)
			fc.removeNode(true);
		else
			container.insertAdjacentHTML('beforeEnd', graphicalTable.outerHTML);
	}
	

	function calendar_refreshCalendar(ctrlInst,calpart, calvalue)
	{
		switch(calpart)
		{
			case "year":
				ctrlInst.year = calvalue;
				calendar_renderCalendar(ctrlInst);
				break;
			case "month":
				ctrlInst.month = calvalue;
				calendar_renderCalendar(ctrlInst);
				break;
			case "day":
				for(var i=0; i<ctrlInst.all.tags("TABLE").length;i++)
				{ 
					if(ctrlInst.all.tags("TABLE")[i].mxpart=="monthcal")
					{
						var daycells = ctrlInst.all.tags("TABLE")[i].cells;
						var currentDayCell = null;
						for(var j=0;j<daycells.length;j++)
						{
							var mxpart = daycells[j].mxpart; 
							if( (mxpart=="day") || (mxpart=="today") || (mxpart=="current") )
							{
								if(daycells[j].className.indexOf("currentdateval")!=-1)
								{
									currentDayCell = daycells[j]; 
								}
							}		
						}						
						for(var k=0;k<daycells.length;k++)
						{
							var mxpart = daycells[k].mxpart; 
							if( (mxpart=="day") || (mxpart=="today") || (mxpart=="current") )
							{
								if(daycells[k].mxvalue==calvalue)
								{
									if(currentDayCell!=daycells[k])
									{
										if(!undef(currentDayCell))
										{
											var ctrlClassName = currentDayCell.className;
											ctrlClassName = ctrlClassName.replace(" currentdateval", "");
											ctrlClassName = ctrlClassName.replace("currentdateval", "");
											ctrlClassName = ctrlClassName.replace(/'  '+/g, '');
											currentDayCell.className = ctrlClassName;
										}
										daycells[k].className += " currentdateval";
										break;
									}
								}
							}		
						}
						break;	
					} 
				}
				break;
			case "hour":
				ctrlInst.hour = calvalue;
				break;
			case "minute":
				ctrlInst.minute = calvalue;
				break;
			case "second":
				ctrlInst.second = calvalue;
				break;
			case "am_pm":
				ctrlInst.am_pm = calvalue;
				break;										
			default: break;
		}
	}

	function calendar_handleYear(ctrlInst, calYear, interval)
	{
		var partElement = getPart(ctrlInst, "yearstring");
		if(!undef(partElement))
		{
			if(!undef(interval))
			{
				calYear = String( parseInt(calYear) + interval);
			}
			partElement.value = calYear;
		}
		return String(calYear);
	}
	
	function calendar_handleMonth(ctrlInst, calMonth, interval)
	{
		calMonth = shared_handleMonth(calMonth, interval);
		var part = getPart(ctrlInst, "monthstring");
		if(undef(ctrlInst.months))
		{
			ctrlInst.months = ctrlInst.getAttribute("monthstring").split(",");
		}
		part.value = ctrlInst.months[parseInt(calMonth)];
		return String(calMonth);
	}

	function calendar_handleHour(ctrlInst, calHour, interval)
	{
		if(ctrlInst.displaytype!="DATE")
		{
			var part = getPart(ctrlInst, "calendarhour");
			var supports24Hours = part.supports24Hours;
			calHour = shared_handleHour(calHour, supports24Hours, interval);
			part.value = calHour;
			return String(calHour);
		}	
	}
	
	function calendar_handleMinutes(ctrlInst, calMin, interval)
	{
		if(ctrlInst.displaytype!="DATE")
		{
			calMin = shared_handleMinutes(calMin, interval);
			var part = getPart(ctrlInst, "calendarminute");
			part.value = calMin;
			return String(calMin);
		}
	}
	
	function calendar_handleSeconds(ctrlInst, calSec, interval)
	{					
		if(ctrlInst.displaytype!="DATE")
		{
			calSec = shared_handleSeconds(calSec, interval);
			var part = getPart(ctrlInst, "calendarsecond");
			part.value = calSec;
			return String(calSec);
		}
	}

	function calendar_handleAMPM(ctrlInst, calAM_PM)
	{
		if(ctrlInst.displaytype!="DATE")
		{
			var part = getPart(ctrlInst, "calendarampm");
			if(undef(ctrlInst.ampm))
			{
				ctrlInst.ampm = ctrlInst.getAttribute("ampmstring").split(",");
			}
			part.value = ctrlInst.ampm[parseInt(calAM_PM)];
		}
		return calAM_PM;
	}

	function calendar_onfocus(ctrlInst)
	{
		ctrlInst.select();
		event.cancelBubble = true;
	}

/**************** END Standard functions for calendar**********************/

/**************** BEGIN Standard functions for checkbox**********************/
	function checkbox_onactivate(ctrlInst)
	{
		setfocusField(event.srcElement);
	}

	function checkbox_updateValue(ctrlInst,mxpart, val)
	{
		if(ctrlInst.checked=!val)
			parent.addUpdateField(getpart(ctrlInst,"textbox"),val);
		ctrlInst.checked=val;
	}

	function checkbox_updateRequired(ctrlInst,mxpart, req)
	{
		//Do nothing - checkboxes are by definition, always required but not marked so
	}
	
	function checkbox_updateReadOnly(ctrlInst,mxpart, roBoolean)
	{
		ctrlInst.readonly=roBoolean;
	}


	function checkbox_onkeydown(ctrlInst)
	{
		showFieldHelp();
	}

	function checkbox_onkeypress(ctrlInst)
	{
		if(ctrlInst.readonly=="true" || ctrlInst.readonly==true)
			return;
			
		if(event.keyCode==KEYCODE_SPACEBAR)
		{
			img = ctrlInst.all.namedItem(ctrlInst.id+"_box");
			img.click();
			event.cancelBubble=true;
		}
	}

	function checkbox_onclick(ctrlInst)
	{
		if(ctrlInst.readonly=="true" || ctrlInst.readonly==true)
			return;
			
		
		if(event.srcElement.mxpart)
		{	
			if(ctrlInst.mxevent=="setvalue")
			{
				//Check if the control is in a table (need to pass row for table)
				var ontable=ctrlInst.getAttribute("ontable");
				var foundRow = false;				
				
				if(!undef(ontable))
				{
					tablerow = ctrlInst.getAttribute("tablerow");
					if(!undef(tablerow))
						foundRow = true;
				}
				img = ctrlInst.all.namedItem(ctrlInst.id+"_box");
				if(foundRow)
					setValue(ctrlInst, img, ctrlInst.tablerow);
				else
				{
					setValue(ctrlInst, img);
				}	
			}	
			else 
			{
				sendEvent(ctrlInst.mxevent, ctrlInst.id);
			}	
		}
	}
	
	function checkbox_onpropertychange(ctrlInst)
	{
	   	if(event.propertyName=="checked")
	   	{
			img = ctrlInst.all.namedItem(ctrlInst.id+"_box");
			oldLabel = img.alt;
			if(ctrlInst.checked!="false")
			{
				img.src=IMAGE_PATH+"cb_checked.gif";
				img.alt = oldLabel.replace(/Unchecked/,"Checked");
			}
			else
			{
				img.src=IMAGE_PATH+"cb_unchecked.gif";
				img.alt = oldLabel.replace(/Checked/,"Unchecked");
			}
		}

	   	if(event.propertyName=="readonly")
	   	{
			img = ctrlInst.all.namedItem(ctrlInst.id+"_box");
			if(ctrlInst.readonly==true)
			{
				if(ctrlInst.checked!="false")
				{
					img.src=IMAGE_PATH+"RO_cb_checked.gif";
				}
				else
				{
					img.src=IMAGE_PATH+"RO_cb_unchecked.gif";
				}
				img.tabIndex=READ_ONLY_TAB_INDEX;
			}
			else
			{
				ctrlInst.style.cursor="hand";
				if(ctrlInst.checked!="false")
				{
					img.src=IMAGE_PATH+"cb_checked.gif";
				}
				else
				{
					img.src=IMAGE_PATH+"cb_unchecked.gif";
				}
				img.tabIndex="0";
			}
		}
	}


	function checkbox_oncontextmenu(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "textbox":
				menuX=event.clientX-event.offsetX+15;
				menuY=event.clientY-event.offsetY+5;
				sendEvent("showfieldhelp", ctrlInst.id, "textbox", "dataattribute");
				break;
		}
		event.cancelBubble=true;
		event.returnValue=false;
	}

	function checkbox_onmouseover(ctrlInst)
	{
		img = ctrlInst.all.namedItem(ctrlInst.id+"_box");
		if(ctrlInst.readonly=="true" || ctrlInst.readonly==true)
		{
			img.style.cursor="default";
			return;
		}
		img.style.cursor="hand";
		el = event.srcElement;
		switch(el.mxpart)
		{
			case "textbox":
				el.className="checkboximage checkboxfocus";
				break;
		}
	}


	function checkbox_onmouseout(ctrlInst)
	{
		if(ctrlInst.readonly=="true" || ctrlInst.readonly==true)
			return;
			
		el = event.srcElement;
		switch(el.mxpart)
		{
			case "textbox":
				el.className="checkboximage";
				break;
		}
	}



	function checkbox_setClass(ctrlInst)
	{
		img = ctrlInst.all.namedItem(ctrlInst.id+"_box");		
		if(ctrlInst.readonly=="true" || ctrlInst.readonly==true)
		{
			img.style.cursor="default";
			return;
		}
			
		if(ctrlInst.checked=="true" || ctrlInst.checked!="false")
		{
			ctrlInst.checked="false";
		}
		else
		{
			ctrlInst.checked="true";
		}
		img.focus();
	}

	function checkbox_onselectedtablerow(ctrlInst)
	{
	}

/**************** END Standard functions for checkbox**********************/

/**************** BEGIN Standard functions for combobox**********************/


	function combobox_onclick(ctrlInst,mxpart, toEl)
	{
		
		if(event.srcElement.mxpart && ctrlInst.readonly!="true")
		{	
			if(ctrlInst.mxevent=="setvalue")
				setValue(ctrlInst, getPart(ctrlInst, "textbox"));
			else
				sendEvent(ctrlInst.mxevent, ctrlInst.id);
		}
	}


	function combobox_updateValue(ctrlInst,mxpart, val)
	{
		var part=getPart(ctrlInst, mxpart);
		if(!undef(part))
		{
			part.value=val;
			shared_unMarkAsChanged(part);
		}
	}
	

	function combobox_updateRequired(ctrlInst,mxpart, req)
	{
		requiredimg = getPart(ctrlInst, "required")
		if(!undef(requiredimg))
			requiredimg.src=IMAGE_PATH+req+".gif";
	}

	function combobox_updateReadOnly(ctrlInst,mxpart, ro)
	{
		el = getPart(ctrlInst, mxpart);
		type="description";
		displaytype="";
		if(mxpart=="textbox")
		{
			type="text";
			displaytype=el.displaytype;
		}
		el.className = "input_parts text input "+type+" "+displaytype;

		if(ro==true)
		{
			el.tabIndex=READ_ONLY_TAB_INDEX;
			el.className += " readonlytrue";
		}
		else
		{
			el.tabIndex="0";
			el.className += " readonlyfalse";
		}
		el.readOnly=ro;
	}

	function combobox_showThisMenu(ctrlInst)
	{
		box = getPart(ctrlInst, "textbox");
		if(box.readOnly==true)
			return;
		x=event.clientX-event.offsetX-1-box.clientWidth+event.srcElement.clientWidth;
		y=event.clientY-event.offsetY+box.clientHeight;
		getMenu(ctrlInst.id, x, y);
		event.cancelBubble=true;
		event.returnValue=false;
		return false;
	}
 
 	function combobox_onkeyup(ctrlInst)
	{
		el = event.srcElement;
		key=event.keyCode;
		switch (el.mxpart)
		{
			case "textbox":
				if(key==KEYCODE_DOWN_ARROW || key==KEYCODE_RIGHT_ARROW)
				{
					getPart(ctrlInst, "dropimage").fireEvent("onclick");
				}
				break;
		}
	}

	function combobox_oncontextmenu(ctrlInst)
	{
	 	event.cancelBubble=true;
	}


	function combobox_onactivate(ctrlInst)
	{
		el = event.srcElement;
		setfocusField(el);
		switch(el.mxpart)
		{
			case "textbox":
				if(el.readOnly==true)
				{
					if(getPart(ctrlInst, el.mxpart).tabIndex=="-1")
					{
						event.returnValue=false;
						event.cancelBubble=true;
					}
					else
					{
						el.style.backgroundColor=FIELD_FOCUS_READ_ONLY_COLOR;
					}
					return false;
				}
				el.style.backgroundColor=FIELD_FOCUS_COLOR;
				el.select();
				break;
			case "dropimage":
				el.fireEvent("onmouseover");
				break;
		}
	}

	function combobox_ondeactivate(ctrlInst)
	{
		el = event.srcElement;
		original = el.className.substr(0,el.className.lastIndexOf(" "));
		switch (el.mxpart)
		{
			case "textbox":
				if(el.readOnly==true && getPart(ctrlInst, el.mxpart).tabIndex=="-1")
				{
					event.returnValue=false;
					event.cancelBubble=true;
					return false;
				}
				el.style.backgroundColor="";
				break;
			case "dropimage":
				el.fireEvent("onmouseout");
				break;
		}
	}


	function combobox_onclick(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "textbox":
				break;
			case "dropimage":
				combobox_showThisMenu(ctrlInst);
				break;
		}
		event.returnValue=false;
	}


	function combobox_onmouseover(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "control":
				break;
			case "textbox":
				el.title=ctrlInst.label+" "+el.value;
				break;
			case "dropimage":
			{
				el.className=el.className + " combobox_dropimagehighlight";
				break;
			}
		}
	}

	function combobox_onmouseout(ctrlInst)
	{
		el = event.srcElement;
		detail = el.className.substr(0,el.className.lastIndexOf(" "));
		switch (el.mxpart)
		{
			case "textbox":
				break;
		}
	}

	function combobox_onkeydown(ctrlInst)
	{
	 	keyCode = event.keyCode;
	 	switch(keyCode)
	 	{
	 		case KEYCODE_TAB:
	 		case KEYCODE_ENTER:
	 		case KEYCODE_CTRL:
	 		case KEYCODE_DOWN_ARROW:
	 			break;
			default:
				event.returnValue=false;
				break;
	 	}
		showFieldHelp();
	}

	//End internal events

/**************** END Standard functions for combobox**********************/

/**************** BEGIN Standard functions for designer_toolbox**********************/

	var g_control_selected = null;

	function designer_toolbox_onmouseover(ctrlInst)
	{
		var evtElement = designer_toolbox_getElementHavingMXPart(ctrlInst,event.srcElement);
		var mxpart = evtElement.getAttribute("mxpart");
		if(mxpart=="control")
		{
			evtElement.className="toolbox_control_highlight";
		}
	}
	function designer_toolbox_onmouseout(ctrlInst)
	{
		var evtElement = designer_toolbox_getElementHavingMXPart(ctrlInst,event.srcElement);
		var mxpart = evtElement.getAttribute("mxpart");
		if(mxpart=="control")
		{
			if(g_control_selected!=evtElement)
			{
				evtElement.className="toolbox_control";
			}	
		}
	}
	
	function designer_toolbox_onclick(ctrlInst,evtElement)
	{
		if(undef(ctrlInst,evtElement)){evtElement = getElementHavingMXPart(event.srcElement);}
		var mxpart = evtElement.getAttribute("mxpart");
		if(mxpart=="control")
		{
			if(g_control_selected != evtElement)
			{
				if(!undef(ctrlInst,g_control_selected))
				{
					g_control_selected.className = "toolbox_control";
				} 
				g_control_selected = evtElement;
				evtElement.className="toolbox_control_selected";
			}
		}
		designer_toolbox_handleEvents(ctrlInst,evtElement);
	}
	
	function designer_toolbox_onkeypress(ctrlInst,evtElement)
	{
		var keyCode = event.keyCode;
		switch(keyCode)
		{
			case KEYCODE_ENTER:
				if(undef(ctrlInst,evtElement)){handleClick(event.srcElement);}
				else{designer_toolbox_onclick(ctrlInst,evtElement);}
				break;
			default: break;
		}
	}
	
	function designer_toolbox_getSelectedControl(ctrlInst)
	{
		return g_control_selected;
	}

	function designer_toolbox_resetSelectedControl(ctrlInst)
	{ 
		if(!undef(ctrlInst,g_control_selected))
		{
			g_control_selected.className = "toolbox_control";
			g_control_selected = null;
		}
	}
	
	function designer_toolbox_handleEvents(ctrlInst,evtElement)
	{
		var evtElement = designer_toolbox_getElementHavingMXEvent(ctrlInst,evtElement);
		var mxevent = evtElement.getAttribute("mxevent");
		switch(mxevent)
		{
			case "selectcontrol": 
				break;
			case "clearselection": 
				designer_toolbox_resetSelectedControl(ctrlInst); 
				break;
			default: 
				//alert(mxevent + " not implemented!!!");
				break;
		}
	}	
	
					
	function designer_toolbox_getElementHavingMXPart(ctrlInst,evtElement)
	{
		var mxpart = evtElement.getAttribute("mxpart");
		if(undef(ctrlInst,mxpart))
		{
			while(undef(ctrlInst,mxpart) && evtElement != ctrlInst)
			{
				evtElement = evtElement.parentElement;
				mxpart = evtElement.getAttribute("mxpart"); 	
			}
		}
		return evtElement;
	}
	
	function designer_toolbox_getElementHavingMXEvent(ctrlInst,evtElement)
	{
		var mxevent = evtElement.getAttribute("mxevent");
		if(undef(ctrlInst,mxevent))
		{
			while(undef(ctrlInst,mxevent) && evtElement != ctrlInst)
			{
				evtElement = evtElement.parentElement;
				mxevent = evtElement.getAttribute("mxpart"); 	
			}
		}
		return evtElement;
	}

/**************** END Standard functions for designer_toolbox**********************/

/**************** BEGIN Standard functions for dialog**********************/

	function dialog_onkeypress(ctrlInst)
	{
	}
	
	function dialog_onclick(ctrlInst)
	{		
		stopevents=false;
		var element = dialog_getElementHavingEvent(event.srcElement);
		var mxevents = dialog_getMxEvents(element);	
		var dialog = dialog_getDialog(element);
		dialog_cancelEventBubbling();
		for(var i=0; i<mxevents.length; i++)
		{
			var mxevent = mxevents[i];
			switch(mxevent)
			{
				case "dialogclose":
					parent.removeDialog(dialog.id);
					break;
				case "dialogok": 
					sendEvent(mxevent, dialog.id, null, null); 
					break;
				case "dialogcancel": 
					sendEvent(mxevent, dialog.id, null, null); 
					break;
				case "dialogyes": 
					sendEvent(mxevent, dialog.id, null, null); 
					break;
				case "dialogno": 
					sendEvent(mxevent, dialog.id, null, null); 
					break;
			}
		}	
	}
	
	function dialog_getMxEvents(element)
	{
		var element = dialog_getElementHavingEvent(element);
		var mxeventColl = element.getAttribute("mxevent");
		if(mxeventColl==null)
		{
			mxeventColl = "";
		}
		mxeventColl = mxeventColl.split(",");
		return mxeventColl;
	}
	
	function xdialog_getMxEvents(ctrlInst)
	{
		var nwelement = dialog_getElementHavingEvent(ctrlInst);
		var mxeventColl = nwelement.getAttribute("mxevent");
		if(mxeventColl==null)
		{
			mxeventColl = "";
		}
		mxeventColl = mxeventColl.split(",");
		return mxeventColl;
	}
		
	function dialog_getElementHavingEvent(element)
	{
		var startElement = element;
		var mxeventColl = element.getAttribute("mxevent");
		while(mxeventColl==null)
		{
			element = element.parentElement;
			if( (element==this) || (element==null) )
			{
				break;
			}
			mxeventColl = element.getAttribute("mxevent");
		}
		if(element==null)
		{
			element = startElement;
		}
		return element;
	}		
	var DIALOG_HEADER_SUFFIX = "_header";
	var DIALOG_CONTENT_SUFFIX = "_content"; 
	function dialog_getDialog(element)
	{
		var startElement = element;
		var control = (element.getAttribute("control")==null)? "":element.getAttribute("control");
		while(control=="")
		{
			element = element.parentElement;
			if(element==null)
			{
				element = this;
				break;
			}
			control = (element.getAttribute("control")==null)? "":element.getAttribute("control");
		}
		return element;
	}

	function dialog_getHeader(dialog)
	{
		var header = dialog.all.namedItem(dialog.id + DIALOG_HEADER_SUFFIX);
		return header;
	}
	
	function dialog_getContent(dialog)
	{
		var content = dialog.all.namedItem(dialog.id + DIALOG_CONTENT_SUFFIX);
		return content;
	}
	
	function dialog_cancelEventBubbling()
	{
		event.cancelBubble = true;
	}
/**************** END Standard functions for dialog**********************/

/**************** BEGIN Standard functions for doclinkuploadbutton**********************/

	function doclinkuploadbutton_enabled(ctrlInst,val)
	{
		className = (val)?"doclinkuploadbutton":"doclinkuploadbutton pushbuttondisabled";
		disabled=!val;
	}

	function doclinkuploadbutton_pressButton(ctrlInst)
	{
		upload_iframeDoc = ctrlInst.document.getElementById("upload_iframe").contentWindow.document;
		uploadForm = upload_iframeDoc.getElementById("IMPORT");
		uploadForm.submit();
	}
	
	function doclinkuploadbutton_onkeypress(ctrlInst)
	{
		if(event.keyCode==KEYCODE_ENTER || event.keyCode==KEYCODE_SPACEBAR)
		{
			over=true;
			doclinkuploadbutton_onmousedown(ctrlInst);
			doclinkuploadbutton_onmouseup(ctrlInst);
		}
	}

	function doclinkuploadbutton_onclick(ctrlInst)
	{
		if(usefiringcontrol && firingControl!=null)
		{
			doclinkuploadbutton_onmouseup(ctrlInst);
		}
		else
		{
			event.cancelBubble=true;
			event.returnValue=false;
		}
	}

	function doclinkuploadbutton_onmousedown(ctrlInst)
	{
		className="doclinkuploadbutton pushbuttondown";
	}

	function doclinkuploadbutton_onmouseup(ctrlInst)
	{
		doclinkuploadbutton_pressButton(ctrlInst);
		className="doclinkuploadbutton";
		var tmppart = getPart(ctrlInst, "table");
		{
			if(!undef(tmppart))
			{
				tmppart.setActive();
			}
		}
	}

	function doclinkuploadbutton_onmouseover(ctrlInst)
	{
		middle = getPart(ctrlInst, "middle");
		table = getPart(ctrlInst, "table");
		table.className="pushbuttonmain pushbuttonhighlight";
		if(middle.className.indexOf("over")==-1)
		{
			middle.className+=" pushbuttonovertext";
		}	
	}

	function doclinkuploadbutton_onmouseout(ctrlInst)
	{
		middle = getPart(ctrlInst, "middle");
		table = getPart(ctrlInst, "table");
		table.className="pushbuttonmain";
		
		if(middle.className.indexOf("over")>-1)
			middle.className=middle.className.substr(0,middle.className.lastIndexOf(" "));
	}


	function doclinkuploadbutton_ondeactivate(ctrlInst)
	{
		doclinkuploadbutton_onmouseout(ctrlInst);
	}

	function doclinkuploadbutton_onfocus(ctrlInst)
	{
		doclinkuploadbutton_onmouseover(ctrlInst);
		el = event.srcElement;
		setfocusField(el);
	}

/**************** END Standard functions for doclinkuploadbutton**********************/

/**************** BEGIN Standard functions for dynamictoolbarbuttons**********************/
function dynamictoolbar_getPart()
{
	part=null;
	partName = currentPartName;
	ctrlInst = currentObject;
	switch(partName)
	{
		case "label":
			part = ctrlInst.firstChild.cells[1];
			break;
		case "dropimage":
			part = ctrlInst.firstChild.cells[1].all[0];
			break;
	}
	return part;
}

function dynamictoolbar_onclick(ctrlInst)
{
	label = getPart(ctrlInst, "label");
	if(!undef(label))
	{
		if(label.menuEnabled!="true" && label.menuEnabled!=true)
			return;
	}	
	if(event.srcElement.tagName=="IMG")
	{
		event.srcElement.parentElement.fireEvent("onclick");
	}
	else
	{
		x = event.clientX-event.offsetX;
		y = event.clientY-event.offsetY + 20;
		getMenu(ctrlInst.id, x, y);
	}
}

function dynamictoolbar_onkeydown(ctrlInst)
{
	key = event.keyCode;
	if(event.srcElement.mxpart=="label" && (key==KEYCODE_SPACEBAR || key==KEYCODE_ENTER || KEYCODE_DOWN_ARROW))
		event.srcElement.click();
}

function dynamictoolbar_enablemenu(ctrlInst, menuEnabled)
{
	label = getPart(ctrlInst, "label");
	if(undef(label))
	{
		return;
	}
	dropImage = getPart(ctrlInst, "dropimage");
	label.menuEnabled = menuEnabled;
	if(menuEnabled==true || menuEnabled=="true")
	{
		dropImage.style.display="";
		label.style.cursor="hand";
		label.style.color="#000000";
		label.tabIndex="0";
	}
	else
	{
		dropImage.style.display="none";
		label.style.cursor="default";
		label.style.color="#595959";
		label.tabIndex="-1";
	}
}

/**************** END Standard functions for dynamictoolbarbuttons**********************/

/**************** BEGIN Standard functions for expbutton**********************/

	function expbutton_pressButton(ctrlInst)
	{
		var eventElement = event.srcElement;
		var elementid = ctrlInst.id;
		beanaction = "expbuttonpressed"
		targetdatasrc=elementid.substr(0,elementid.lastIndexOf("_"))
		sendEvent(beanaction,targetdatasrc,ctrlInst.value)
	}	

	function expbutton_onkeypress(ctrlInst)
	{
		if(event.keyCode==KEYCODE_ENTER || event.keyCode==KEYCODE_SPACEBAR)
		{
			over=true
			expbutton_onmousedown(ctrlInst)
			expbutton_onmouseup(ctrlInst)
		}
	}

	function expbutton_onclick(ctrlInst)
	{
		event.cancelBubble=true
		event.returnValue=false
	}

	function expbutton_onmousedown(ctrlInst)
	{
		ctrlInst.className="pushbuttonexp pushbuttonexpdown"
	}

	function expbutton_onmouseup(ctrlInst)
	{
		expbutton_pressButton(ctrlInst)
		ctrlInst.className="pushbuttonexp"
		getPart(ctrlInst, "table").setActive()
	}

	function expbutton_onmouseover(ctrlInst)
	{
		middle = getPart(ctrlInst, "middle");
		table = getPart(ctrlInst, "table");
		table.className="pushbuttonexpmain pushbuttonexphighlight";
		if(middle.className.indexOf("over")==-1)
		{
			middle.className+=" pushbuttonexpovertext";
		}	
	}

	function expbutton_onmouseout(ctrlInst)
	{
		middle = getPart(ctrlInst, "middle")
		table = getPart(ctrlInst, "table")
		table.className="pushbuttonexpmain"
		
		if(middle.className.indexOf("over")>-1)
			middle.className=middle.className.substr(0,middle.className.lastIndexOf(" "))
	}

	function expbutton_onblur(ctrlInst)
	{
		expbutton_onmouseout(ctrlInst)
	}

	function expbutton_onfocus(ctrlInst)
	{
		expbutton_onmouseover(ctrlInst)
	}
	
	function expbutton_onmyclick(ctrlInst) 
	{
	}

	var m_id = "section_";
	var m_label = "...label...";
	var m_icon = "../../images/header.gif";
	//var image_path = "../../images/";
	var m_row_count = 0;
	var m_col_count = 0;
	var m_show_header = false;
	var m_show_content = true;
	
	var m_previous_section = null;
	var m_current_section = null;

	//*****************************************************************************
	// Constants used for generating IDs for the HTML elements in ctrlInst control. Refer
	// to control's jsp page to see the usage of these constants.
	//*****************************************************************************
	var SECTION_HEADER_SUFFIX = "_header";
	var SECTION_LABEL_SUFFIX = "_label";
	var SECTION_CONTENT_SUFFIX = "_content";
	var SECTION_TABLE_SUFFIX = "_table";
	var SECTION_FOOTER_SUFFIX = "_footer";
	
	var PANEL_CONDITION  = "cond1";
	var PANEL_EXPRESS = "express";
	var PANEL_MATH = "math";
	var PANEL_KEYWORD = "keyw";
	var PANEL_MISC = "misc";
	
	var SECTION_FOLD = "fold";
	var SECTION_UNFOLD = "unfold";
	
	var SECTION_IMAGE_MIN = "image_min";
	var SECTION_IMAGE_MAX = "image_max";
	

	function expbutton_onclick(ctrlInst)
	{
		var id = event.srcElement.getAttribute("id");
		var action = event.srcElement.getAttribute("action");
		var panel = event.srcElement.getAttribute("panel");
		expbutton_handleMinMaxClick(ctrlInst,panel,null);
	}
		
	function expbutton_ondblclick(ctrlInst)
	{
		var action = event.srcElement.getAttribute("action");
		var panel = event.srcElement.getAttribute("panel");
		
		// get the image object - there should be only one
		var imgObject = ctrlInst.parentElement.all.tags("IMG");
		expbutton_handleMinMaxClick(ctrlInst,panel,imgObject(0));
	}


	function expbutton_handleMinMaxClick(ctrlInst,panel,imageObj)
	{
		imageObj = (imageObj == null ? ctrlInst : imageObj);
		var newImg = "";
		var newmxpart = "";
		var action = "";
		if (imageObj.mxpart == SECTION_IMAGE_MIN)
		{
			newImg = IMAGE_PATH+"maximize.gif";
			newmxpart = SECTION_IMAGE_MAX;
			action = SECTION_FOLD;
		} else
		{
			newImg = IMAGE_PATH+"minimize.gif";
			newmxpart = SECTION_IMAGE_MIN;
			action = SECTION_UNFOLD;
		}
		switch(panel)
		{
			case PANEL_CONDITION: 
				if (action == SECTION_FOLD)
				{
					panelcondtop.style.display="none";
					panelcondbottom.style.display="none";
				}else
				{
					panelcondtop.style.display="";
					panelcondbottom.style.display="";
				}
				break;
			case PANEL_EXPRESS: 
				if (action == SECTION_FOLD)
				{
					panelexpress.style.display="none";
				} else
				{
					panelexpress.style.display="";
				}
				break;
			case PANEL_MATH: 
				if (action == SECTION_FOLD)
				{
					panelmath.style.display="none";
					panelmathbottom.style.display="none";
				} else
				{
					panelmath.style.display="";
					panelmathbottom.style.display="";
				}
				break;
			case PANEL_KEYWORD: 
				if (action == SECTION_FOLD)
				{
					panelkeyw.style.display="none";
					panelkeywbottom.style.display="none";
				} else
				{
					panelkeyw.style.display="";
					panelkeywbottom.style.display="";
				}
				break;
			case PANEL_MISC: 
				if (action == SECTION_FOLD)
				{
					panelmisc.style.display="none";
				} else
				{
					panelmisc.style.display="";
				}
				break;
			default: break;
		}
		imageObj.src=newImg;
		imageObj.mxpart = newmxpart;
	}
	
/**************** END Standard functions for expbutton**********************/

/**************** BEGIN Standard functions for glnavigator**********************/

	function glnavigator_onclick(ctrlInst)
	{
		var eventElement = library_getElementHavingEvent(ctrlInst,event.srcElement);
		var mxpart = eventElement.getAttribute("mxpart");
		switch(mxpart)
		{
			case "segment": glnavigator_handleSelectSegment(ctrlInst,eventElement); break;
			default: glnavigator_handleEvent(ctrlInst,eventElement); break; 
		}
	}
	
	function glnavigator_onkeypress(ctrlInst)
	{		
		var eventElement = library_getElementHavingEvent(ctrlInst,event.srcElement);
		var keyCode =  event.keyCode;
		switch(keyCode)
		{
			case KEYCODE_ENTER:
				glnavigator_handleEvent(ctrlInst,eventElement); break;
			default: break;
		}
	}
	
	function glnavigator_handleEvent(ctrlInst,eventElement)
	{
		var mxevents = library_getMxEvents(ctrlInst,eventElement);
		for(var i=0; i<mxevents.length; i++)
		{
			var mxevent = mxevents[i];
			switch(mxevent)
			{
				case "setsegment": 
					glnavigator_handleSelectSegment(ctrlInst,eventElement);
					break;
				default: break;
			}
		}
	}
	
	function glnavigator_handleSelectSegment(ctrlInst,eventElement)
	{
		if(!undef(eventElement))
		{
			var segmentid = eventElement.getAttribute("glsegmentid");  
			var segmentvalue = eventElement.getAttribute("glsegmentvalue");
			sendEvent("setsegment", ctrlInst.id, segmentid);
		}
	}	
/**************** END Standard functions for glnavigator**********************/

/**************** BEGIN Standard functions for hyperlink**********************/

	function hyperlink_onclick(ctrlInst)
	{
		ctrlLink = ctrlInst.href;
		if(!undef(ctrlLink))
		{
			event.cancelBubble=true;
			parent.stopFocus=true;
			if(ctrlInst.newwindow=="true")
				window.open(ctrlLink);
			else
				document.location = ctrlLink;
			return;
		}
		if(ctrlInst.mxevent=="showmenu")
		{
			menuX=event.clientX-event.offsetX-2+5;
			menuY=event.clientY-event.offsetY-2+14;
		}
		if(!undef(ctrlInst.eventdatasrc))
		{
			addCommInput("eventdatasrc", ctrlInst.eventdatasrc);
		}
		sendEvent(ctrlInst.mxevent, ctrlInst.targetid, ctrlInst.value);
	}
	
	function hyperlink_onkeydown(ctrlInst)
	{
		key = event.keyCode;
		switch(key)
		{
			case KEYCODE_ENTER: //enter
			case KEYCODE_SPACEBAR: //spacebar
				ctrlInst.fireEvent("onclick");
				break;
		}
	}
	
	function hyperlink_onmouseover(ctrlInst)
	{
		ctrlInst.style.textDecoration="underline";
		ac = getPart(ctrlInst,'accesskey');
		if(ac)
		{
			ac.className="text hyperlink hyperlinkaccesskeyoff";
		}
	}

	function hyperlink_onmouseout(ctrlInst)
	{
		ctrlInst.style.textDecoration="none";
		ac = getPart(ctrlInst,'accesskey');
		if(ac)
		{
			ac.className="text hyperlink hyperlinkaccesskey";
		}
	}
/**************** END Standard functions for hyperlink**********************/

/**************** BEGIN Standard functions for imagelink**********************/

	function imagelink_onclick(ctrlInst)
	{
		sendEvent(ctrlInst.mxevent, ctrlInst.target, ctrlInst.value)
	}

	function imagelink_onkeydown(ctrlInst)
	{
		key = event.keyCode;
		switch(key)
		{
			case KEYCODE_ENTER: //enter
			case KEYCODE_SPACEBAR: //spacebar
				ctrlInst.fireEvent("onclick");
				break;
		}
	}
/**************** END Standard functions for imagelink**********************/

/**************** BEGIN Standard functions for kpigraph**********************/



	function kpigraph_updatekpi(ctrlInst,uid)
	{
		sendEvent('updatekpi',"kpi","kpi",null,null,uid);		
	}
	
/**************** END Standard functions for kpigraph**********************/



/**************** BEGIN Standard functions for listbox**********************/

	function listbox_onclick(ctrlInst)
	{
		if(ctrlInst.readonly=="true")
			return;
		var eventElement = library_getElementHavingEvent(ctrlInst,event.srcElement);
		var mxpart = eventElement.getAttribute("mxpart");
		switch(mxpart)
		{
			case "listitem": listbox_handleSelectItem(ctrlInst,eventElement); break;
			default: listbox_handleEvent(ctrlInst,eventElement); break; 
		}
	}
	
	function listbox_onkeypress(ctrlInst)
	{		
		if(ctrlInst.readonly=="true")
			return;
		var eventElement = library_getElementHavingEvent(ctrlInst,event.srcElement);
		var keyCode =  event.keyCode;
		switch(keyCode)
		{
			case KEYCODE_ENTER:
				listbox_handleEvent(ctrlInst,eventElement); break;
			default: break;
		}
		showFieldHelp();		
	}
	
	function listbox_onmouseover(ctrlInst)
	{
		if(ctrlInst.readonly=="true")
			return;
		eventElement = event.srcElement;
		if(eventElement.selected!="true")
			eventElement.className +=" itemover";
	}

	function listbox_onmouseout(ctrlInst)
	{
		if(ctrlInst.readonly=="true")
			return;
		eventElement = event.srcElement;
		if(eventElement.selected!="true")
			eventElement.className = eventElement.className.replace(" itemover","");
	}
	
	function listbox_onkeydown(ctrlInst)
	{
		if(ctrlInst.readonly=="true")
			return;
		var keyCode = event.keyCode;
		var eventElement = library_getElementHavingEvent(ctrlInst,event.srcElement);
		switch(keyCode)
		{
			case KEYCODE_UP_ARROW: 
				listbox_highlightPreviousItem(ctrlInst,eventElement);
				library_cancelEventBubbling(ctrlInst);
				break;			
			case KEYCODE_DOWN_ARROW:
				listbox_highlightNextItem(ctrlInst,eventElement);
				library_cancelEventBubbling(ctrlInst); 
				break;
			default: break;
		}
	}

	function listbox_handleEvent(ctrlInst,eventElement)
	{
		var mxevents = library_getMxEvents(ctrlInst,eventElement);
		for(var i=0; i<mxevents.length; i++)
		{
			var mxevent = mxevents[i];
			switch(mxevent)
			{
				case "setvalue": 
					listbox_handleSelectItem(ctrlInst,eventElement);
					break;
				default: break;
			}
		}
	}
	
	function listbox_handleSelectItem(ctrlInst,eventElement)
	{
		if(ctrlInst.readonly=="true")
			return;
		if(!undef(eventElement))
		{
			//If the selected element is same as the current element, its a NO-OP
			if(eventElement.selected=="false")
			{
				var keyvalue = eventElement.getAttribute("keyvalue");
				sendEvent("setvalue", ctrlInst.id, keyvalue, "dataattribute");
			}	
		}
	}	
	
	function listbox_fnHandleReplaceListItems(ctrlInst,newListItems)
	{
		var contentElement = ctrlInst.document.getElementById(ctrlInst.id + "_contents");
		if(!undef(contentElement) && !undef(newListItems.innerHTML))
		{
			contentElement.innerHTML = "";
			contentElement.innerHTML = newListItems.innerHTML;
		}
	}

	function listbox_highlightPreviousItem(ctrlInst,eventElement)
	{
		var mxpart = eventElement.getAttribute("mxpart");
		while( (mxpart!="listitem") && (eventElement!= ctrlInst))
		{
			eventElement = eventElement.parentElement;
			mxpart = eventElement.getAttribute("mxpart");
		}
		if(eventElement!= ctrlInst)
		{
			if(!undef(eventElement.previousSibling))
			{
				eventElement.previousSibling.focus();
			}
		}
	}
	
	function listbox_highlightNextItem(ctrlInst,eventElement)
	{	
		var mxpart = eventElement.getAttribute("mxpart");
		while( (mxpart!="listitem") && (eventElement!= ctrlInst))
		{
			eventElement = eventElement.parentElement;
			mxpart = eventElement.getAttribute("mxpart");
		}
		if(eventElement!= ctrlInst)
		{
			if(!undef(eventElement.nextSibling))
			{
				newel=eventElement.nextSibling;
				newel.focus();
			}
		}
	}
/**************** END Standard functions for listbox**********************/

/**************** BEGIN Standard functions for longop**********************/

	var g_intervalId = null;
	function longop_ondocumentready(ctrlInst)
	{
		var sourceElement = event.srcElement;
		var intval = -1;
		if (ctrlInst.interval)
		{
			intval = ctrlInst.interval;
		}
		if (intval <= 0)	
			intval = 4000;
		g_intervalId = window.setInterval(longop_refreshLongopDialog, ctrlInst.intval);		
	}
	function longop_refreshLongopDialog(ctrlInst)
	{
		sendEvent("longopcheck", ctrlInst.id);
	}

	function longop_fnHandleDoneOp(ctrlInst)
	{
		if(!undef(ctrlInst.g_intervalId))
		{
			window.clearInterval(ctrlInst.g_intervalId);
		}
	}

/**************** END Standard functions for longop**********************/

/**************** BEGIN Standard functions for menuitem**********************/

	function menuitem_oncontextmenu(ctrlInst)
	{
		hideMenu();
		event.returnValue=false;
	}

	
	function menuitem_onmouseover(ctrlInst)
	{
		menu=getControl(ctrlInst);
		mh = menu.highlighted; 
		if(mh)
		{
			mh.fireEvent("onmouseout");
		}

		type=event.type;
		sub = menu.getAttribute("opensub");
		mSub = ctrlInst.menusub;
		if(sub!=null && sub!=mSub)//only hide sub menu if it's not the one for ctrlInst item
		{
			hideSubMenu(menu);
		}
		
		if(type=="mouseover")
		{
			if(mSub!=null && mSub!="")//only show sub menu if it's not already shown
			{
				showMenu(mSub, 20, ctrlInst);
			}
		}

		window.clearTimeout(menufocus);
		menufocus=null;

		//begin -  change the look of a de-highlighted menu item
		cells = ctrlInst.firstChild.cells;
		ctrlInst.className='menuitemall '+ctrlInst.menuType+'menuItemOver';
		cells[0].className=ctrlInst.menuType+'menuItemleft '+ctrlInst.menuType+'menuItemOver';
		if(cells[1].scrollWidth>cells[1].clientWidth)
		{
			cells[1].title=ctrlInst.innerText;
		}
		if(ctrlInst.sep==true)
		{
			ctrlInst.className+=' menugroupsep';
		}
		//end -  change the look of a de-highlighted menu item
		menu.highlighted=ctrlInst;
	}

	function menuitem_ondeactivate(ctrlInst)
	{
		toEl = event.toElement;

		if(ctrlInst.firstChild.contains(toEl))
			return;

		//begin -  change the look of a highlighted menu item
		cells = ctrlInst.firstChild.cells;
		ctrlInst.className='menuitemall';
		cells[0].className=ctrlInst.menuType+'menuItemleft';

		if(ctrlInst.scrollWidth>openMenu.clientWidth)
			cells[1].title=ctrlInst.innerText;
			
		if(ctrlInst.sep==true)
		{
			ctrlInst.className+=' menugroupsep';
		}
		//end -  change the look of a highlighted menu item
	}

	function menuitem_onclick(ctrlInst)
	{
		stopFocus=false;
		mSub = ctrlInst.menusub;
		if(ctrlInst.disabled==true)
		{
			event.cancelBubble=true;
			event.returnValue=false;
			return false;
		}
		if(!undef(mSub))
		{
			event.cancelBubble=true;
			event.returnValue=false;
			return;
		}
		
		if(ctrlInst.menuEvent=="updateowner")
		{
			ctrl = getControl(ctrlInst.menuowner);
			fld=getPart(ctrl, "textbox");
			fld.value=ctrlInst.menuValue;
			fld.changed="true";
			//displayFld.value=ctrlInst.menuValue;
			shared_handleChange(fld);
	
			//Need to re-set the combobox with display value, so that the actual value
			// is not visible to the user during the server interaction.
			if(!undef(ctrlInst.displayValue)){
				fld.value=ctrlInst.displayValue;
			}
		}
		else if(ctrlInst.menuEvent=="loadlink" && ctrlInst.menuValue!="")
		{
			
			window.open(ctrlInst.menuValue);
			stopFocus=true;
		}
		else
		{
			if(ctrlInst.menuEvent=="applink")
			{
				sendEvent(ctrlInst.menuEvent, ctrlInst.eventtarget, ctrlInst.applinkid);
				return;
			}
			else if(menuEvent=="changeapp")
			{
				sendEvent(ctrlInst.menuEvent, ctrlInst.eventtarget, ctrlInst.menuValue);
				return;
			}
			if(!undef(ctrlInst.eventdatasrc))
			{
				addCommInput("eventdatasrc", ctrlInst.eventdatasrc);
			}
			tg = ctrlInst.eventtarget;
			if(tg)
			{
				sendEvent(ctrlInst.menuEvent, tg, ctrlInst.menuValue);
			}
			else
			{
				mo = ctrlInst.menuowner;
				if(mo)
					sendEvent(ctrlInst.menuEvent, mo.id ,ctrlInst.menuValue);
				else
				{
					sendEvent(ctrlInst.menuEvent, "", ctrlInst.menuValue);
				}
			}
		}		
		hideMenu();
		mo=ctrlInst.menuowner;
		if(mo)
		{
			try
			{
				fld=getPart(getControl(ctrlInst.menuowner), "textbox");
	
				if(fld==null || fld.type=="hidden" || fld.style.visibility=="hidden")
					fld=getPart(getControl(ctrlInst.menuowner), "display");
	
				if(fld)
					fld.focus();
			}
			catch(exception)
			{
				//Do Nothing
			}
		}
	}

	function menuitem_keynext(ctrlInst,tr)
	{
		tb = tr.parentElement;
		if(tr == tb.lastChild)
		{
			if(tb.firstChild.firstChild.disabled)
				menuitem_keynext(ctrlInst,tb.firstChild.nextSibling);
			else
			{
				menuItem = tb.firstChild.firstChild.firstChild;
				menuItem.setActive();
				getControl(tb).highlighted = menuItem;
			}
		}
		else
		{
			if(tr.nextSibling.firstChild.disabled)
				menuitem_keynext(ctrlInst,tr.nextSibling);
			else
			{
				menuItem = tr.nextSibling.firstChild.firstChild;
				menuItem.setActive();
				getControl(tb).highlighted = menuItem;
			}
		}

	}

	function menuitem_keyback(ctrlInst,tr)
	{
		tb = tr.parentElement;
		if(tr == tb.firstChild)
		{
			if(tb.lastChild.firstChild.disabled)
				menuitem_keyback(ctrlInst,tb.lastChild.previousSibling);
			else
			{
				menuItem = tb.lastChild.firstChild.firstChild;
				menuItem.setActive();
				getControl(tb).highlighted = menuItem;
			}
		}
		else
		{
			if(tr.previousSibling.firstChild.disabled)
				menuitem_keynext(ctrlInst,tr.previousSibling);
			else
			{
				menuItem = tr.previousSibling.firstChild.firstChild;
				menuItem.setActive();
				getControl(tb).highlighted = menuItem;
			}
		}
	}

	function menuitem_onkeypress(ctrlInst)
	{
		event.cancelBubble=true;
		event.returnValue=false;
	}

	function menuitem_onkeydown(ctrlInst)
	{
		srcEl = event.srcElement;
		parentEl = ctrlInst.parentNode;
		menu = getControl(ctrlInst.parentElement);
		menuDiv = srcEl.parentNode.parentNode.parentNode;
		mSub = ctrlInst.menusub;
		submenu = document.getElementById(ctrlInst.submenu);
		hassub = (mSub!=null && mSub!="");
		key = event.keyCode;
		hideit = 0;
		om = menu.openermenu;
		oi = menu.openeritem;
		issub = (om!=null);
		
		switch(key)
		{
			case KEYCODE_UP_ARROW: //up
				menuitem_keyback(ctrlInst,parentEl);
				event.cancelBubble=true;
				event.returnValue=false;
				break;
			case KEYCODE_DOWN_ARROW: //down
				menuitem_keynext(ctrlInst,parentEl);
				event.cancelBubble=true;
				event.returnValue=false;
				break;
			case KEYCODE_RIGHT_ARROW: //right
				if(hassub)
				{
					showMenu(mSub, 20, ctrlInst);
					focusFirst(mSub);
				}
				event.cancelBubble=true;
				event.returnValue=false;
				break;
			case KEYCODE_LEFT_ARROW: //left
			case 27: //escape
				if(issub)
				{
					hideSubMenu(om);
					delayedFocus(oi.firstChild);
				}
				else
				{
					hideMenu(menu);
					event.cancelBubble=true;
					event.returnValue=false;
				}
				event.cancelBubble=true;
				event.returnValue=false;
				break;
			case KEYCODE_ENTER: //enter
				if(hassub)
				{
					showMenu(mSub, 20, ctrlInst);
					delayedMenuFocus();
					delayedFocus(oi.firstChild);
				}	
				else
				{
					srcEl.click();
				}
				event.cancelBubble=true;
				event.returnValue=false;
				break;
		}
	}

/**************** END Standard functions for menuitem**********************/

/**************** BEGIN Standard functions for moveable**********************/

	
	function moveable_oncontextmenu(ctrlInst)
	{
	}
	
	function moveable_onactivate(ctrlInst)
	{
		el = event.srcElement;
		part = el.mxpart;
		switch(part)
		{
			case "first":
				last = ctrlInst.document.getElementById(getPart(ctrlInst,"last").lastbuttonid);
				if(last)
				{
					getPart(last, "table").focus();
					getPart(last, "table").setActive();
				}
				break;
			case "last":
				ti = getPart(ctrlInst, "toggleImage");
				if(ti)
				{
					ti.focus();
					ti.setActive();
				}
				break;
		}
		
	}
	function moveable_onkeydown(ctrlInst)
	{
		stopevents=false;
		key = event.keyCode;
		if(key==KEYCODE_TAB && event.ctrlKey==true)	
		{
			event.cancelBubble=true;
			event.returnValue=false;
			return false;
		}
	}
	function moveable_onkeypress(ctrlInst)
	{
		key = event.keyCode;
		switch(key)
		{
			case KEYCODE_ENTER:
				part = event.srcElement.mxpart;
				switch(part)
				{
					default:
						if(!undef(ctrlInst.defaultbutton))
						{
							defid = ctrlInst.defaultbutton;
							
							if(defid && defid==getControl(event.srcElement).id)
								break;

							itemtoclick = document.getElementById(defid);
							itemtoclick.focus();
							itemtoclick.setActive();
 							sendFrontEndEvent("clickDefaultButton", ctrlInst.id);
							event.cancelBubble=true;
							event.returnValue=false;
							return false;
						}
						break;					
				}
				break;
			case 27:
				dc = getPart(ctrlInst,"dialogClose");
				if(dc && dc.disabled!=true)
				{
					dc.click();
					event.cancelBubble=true;
					event.returnValue=false;
				}
				break;
		}
	}

    function moveable_ondragstart(ctrlInst)
    {
        if(event.srcElement.className == "clsPartHead" )
        {
            window.event.returnValue = false;
        }
    }
    
    function moveable_onmousedown(ctrlInst)
    {
		stopevents=false;
    	ev=event;
    	if(!ev)
    		return;
    	if(ev.button==2)
			return;
    		
        var oEl = event.srcElement;
    	if(ctrlInst.controltype=="moveablewindow" || designmode==true)
    	{
    		if(ctrlInst.id!="debug_eventwindow" && ctrlInst.id!="debug_eventlog")
			{
	        	moveableTopZ++
	        	ctrlInst.style.zIndex=moveableTopZ;
	        }
	        else
	        {
		        debugTopZ++
	        	ctrlInst.style.zIndex=debugTopZ;
	        }
        }
        
        if(moveable_correctElement(ctrlInst))
        {
        	if(oEl.tagName=="IMG")
        	{
        		oEl=oEl.parentElement;
        	}
        		
			ctrlInst.offsetY = event.offsetY + event.srcElement.offsetTop;
			ctrlInst.offsetX = event.offsetX + event.srcElement.offsetLeft;
			
            ctrlInst.current = ctrlInst;

		    if(ctrlInst.scrollList)
		    {
			    scrollList=ctrlInst.scrollList.split(",");
				for(scrollItem=0;scrollItem<scrollList.length;scrollItem++)
				{
					scrll=document.getElementById(scrollList[scrollItem]);
					if(scrll)
					{
						scrll.style.overflowX="hidden";
						scrll.style.overflowY="hidden";
					}
				}
			}

            if(ctrlInst.dragwindow==null)
	            ctrlInst.dragwindow=ctrlInst.document.getElementById("dragWindow");
    
            movingItem=ctrlInst;
            window.document.attachEvent( "onmousemove"  , moveable_fnMove );
            window.document.attachEvent( "onscroll"  , moveable_fnMove );
            window.document.attachEvent( "onmousemove" , moveable_fnCheckState );
            window.document.attachEvent( "onmouseup"    , moveable_releaseHold );
            window.document.attachEvent( "onselectstart", moveable_fnSelect );
        }
        
    }
    
	function moveable_showDragWindow(ctrlInst)
	{
		if(showWindowContentsWhileDragging)
		{
			return;
		}
		if(ctrlInst.collapsed)
		{
			ctrlInst.dragwindow.style.height = ctrlInst.cells(0).firstChild.cells(1).offsetHeight;
		}
		else
		{
			ctrlInst.dragwindow.style.height = ctrlInst.clientHeight - 3;
		}
		ctrlInst.dragwindow.style.width = ctrlInst.clientWidth;
		ctrlInst.dragwindow.style.top = event.clientY - ctrlInst.offsetY + window.document.body.scrollTop-2;
		ctrlInst.dragwindow.style.left = event.clientX - ctrlInst.offsetX + window.document.body.scrollLeft-6;
		
		if(ctrlInst.id!="debug_eventwindow" && ctrlInst.id!="debug_eventlog")
		{
        	ctrlInst.dragwindow.style.zIndex=moveableTopZ+1;
        }
        else
        {
        	ctrlInst.dragwindow.style.zIndex=debugTopZ+1;
        }

		ctrlInst.dragwindow.style.visibility = "visible";
		//ctrlInst.style.visibility="hidden";
	}

	function moveable_hideDragWindow(ctrlInst)
	{
		if(showWindowContentsWhileDragging)
			return;
		ctrlInst.dragwindow.style.visibility = "hidden";
		//ctrlInst.style.visibility="visible";
		ctrlInst.dragwindow.style.height = "";
		ctrlInst.dragwindow.style.top = "";
		ctrlInst.dragwindow.style.left = "";
		ctrlInst.dragwindow.style.width = "";
		ctrlInst.dragwindow.zIndex = "";
		ctrlInst.zIndex=parseInt(ctrlInst.zIndex)+1
	}

    
    function moveable_fnMove()
    {
		moveable_showDragWindow(ctrlInst, ctrlInst );
	    ctrlInst = movingItem;
	    if(ctrlInst)
	    {
			if (event.button != 1)
			{
				moveable_releaseHold(ctrlInst);
				return;
			}

			if(showWindowContentsWhileDragging)
			{

				ctrlInst.style.top = event.clientY - ctrlInst.offsetY + window.document.body.scrollTop;  
				ctrlInst.style.left = event.clientX - ctrlInst.offsetX + window.document.body.scrollLeft;
			}
			else
			{
				movingItem.dragwindow.style.top = event.clientY - ctrlInst.offsetY + window.document.body.scrollTop;  
				movingItem.dragwindow.style.left = event.clientX - ctrlInst.offsetX + window.document.body.scrollLeft;
			}
		}
    }
    
    function moveable_releaseHold()
    {
       	event.cancelBubble=true;
	    ctrlInst = movingItem;
	    if(ctrlInst)
	    {
	        window.document.detachEvent( "onmousemove" , moveable_fnMove );
	        window.document.detachEvent( "onscroll" , moveable_fnMove );
	        window.document.detachEvent( "onmousemove" , moveable_fnCheckState );
	        window.document.detachEvent( "onmouseup" , moveable_releaseHold );
	        window.document.detachEvent( "onselectstart", moveable_fnSelect );
			ctrlInst.style.position="absolute";
			if(showWindowContentsWhileDragging)
			{
				ctrlInst.top = ctrlInst.dragwindow.style.posTop;
				ctrlInst.left = ctrlInst.dragwindow.style.posLeft;
				if(ctrlInst.saveposition) 
					saveWindowPosition(ctrlInst.id, ctrlInst.top, ctrlInst.left);
				
			}
			else
			{
				y=ctrlInst.dragwindow.style.pixelTop;
			    x=ctrlInst.dragwindow.style.pixelLeft-12;
				ctrlInst.style.posTop = y;
				ctrlInst.style.posLeft = x;
			}			
			    if(ctrlInst.scrollList)
			    {
			    	lst = ctrlInst.scrollList.split(",");
					for(scrollItem=0;scrollItem<scrollList.length;scrollItem++)
					{
						scrll=document.getElementById(scrollList[scrollItem]);
						if(scrll)
						{
							scrll.style.overflowX="auto";
							scrll.style.overflowY="auto";
						}
					}
				}
			if(showWindowContentsWhileDragging)
				return;
			
			moveable_hideDragWindow(ctrlInst); 

			if(ctrlInst.saveposition) 
				saveWindowPosition(ctrlInst.id, y, x);
		}
    }
		
    function moveable_ondblclick(ctrlInst)
    {
       	event.cancelBubble=true;
		if(moveable_correctElement(ctrlInst))
		{
			togimg = getPart(ctrlInst, "toggleImage");
			dragright = getPart(ctrlInst, "dragright");
			dragleft = getPart(ctrlInst, "dragleft");
			if(ctrlInst.rows(1).style.display=="none")
			{
				ctrlInst.style.width="";
				ctrlInst.rows(1).style.display="block";
				togimg.src=IMAGE_PATH+"minimizesection.gif";
				collapsed = false;
			}
			else
			{
				wdth = ctrlInst.offsetWidth;
				ctrlInst.rows(1).style.display="none";
				ctrlInst.rows(1).style.height="0";
				ctrlInst.style.backgroundImage="";
				ctrlInst.style.background="transparent";
				togimg.src=IMAGE_PATH+"maximizesection.gif";
				ctrlInst.style.width=wdth;
				collapsed = true;
			}
		}
    }
    
    function moveable_correctElement()
    {
        if(event.srcElement.className != "moveableHead")
        {
            window.event.returnValue = false;
            return false;
        }
        return true;
    }
    

    function moveable_fnCheckState()
    {
	     ctrlInst = movingItem;
	    if(ctrlInst)
	    {
	        if( event.button != 1 )
	        	moveable_releaseHold(ctrlInst);
		}
    }

    function moveable_fnSelect()
    {
        return false;
    }
    
    
/**************** END Standard functions for moveable**********************/


/**************** BEGIN Standard functions for multilinetextbox**********************/

	function multilinetextbox_setvalue(ctrlInst,part)
	{
		setValue(ctrlInst, part);
	}

	function multilinetextbox_detailClick(ctrlInst)
	{
		eventname = event.srcElement.mxevent;
		var control = getControl(event.srcElement);
		
		//Custom code to handling selecting of row before the event can be processed
		// on the input element inside a table. This is applicable ONLY to non-query
		// table rows.
		var queueevent = false;
		var ontable = (control.getAttribute("ontable")=="true");
		var query = (control.getAttribute("query")=="true");
		queueevent = ontable && !query;
				
		detailtype = event.srcElement.detailtype;
		partid = event.srcElement.mxpart;
		setfocusField(getPart(control , "textbox"));
		id = control.id;
		if(eventname=="showmenu")
		{
			x=event.clientX-event.offsetX-2;
			y=event.clientY-event.offsetY-2;
			getMenu(ctrlInst.id, x, y, "", "textbox");
			if (!queueevent)
			{
				event.cancelBubble=true;
				event.returnValue=false;
			}
		}
		else
		{
			menuX=event.clientX-event.offsetX-2;
			menuY=event.clientY-event.offsetY-2;
			if(detailtype=="datelookup")
			{
				tb = getPart(control ,"textbox");
				if (queueevent)
					clientEventQueue[clientEventQueue.length]=new clientEvent("datelookup", id, "textbox", tb.dataattribute);
				else
					sendEvent("datelookup", ctrlInst.id, "textbox", tb.dataattribute);
			}
			else if(partid=="detail")
			{
				if (queueevent)
					clientEventQueue[clientEventQueue.length]=new clientEvent(eventname, id, detailtype, "dataattribute");
				else
					sendEvent(eventname, ctrlInst.id, detailtype, "dataattribute");
			}
			else
			{
				if (queueevent)
					clientEventQueue[clientEventQueue.length]=new clientEvent(eventname, id, detailtype, "descdataattribute");
				else
					sendEvent(eventname, ctrlInst.id, detailtype, "descdataattribute");
			}
		}
	}

	function multiparttextbox_haslongdesc(ctrlInst,hasLD)
	{		
		var descimg = ctrlInst.document.getElementById(ctrlInst.id+"_detaildesc");
		
		if(!undef(descimg))
		{
			if(hasLD)
			{
				descimg.src = IMAGE_PATH+"img_longdescription_on.gif"
			}
			else
			{
				descimg.src = IMAGE_PATH+"img_longdescription_off.gif"
			}
		}
	}
	
	function multilinetextbox_updateValue(ctrlInst,mxpart, val)
	{
		part=getPart(ctrlInst, mxpart);
		if(!undef(part))
		{
			if(part.value!=val)
				parent.addUpdateField(part,val);
			part.value=val;
			shared_unMarkAsChanged(part);
		}
	}


	function multilinetextbox_updateReadOnly(ctrlInst,mxpart, roBoolean)
	{
		displaytype="";
		el = getPart(ctrlInst, mxpart);
		if(roBoolean==true)
		{
			el.tabIndex=READ_ONLY_TAB_INDEX;
			el.className = "text input "+displaytype+" readonlytrue";
		}
		else
		{
			el.tabIndex="0";
			el.className = "text input "+displaytype+" readonlyfalse";
		}
		el.readOnly=roBoolean;
	}

	function multilinetextbox_onkeypress(ctrlInst)
	{
		key=event.keyCode;
		if(key==10)
		{
			if(event.ctrlKey==true)
			{
				det = getPart(ctrlInst, "detail");
				if(det)
				{
					if(det.style.visibility!="hidden")
					{
						if(!SCREENREADER)
							det.focus();
						det.fireEvent("onclick");
						
					}
				}
			}
		}
		else if(key==KEYCODE_ENTER)
		{
			event.cancelBubble=true;
		}
	}

	function multilinetextbox_onkeydown(ctrlInst)
	{
		textbox =  getPart(ctrlInst, "textbox");
		ml = ctrlInst.maxlength;
		if(!undef(ml))
		{
			ml=parseInt(ml);
			innerText=textbox.innerText;
			key = event.keyCode;
			if(innerText.length==ml)
			{
				switch(key)
				{
					case KEYCODE_BACKSPACE:
						break;
					case KEYCODE_TAB:
						break;
					case KEYCODE_CTRL:
						break;
					case KEYCODE_ENTER:
						if(event.ctrlKey!=true)
							event.returnValue=false
						break;
					default:
						event.returnValue=false;
				}
			}

		}
	}


	function multilinetextbox_updateRequired(ctrlInst,mxpart, req)
	{
		requiredimg = getPart(ctrlInst, "required")
		if(!undef(requiredimg))
			requiredimg.src=IMAGE_PATH+req+".gif";
	}

	function multilinetextbox_onactivate(ctrlInst)
	{
		el = event.srcElement;
		setfocusField(el);
		switch (el.mxpart)
		{
			case "textbox":
			 	el.style.overflow="auto";
				if(el.readOnly==true)
				{
					if(getPart(ctrlInst, el.mxpart).tabIndex=="-1")
					{
						event.returnValue=false;
						event.cancelBubble=true;
					}
					else
					{
						el.style.backgroundColor=FIELD_FOCUS_READ_ONLY_COLOR;
					}
					return false;
				}
				el.style.backgroundColor=FIELD_FOCUS_COLOR;
				el.select();
				break;
			case "detail":
				el.fireEvent("onmouseover");
				break;
		}
	}

	function multilinetextbox_ondeactivate(ctrlInst)
	{
		el = event.srcElement;
		original = el.className.substr(0,el.className.lastIndexOf(" "));
		switch (el.mxpart)
		{
			case "textbox":
				el.style.overflow="hidden";
				if(el.readOnly==true && getPart(ctrlInst, el.mxpart).tabIndex=="-1")
				{
					event.returnValue=false;
					event.cancelBubble=true;
					return false;
				}
				el.style.backgroundColor="";
				break;
			case "detail":
				el.fireEvent("onmouseout");
				break;
		}
	}


	function multilinetextbox_onclick(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "detail":
				if(!isTrue(ctrlInst.getAttribute("ontable")))
				{
				 	event.cancelBubble=true;
				}
				multilinetextbox_detailClick(ctrlInst);
				break;		
		}
	}


	function multilinetextbox_onmouseover(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "control":
				break;
			case "textbox":
				txt = el.innerText;
				if(txt.length>30)
					x = txt.substr(0,30)+"...";
				else
					x = txt;
				el.title=ctrlInst.label+" "+x;
				break;
			case "detail":
			{
				el.className=el.className+" detailhighlight";
				break;
			}
		}
	}

	function multilinetextbox_onmouseout(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "textbox":
				break;
			case "detail":
				el.className=el.className.replace(" detailhighlight", "");
				break;
		}
	}

/**************** END Standard functions for multilinetextbox**********************/

/**************** BEGIN Standard functions for multiparttextbox**********************/

	function multiparttextbox_setvalue(ctrlInst,part)
	{
		setValue(ctrlInst, part)
	}

	function multiparttextbox_detailClick(ctrlInst)
	{
		eventname = event.srcElement.mxevent;
		detailtype = event.srcElement.detailtype;
		partid = event.srcElement.mxpart;
		//setfocusField(getPart(ctrlInst, partid));
		if(eventname=="showmenu")
		{
			x=event.clientX-event.offsetX-2;
			y=event.clientY-event.offsetY-2;
			getMenu(ctrlInst.id, x, y, "", "textbox");
			event.cancelBubble=true;
			event.returnValue=false;
			return false;
		}
		else
		{
			if(partid=="detail")
			{
				sendEvent(eventname, ctrlInst.id, detailtype, "dataattribute");
			}
			else
			{
				setfocusField(getPart(ctrlInst, "textboxdesc"));
				sendEvent(eventname, ctrlInst.id, detailtype, "descdataattribute");
			}
		}
	}

	function multiparttextbox_updateValue(ctrlInst,mxpart, val)
	{
		part=getPart(ctrlInst, mxpart);
		if(!undef(part))
		{
			if(part.value!=val)
			{
				parent.addUpdateField(part,val);
			}
			part.value=val;
			shared_unMarkAsChanged(part);
		}
	}

	function multiparttextbox_setLDMarker(ctrlInst,ldstate)
	{
		var descimg = ctrlInst.document.getElementById(ctrlInst.id+"_detaildesc");

		if(!undef(descimg))
		{
			descimg.src = IMAGE_PATH+"img_longdescription_"+ldstate+".gif"
			if(ldstate == "on")
				descimg.style.display="";
		}
	}

	function multiparttextbox_updateRequired(ctrlInst,mxpart, req)
	{
		desc="";
		if(mxpart=="textboxdesc")
			desc="desc";

		var part = getPart(ctrlInst, desc+"required");
		
		if ( part != null )
		{
			part.src=IMAGE_PATH+req+".gif";
		}
	}

	function multiparttextbox_haslongdesc(ctrlInst,hasLD)
	{		
		var descimg = ctrlInst.document.getElementById(ctrlInst.id+"_detaildesc");
		
		if(!undef(descimg))
		{
			if(hasLD)
			{
				descimg.style.display='';
				descimg.src = IMAGE_PATH+"img_longdescription_on.gif"
			}
			else
			{
				descimg.src = IMAGE_PATH+"img_longdescription_off.gif"
			}
		}
	}

	function multiparttextbox_updateReadOnly(ctrlInst,mxpart, ro)
	{
		el = getPart(ctrlInst, mxpart);
		type="description";
		displaytype="";
		if(mxpart=="textbox")
		{
			type="text";
			displaytype=el.displaytype;
		}
		tempClassName=el.className;
		if(ro==true)
		{
			el.tabIndex=READ_ONLY_TAB_INDEX;
			if(tempClassName.indexOf("readonly")==-1)
			{
				el.className += " readonlytrue";
			}
			else
			{
				tempClassName = tempClassName.replace("readonlyfalse", "readonlytrue");
				el.className = tempClassName;
			}	
		}
		else
		{
			el.tabIndex="0";
			if(tempClassName.indexOf("readonly")==-1)
			{
				el.className += " readonlyfalse";
			}
			else
			{
				tempClassName = tempClassName.replace("readonlytrue", "readonlyfalse");
				el.className = tempClassName; 
			}	
		}
		el.readOnly=ro;
	}


	function multiparttextbox_showThisMenu(ctrlInst,part)
	{
		x=event.clientX-event.offsetX-2;
		y=event.clientY-event.offsetY-2;
		getMenu(ctrlInst.id, x, y);
	}

	function multiparttextbox_onkeypress(ctrlInst)
	{
		key=event.keyCode;
		el = event.srcElement;
		switch(key)
		{
			case 10:
				switch(el.mxpart)
				{
					case "textbox":
						if(event.ctrlKey==true)
							det = getPart(ctrlInst, "detail");
						break;
					case "textboxdesc":
						if(event.ctrlKey==true)
							det = getPart(ctrlInst, "detaildesc");
						break;
				}
				if(det)
				{
					if(!SCREENREADER)
						det.focus();
					det.fireEvent("onclick");
					event.cancelBubble=true;
				}
				break;
			case 13:
				shared_handleChange(el);
				if(el.filtercol!="true")
				{
					event.cancelBubble=true;
				}
				break;
		}
	}

	function multiparttextbox_onactivate(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "textbox":
			case "textboxdesc":
				if(el.readOnly==true)
				{
					if(getPart(ctrlInst, el.mxpart).tabIndex=="-1")
					{
						event.returnValue=false;
						event.cancelBubble=true;
					}
					else
					{
						el.style.backgroundColor=FIELD_FOCUS_READ_ONLY_COLOR;
					}
					return false;
				}
				el.style.backgroundColor=FIELD_FOCUS_COLOR;
				el.select();
				if(el.numeric=="numeric")
					el.style.textAlign="left";
				setfocusField(el);
				break;
			case "detail":
			case "detaildesc":
				el.fireEvent("onmouseover");
				break;
		}
	}

	function multiparttextbox_ondeactivate(ctrlInst)
	{
		el = event.srcElement;
		original = el.className.substr(0,el.className.lastIndexOf(" "));
		switch (el.mxpart)
		{
			case "textbox":
			case "textboxdesc":
				if(el.readOnly==true && getPart(ctrlInst, el.mxpart).tabIndex=="-1")
				{
					event.returnValue=false;
					event.cancelBubble=true;
					return false;
				}
				el.style.backgroundColor="";
				if(el.numeric=="numeric")
					el.style.textAlign="right";
				break;
			case "detail":
			case "detaildesc":
				el.fireEvent("onmouseout");
				break;
		}
	}


	function multiparttextbox_onclick(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "detail":
			case "detaildesc":
				if(!isTrue(ctrlInst.getAttribute("ontable")))
				{
				 	event.cancelBubble=true;
				}
				multiparttextbox_detailClick(ctrlInst);
				break;
		}
	}


	function multiparttextbox_onmouseover(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "control":
				break;
			case "textbox":
      {
        if(el.type!="password")
          el.title=ctrlInst.label+" "+el.value;
        else
        {
          el.title=ctrlInst.label;
        }
				break;
      }
			case "textboxdesc":
			{
        if(el.type!="password")
          el.title=ctrlInst.label+" "+ctrlInst.desclabel+" "+el.value;
        else
        {
          el.title=ctrlInst.label+" "+desclabel;
        }
        break;
			}			
			case "detail":
			case "detaildesc":
			{
				el.className=el.className+" detailhighlight";
				break;
			}
		}
	}

	function multiparttextbox_onmouseout(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "textbox":
			case "textboxdesc":
				break;
			case "detail":
			case "detaildesc":
				el.className=el.className.replace(" detailhighlight", "");
				break;
		}
	}

/**************** END Standard functions for multiparttextbox**********************/

/**************** BEGIN Standard functions for page**********************/

	function page_onclick(ctrlInst)
	{
		var eventElement = library_getElementHavingEvent(ctrlInst,event.srcElement); 
		page_handleEvent(ctrlInst,eventElement); 
	}
	
	function page_onkeypress(ctrlInst)
	{		
		var eventElement = library_getElementHavingEvent(ctrlInst,event.srcElement);
		var keyCode =  event.keyCode;
		switch(keyCode)
		{
			case KEYCODE_ENTER:
				page_handleEvent(ctrlInst,eventElement); break;
			default: break;
		}
	}
	
	function page_handleEvent(ctrlInst,eventElement)
	{
		var mxevents = library_getMxEvents(ctrlInst,eventElement);
		for(var i=0; i<mxevents.length; i++)
		{
			var mxevent = mxevents[i];
			switch(mxevent)
			{
				case "returntoapp": 
					var currentAppid = eventElement.getAttribute("mxapp");
					var newAppid=eventElement.getAttribute("mxvalue");
					sendEvent(mxevent, currentAppid, newAppid);
					break;
				default: break;	
			}
		}
	}
/**************** END Standard functions for page**********************/

/**************** BEGIN Standard functions for performancelink**********************/

	function performancelink_onclick(ctrlInst)
	{
		if(ctrlInst.mxevent=="showmenu")
		{
			menuX=event.clientX-event.offsetX-2+5;
			menuY=event.clientY-event.offsetY-2+14;
		}

		sendEvent(ctrlInst.mxevent, ctrlInst.targetid, ctrlInst.value);
	}

	function performancelink_onkeydown(ctrlInst)
	{
		key = event.keyCode;
		switch(key)
		{
			case KEYCODE_ENTER: //enter
			case KEYCODE_SPACEBAR: //spacebar
				ctrlInst.fireEvent("onclick");
				break;
		}
	}
	
	function performancelink_onmouseover(ctrlInst)
	{
		ctrlInst.style.textDecoration="underline";
	}

	function performancelink_onmouseout(ctrlInst)
	{
		ctrlInst.style.textDecoration="none";
	}
/**************** END Standard functions for performancelink**********************/

/**************** BEGIN Standard functions for popup**********************/

	function popup_onclick(ctrlInst)
	{
		event.cancelBubble=true;
		return false;
	}

	function popup_onkeydown(ctrlInst)
	{
		event.cancelBubble=true;
		return false;
	}

	function popup_onkeypress(ctrlInst)
	{
		key = event.keyCode;
		switch(key)
		{
			case 27: //esc
				hidePopup(true);
				enableDoc();
				event.cancelBubble=true;
				break;
			default:
				event.cancelBubble=true;
				break;	
		}
	}
	
/**************** END Standard functions for popup**********************/

/**************** BEGIN Standard functions for pushbutton**********************/

	function pushbutton_onactivate(ctrlInst)
	{

	}
	
	function pushbutton_clickButton(ctrlInst)
	{
		stopevents=false;
		tb = ctrlInst.firstChild; //getPart(ctrlInst, "table");
		tb.fireEvent("onmousedown");
		tb.fireEvent("onmouseup");
	}

	function pushbutton_enabled(ctrlInst,val)
	{
		className = (val)?"pushbutton":"pushbutton pushbuttondisabled";
		ctrlInst.disabled=!val;
	}

	function pushbutton_pressButton(ctrlInst)
	{
		if(stopClick==true)
		{
			stopClick=false;
			return;
		}	
	
		stopevents=false;
		mxevent=ctrlInst.mxevent;
			
		if(mxevent=="showmenu")
		{
			menuX=event.clientX-event.offsetX-2;
			menuY=event.clientY-event.offsetY-2+14;
		}
		
		if(mxevent.indexOf("clientevent:")==0)
		{
			newevent = mxevent.substr(12);
			eval(newevent);
		}
		else if(mxevent=="link")
		{
			event.cancelBubble=true;
			parent.stopFocus=true;
			window.open(ctrlInst.targetdatasrc);
		}
		else
		{
			if(!undef(ctrlInst.eventdatasrc))
			{
				addCommInput("eventdatasrc", ctrlInst.eventdatasrc);
			}
			if (ctrlInst.value)
				sendEvent(mxevent,ctrlInst.targetdatasrc,ctrlInst.value);
			else
				sendEvent(mxevent,ctrlInst.targetdatasrc);
		}
	}
	
	function pushbutton_onkeypress(ctrlInst)
	{
		stopevents=false;
		if(!pushbutton_isVisualButton(ctrlInst,event.srcElement))
			return;
		if(event.keyCode==KEYCODE_ENTER || event.keyCode==KEYCODE_SPACEBAR)
		{
			ctrlInst.over=true;
			event.cancelBubble=true;
			pushbutton_clickButton(ctrlInst);
		}
	}

	function pushbutton_onclick(ctrlInst)
	{
		if(!pushbutton_isVisualButton(ctrlInst,event.srcElement) || stopClick==true)
		{
			stopClick=false;
			return;
		}
		if(usefiringcontrol && firingControl!=null)
		{
			firingControl=null;
			event.cancelBubble=true;
			pushbutton_onmouseup(ctrlInst);
		}
		event.cancelBubble=true;
		event.returnValue=false;
	}

	function pushbutton_onmousedown(ctrlInst)
	{
		stopevents=false;
		if(!pushbutton_isVisualButton(ctrlInst,event.srcElement))
			return;
		ctrlInst.className="pushbutton pushbuttondown";
	}

	function pushbutton_onmouseup(ctrlInst)
	{
		stopevents=false;
		if(!pushbutton_isVisualButton(ctrlInst,event.srcElement))
			return;

		if(firingControl!=null)
			return;	

		ctrlInst.className="pushbutton";
		var tmppart = ctrlInst.firstChild;
		{
			if(!undef(tmppart))
			{
				tmppart.setActive();
			}
		}
		el = event.srcElement;
		tb = getPart(ctrlInst, "table");
		sf = ctrlInst.setsfocus;
		if(undef(sf) || sf=="true")
			setfocusField(tb);
		pushbutton_pressButton(ctrlInst);
	}
	
	function pushbutton_onmouseover(ctrlInst)
	{
		if(!pushbutton_isVisualButton(ctrlInst,event.srcElement))
			return;
		middle = ctrlInst.firstChild.cells[1];//getPart(ctrlInst, "middle");
		table = ctrlInst.firstChild; // getPart(ctrlInst, "table");
		table.className="pushbuttonmain pushbuttonhighlight";
		if(middle.className.indexOf("over")==-1)
		{
			middle.className+=" pushbuttonovertext";
		}	
	}

	function pushbutton_onmouseout(ctrlInst)
	{
		if(!pushbutton_isVisualButton(ctrlInst,event.srcElement))
			return;
		middle = ctrlInst.firstChild.cells[1];//getPart(ctrlInst, "middle");
		table = ctrlInst.firstChild; // getPart(ctrlInst, "table");
		table.className="pushbuttonmain";
		
		if(middle.className.indexOf("over")>-1)
			middle.className=middle.className.substr(0,middle.className.lastIndexOf(" "));
	}


	function pushbutton_ondeactivate(ctrlInst)
	{
		if(!pushbutton_isVisualButton(ctrlInst,event.srcElement))
			return;
		pushbutton_onmouseout(ctrlInst);
	}

	function pushbutton_onfocus(ctrlInst)
	{
		if(!pushbutton_isVisualButton(ctrlInst,event.srcElement))
			return;
		pushbutton_onmouseover(ctrlInst);
		el = event.srcElement;
		sf = ctrlInst.setsfocus;
		if(undef(sf) || sf=="true")
			setfocusField(el);
	}
	
	function pushbutton_isVisualButton(ctrlInst,el)
	{
		part=el.mxpart;
		if(!part || (part!="left" && part!="middle" && part!="right" && part!="table" && part!="control" && part!="sepimage" && part!="menuicon"))
		{
			return false;
		}
		else
		{
			return true;
		}
	}
/**************** END Standard functions for pushbutton**********************/

/**************** BEGIN Standard functions for quicksearch**********************/
 
	function quicksearch_onkeypress(ctrlInst)
	{
		key=event.keyCode
		if(key==KEYCODE_ENTER)
		{
			getPart(getControl(event.srcElement), "findimage").fireEvent("onclick")
		}
	}

	function quicksearch_oncontextmenu(ctrlInst)
	{
	 	event.cancelBubble=true;
	}

	function quicksearch_onactivate(ctrlInst)
	{
		el = event.srcElement
		setfocusField(el);
		switch (el.mxpart)
		{
			case "searchvalue":
				el.style.backgroundColor="#CCC18E";
				el.select();
				break;
			case "findimage":
				break;
		}
	}

	function quicksearch_ondeactivate(ctrlInst)
	{
		el = event.srcElement
		original = el.className.substr(0,el.className.lastIndexOf(" "))
		switch (el.mxpart)
		{
			case "searchvalue":
				el.style.backgroundColor=""
				break;
			case "findimage":
				break;
		}
	}

	function quicksearch_onclick(ctrlInst)
	{
		el = event.srcElement
		switch (el.mxpart)
		{
			case "searchvalue":
				break;
			case "findimage":
				var searchBox = getPart(getControl(ctrlInst), 'searchvalue');
				var searchVal = trim(searchBox.value);
				if(searchVal == "")
				  break;	
				searchBox.value = "";
				sendEvent('quicksearch', getControl(getControl(ctrlInst).parentElement).id, searchVal)
				break;		
		}
		event.returnValue=false		
	}

/**************** END Standard functions for quicksearch**********************/

/**************** BEGIN Standard functions for radiobutton**********************/

	var scroll_interval;
	var down;
	var cancelclick = false

	function radiobutton_onactivate(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "textbox":
				if(el.checked=="false")
				{
					el.src=IMAGE_PATH+"rb_unchecked_over.gif";
				}
				else
				{
					el.src=IMAGE_PATH+"rb_checked_over.gif";
				}
				break;
		}
	}

	function radiobutton_ondeactivate(ctrlInst)
	{
		el = event.srcElement;
		original = el.className.substr(0,el.className.lastIndexOf(" "));
		switch (el.mxpart)
		{
			case "textbox":
				if(el.checked=="false")
				{
					el.src=IMAGE_PATH+"rb_unchecked.gif";
				}
				else
				{
					el.src=IMAGE_PATH+"rb_checked.gif";
				}
				break;
		}
	}

	function radiobutton_onmouseover(ctrlInst)
	{
		img = getPart(ctrlInst, "textbox");		
		el=event.srcElement;
		disabled = getControl(ctrlInst).disabled;
		if(disabled=="true" || disabled==true)
			return;
			
		switch(el.mxpart)
		{
			case "textbox":
				el.style.cursor="hand";
				if(el.checked=="false")
				{
					el.src=IMAGE_PATH+"rb_unchecked_over.gif";
				}
				break;
		}
	}

	function radiobutton_onmouseout(ctrlInst)
	{
		el=event.srcElement;
		switch(el.mxpart)
		{
			case "textbox":
				el.style.cursor="default";
				if(el.checked=="false")
				{
					el.src=IMAGE_PATH+"rb_unchecked.gif";
				}
				break;
		}
	}
	
	function radiobutton_onpropertychange(ctrlInst)
	{
	   	dis = (getControl(ctrlInst).disabled)?"disabled":"";
	   	if(event.propertyName=="checked")
	   	{
			if(ctrlInst.checked!=false && ctrlInst.checked!="false")
			{
				ctrlInst.src=IMAGE_PATH+"rb_checked"+dis+".gif";
				ctrlInst.tabIndex="0";
			}
			else
			{
				ctrlInst.src=IMAGE_PATH+"rb_unchecked.gif";
				ctrlInst.tabIndex="-1";
			}
		}
	}

	function radiobutton_onkeydown(ctrlInst)
	{
		showFieldHelp();
	}

/**************** END Standard functions for radiobutton**********************/

/**************** BEGIN Standard functions for radiobuttongroup**********************/

	var scroll_interval;
	var down;
	var cancelclick = false;

	function radiobuttongroup_updateValue(ctrlInst,mxpart, val)
	{
		buttons = radiobuttongroup_getButtons(ctrlInst);
		imlen = buttons.length;
		for(j=0;j<imlen;j++)
		{
			if(buttons[j].value==val)
			{
				ctrlInst.title=getControl(ctrlInst).label+" "+buttons[j].value;
				buttons[j].checked="true";
				ctrlInst.selectedindex=j;
			}
			else
			{
				buttons[j].tabIndex="-1";
				buttons[j].checked="false";
			}
		}
	}

	function radiobuttongroup_updateRequired(ctrlInst, mxpart, req)
	{
		var tmpMXPart = getPart(ctrlInst, "required");
		if(!undef(tmpMXPart))
		{
			tmpMXPart.src=IMAGE_PATH+req+".gif"; 
		}
	}

	function radiobuttongroup_onactivate(ctrlInst)
	{
		el = event.srcElement;
		setfocusField(el);
	}

	function radiobuttongroup_updateReadOnly(ctrlInst,mxpart, ro)
	{
		ctrlInst.disabled=ro;
		focusbuttonelement=radiobuttongroup_getButtonForIndex(ctrlInst,ctrlInst.selectedindex);
		wrapper = getPart(ctrlInst,"wrappertable");
		if(!undef(focusbuttonelement))
		{
			focusbuttonelement.checked="true";
			if(ro)
				focusbuttonelement.tabIndex=READ_ONLY_TAB_INDEX;
			else
				focusbuttonelement.tabIndex="0";
			wrapper.disabled = ro;
		}
	}

	function radiobuttongroup_sendChange(ctrlInst,focusbutton)
	{
		sendEvent("setvalue",ctrlInst.id,focusbutton.value);
	}

	function radiobuttongroup_onpropertychange(ctrlInst)
	{

	}

	function radiobuttongroup_onkeypress(ctrlInst)
	{
	}

	function radiobutton_onmouseover(ctrlInst)
	{
		img = getPart(ctrlInst, "textbox");		
		el=event.srcElement;
		disabled = getControl(ctrlInst).disabled;
		if(disabled=="true" || disabled==true)
			return;
			
		switch(el.mxpart)
		{
			case "textbox":
				el.style.cursor="hand";
				if(el.checked=="false")
				{
					el.src=IMAGE_PATH+"rb_unchecked_over.gif";
				}
				break;
		}
	}

	// Stops non-numeric keystrokes from changing value and kicks off interval for changing
	function radiobuttongroup_onkeydown(ctrlInst)
	{
		key = event.keyCode;
		el = event.srcElement;
		num = parseInt(el.buttonnumber);
		count = parseInt(ctrlInst.buttoncount);
		ctrlInst.focusbutton=-1;
		returnval=true;
		switch(key)
		{
			case KEYCODE_RIGHT_ARROW: //right arrow
			case KEYCODE_DOWN_ARROW: //down arrow
				if(num<count)
				{
					ctrlInst.focusbutton=num+1;
				}
				else
				{
					ctrlInst.focusbutton=0;
				}
				returnval = false;
				break;
			case KEYCODE_UP_ARROW: //up arrow
			case KEYCODE_LEFT_ARROW: //left arrow
				if(num>0)
				{
					ctrlInst.focusbutton=num-1;
				}
				else
				{
					ctrlInst.focusbutton=count;
				}
				returnval = false;
				break;
			case KEYCODE_ENTER: //enter
			case KEYCODE_SPACEBAR: //spacebar
				ctrlInst.focusbuttonelement=radiobuttongroup_getButtonForIndex(ctrlInst,num);
				if(ctrlInst.focusbuttonelement)
				{
					ctrlInst.focusbuttonelement.click();
					returnval = false;
				}
				return;
				break;
			default:
				ctrlInst.focusbutton=-1;
				break;
		}
		
		if(ctrlInst.focusbutton>-1)
		{
			ctrlInst.focusbuttonelement=radiobuttongroup_getButtonForIndex(ctrlInst,ctrlInst.focusbutton)
			if(ctrlInst.focusbuttonelement)
			{
				radiobuttongroup_noTabIndex(ctrlInst);
				ctrlInst.focusbuttonelement.tabIndex="0";
				ctrlInst.focusbuttonelement.fireEvent("onactivate");
				ctrlInst.focusbuttonelement.focus();
			}
		}

		event.cancelBubble=(!returnval);
		event.returnValue=returnval;
		return returnval;
	}

	function radiobuttongroup_noTabIndex(ctrlInst)
	{
		return;
		
		
		images = ctrlInst.all.tags("IMG");
		len = images.length;
		for(i=0;i<len;i++)
		{
			images[i].tabIndex="-1";
		}
	}

	function radiobuttongroup_onclick(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "textbox":
				if(getControl(el).id==ctrlInst.id)
				{
					if(event.srcElement!=ctrlInst.selectedindex)
						radiobuttongroup_sendChange(ctrlInst,event.srcElement);
				}
				break;
		}
		event.cancelBubble=true;
		return false;
	}
	
	function radiobuttongroup_getButtons(ctrlInst)
	{
		if(!undef(ctrlInst.buttons))
			return ctrlInst.buttons;

		btns = new Array();

		images = ctrlInst.all.tags("IMG");
		imlen = images.length;
		for(j=0;j<imlen;j++)
		{
			rb = images[j].rbcontrol;
			if(!undef(rb) && rb=="true")
			{
				btns[btns.length]=images[j];
			}
		}
		ctrlInst.buttons = btns;
		return btns;
	}

	function radiobuttongroup_getButtonForIndex(ctrlInst,index)
	{
		btns = radiobuttongroup_getButtons(ctrlInst);

		if(!undef(btns))
			return btns[index];
		else
			return null;
	}

/**************** END Standard functions for radiobuttongroup**********************/

/**************** BEGIN Standard functions for reasonchange**********************/

	function reasonchange_updateValue(ctrlInst,mxpart, val)
	{
		textbox_updateValue(ctrlInst,mxpart, val);
	}

	function reasonchange_updateRequired(ctrlInst,mxpart, req)
	{
		textbox_updateRequired(ctrlInst,mxpart, req);
	}

	function reasonchange_haslongdesc(ctrlInst,hasLD)
	{
		textbox_haslongdesc(ctrlInst,hasLD);
	}

	function reasonchange_updateReadOnly(ctrlInst,mxpart, ro)
	{
		textbox_updateReadOnly(ctrlInst,mxpart, ro);
	}

/**************** END Standard functions for reasonchange**********************/

/**************** BEGIN Standard functions for reportbutton**********************/

	function reportbutton_enabled(ctrlInst,val)
	{
		className = (val)?"reportbutton":"reportbutton reportbuttondisabled";
		disabled=!val;
	}

	function reportbutton_pressButton(ctrlInst)
	{
		if(mxevent.indexOf("clientevent:")==0)
		{
			newevent = mxevent.substr(12);
			eval(newevent);
		}
		else
		{
			if (value)
				sendEvent(mxevent,targetdatasrc,value);
			else
				sendEvent(mxevent,targetdatasrc);
		}
	}
	
	function reportbutton_onkeypress(ctrlInst)
	{
		if(event.keyCode==KEYCODE_ENTER || event.keyCode==KEYCODE_SPACEBAR)
		{
			over=true;
			reportbutton_onmousedown(ctrlInst);
			reportbutton_onmouseup(ctrlInst);
		}
	}

	function reportbutton_onclick(ctrlInst)
	{

	}

	function reportbutton_onmousedown(ctrlInst)
	{
		className="reportbutton reportbuttondown";
	}

	function reportbutton_onmouseup(ctrlInst)
	{
		makeReportFormElements();
	}

	function reportbutton_onmouseover(ctrlInst)
	{
		middle = getPart(ctrlInst, "middle");
		table = getPart(ctrlInst, "table");
		table.className="reportbuttonmain reportbuttonhighlight";
		if(middle.className.indexOf("over")==-1)
		{
			middle.className+=" reportbuttonovertext";
		}	
	}

	function reportbutton_onmouseout(ctrlInst)
	{
		middle = getPart(ctrlInst, "middle");
		table = getPart(ctrlInst, "table");
		table.className="reportbuttonmain";
		
		if(middle.className.indexOf("over")>-1)
			middle.className=middle.className.substr(0,middle.className.lastIndexOf(" "));
	}


	function reportbutton_ondeactivate(ctrlInst)
	{
		reportbutton_onmouseout(ctrlInst);
	}

	function reportbutton_onfocus(ctrlInst)
	{
		reportbutton_onmouseover(ctrlInst);
	}

/**************** END Standard functions for reportbutton**********************/

/**************** BEGIN Standard functions for section**********************/

	function section_onclick(ctrlInst)
	{
		if(section_handleEvents(ctrlInst, event.srcElement))
		{
			event.returnValue=false;
			event.cancelBubble=true;
		}
	}

	function section_ondblclick(ctrlInst)
	{
		if(section_handleEvents(ctrlInst, event.srcElement))
		{
			event.returnValue=false;
			event.cancelBubble=true;
		}
	}

	function section_onkeypress(ctrlInst)
	{
		var handled = false;
		var keyCode = event.keyCode;
		switch(keyCode)
		{
			case KEYCODE_ENTER:
				if(!section_handleEvents(ctrlInst, event.srcElement))
				{
					if(!undef(ctrlInst.defaultbutton))
					{
						defid = ctrlInst.defaultbutton;
						if(defid && defid==library_getControlByType(event.srcElement, "section").id)
							break;
						itemtoclick = document.getElementById(defid);
						itemtoclick.focus();
						itemtoclick.setActive();
						sendFrontEndEvent("clickDefaultButton", ctrlInst.id);
						event.cancelBubble=true;
						event.returnValue=false;
						return false;
					}
				}
				break;
			default:
				break;
		}
	}

	function section_fnHandleToggleState(ctrlInst)
	{
		var expanded = section_isExpanded(ctrlInst);
		if(expanded)
		{
			section_fnHandleCollapse(ctrlInst);
		}
		else
		{
			section_fnHandleExpand(ctrlInst);		
		}
	}

	function section_fnHandleCollapse(ctrlInst)
	{
		var section_header = section_getHeader(ctrlInst);		
		var section_content = section_getContent(ctrlInst);
		if(!undef(section_header) && !undef(section_content))
		{
			var section_images = section_header.all.tags("IMG");
			for(var i=0; i <section_images.length; i++)
			{
				var mxpart = section_images(i).getAttribute("mxpart")
				switch(mxpart)
				{
					case "image_min": 
						section_images(i).style.display="none"; 
						break;
					case "image_max": 
						section_images(i).style.display="";
						break;
					default: break;
				}
			}
			section_content.style.display="none";
		}	
	}
	
	function section_fnHandleExpand(ctrlInst)
	{
		var section_header = section_getHeader(ctrlInst);		
		var section_content = section_getContent(ctrlInst);
		var section_images = section_header.all.tags("IMG");
		if(!undef(section_header) && !undef(section_content))
		{
			for(var i=0; i <section_images.length; i++)
			{
				var mxpart = section_images(i).getAttribute("mxpart")
				switch(mxpart)
				{
					case "image_min": 
						section_images(i).style.display="";
						break;
					case "image_max": 
						section_images(i).style.display="none"; 
						break;
					default: break;
				}
			}
			section_content.style.display="";
		}	
	}

	function section_handleEvents(ctrlInst, eventElement)
	{
		var handled = false;
		eventElement = library_getElementHavingEvent(ctrlInst, eventElement);
		var mxevents = library_getMxEvents(ctrlInst, eventElement);
		var srcControl = library_getControlByType(eventElement, "section");
		if(srcControl == ctrlInst)
		{
			for(var i=0; i<mxevents.length; i++)
			{
				var mxevent = mxevents[i];
				switch(mxevent)
				{
					case "collapse":
						section_fnHandleCollapse(ctrlInst); 
						handled = true;
						break;
					case "expand":
						section_fnHandleExpand(ctrlInst); 
						handled = true;
						break;
					case "togglestate":
						section_fnHandleToggleState(ctrlInst);
						handled = true;
						break; 
					default:
						handled = false;
						break;
				}
			}
		}	
		return handled;
	}
	
	function section_isExpanded(ctrlInst)
	{
		var expanded = false;
		var section_content = section_getContent(ctrlInst);
		if(!undef(section_content))
		{
			expanded = (section_content.style.display=="")?true:false;
		}
		return expanded;
	}
		
	function section_getHeader(ctrlInst)
	{
		var header = ctrlInst.all.namedItem(ctrlInst.id + SECTION_HEADER_SUFFIX);
		return header;
	}
		
	function section_getLabel(ctrlInst)
	{
		var section_header = section_getHeader(ctrlInst);
		var label = ctrlInst.all.namedItem(ctrlInst.id + SECTION_LABEL_SUFFIX);
		return label;
	}
	
	function section_getContent(ctrlInst)
	{
		var content = ctrlInst.all.namedItem(ctrlInst.id + SECTION_CONTENT_SUFFIX);
		return content;
	}
	
	function section_getFooter(ctrlInst)
	{
		var footer = ctrlInst.all.namedItem(ctrlInst.id + SECTION_FOOTER_SUFFIX);
		return footer;
	}
/**************** END Standard functions for section**********************/

/**************** BEGIN Standard functions for shared**********************/

	function shared_oncontextmenu(ctrlInst)
	{
	 	event.cancelBubble=true;
	}

	function shared_handleDoubleClick(ctrlInst)
	{
		el = event.srcElement
		control=getControl(el);
		
		switch (el.mxpart)
		{
			case "textbox":
			case "textboxdesc":
				menuX=event.clientX-event.offsetX+15;
				menuY=event.clientY-event.offsetY+5;
				sendEvent("showfieldhelp", control.id, el.mxpart, el.dataattribute);
				break;
		}
		event.cancelBubble=true;
		event.returnValue=false;
	}

	function shared_ondeactivate(ctrlInst)
	{
		fromEl = event.srcElement;
		ch = fromEl.changed;
		if(ch==true)
		{
			toEl = event.toElement;
			toCtrl = getControl(toEl);
			ctrl = getControl(fromEl);
			update = ctrl.updateonchange;
			if(firingControl==null)
			{
				if(event && !undef(toEl))
				{
					toControl = getControl(toEl);
					if(!undef(toControl))
					{
						toEvent = toControl.mxevent;
						if (!undef(toEvent) && toEvent=="dialogcancel")
						{
							ctrlInst.changed=false;
						}
					}
					if(toEl.tagName=="IFRAME" && toEl.id=="upload_iframe")
					{
						firingControl = toEl.contentWindow.document.getElementById("file");
					}
					else
					{
						firingControl = toEl;
					}
				}
			}
			cfd = document.getElementById("commframe");
			commframedoc = document.getElementById("commframe").contentWindow.document;
			hiddenForm = commframedoc.getElementById("hiddenform");
			inputs = hiddenForm.elements;
			if(toEl)
			{
				setfocusField(toEl);
				event.returnValue=false;
				event.cancelBubble=true;	
				document.body.focus();
				stopClick=true;
				if(ctrlInst.changed==true)
					shared_handleChange(ctrlInst);
				else if(firingControl)
				{
					firingControl.fireEvent("onclick");
					clearFiring();
				}
			}
		}
		
	}
	
	function shared_onchange(ctrlInst)
	{
		ctrlInst.changed=true;
	}

	function shared_unMarkAsChanged(ctrlInst)
	{
		ctrlInst.changed=false;
		ctrlInst.fireEvent("ondeactivate");
	}

	function shared_markAsChanged(ctrlInst)
	{
		ctrlInst.changed=true;
	}

	function shared_handleChange(ctrlInst)
	{
		stop = ctrlInst.cancelSetValue;
		if(stop!=null && stop=="true")
			return;

		elId = ctrlInst.id;

		control = getControl(ctrlInst);
		
		if(control==null)
			return;
			
		iscontrol = control.control;
		

		if(iscontrol==null || iscontrol==false)
			return;
	
		//Check if the control is in a table (need to pass row for table)		
		var ontable=control.getAttribute("ontable");
		var foundRow = false;
		if(!undef(ontable))
		{
			tablerow = control.getAttribute("tablerow");
			if(!undef(tablerow))
				foundRow = true;
		}
		usefiringcontrol = true;
		stopClick=false;
		if(foundRow)
			setValue(getControl(ctrlInst), ctrlInst, tablerow);
		else		
			setValue(getControl(ctrlInst), ctrlInst);
	}
	
	function shared_onfocus(ctrlInst)
	{
		try
		{
			if(event.srcElement.tagName!="TEXTAREA")
				ctrlInst.select(); 
		}
		catch(error)
		{
		}
	}

	//Special handling for Dates (support for CTRL+ or CTRL- keys)
	//When CTRL+ is pressed, if there is a date, increment the date (next day)
	//                       else, put current date and time in the field
	//When CTRL- is pressed, if there is a date, decrement the date (previous day)
	//                       else, put current date and time in the field
	function shared_onkeydown(ctrlInst)
	{
		key=event.keyCode;
		el = event.srcElement;
		control=getControl(el);
		switch(key)
		{
	        case KEY_CODE_PLUS:
	        case NUMERIC_PAD_KEY_CODE_PLUS:
	        case KEY_CODE_MINUS:
	        case NUMERIC_PAD_KEY_CODE_MINUS:
	        	var fieldType = el.datatype;
				if(!undef(fieldType)) fieldType = parseInt(fieldType);
				if(event.ctrlKey && ((fieldType==FIELD_TYPE_DATE) || (fieldType==FIELD_TYPE_DATETIME)))
				{
					switch(key)
					{
				        case KEY_CODE_PLUS:
				        case NUMERIC_PAD_KEY_CODE_PLUS:
							increment=1;
				        	break;
				        case KEY_CODE_MINUS:
				        case NUMERIC_PAD_KEY_CODE_MINUS:
							increment=-1;
				        	break;
				        default:break;
					}
		        	if(undef(el.value))
		        	{
		        		sendEvent("setcurrentdate", control.id, "", "dataattribute");
					}
		        	else
		        	{
		        		el.value = shared_incrementDay(control, el.value, increment);
		        		el.changed = true;
		        	}
					event.returnValue=false;
					event.cancelBubble=true;
				}
	            break;
	        case 8:
				if(el.readOnly==true)
				{
					event.returnValue=false;
					event.cancelBubble=true;
					return false;
				}
				break;
	        default: 
	        	break;
	    }
		showFieldHelp();
	}
	
	function shared_incrementDay(ctrlInst, dateTimeValue, interval)
	{
		if(!undef(dateTimeValue))
		{
			var twoDigitDay = ctrlInst.twodigitday;
			var twoDigitMonth = ctrlInst.twodigitmonth;
			var fourDigitYear = ctrlInst.fourdigityear;
			var dayposition=( undef(ctrlInst.dayposition)? 1 : parseInt(ctrlInst.dayposition) );
			var monthposition=( undef(ctrlInst.monthposition)? 0 : parseInt(ctrlInst.monthposition) );
			var yearposition=( undef(ctrlInst.yearposition)? 2 : parseInt(ctrlInst.yearposition) );
			var dateTimeParts = dateTimeValue.split(" ");
			var dateString = dateTimeParts[0];
			var dateParts = dateString.split("/");
			var testDate = new Date();
			testDate.setYear(dateParts[yearposition]);
			testDate.setMonth(parseInt(dateParts[monthposition])-1);
			testDate.setDate(parseInt(dateParts[dayposition])+interval);
			dateParts[dayposition]=testDate.getDate();
			month = testDate.getMonth()+1;
			if(twoDigitMonth=="true" && month<10)
				dateParts[monthposition]="0"+month;
			else
				dateParts[monthposition]=month;
			day = testDate.getDate();
			if(twoDigitDay=="true" && day<10)
				dateParts[dayposition]="0"+day;
			else
				dateParts[dayposition]=day;
			if(fourDigitYear=="true")
				dateParts[yearposition]=testDate.getFullYear();
			else
			{
				year = testDate.getYear();
				if(year>=10)
					dateParts[yearposition]=year;
				else
					dateParts[yearposition]="0"+year;
			}
			dateTimeParts[0] = dateParts.join("/");
			timeString="";
			if(dateTimeParts.length>1)
			{
				timeString = " " +dateTimeParts[1] + " " +dateTimeParts[2];
			}
			dateTimeValue=dateTimeParts[0] + timeString;
		}
		return dateTimeValue;
	}


	function shared_incrementDateTimePart(ctrlInst, dateTimeValue, part, interval)
	{
		if(!undef(dateTimeValue)){




			var dayposition=( undef(ctrlInst.dayposition)? 1 : parseInt(ctrlInst.dayposition) );
			var monthposition=( undef(ctrlInst.monthposition)? 0 : parseInt(ctrlInst.monthposition) );
			var yearposition=( undef(ctrlInst.yearposition)? 2 : parseInt(ctrlInst.yearposition) );

			var dateTimeParts = dateTimeValue.split(" ");
			var dateString = dateTimeParts[0];
			var dateParts = dateString.split("/");
			if(dateParts.length==3)

















			{
				switch(part){
					case "month": dateParts[monthposition] = shared_handleMonth(dateParts[monthposition], interval); break;
					case "day": dateParts[dayposition] = shared_handleDay(dateParts[dayposition], interval); break;
					case "year": dateParts[yearposition] = shared_handleYear(dateParts[yearposition], interval); break;

				}
				dateTimeParts[0] = dateParts.join("/");
			}
			if(dateTimeParts.length>1)
			{
				var timeString = dateTimeParts[1];
				var timeParts = timeString.split(":");
				if(timeParts.length>=2)
				{
					switch(part){
						case "hour": timeParts[0] = shared_handleHour(timeParts[0], true, interval); break;
						case "minute": timeParts[1] = shared_handleMinutes(timeParts[1], interval); break;
						case "second": timeParts[2] = shared_handleSeconds(timeParts[2], interval); break;
					}
					dateTimeParts[1] = timeParts.join(":");
				}
			}
			dateTimeValue = dateTimeParts.join(" ");
		}
		return dateTimeValue;
	}

	function shared_handleMonth(calMonth, interval)
	{
		if(calMonth.length==2)
		{
			if(calMonth.charAt(0)=="0"){calMonth = calMonth.substr(1,1);}
		}	
		if(!undef(interval))
		{
			calMonth = String( parseInt(calMonth) + interval);
		}
		if(parseInt(calMonth)>11)
		{
			calMonth="0";
		}
		else if(parseInt(calMonth)<0)
		{
			calMonth="11";
		}
		return calMonth;
	}

	function shared_handleDay(calDay, interval)
	{
		if(calDay.charAt(0)=="0"){calDay = calDay.substr(1,1);}
		if(!undef(interval))
		{
			calDay = String( parseInt(calDay) + interval);
		}
		if(parseInt(calDay)>31 || parseInt(calDay)==0)
		{
			calDay="01";
		}
		return calDay;
	}

	function shared_handleYear(calYear, interval)
	{
		if(calYear.charAt(0)=="0"){calYear = calYear.substr(1,1);}
		if(!undef(interval))
		{
			calYear = String( parseInt(calYear) + interval);
		}
		if(calYear.length==1){calYear = "0" + calYear;}
		return calYear;
	}
	
	function shared_handleHour(calHour, supports24Hours, interval)
	{
		if(undef(supports24Hours)){supports24Hours = true;}
		if(calHour.length==2)
		{
			if(calHour.charAt(0)=="0"){calHour = calHour.substr(1,1);}
		}	
		if(!undef(interval))
		{
			calHour = String( parseInt(calHour) + interval);
		}
		if(parseInt(calHour)<0)
		{
			calHour = "0";
		}
		if(calHour.length<2 || parseInt(calHour)<10)
		{
			calHour="0"+calHour;
		}
		else
		{
			if(supports24Hours)
			{
				if(parseInt(calHour)>=25)
				{
					calHour = "00";
				}
			}
			else
			{
				if(parseInt(calHour)>=13)
				{
					calHour = "00";
				}
			}	
		}
		return calHour;
	}

	function shared_handleMinutes(calMin, interval)
	{
		if(calMin.length==2)
		{
			if(calMin.charAt(0)=="0"){calMin = calMin.substr(1,1);}
		}	
		if(!undef(interval))
		{
			calMin = String( parseInt(calMin) + interval);
		}
		if(parseInt(calMin)<0)
		{
			calMin = "0";
		}
		if(calMin.length<2 || parseInt(calMin)<10)
		{
			calMin = "0" + calMin;
		}
		else
		{
			if(parseInt(calMin)>=60)
				calMin="00";
		}
		return calMin;
	}	


	function shared_handleSeconds(calSec, interval)
	{
		if(calSec.length==2)
		{
			if(calSec.charAt(0)=="0"){calSec = calSec.substr(1,1);}
		}	
		if(!undef(interval))
		{
			calSec = String( parseInt(calSec) + interval);
		}
		if(parseInt(calSec)<0)
		{
			calSec = "0";
		}
		if(calSec.length<2 || parseInt(calSec)<10)
		{
			calSec = "0" + calSec;
		}
		else
		{
			if(parseInt(calSec)>=60)
				calSec="00";
		}
		return calSec;
	}

	function shared_updateValue(ctrlInst,mxpart, val)
	{
		part=getPart(ctrlInst, mxpart);
		if(!undef(part))
		{
			if(part.value!=val)
				parent.addUpdateField(part,val);
			part.value=val;
			shared_unMarkAsChanged(part);
		}
	}

	function shared_onselectedtablerow(ctrlInst,sel)
	{
		if(ctrlInst.controltype=="checkbox")
			return;
			
		tb = getPart(ctrlInst, "textbox")
		cn = tb.className
		if(tb.readOnly==true)
			ro = " readonlytrue";
		else
			ro = " readonlyfalse";
			
		if(sel==true)
		{
			newcn = "input_parts input text tableinputrowselected" + ro;
		}
		else
		{
			newcn = "input_parts input text tableinputrownotselected";
		}
		tb.className=newcn;
	}

/**************** END Standard functions for shared**********************/

/**************** BEGIN Standard functions for startcenter**********************/

	//common method to handle key strokes on
	function startcenter_onkeypress(ctrlInst)
	{
		var eventElement = event.srcElement;
		var keyCode =  event.keyCode;
		switch(keyCode)
		{
			case KEYCODE_ENTER:
				if(!undef(eventElement)){
					eventElement.click();
					event.cancelBubble=true;
				}
		}
	}
	
	function startcenter_togglePortlet(ctrlInst,doc,portletId)
	{		
			var tableDiv = doc.getElementById("portlet"+portletId);
			var minImg	= doc.getElementById("portletimage_min_"+portletId);
			var maxImg  = doc.getElementById("portletimage_max_"+portletId);
			
			if (tableDiv.style.display != 'none')
			{													
				minImg.style.display = 'none';
				maxImg.style.display = 'inline';								

				sendEvent("toggleportlet","scportlets",0,"state",null,null,portletId);								
			}
			else
			{							
				minImg.style.display = 'inline';
				maxImg.style.display = 'none';									
			
				sendEvent("toggleportlet","scportlets",1,"state",null,null,portletId);									
			}			
	}

	function startcenter_deletePortlet(ctrlInst,portletid)
	{
		sendEvent("deleteportlet","scportlets",portletid,null,null,null,portletid);
	}

	function startcenter_openRecord(ctrlInst,appname,uniqueId)
	{
		sendEvent("changeapp","startcntr",appname, null, null, null, uniqueId);
	}			

	function startcenter_changeStartCenter(ctrlInst,uniqueId)
	{
		sendEvent("changeapp","startcntr","startcntr", null, null, null, uniqueId);
	}

	function startcenter_createTemplate(ctrlInst,uniqueId)
	{
		sendEvent("createtemplate","startcntr",uniqueId);
	}

	function startcenter_deleteTemplate(ctrlInst,uniqueId)
	{
		sendEvent("deletetemplate","startcntr",uniqueId);
	}
	
	function startcenter_cancelChanges(ctrlInst,uniqueId)
	{
		sendEvent("cancelchanges","startcntr",uniqueId);
	}		
	
	function startcenter_modifyTemplate(ctrlInst,uniqueId)
	{
		sendEvent("modifytemplate","startcntr",uniqueId);
	}	
	
	function startcenter_saveTemplate(ctrlInst,uniqueId)
	{
		sendEvent("savetemplate","startcntr",uniqueId);
	}		

	function startcenter_updateTemplate(ctrlInst,uniqueId)
	{
		sendEvent("updatestartcenter","startcntr",uniqueId);
	}		
		
	function startcenter_displaySettings(ctrlInst,uniqueId)
	{
		sendEvent("displaysettings","startcntr",uniqueId);
	}
			
	function startcenter_changeContent(ctrlInst)
	{
		sendEvent("changeapp","startcntr","scconfig");
	}	
	
	function startcenter_scrollData(ctrlInst,layoutId,startvalue)
	{
		sendEvent('scrolldata',"startcntr",startvalue, null, null,null, layoutId);		
	}

	function startcenter_passScrollValue(ctrlInst)
	{
		 var scrollValue = (typeof document.getElementsByTagName('body')[0] != 'undefined') ? 	document.getElementsByTagName('body')[0].scrollTop : (typeof window.PageYOffset != 'undefined') ? window.PageYOffset : null;

		 return  scrollValue;
	}

	function startcenter_changeRSDisplay(ctrlInst,doc,displayType,portletId,isfilterset)
	{
		var graphPart = doc.getElementById("portletgraph"+portletId);
		var listPart = doc.getElementById("portletdata"+portletId);
		var filterPart = doc.getElementById("filter_span_"+portletId);
		
		if(!undef(graphPart) && !undef(listPart))
		{
			if(displayType == "LIST")
			{
				filterPart.style.display = 'inline';
				graphPart.style.display = 'none';
				listPart.style.display = 'inline';
				
				if(isfilterset)
					clearfilter.style.display = 'inline';
				else
					clearfilter.style.display = 'none';
			}
			else
			{	
				filterPart.style.display = 'none';
				graphPart.style.display = 'inline';
				listPart.style.display = 'none';
			}
				
			sendEvent('changersdisplay',"scportlets",displayType, null, null,null,portletId);				
		}
	}
				
	function startcenter_changeRSSettings(ctrlInst,portletId)
	{
		sendEvent('rsdisplay',"startcntr",portletId, null, null,null,portletId);
	}
	
	function startcenter_sortResultSet(ctrlInst,columnname,portletId,sorttype)
	{	
		var sortby = columnname+" "+sorttype;
		
		if(sorttype == '')					
			sortby = "";
			
		sendEvent('sortresultset',"scportlets",sortby, null, null,null,portletId);		
	}
	
	function startcenter_filterResultSet(ctrlInst,portletId)
	{				
		sendEvent('filterresultset',"scportlets",portletId, null, null,null,portletId);		
	}
	
	function startcenter_clearFilter(ctrlInst,portletId)
	{				
		sendEvent('clearfilter',"scportlets",portletId, null, null,null,portletId);		
	}
			
	function startcenter_filterDeactivate(ctrlInst,portletId)
	{
		var el = event.srcElement;
		el.style.backgroundColor="";
	}	
	
	function startcenter_filterChanged(ctrlInst,portletId)
	{
		var el = event.srcElement;
		var attribname = el.columnname;
		var value = el.value;
		var qbe = attribname+"~^"+value;
		
		sendEvent("setqbeonrs","scportlets",qbe,null,null,null,portletId);
	}		
		
	function startcenter_filterActivate(ctrlInst)
	{
		var el = event.srcElement;
		el.style.backgroundColor="#CCC18E";
		
	}
	
	function startcenter_enterOnFilter(ctrlInst,portletId)
	{
		if(event.keyCode==KEYCODE_ENTER)
		{	
			var el = event.srcElement;
			var attribname = el.columnname;
			var value = el.value;
			var qbe = attribname+"~^"+value;

			sendEvent('setqbeonrsandfilter',"scportlets",qbe, null, null,null,portletId);	
		}

	}
	
	function startcenter_toggleFilter(ctrlInst,doc,portletId)
	{
		var expandSpan = doc.getElementById("span_expand_"+portletId);
		var collapseSpan = doc.getElementById("span_collapse_"+portletId);
		var filterBtns = doc.getElementById("filter_btns_"+portletId);
		
		//if filter open image is displayed, turn it off and turn another on
		if(!undef(expandSpan))
		{
			if(expandSpan.style.display != 'none')
			{	
				expandSpan.style.display = 'none';
				collapseSpan.style.display = 'inline';
			}
			else
			{	
				expandSpan.style.display = 'inline';
				collapseSpan.style.display = 'none';
			}	
		}
		
		var filterCells = doc.getElementsByName("filter_cells_"+portletId);
		
		for(i = 0; i < filterCells.length;i++)
		{
			var filterCell = filterCells.item(i);
			
			if(filterCell.className == "rsfilter_col_open")	
				filterCell.className = "rsfilter_col_closed";
			else
				filterCell.className = "rsfilter_col_open";	
		}
		
		var filterSpans = doc.getElementsByName("filter_dataspan_"+portletId);
		for(i = 0; i < filterSpans.length;i++)
		{
			var inputSpan = filterSpans.item(i);
			if(inputSpan.style.display != 'none')
				inputSpan.style.display = 'none'
			else
				inputSpan.style.display = 'inline'				
		}
		
	}	
	
	function startcenter_rsFilter(ctrlInst,link)
	{
		location.href =  link;
	}
	
	function startcenter_routeInbox(ctrlInst,app,recordid,assignid)
	{
		sendEvent("wflaunch","startcntr",app,null,null,assignid,recordid);
	}
	
	function startcenter_gotoInboxRecord(ctrlInst,app,recordId)
	{
		if(recordId != "")
			sendEvent("changeapp","startcntr",app,null,null,"inboxwf",recordId);
	}
	
	function startcenter_updateInbox(ctrlInst,uniqueId)
	{
		sendEvent("changeapp","startcntr","startcntr", null, null, null, uniqueId);
	}	

	function startcenter_updatekpi(ctrlInst,portletid)
	{
		sendEvent('updatekpi',"scportlets",portletid,null,null,portletid);		
	}
	
	
	function startcenter_openReport(ctrlInst,reportDialog,portletid) {
		sendEvent(reportDialog,"scportlets","scportlets");
	}

 	function startcenter_gotoAction(ctrlInst,appname,actionName)
	{
		sendEvent('changeapp', "startcntr",appname, null, null, actionName);
				
	}	

 	function startcenter_gotoApp(ctrlInst,appname)
	{
		sendEvent('changeapp',"startcntr",appname);
	}	

	function startcenter_bbButton(ctrlInst,option,Id,doc)
	{	
		if(option == "in")
		{		
			var table = doc.getElementById("bbbtntable_"+Id);
			table.className="bbpushbutton pushbuttonmain pushbuttonhighlight";
		
			var middle = doc.getElementById("bbbtntext_"+Id);
		
			if(middle.className.indexOf("over")==-1)
			{
				middle.className+=" bbpushbuttonovertext";
			}			
		}
		
		if(option == "out")
		{
		
		var middle = doc.getElementById("bbbtntext_"+Id);
		var table = doc.getElementById("bbbtntable_"+Id);
		
		table.className="bbpushbutton bbpushbuttonmain";
		
		if(middle.className.indexOf("over")>-1)
			middle.className="text bbpushbuttonmiddle bbpushbuttonmiddleback bbpushbutton_default";
		}	
	}
	


/**************** END Standard functions for startcenter**********************/

/**************** BEGIN Standard functions for statictext**********************/

  	function statictext_updateValue(ctrlInst,mxpart, val)
	{
   		var lbl = getPart(ctrlInst, mxpart);
		if(lbl.innerText!=val)
			parent.addUpdateField(lbl.innerText,val);
	    lbl.innerText=val;
	    lbl.title=val;
	}

/**************** END Standard functions for statictext**********************/

/**************** BEGIN Standard functions for systemprop**********************/

  	function systemprop_updateValue(ctrlInst,mxpart, val)
	{
	   	var lbl = getPart(ctrlInst, mxpart);
	    lbl.innerText=val;
	    lbl.title=val;
	}

/**************** END Standard functions for systemprop**********************/

/**************** BEGIN Standard functions for tab**********************/


	function tab_getPart()
	{
		part=null;
		partName = currentPartName;
		ctrlInst = currentObject;
		switch(partName)
		{
			case "tablabel":
				part = ctrlInst.cells[1].firstChild;
				break;
			default:
				part = ctrlInst.all.namedItem(partName);
				break;
		}
		return part;
	}

	function tab_designerUnselected(ctrlInst)
	{
		ctrlInst.style.filter="";
	}

	function tab_designerSelected(ctrlInst)
	{
		ctrlInst.style.filter="light();";
		ctrlInst.filters[0].addAmbient(DESIGNER_HIGHLIGHT.red, DESIGNER_HIGHLIGHT.green, DESIGNER_HIGHLIGHT.blue, 100);
	}
	
	
	function tab_onkeypress(ctrlInst)
	{
		if(event.keyCode==KEYCODE_ENTER || event.keyCode==KEYCODE_SPACEBAR)
		{
			tabcontrol = getControl(event.srcElement);
	
			if(tabcontrol.id!=ctrlInst.id)
				return;
	
			tab_select(ctrlInst);
		}
	}

	function tab_onactivate(ctrlInst)
	{
		tabcontrol = getControl(event.srcElement);

			if(tabcontrol.id!=ctrlInst.id)
			return;

		tab_onmouseover(ctrlInst);
	}

	function tab_ondeactivate(ctrlInst)
	{
		tabcontrol = getControl(event.srcElement);

			if(tabcontrol.id!=ctrlInst.id)
			return;

		tab_onmouseout(ctrlInst);
	}

	function tab_onclick(ctrlInst)
	{
		tabcontrol = getControl(event.srcElement);

		if(tabcontrol.id!=ctrlInst.id)
			return;

		tab_select(ctrlInst);
	}

	function tab_select(ctrlInst)
	{
		if(!undef(ctrlInst.selected) && ctrlInst.selected=="true")
			return;
		sendEvent("changetab", getControl(ctrlInst.parentElement).id, ctrlInst.tabname);
	}
	
	function tab_onpropertychange(ctrlInst)
	{
		if(event && event.propertyName!="selected")
			return;

		tabbar = getContainer(ctrlInst, "tabbar");
		tabMiddle = getPart(ctrlInst, "middle");
		if(ctrlInst.selected!="true")
		{
			ctrlInst.className=ctrlInst.classprefix + "mainoff";
			tabMiddle.tabIndex="0";
			if(ctrlInst.tabnum==0)
				ctrlInst.cells(0).className=ctrlInst.tabstyle+"first" + ctrlInst.classprefix + "leftoff";
			else
				ctrlInst.cells(0).className=ctrlInst.tabstyle+ ctrlInst.classprefix + "leftoff";
			ctrlInst.cells(1).className=ctrlInst.tabstyle+"text "+ctrlInst.tabstyle+ ctrlInst.classprefix + " " +ctrlInst.tabstyle+ ctrlInst.classprefix + "off";
			ctrlInst.cells(2).className=ctrlInst.tabstyle+ ctrlInst.classprefix + "rightoff";
			if(ctrlInst.loadalltabs=="true")
			{
				tabbody = getPart(tabbar, tabbar.id+"_body_"+ctrlInst.tabname);
				if(tabbody!=null)
				{
					tabbody.style.display="none";
				}
			}
		}
		else
		{
			ctrlInst.className=ctrlInst.classprefix + "mainon";
			ctrlInst.cells(0).className=ctrlInst.tabstyle+ctrlInst.classprefix+"lefton";
			ctrlInst.cells(1).className=ctrlInst.tabstyle+"text "+ctrlInst.tabstyle+ctrlInst.classprefix+" "+ctrlInst.tabstyle+ ctrlInst.classprefix + "on";
			ctrlInst.cells(2).className=ctrlInst.tabstyle+ctrlInst.classprefix+"righton";
			tabMiddle.tabIndex="-1";
			
			if(ctrlInst.loadalltabs=="true")
			{
				tabbody = getPart(tabbar, tabbar.id+"_body_"+ctrlInst.tabname);
				if(tabbody!=null)
				{
					tabbody.style.display="inline";
				}
			}
		}
	}
	
	function tab_highlight(ctrlInst)
	{
		ctrlLabel=getPart(ctrlInst, "tablabel");
		if(ctrlInst.selected!="true")
		{
			if (!undef(ctrlLabel))
				ctrlLabel.className=ctrlInst.tabstyle+ ctrlInst.classprefix+ "over";
		}

	}

	function tab_dehighlight(ctrlInst)
	{
		ctrlLabel=getPart(ctrlInst, "tablabel");
		if(!undef(ctrlLabel))
			ctrlLabel.className="";	
	}


	function tab_onmouseover(ctrlInst)
	{
		tabcontrol = getControl(event.srcElement);

		if(tabcontrol==ctrlInst)
			tab_highlight(ctrlInst);
	}


	function tab_onmouseout(ctrlInst)
	{
		tabcontrol = getControl(event.srcElement);
		if(tabcontrol==ctrlInst)
			tab_dehighlight(ctrlInst);
	}

	
	function tabbody_onkeydown(ctrlInst)
	{
		key=event.keyCode;
		if(key==KEYCODE_TAB && (event.ctrlKey==true || event.ctrlLeft==true))
		{
			tabid = ctrlInst.id;
			stop = tabid.indexOf("_");
			groupId = tabid.substr(0,stop);
			if(event.shiftKey==true || event.shiftLeft==true)
				sendEvent("previoustab", groupId, "true")
			else
				sendEvent("nexttab", groupId, "true")			
			event.cancelBubble=true;
			event.returnValue=false;
		}
		
	}
	
/**************** END Standard functions for tab**********************/

/**************** BEGIN Standard functions for tabgroup**********************/

	function tabgroup_getPart()
	{
		part=null;
		partName = currentPartName;
		ctrlInst = currentObject;
		switch(partName)
		{
			case "tabrow":
				part = ctrlInst.cells[0].firstChild.rows[0];
				break;
			default:
				part = ctrlInst.all.namedItem(partName);
				break;
		}
		return part;
	}

	function tabgroup_handleKeyDown(ctrlInst)
	{
		key = event.keyCode;
		if(key==KEYCODE_TAB && (event.ctrlKey || event.ctrlLeft))
		{
			event.cancelBubble=true;
			event.returnValue=false;
			if(event.shiftKey || event.shiftLeft)
				sendEvent("previoustab",ctrlInst.id, true)
			else
				sendEvent("nexttab",ctrlInst.id, true)
			return;
		}
	}

	function tabgroup_onpropertychange(ctrlInst)
	{
		if(event.propertyName!="selected" || undef(ctrlInst.selected))
			return;
	
		currentTab = getPart(ctrlInst, ctrlInst.selected);
		if(undef(currentTab))
		{
			return;
		}
		ctrlInst.tabname = currentTab.tabname;
		tabCell = getPart(ctrlInst, "tabcell");
		tabs = tabCell.childNodes;
		for(tab=0;tab<tabs.length;tab++)
		{
			el = tabs(tab);
			
			if(!el || el.controltype!="tab" || el.tagName!="TABLE")
				continue;
			
			ctrlInst.tabstyle=el.tabstyle;
			if(el.id==currentTab.id)
			{
				el.selected="true";
				continue;
			}
			el.selected="false";
		}
	}

/**************** END Standard functions for tabgroup**********************/

/**************** BEGIN Standard functions for table**********************/

	function table_ondocumentready(ctrlInst)
	{
		var specifiedwidth = ctrlInst.getAttribute("specifiedwidth");
		if(undef(specifiedwidth))
		{
			table_setWidth(ctrlInst, 100);
		}	
	}
	
	function table_onclick(ctrlInst)
	{	
		table_handleEvents(ctrlInst, event.srcElement);
	}
	
	function table_onkeypress(ctrlInst)
	{
		var keyCode = event.keyCode;
		var sourceElement = event.srcElement;
		switch(keyCode)
		{
			case KEYCODE_ENTER:
				var query = sourceElement.getAttribute("query");
				if(query=="true")
				{
					document.body.focus();
					//if(sourceElement.changed)
					//{
						//shared_handleChange(sourceElement);
					//}
					event.cancelBubble=true;
					event.returnValue=false;
					showWait();
					lockWait();
					sendEvent("filterrows", ctrlInst.id);
				}
				else
				{
					if(table_handleEvents(ctrlInst, event.srcElement)==false)
					{
						if(!undef(ctrlInst.defaultbutton))
						{
							defid = ctrlInst.defaultbutton;
							if(defid && defid==library_getControlByType(event.srcElement, "table").id)
								break;
							itemtoclick = document.getElementById(defid);
							itemtoclick.focus();
							itemtoclick.setActive();
							sendFrontEndEvent("clickDefaultButton", ctrlInst.id);
							event.cancelBubble=true;
						}
					}
				}
				break;
			case KEYCODE_SPACEBAR:
				var ctrlBehavior = sourceElement.getAttribute("behaveascontrol");
				
				if(ctrlBehavior=="checkbox")
				{
					table_handleEvents(ctrlInst, event.srcElement);
				}	
				break;
			default:
		}
	}

	function table_onkeyup(ctrlInst)
	{
		if(event.ctrlKey)
		{
			var keyCode = event.keyCode;
			var srcElement = event.srcElement;
			var mxpart = srcElement.getAttribute("mxpart"); 
			switch(keyCode)
			{
				case KEYCODE_UP_ARROW: 
					if(mxpart=="textbox"){ shared_handleChange(srcElement); }
					sendEvent("prevrow", ctrlInst.id);
					break;			
				case KEYCODE_DOWN_ARROW:
					if(mxpart=="textbox"){ shared_handleChange(srcElement); }
					sendEvent("nextrow", ctrlInst.id);
					break;
				case KEYCODE_RIGHT_ARROW:
					if(mxpart=="textbox"){ shared_handleChange(srcElement); }
					sendEvent("scrollnext", ctrlInst.id);
					break;
				case KEYCODE_LEFT_ARROW:
					if(mxpart=="textbox"){ shared_handleChange(srcElement); }
					sendEvent("scrollprev", ctrlInst.id);
					break;	
				case KEYCODE_Z:
					if(mxpart=="textbox"){ shared_handleChange(srcElement); }
					sendEvent("togglefilterstate", ctrlInst.id);
					break;	
				default: break;
			}
		}
	}
	
	function table_handleEvents(ctrlInst, eventElement)
	{
		var handled = false;
		var eventControl = getControl(eventElement);
		var mxvalue = eventElement.getAttribute("mxvalue");
		var mxevents = library_getMxEvents(ctrlInst, eventElement);
		var targetid = eventElement.getAttribute("targetid");
		var ctype=eventControl.controltype;
		if(undef(targetid))
			targetid = ctrlInst.id;
		var subselecton = (ctrlInst.getAttribute("subselecton")==true);
		for(var i=0; i<mxevents.length; i++)
		{
			//For all events if the current row has changed send "highlightrow" event
			var mxevent = mxevents[i];
			if(mxevent=="selectvalue" && eventControl.getAttribute("filtercol")=="true")
			{
				continue;
			}
			var rowIndex = table_getDataRowIndexByElement(ctrlInst, eventElement);
			var currentRowIndex = table_getCurrentDataRowIndex(ctrlInst);
			if(!undef(mxevent))
			{
				if(!subselecton && mxevent!="toggleselectrow" && mxevent!="highlightrow")
				{
					handled = true;
					var eventColumnId = table_getColumnId(event.srcElement, eventElement);
						sendEvent("highlightrow", targetid, eventElement.id, "", rowIndex);
					if(mxevent!="highlightrow" && ctype.indexOf("table")>-1)
					{
						sendEvent(mxevent, targetid, mxvalue, "", rowIndex);
					}
				}
				else
				{
					if(mxevent=="highlightrow")
					{
						if(rowIndex>=0 && rowIndex!=currentRowIndex)
							sendEvent(mxevent, targetid, eventElement.id, "", rowIndex);
					}
					else
						sendEvent(mxevent, targetid, mxvalue, "", rowIndex);
				}
			}
			if(subselecton)
			{
				if(clientEventQueue.length>0)
					clientEventQueue = new Array();
			}
		}
		return handled;
	}
	
	function table_getColumnId(startElement, endElement)
	{
		var tablecolid = startElement.getAttribute("tablecolid");
		while(undef(tablecolid))
		{
			if(startElement==endElement)
			{
				break;
			}
			startElement = startElement.parentElement;
			tablecolid = startElement.getAttribute("tablecolid");
		}
		if(undef(tablecolid)){tablecolId = "";}
		return tablecolid;
	}
	
	function table_fnFireEvent(ctrlInst, mxevent, value)
	{
		if(undef(value))
		{
			value = "";
		}
		sendEvent(mxevent, ctrlInst.id, value);
	}
		
	function table_fnFireEventOnElement(ctrlInst, eventElement)
	{
		if(!undef(eventElement))
		{
			table_handleEvents(ctrlInst, eventElement);
		}
	}

	function table_swapTitles(ctrlInst, id)
	{
		var titleElement = ctrlInst.document.getElementById(id);
		if (undef(titleElement))
			return;
		var altTitle = null;
		altTitle = titleElement.title;
		titleElement.title = titleElement.alttitle;
		titleElement.alttitle = altTitle;
	}
	
	function table_fnHandleTableExpanded(ctrlInst)
	{
		var success = true;
		success = library_showElement(ctrlInst, ctrlInst.id  + TABLE_CONTAINER_SUFFIX);
		if(success)
		{
			swapImages(ctrlInst.document.getElementById(ctrlInst.id  + TABLE_ICON_COLLAPSE_SUFFIX));
		}
		return success;
	}
	
	function table_fnHandleTableCollapsed(ctrlInst)
	{
		var success = true;
		success = library_hideElement(ctrlInst, ctrlInst.id  + TABLE_CONTAINER_SUFFIX);
		if(success)
		{
			swapImages(ctrlInst.document.getElementById(ctrlInst.id  + TABLE_ICON_COLLAPSE_SUFFIX));
		}
		return success;
	}
	
	function table_fnHandleAtFirstPage(ctrlInst)
	{
		var success = true;
		table_disablePrevPage(ctrlInst);
		return success;
	}
	
	function table_fnHandleAtLastPage(ctrlInst)
	{
		var success = true;
		table_disableNextPage(ctrlInst);
		return success;
	}
	
	function table_fnHandleNotAtFirstPage(ctrlInst)
	{
		var success = true;
		table_enablePrevPage(ctrlInst);
		return success;
	}
	
	function table_fnHandleNotAtLastPage(ctrlInst)
	{
		var success = true;
		table_enableNextPage(ctrlInst);
		return success;
	}
	
	function table_fnHandleAtFirstRow(ctrlInst)
	{
		var success = true;
		table_disablePrevRow(ctrlInst);
		return success;
	}
	
	function table_fnHandleNotAtFirstRow(ctrlInst)
	{
		var success = true;
		table_enablePrevRow(ctrlInst);
		return success;
	}
	
	function table_fnHandlerAtLastRow(ctrlInst)
	{
		var success = true;
		table_disableNextRow(ctrlInst);
		return success;
	}

	function table_fnHandleNotAtLastRow(ctrlInst)
	{
		var success = true;
		table_enableNextRow(ctrlInst);
		return success;
	}

	function table_fnHandleFilterExpanded(ctrlInst)
	{
		var success = true;
		var filterElement = ctrlInst.document.getElementById(ctrlInst.id +  TABLE_FILTER_ACTIONS_SUFFIX);
		if (undef(filterElement) || (filterElement.style.visibility=="visible"))
			return;
		success = library_showElement(ctrlInst, ctrlInst.id  + TABLE_FILTER_ROW_SUFFIX);
		if(success)
		{
			//filterElement.style.visibility = "visible";
			swapImages(ctrlInst.document.getElementById(ctrlInst.id  + TABLE_FILTER_ICON));
			table_swapTitles(ctrlInst, ctrlInst.id + TABLE_FILTER_TOOLTIP);
		}
		return success;
	}
	
	function table_fnHandleFilterCollpased(ctrlInst)
	{
		var success = true;
		var filterElement = ctrlInst.document.getElementById(ctrlInst.id  + TABLE_FILTER_ACTIONS_SUFFIX);
		if (undef(filterElement) || (filterElement.style.visibility=="hidden"))
			return;
		success = library_hideElement(ctrlInst, ctrlInst.id  + TABLE_FILTER_ROW_SUFFIX);
		if(success)
		{
			//filterElement.style.visibility = "hidden";		
			swapImages(ctrlInst.document.getElementById(ctrlInst.id  + TABLE_FILTER_ICON));
			table_swapTitles(ctrlInst, ctrlInst.id + TABLE_FILTER_TOOLTIP);
		}
		return success;
	}

	function table_fnHandleDetailsExpanded(ctrlInst, rowIndex)
	{
		var success = true;
		if(rowIndex>=0)
		{
			var didExpand = table_setRowDetailsState(ctrlInst, rowIndex, true);
			success = library_showElement(ctrlInst, ctrlInst.id + TABLE_ROW_DETAILS_SUFFIX);
			var tabledetails = ctrlInst.document.getElementById(ctrlInst.id + TABLE_ROW_DETAILS_SUFFIX);
			var hasdetails = (tabledetails.children.length==0)?false:true;
		}
		return success;
	}
	
	function table_fnHandleDetailsCollapsed(ctrlInst, rowIndex)
	{
		var success = library_hideElement(ctrlInst, ctrlInst.id + TABLE_ROW_DETAILS_SUFFIX);
		if(rowIndex>=0)
		{
			table_setRowDetailsState(ctrlInst, rowIndex, false);
		}
		return success;
	}
	
	function table_fnHnadleRowSelected(ctrlInst, rowIndex)
	{
		var dataRow = table_getDataRowBasedOnIndex(ctrlInst, rowIndex);
		if(!undef(dataRow))
		{
			for(var i=0; i<dataRow.children.length;i++)
			{
				var col = dataRow.children[i];
				var selectImageContainer = ctrlInst.document.getElementById(col.id + TABLECOL_SELECT_ROW_SUFFIX);
				if (!undef(selectImageContainer))
				{
					if (selectImageContainer.selected=="false")
					{
						swapImages(selectImageContainer);
						selectImageContainer.selected="true";
					}
				}
			}
		}
	}
	
	function table_fnHnadleRowUnSelected(ctrlInst, rowIndex)
	{
		var dataRow = table_getDataRowBasedOnIndex(ctrlInst, rowIndex);
		if(!undef(dataRow))
		{
			for(var i=0; i<dataRow.children.length;i++)
			{
				var col = dataRow.children[i];
				var selectImageContainer = ctrlInst.document.getElementById(col.id + TABLECOL_SELECT_ROW_SUFFIX);
				if (!undef(selectImageContainer))
				{
					if (selectImageContainer.selected=="true")
					{
						swapImages(selectImageContainer);
						selectImageContainer.selected="false";
					}
				}
			}
		}	
	}
	
	function table_fnHnadleRowChanged(ctrlInst, rowIndex)
	{
		rowIndex = parseInt(rowIndex);
		if(rowIndex>=0)
		{
			var rowIndexCurrent = table_getCurrentDataRowIndex(ctrlInst);
			var newRow = table_getDataRowBasedOnIndex(ctrlInst, rowIndex);
			var currentRow = table_getDataRowBasedOnIndex(ctrlInst, rowIndexCurrent);
			if(rowIndexCurrent!=rowIndex)
			{
				var strClassName = " mark_for_delete";
				var currentRowMarkedForDelete = (currentRow.className.indexOf(strClassName)==-1)?false:true;
				var rowMarkedForDelete = (newRow.className.indexOf(strClassName)==-1)?false:true;

				if(!undef(currentRow))
				{
					var newClassName = currentRow.className;
					if(newClassName.indexOf("table_row_selected")!=-1){newClassName = newClassName.replace("table_row_selected", "table_row");}
					else{newClassName += "table_row";}
					currentRow.className = newClassName;
				}
				if(!undef(newRow))
				{
					var newClassName = newRow.className;
					if(newClassName.indexOf("table_row")!=-1){newClassName = newClassName.replace("table_row", "table_row_selected");}
					else{newClassName += "table_row_selected";}
					newRow.className = newClassName;
				}
				currentRow.removeAttribute("currentrow");
				newRow.setAttribute("currentrow", "true");
			}
			table_setRowDetailsState(ctrlInst, rowIndexCurrent, false);
			table_checkAndUpdateRadioButtonSelection(ctrlInst, rowIndex);
		}
	}

	function table_fnHandleColLabelChanged(ctrlInst, colid, newLabel)
	{
		var headerRow = table_getHeaderRow(ctrlInst);
		var colIndex = table_getColIndexFromId(ctrlInst, colid);
		if(colIndex!=-1)
		{
			var headerCol = headerRow.children(colIndex);
			if(!undef(headerCol))
			{
				var elements = headerCol.all.tags("SPAN");
				for(var i=0; i<elements.length; i++)
				{
					var mxpart = elements[i].getAttribute("mxpart");
					if(!undef(mxpart))
					{
						if(mxpart=="header_col_label")
						{	
							elements[i].innerHTML = newLabel;
							break;
						}
					}
				}
			}
		}
	}
	
	function table_fnHandleColDataChanged(ctrlInst, rowIndex, colid, value)
	{
		var dataRow = table_getDataRowBasedOnIndex(ctrlInst, rowIndex);
		var colIndex = table_getColIndexFromId(ctrlInst, colid);
		if(!undef(dataRow) && colIndex!=-1)
		{
			var col = dataRow.children(colIndex); 
			if(!undef(col))
			{
				var elements = col.all;
				for(var i=0; i<elements.length; i++)
				{
					if(elements[i].tagName=="SPAN") 
					{
						var mxpart = elements[i].getAttribute("mxpart");
						if(!undef(mxpart))
						{
							if(mxpart=="col_data_input")
							{	
								var childControl = null;
								for(var k=0; k<elements[i].children.length; k++)
								{
									if(elements[i].children[k].getAttribute("control")=="true")
									{
										childControl = elements[i].children[k];
										break;
									}
								}
								if(!undef(childControl))
								{
									shared_updateValue(childControl, value);
									break;
								}
							}	
							if(mxpart=="col_data")
							{
								//There is no ctrlInst, readonly data
								elements[i].innerHTML = value;
							}
						}
					}
				}
			}
		}	
	}
	
	function table_fnHandleRowsFiltered(ctrlInst)
	{
		//Check and Update the clear-filter icon state
		var clearFilterOn = ctrlInst.document.getElementById(ctrlInst.id + TABLE_CLEARFILTER_SUFFIX + "_on");
		var clearFilterOff = ctrlInst.document.getElementById(ctrlInst.id + TABLE_CLEARFILTER_SUFFIX + "_off");
		if(!undef(clearFilterOn) && !undef(clearFilterOff))
		{
			clearFilterOn.style.display = "";
			clearFilterOff.style.display = "none";
		}
	}
		
	function table_fnHandleRowsUnFiltered(ctrlInst)
	{
		//Check and Update the clear-filter icon state
		var clearFilterOn = ctrlInst.document.getElementById(ctrlInst.id + TABLE_CLEARFILTER_SUFFIX + "_on");
		var clearFilterOff = ctrlInst.document.getElementById(ctrlInst.id + TABLE_CLEARFILTER_SUFFIX + "_off");
		if(!undef(clearFilterOn) && !undef(clearFilterOff))
		{
			clearFilterOn.style.display = "none";
			clearFilterOff.style.display = "";
		}
	}

	function table_fnHandleRefreshFilter(ctrlInst)
	{
		//Update the filter field with current values		
		var filterRow = table_getFilterRow(ctrlInst);
		if(!undef(filterRow ))
		{
			for(var i=0; i<filterRow.children.length; i++)
			{
				var elements = filterRow.children[i].all.tags("SPAN");
				for(var j=0; j<elements.length;j++)
				{
					var mxpart = elements[j].getAttribute("mxpart");
					if(!undef(mxpart))
					{
						if(mxpart=="col_filter_input")
						{	var childControl = null;
							for(var k=0; k<elements[j].children.length; k++)
							{
								if(!undef(elements[j].children[k]))
								{
									if(elements[j].children[k].getAttribute("control")=="true")
									{
										childControl = elements[j].children[k];
										break;
									}
								}	
							}
							if(!undef(childControl))
							{
								shared_updateValue(childControl, "");
								break;
							}
						}	
					}
				}	
			}
		}
	}
	
	function table_fnHandleSelectAllRows(ctrlInst)
	{
		table_toggleSelectAllRows(ctrlInst, true);
		table_toggleSelectAllHeaderIcon(ctrlInst, true);
		table_toggleButtonLabelWithEvent(ctrlInst, "toggleselectallrows");
	}
	
	function table_fnHandleDeSelectAllRows(ctrlInst)
	{
		table_toggleSelectAllRows(ctrlInst, false);
		table_toggleSelectAllHeaderIcon(ctrlInst, false);
		table_toggleButtonLabelWithEvent(ctrlInst, "toggleselectallrows");
	}

	function table_fnHandleToggleInputAndReadOnlyContents(ctrlInst, rowIndex)
	{
		var success = true;
		if(!undef(rowIndex) && rowIndex>=0)
		{
			rowIndex = parseInt(rowIndex);
			var rowIndexCurrent = table_getCurrentDataRowIndex(ctrlInst);
			var currentRow = table_getDataRowBasedOnIndex(ctrlInst, rowIndexCurrent);
			var dataRow = table_getDataRowBasedOnIndex(ctrlInst, rowIndex);
		
			var strClassName = " mark_for_delete";
			if(!undef(currentRow))
			{
				success = table_disableRowEdit(ctrlInst,currentRow);
				var currentRowClassName = currentRow.className;
				if(currentRowClassName.indexOf(strClassName)!=-1)
				{
					table_markChildrenForDelete(ctrlInst,currentRow, strClassName);
				}
			}
			
			if(!undef(dataRow))
			{
				success = table_enableRowEdit(ctrlInst,dataRow);
				var rowClassname = dataRow.className;
				if(rowClassname.indexOf(strClassName)!=-1)
				{
					table_markChildrenForDelete(ctrlInst,dataRow, strClassName);
				}
			}
		}
		return success;
	}

	function table_fnHandleRefreshRows(ctrlInst, newTableData)
	{
		unLockWait();
		if(!undef(newTableData))
		{
			var tableContents = ctrlInst.document.getElementById(ctrlInst.id + TABLE_CONTENT_SUFFIX);
			if(!undef(tableContents))
			{
				tableContents.removeChild(tableContents.firstChild);
				tableContents.innerHTML = newTableData.innerHTML;
			}
			var tableNoRow = ctrlInst.document.getElementById(ctrlInst.id + TABLE_NOROW_MSG_SUFFIX);
			if(!undef(tableNoRow))
			{
				tableNoRow.style.display="none";
			}
		}
	}
	
	function table_fnHandleRefreshNoRows(ctrlInst, norowmessage)
	{
		table_removeAllDataRows(ctrlInst);
		var tableNoRow = ctrlInst.document.getElementById(ctrlInst.id + TABLE_NOROW_MSG_SUFFIX);
		if(!undef(norowmessage))
		{
			tableNoRow.innerHTML = "";
			tableNoRow.innerHTML = norowmessage;
		}	
		tableNoRow.style.display="";
	}

	function table_fnHandleResizeColumn(ctrlInst, columnId, deltaWidth)
	{
		var percentWidth = (parseInt(deltaWidth)/(window.screen.width)) * 100;
		var colIndex = table_getColIndexFromId(ctrlInst, columnId);
		if(colIndex!=-1)
		{
			table_resizeHeaderRow(ctrlInst, colIndex, deltaWidth, percentWidth);
			table_resizeFilterRow(ctrlInst, colIndex, deltaWidth, percentWidth);
			table_resizeDataRows(ctrlInst, colIndex, deltaWidth, percentWidth);
			//table_resizeTemplateRow(ctrlInst, colIndex, deltaWidth, percentWidth);
		}	
	}

	function table_fnHandleReorderColumn(ctrlInst, srcElementId, toElementId)
	{
		var bSuccess = true;
		var srcColIndex = table_getColIndexFromId(ctrlInst, srcElementId);
		var toColIndex = table_getColIndexFromId(ctrlInst, toElementId);
		table_reorderColumnForRow(ctrlInst, table_getHeaderRow(ctrlInst), srcColIndex, toColIndex);
		table_reorderColumnForRow(ctrlInst, table_getFilterRow(ctrlInst), srcColIndex, toColIndex);
		var dataRows = table_getDataRows(ctrlInst);
		for(var i=0; i<dataRows.length; i++)
		{
			table_reorderColumnForRow(ctrlInst,dataRows[i], srcColIndex, toColIndex);
		}
		return bSuccess;
	}

	function table_fnHnadleMarkRowForDelete(ctrlInst, rowIndex)
	{
		var deleteClass = " mark_for_delete";
		var dataRow = table_getDataRowBasedOnIndex(ctrlInst, rowIndex);
		if(!undef(dataRow))
		{
			if (dataRow.className.indexOf("mark_for_delete") == -1)
			{
				dataRow.className += deleteClass;
				var img = getPart(dataRow, "delete_image");
				swapImages(img);
				table_markChildrenForDelete(ctrlInst,dataRow, deleteClass);
			}
		}	
	}
	
	function table_markChildrenForDelete(ctrlInst,dataRow, deleteClass)
	{
		for(var i=0; i<dataRow.children.length;i++)
		{
			var col = dataRow.children(i);
			var input = table_getColumnInput(ctrlInst,col);
			if(!undef(input))
			{
				input.className += deleteClass;
			}
		}
	}
	
	function table_fnHnadleUnMarkRowForDelete(ctrlInst, rowIndex)
	{
		var deleteClass = " mark_for_delete";
		var dataRow = table_getDataRowBasedOnIndex(ctrlInst, rowIndex);
		if(!undef(dataRow))
		{
			var strClassName = dataRow.className;
			if (strClassName.indexOf("mark_for_delete") > -1)
			{
				strClassName = strClassName.replace(deleteClass, "");
				dataRow.className = strClassName;
				var img = getPart(dataRow, "delete_image");
				swapImages(img);
				table_unmarkChildrenForDelete(ctrlInst,dataRow, deleteClass);
			}
		}	
	}
	
	function table_unmarkChildrenForDelete(ctrlInst,dataRow, deleteClass)
	{	
		for(var i=0; i<dataRow.children.length;i++)
		{
			var col = dataRow.children(i);
			var input = table_getColumnInput(ctrlInst,col);
			if(!undef(input))
			{
				var strClassName = input.className;
				strClassName = strClassName.replace(deleteClass, "");
				input.className = strClassName;
			}
		}
	}

	function table_fnHandleSortColumn(ctrlInst, colid, sortFlags)
	{
		var sortIconContainer = ctrlInst.document.getElementById(colid + "_sort_icons_container");
		if(!undef(sortIconContainer))
		{
			var sortIcons = sortIconContainer.all.tags("IMG");
			if(sortIcons.length>1)
			{
				sortIcons[0].style.display ="none";
				sortIcons[1].style.display ="none";
				switch(sortFlags)
				{
					case TABLECOL_SORTED_ASC: sortIcons[0].style.display =""; break;
					case TABLECOL_SORTED_DESC: sortIcons[1].style.display =""; break;
				}
			}
		}
	}	
	
	function table_fnHandleRefreshHeaderLabel(ctrlInst, strLabel)
	{
		var labelElement = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_LABEL_SUFFIX);
		if(!undef(labelElement))
		{
			labelElement.innerHTML = strLabel;
		}
	}
	
	function table_fnHandleToggleSubselect(ctrlInst, subselecton)
	{
		ctrlInst.setAttribute("subselecton", subselecton);
		//Toggle header group (filter and other icons)
		var headerGroup = ctrlInst.document.getElementById(ctrlInst.id + "_filter_group");
		if(!undef(headerGroup))
		{
			headerGroup.style.display = (subselecton)?"none":"";
		}
		var subselectimage = ctrlInst.document.getElementById(ctrlInst.id + "_subselectA" + "_icon");
		if(!undef(subselectimage))
		{	
			var imgSrc = subselectimage.src;
			if(subselecton && imgSrc.indexOf("cb_checked.gif")==-1)
				swapImages(subselectimage);
			if(!subselecton && imgSrc.indexOf("cb_unchecked.gif")==-1)	
				swapImages(subselectimage);
		}
	}
		
	function table_reorderColumnForRow(ctrlInst,row, srcColIndex, toColIndex)
	{
		var bSuccess = true;
		if(!undef(row) && !undef(srcColIndex) && !undef(toColIndex))
		{
			var srcElement = row.cells.item(srcColIndex);
			var targetControl = row.cells.item(toColIndex);
			targetControl.insertAdjacentElement("beforeBegin", srcElement);
		}
		return bSuccess;
	}

	function table_copyAttributes(ctrlInst,srcElement, destElement)
	{
		destElement.id = srcElement.id;
		destElement.className = srcElement.className;
		destElement.noWrap = srcElement.noWrap;
		destElement.setAttribute("nowrap", srcElement.getAttribute("nowrap"));
		destElement.setAttribute("width", srcElement.getAttribute("width"));
		destElement.setAttribute("height", srcElement.getAttribute("height"));
		destElement.setAttribute("style", srcElement.getAttribute("style"));
		destElement.setAttribute("mxpart", srcElement.getAttribute("mxpart"));
		destElement.setAttribute("mxevent", srcElement.getAttribute("mxevent"));
		destElement.setAttribute("tableid", srcElement.getAttribute("tableid"));
		destElement.setAttribute("tablecolid", srcElement.getAttribute("tablecolid"));
		destElement.innerHTML = srcElement.innerHTML;
	}

	function table_getColIndexFromId(ctrlInst, columnId)
	{
		var colIndex = -1;
		var headerRow = table_getHeaderRow(ctrlInst);
		if(!undef(headerRow))
		{
			for(var i=0; i<headerRow.children.length;i++)
			{
				if(headerRow.children[i].id==columnId)
				{
					colIndex = i;
					break;
				}
			}
		}
		return colIndex;
	}

	function table_getColIndexFromAttributeValue(ctrlInst, attribute, value)
	{
		var colIndex = -1;
		var headerRow = table_getHeaderRow(ctrlInst);
		if(!undef(headerRow))
		{
			for(var i=0; i<headerRow.cells.length;i++)
			{
				var col = headerRow.cells[i];
				var attrValue = col.getAttribute(attribute);
				if(attrValue==value)
				{
					colIndex = i;
					break;
				}
			}
		}
		return colIndex;
	}

	function table_getColumnIndexFromId(ctrlInst,dataRow, columnId)
	{
		var colIndex = -1;
		if(!undef(dataRow))
		{
			for(var i=0; i<dataRow.children.length;i++)
			{
				if(dataRow.children[i].id==columnId)
				{
					colIndex = i;
					break;
				}
			}
		}
		return colIndex;
	}
	
	function table_resizeHeaderRow(ctrlInst, colIndex, deltaWidth, percentWidth)
	{
		var headerRow = table_getHeaderRow(ctrlInst);
		if(!undef(headerRow))
		{
			headerRow.children(colIndex).style.pixelWidth += deltaWidth;
			headerRow.lastChild.style.pixelWidth += -(deltaWidth);
		}
	}
	
	function table_resizeFilterRow(ctrlInst, colIndex, deltaWidth, percentWidth)
	{
		var filterRow = table_getFilterRow(ctrlInst);
		if(!undef(filterRow))
		{	 
			filterRow.children(colIndex).style.pixelWidth += deltaWidth;	
			filterRow.lastChild.style.pixelWidth += -(deltaWidth);
		}
	}
	
	function table_resizeDataRows(ctrlInst, colIndex, deltaWidth, percentWidth)
	{
		var dataRows = table_getDataRows(ctrlInst);
		for(var i=0; i<dataRows.length;i++)
		{
			var dataRow = dataRows[i];
			dataRow.children(colIndex).style.pixelWidth += deltaWidth;
			dataRow.lastChild.style.pixelWidth += -(deltaWidth);
		}
	}

	function table_resizeTemplateRow(ctrlInst, colIndex, deltaWidth, percentWidth)
	{
		var templateRow = table_getTemplateRow(ctrlInst);
		if(!undef(templateRow))
		{
			templateRow.children(colIndex).style.pixelWidth += deltaWidth;
			templateRow.lastChild.style.pixelWidth += -(deltaWidth);
		}
	}
	
	function table_getDataRows(ctrlInst)
	{
		var dataRows = new Array();
		var tableContent = ctrlInst.document.getElementById(ctrlInst.id + TABLE_CONTENT_TABLE);
		if(!undef(tableContent))
		{
			for(var i=0; i<tableContent.firstChild.children.length; i++)
			{
				var mxpart = tableContent.firstChild.children(i).getAttribute("mxpart");
				var rowindex = tableContent.firstChild.children(i).getAttribute("rowindex");
				if(mxpart=="datarow" && !undef(rowindex))
				{	  
					dataRows[dataRows.length] =  tableContent.firstChild.children(i);
				}
			}
		}
		return dataRows;
	}
	
	function table_getDataRowBasedOnIndex(ctrlInst, index)
	{
		var dataRow = null;
		var tableContent = ctrlInst.document.getElementById(ctrlInst.id + TABLE_CONTENT_TABLE);
		for(var i=0; i<tableContent.firstChild.children.length; i++)
		{
			var mxpart = tableContent.firstChild.children(i).getAttribute("mxpart");
			var rowIndex = tableContent.firstChild.children(i).getAttribute("rowindex");
			if( (mxpart=="datarow") && (rowIndex==index) )
			{	  
				dataRow = tableContent.firstChild.children(i);
				break;
			}
		}
		return dataRow;
	}
	
	function table_getColumnInput(ctrlInst,col)
	{
		var inputCtrl = null;
		var inputColl = col.all.tags("INPUT");
		if(inputColl.length>0)
		{
			for(var i=0; i<inputColl.length;i++)
			{
				var mxpart = inputColl(i).getAttribute("mxpart"); 
				if(mxpart=="textbox")
				{
					inputCtrl = inputColl(i);
					break;
				}
			}
		}
		return inputCtrl;
	}
	
	function table_getCellFromRowAndColIndex(ctrlInst,row, colIndex)
	{
		var col = null;
		if(!undef(row) && !undef(row.children(colIndex)))
		{
			col = row.children(colIndex);		
		}
		return col;
	}

	function table_getHeaderRow(ctrlInst)
	{
		var headerRow = null;
		headerRow = ctrlInst.document.getElementById(ctrlInst.id + TABLE_CONTENT_HEADER_SUFFIX);
		return headerRow;
	}
	
	function table_getFilterRow(ctrlInst)
	{
		var filterRow = null;
		filterRow = ctrlInst.document.getElementById(ctrlInst.id + TABLE_FILTER_ROW_SUFFIX);
		return filterRow;
	}

	function table_getTemplateRow(ctrlInst)
	{
		var templateRow = null;
		templateRow = ctrlInst.document.getElementById(ctrlInst.id + TABLE_FILTER_ROW_SUFFIX);
		return templateRow;
	}
	
	function table_getButtonsContainer(ctrlInst)
	{
		var buttonContainer = ctrlInst.document.getElementById(ctrlInst.id + TABLEBUTTONS_SUFFIX);
		return buttonContainer;
	}
	
	function table_removeAllDataRows(ctrlInst)
	{
		var dataRowsContainer = ctrlInst.document.getElementById(ctrlInst.id + TABLE_CONTENT_TABLE)  
		for(var i=0;i<dataRowsContainer.firstChild.children.length; i++)
		{
			var mxpart = dataRowsContainer.firstChild.children[i].getAttribute("mxpart"); 
			if(mxpart=="datarow")
			{
				dataRowsContainer.firstChild.removeChild(dataRowsContainer.firstChild.children[i]);
				i--;
			}
		}
	}
	
	function table_toggleButtonLabelWithEvent(ctrlInst, mxevent)
	{	
		//Toggle button label
		var buttonContainer = table_getButtonsContainer(ctrlInst);
		if(!undef(buttonContainer))
		{
			for(var i=0; i<buttonContainer.children.length; i++)
			{
				var button = buttonContainer.children(i);
				if(button.getAttribute("mxevent")==mxevent)
				{
					var label = ctrlInst.document.getElementById(button.id + TABLEBUTTON_LABEL_SUFFIX);
					if(!undef(label))
					{
						table_toggleLabel(ctrlInst,label);
						break;
					}
				}
			}
		}
	}
	
	function table_toggleSelectAllRows(ctrlInst, selectAll)
	{
		var dataRows = table_getDataRows(ctrlInst);
		for(var i=0; i<dataRows.length; i++)
		{
			var dataRow = dataRows[i];
			var dataCells = dataRow.children;
			for(j=0; j<dataCells.length; j++)
			{	
				if(dataCells[j].getAttribute("mxevent")=="toggleselectrow")
				{
					var selectImageContainer = ctrlInst.document.getElementById(dataCells[j].id + TABLECOL_SELECT_ROW_SUFFIX);
					if(!undef(selectImageContainer))
					{
						if (selectAll)
						{
							if (selectImageContainer.selected=="false")
							{
								swapImages(selectImageContainer);
								selectImageContainer.selected="true";
							}
						} else
						{
							if (selectImageContainer.selected=="true")
							{
								swapImages(selectImageContainer);
								selectImageContainer.selected="false";
							}
						}
					}	
				}
			}	
		}
	}
	
	
	function table_toggleSelectAllHeaderIcon(ctrlInst, selectAll)
	{
		var selectImageContainer = ctrlInst.document.getElementById(ctrlInst.id + TABLECOL_SELECTALL_ICON_SUFFIX);
		if(!undef(selectImageContainer))
		{
			if (selectAll)
			{
				if (selectImageContainer.selected=="false")
				{
					swapImages(selectImageContainer);
					selectImageContainer.selected="true";
				}
			} else
			{
				if (selectImageContainer.selected=="true")
				{
					swapImages(selectImageContainer);
					selectImageContainer.selected="false";
				}
			}
		}
	}
		
	function table_getDataRowIndexByElement(ctrlInst, eventElement)
	{
		var row = null;
		var parent = eventElement;
		var dataRowIndex = -1;
		var tableContainer = ctrlInst.document.getElementById(ctrlInst.id + TABLE_CONTENT_TABLE);
		if(!undef(parent))
		{
			while(!undef(parent) && parent!=tableContainer)
			{ 
				if(parent.getAttribute("mxpart")=="datarow")
				{
					row = parent;
					break;
				}
				parent = parent.parentElement;
			}
			
			if(!undef(row))
			{
				var dataRows = table_getDataRows(ctrlInst);
				for(var i=0; i<dataRows.length; i++)
				{
					var dataRow = dataRows[i];
					if(dataRow.getAttribute("mxpart")=="datarow")
					{	
						if(row==dataRow)
						{
							dataRowIndex = parseInt(dataRow.getAttribute("rowindex"));
							break;
						}
					}	
				}
			}	
		}	
		return dataRowIndex;
	}
	
	function table_getCurrentDataRowIndex(ctrlInst)
	{
		var rowIndex = 0;
		var dataRows = table_getDataRows(ctrlInst);
		for(i=0; i<dataRows.length; i++)
		{
			var dataRow = dataRows[i]; 
			if(dataRow.getAttribute("mxpart")=="datarow")
			{
				var currentRow = dataRow.getAttribute("currentrow"); 
				if(currentRow=="true")
				{
					rowIndex = parseInt(dataRow.getAttribute("rowindex"));
					break;
				}
			}	
		}
		return rowIndex;
	}
	
	function table_disableRowEdit(ctrlInst,dataRow)
	{
		var success = true;
		var cols = dataRow.children;
		for(var i=0; i<cols.length; i++)
		{
			var elements = cols[i].all.tags("SPAN");
			for(j=0;j<elements.length;j++)
			{
				var mxpart = elements[j].getAttribute("mxpart");
				if(!undef(mxpart) && ( mxpart=="col_data_input"))
				{
					var childControl = null;
					for(var k=0; k<elements[j].children.length; k++)
					{
						if(elements[j].children[k].getAttribute("control")=="true")
						{
							childControl = elements[j].children[k];
							break;
						}
					}
					if(!undef(childControl))
					{
						shared_onselectedtablerow(childControl, false);
					}
				}	
			}
		}
		return success;	
	}	
	
	function table_enableRowEdit(ctrlInst,dataRow)
	{
		var success = true;
		var cols = dataRow.children;
		for(var i=0; i<cols.length; i++)
		{
			var inputElement  = null;
			var elements = cols[i].all.tags("SPAN");
			for(j=0;j<elements.length;j++)
			{
				var mxpart = elements[j].getAttribute("mxpart");
				if(!undef(mxpart) && ( mxpart=="col_data_input"))
				{
					if(mxpart=="col_data_input")
					{
						var childControl = null;
						for(var k=0; k<elements[j].children.length; k++)
						{
							if(elements[j].children[k].getAttribute("control")=="true")
							{
								childControl = elements[j].children[k];
								break;
							}
						}
						if(!undef(childControl))
						{
							shared_onselectedtablerow(childControl, true);
						}
					}
				}
			}
		}
		return success;	
	}
	
	function table_enableNextRow(ctrlInst)
	{
		var nextRowOn = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_NEXTROW_ON_SUFFIX);
		var nextRowOff = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_NEXTROW_OFF_SUFFIX);
		if(!undef(nextRowOn) && !undef(nextRowOff))
		{
			nextRowOn.style.display="";
			nextRowOff.style.display="none";
		}	
	}
	
	function table_disableNextRow(ctrlInst)
	{
		var nextRowOn = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_NEXTROW_ON_SUFFIX);
		var nextRowOff = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_NEXTROW_OFF_SUFFIX);
		if(!undef(nextRowOn) && !undef(nextRowOff))
		{
			nextRowOn.style.display="none";
			nextRowOff.style.display="";
		}	
	}
	
	function table_enablePrevRow(ctrlInst)
	{
		var prevRowOn = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_PREVROW_ON_SUFFIX);
		var prevRowOff = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_PREVROW_OFF_SUFFIX);
		if(!undef(prevRowOn) && !undef(prevRowOff))
		{
			prevRowOn.style.display="";
			prevRowOff.style.display="none";
		}	
	}
	
	function table_disablePrevRow(ctrlInst)
	{
		var prevRowOn = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_PREVROW_ON_SUFFIX);
		var prevRowOff = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_PREVROW_OFF_SUFFIX);
		if(!undef(prevRowOn) && !undef(prevRowOff))
		{
			prevRowOn.style.display="none";
			prevRowOff.style.display="";
		}	
	}
	
	function table_enableNextPage(ctrlInst)
	{
		var nextPageOn = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_NEXTPAGE_ON_SUFFIX);
		var nextPageOff = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_NEXTPAGE_OFF_SUFFIX);
		if(!undef(nextPageOn) && !undef(nextPageOff))
		{
			nextPageOn.style.display="";
			nextPageOff.style.display="none";
		}	
	}
		
	function table_disableNextPage(ctrlInst)
	{
		var nextPageOn = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_NEXTPAGE_ON_SUFFIX);
		var nextPageOff = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_NEXTPAGE_OFF_SUFFIX);
		if(!undef(nextPageOn) && !undef(nextPageOff))
		{
			nextPageOn.style.display="none";
			nextPageOff.style.display="";
		}	
	}
		
	function table_enablePrevPage(ctrlInst)
	{
		var prevPageOn = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_PREVPAGE_ON_SUFFIX);
		var prevPageOff = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_PREVPAGE_OFF_SUFFIX);
		if(!undef(prevPageOn) && !undef(prevPageOff))
		{
			prevPageOn.style.display="";
			prevPageOff.style.display="none";
		}	
	}
		
	function table_disablePrevPage(ctrlInst)
	{
		var prevPageOn = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_PREVPAGE_ON_SUFFIX);
		var prevPageOff = ctrlInst.document.getElementById(ctrlInst.id + TABLE_HEADER_ICON_PREVPAGE_OFF_SUFFIX);
		if(!undef(prevPageOn) && !undef(prevPageOff))
		{
			prevPageOn.style.display="none";
			prevPageOff.style.display="";
		}	
	}
	
	function table_setRowDetailsState(ctrlInst, rowIndex, expand)
	{
		var rowDetailsExpanded = table_isRowDetailsExpanded(ctrlInst);
		if(expand)
		{
			library_showElement(ctrlInst, ctrlInst.id + "_" + rowIndex + TABLECOL_ROW_DETAILS_ICON_COLLAPSE);
			library_hideElement(ctrlInst, ctrlInst.id + "_" + rowIndex + TABLECOL_ROW_DETAILS_ICON_EXPAND);
		}
		else
		{
			library_hideElement(ctrlInst, ctrlInst.id + "_" + rowIndex + TABLECOL_ROW_DETAILS_ICON_COLLAPSE);
			library_showElement(ctrlInst, ctrlInst.id + "_" + rowIndex + TABLECOL_ROW_DETAILS_ICON_EXPAND);
		}
		return !rowDetailsExpanded;
	}
	
	function table_isRowDetailsExpanded(ctrlInst)
	{	
		var expanded = false;
		var rowDetails = ctrlInst.document.getElementById(ctrlInst.id + TABLE_ROW_DETAILS_SUFFIX);
		if(!undef(rowDetails))
		{
			if(rowDetails.style.display=="")
			{
				expanded = true;
			}
		}
		return expanded;
	}

	function table_setWidth(ctrlInst, percent)
	{
		var availWidth = ctrlInst.parentElement.offsetWidth;
		if(availWidth==0)
		{	
			availWidth = window.screen.width - 20;
		}
		var convertedWidth = (percent/100)*(availWidth);
		var scrollContainer = ctrlInst.document.getElementById(ctrlInst.id + TABLE_CONTENT_SUFFIX);
		if(ctrlInst.clientWidth > convertedWidth)
		{
			ctrlInst.style.pixelWidth = convertedWidth;
			scrollContainer.style.pixelWidth = convertedWidth;
		}
	}

	function table_toggleColumn(ctrlInst, colIndex, show)
	{
		var headerRow = table_getHeaderRow(ctrlInst);
		var filterRow = table_getFilterRow(ctrlInst);
		var dataRows = table_getDataRows(ctrlInst);
		if(!undef(headerRow))
		{
			headerRow.cells[colIndex].style.display = (show)?"":"none";
			headerRow.lastChild.style.pixelWidth =  (show)? (headerRow.lastChild.style.pixelWidth - headerRow.cells[colIndex].style.pixelWidth) : (headerRow.lastChild.style.pixelWidth + headerRow.cells[colIndex].style.pixelWidth);    
		}
		if(!undef(filterRow))
		{
			filterRow.cells[colIndex].style.display = (show)?"":"none";
			filterRow.lastChild.style.pixelWidth =  (show)? (filterRow.lastChild.style.pixelWidth - filterRow.cells[colIndex].style.pixelWidth) : (filterRow.lastChild.style.pixelWidth + filterRow.cells[colIndex].style.pixelWidth);
		}
		for(var i=0; i<dataRows.length; i++)
		{
			dataRows[i].cells[colIndex].style.display = (show)?"":"none";
			dataRows[i].lastChild.style.pixelWidth =  (show)? (dataRows[i].lastChild.style.pixelWidth - dataRows[i].cells[colIndex].style.pixelWidth) : (dataRows[i].lastChild.style.pixelWidth + dataRows[i].cells[colIndex].style.pixelWidth);
		}
	}
	
	function table_checkAndUpdateRadioButtonSelection(ctrlInst, rowIndex)
	{
		var row = table_getDataRowBasedOnIndex(ctrlInst, rowIndex);
		if(!undef(row))
		{
			var inputElements = row.all.tags("INPUT");
			for(var i=0; i<inputElements.length; i++)
			{
				var inputElement = inputElements[i];
				var mxevent = inputElement.getAttribute("mxevent"); 
				if(inputElement.type=="radio" && mxevent=="selectrecord")
				{
					inputElement.checked = true;
					break;
				}
			}
		}
	}
	
	function table_toggleLabel(ctrlInst,eventElement)
	{
		var strToggleLabel = eventElement.getAttribute("togglelabel");
		if(!undef(strToggleLabel))
		{
			var strInnerHTML = eventElement.innerHTML;
			eventElement.setAttribute("togglelabel", strInnerHTML);
			eventElement.innerHTML = strToggleLabel;
		}
	}

/**************** END Standard functions for table**********************/

/**************** BEGIN Standard functions for tablecol**********************/

	var TABLE_CONTENT_SUFFIX = "_content";
	var TABLE_CONTENT_TABLE = "_content_table";

	var g_drag_element = null;

	function tablecol_onmousedown(ctrlInst)
	{
		var tableid = ctrlInst.getAttribute("tableid");
		var tableBody = ctrlInst.document.getElementById(tableid + TABLE_CONTENT_TABLE);
		var tableBodyHeight = 220;
		if(!undef(ctrlInst,tableBody))
		{
			tableBodyHeight = tableBody.offsetHeight;
		}
		var dragelement = ctrlInst.document.createElement("DIV");
		dragctrlInst.className = "resizer_draggable";
		dragctrlInst.style.left = window.event.x;
		dragctrlInst.style.top = window.event.y - window.event.offsetY;
		dragctrlInst.style.pixelHeight = tableBodyHeight;
		g_drag_element = ctrlInst.document.body.appendChild(dragelement);
		
		setCapture();
		ctrlInst.previousSibling.setAttribute("startX", window.event.x);
		attachEvent ("onmousemove", tablecol_onMouseMove);
		dragstart.fire();
		tablecol_onclick(ctrlInst);
	}
	
	function tablecol_onmouseup(ctrlInst)
	{
		ctrlInst.document.body.removeChild(g_drag_element);
		tablecol_resizeColumn(ctrlInst);
		releaseCapture();
		detachEvent ("onmousemove", tablecol_onMouseMove);
		dragend.fire();
		tablecol_onclick(ctrlInst);
	}
	
	function tablecol_onMouseMove(ctrlInst)
	{
		ctrlInst.previousSibling.setAttribute("endX", window.event.x);
		g_drag_ctrlInst.style.left = window.event.x;
		drag.fire();
	}

	function tablecol_onmouseover(ctrlInst){ctrlInst.className="resizer_highlight";}
	function tablecol_onmouseout(ctrlInst){ctrlInst.className="resizer";}
	
	function tablecol_resizeColumn(ctrlInst,element)
	{
		var startX = ctrlInst.previousSibling.getAttribute("startX");  
		var endX = ctrlInst.previousSibling.getAttribute("endX");
		
		if(!undef(ctrlInst,startX) && !undef(ctrlInst,endX))
		{
			var deltaWidth = parseInt(endX) - parseInt(startX);
			if(!undef(ctrlInst,deltaWidth))
			{ 
				var tableid = ctrlInst.getAttribute("tableid");
				var tablecolid = ctrlInst.getAttribute("tablecolid");
				if(!undef(ctrlInst,tableid) && !undef(ctrlInst,tablecolid))
				{
					var table = ctrlInst.document.getElementById(tableid);
					table.fnHandleResizeColumn(tablecolid, deltaWidth);
				}
			}
		}
	}
	
	function tablecol_onclick(ctrlInst)
	{
		
		window.event.cancelBubble = true;
	}	
/**************** END Standard functions for tablecol**********************/

/**************** BEGIN Standard functions for textbox**********************/

	function textbox_getPart()
	{
		part=null;
		part = currentObject.all.namedItem(currentObject.id+"_"+currentPartName);
		return part;
	}

	function textbox_detailClick(ctrlInst)
	{
		eventname = event.srcElement.mxevent;
		var control = getControl(event.srcElement);
		
		//Custom code to handling selecting of row before the event can be processed
		// on the input element inside a table. This is applicable ONLY to non-query
		// table rows.
		var queueevent = false;
		var ontable = (control.getAttribute("ontable")=="true");
		var query = (control.getAttribute("query")=="true");
		queueevent = ontable && !query;
				
		detailtype = event.srcElement.detailtype;
		partid = event.srcElement.mxpart;
		setfocusField(getPart(control , "textbox"));
		id = control.id;
		if(eventname=="showmenu")
		{
			x=event.clientX-event.offsetX-2;
			y=event.clientY-event.offsetY-2;
			getMenu(ctrlInst.id, x, y, "", "textbox");
			if (!queueevent)
			{
				event.cancelBubble=true;
				event.returnValue=false;
			}
		}
		else
		{
			menuX=event.clientX-event.offsetX-2;
			menuY=event.clientY-event.offsetY-2;
			if(detailtype=="datelookup")
			{
				tb = getPart(control ,"textbox");
				if (queueevent)
					clientEventQueue[clientEventQueue.length]=new clientEvent("datelookup", id, "textbox", tb.dataattribute);
				else
					sendEvent("datelookup", ctrlInst.id, "textbox", tb.dataattribute);
			}
			else if(partid=="detail")
			{
				if (queueevent)
					clientEventQueue[clientEventQueue.length]=new clientEvent(eventname, id, detailtype, "dataattribute");
				else
					sendEvent(eventname, ctrlInst.id, detailtype, "dataattribute");
			}
			else
			{
				if (queueevent)
					clientEventQueue[clientEventQueue.length]=new clientEvent(eventname, id, detailtype, "descdataattribute");
				else
					sendEvent(eventname, ctrlInst.id, detailtype, "descdataattribute");
			}
		}
	}

	function textbox_setvalue(ctrlInst,mxpart, toEl)
	{
		setValue(ctrlInst, mxpart, toEl);
	}


	function textbox_updateValue(ctrlInst,mxpart, val)
	{
		part=getPart(ctrlInst, mxpart);
		if(!undef(part))
		{
			if(part.value!=val)
				parent.addUpdateField(part,val);
			part.value=val;
			shared_unMarkAsChanged(part);
		}
	}

	function textbox_updateRequired(ctrlInst,mxpart, req)
	{
		requiredimg = getPart(ctrlInst, "required")
		if(!undef(requiredimg))
			requiredimg.src=IMAGE_PATH+req+".gif";
	}

	function textbox_haslongdesc(ctrlInst,hasLD)
	{
		ldimage = getPart(ctrlInst, "detail");
		if(undef(ldimage))
			return;
			
		if(ldimage.detailtype != "longdesc")
			return;			
				
		ldimage.src=IMAGE_PATH+"img_longdescription_"+hasLD+".gif";
	}

	function textbox_updateReadOnly(ctrlInst,mxpart, ro)
	{
		el = getPart(ctrlInst, mxpart);
		type="description";
		displaytype="";
		if(mxpart=="textbox")
		{
			type="text";
			displaytype=el.displaytype;
		}
		tempClassName=el.className;
		if(ro==true)
		{
			el.tabIndex=READ_ONLY_TAB_INDEX;
			if(tempClassName.indexOf("readonly")==-1)
			{
				el.className += " readonlytrue";
			}
			else
			{
				if(!undef(focusField) && el.id==focusField.id)
				{
					if(!undef(lastFocusField))
						setFieldFocus(lastFocusField);
				}
				tempClassName = tempClassName.replace("readonlyfalse", "readonlytrue");
				el.className = tempClassName;
			}	
		}
		else
		{
			el.tabIndex="0";
			if(tempClassName.indexOf("readonly")==-1)
			{
				el.className += " readonlyfalse";
			}
			else
			{
				tempClassName = tempClassName.replace("readonlytrue", "readonlyfalse");
				el.className = tempClassName; 
			}	
		}
		el.readOnly=ro;
	}

	function textbox_onselectedtablerow(ctrlInst,sel)
	{
		tb = getPart(ctrlInst, "textbox")
		cn = tb.className
		if(tb.readOnly==true)
			ro = " readonlytrue";
		else
			ro = " readonlyfalse";
			
		if(sel==true)
		{
			newcn = "input_parts input text tableinputrowselected" + ro;
		}
		else
		{
			newcn = "input_parts input text tableinputrownotselected";
		}
		tb.className=newcn;
	}

	function textbox_onkeypress(ctrlInst)
	{
		key=event.keyCode;
		switch(event.keyCode)
		{
			case 10:
				if(event.ctrlKey==true)
				{
					det = getPart(ctrlInst, "detail");
					if(det)
					{
						if(!SCREENREADER)
							det.focus();
						det.fireEvent("onclick");
						event.cancelBubble=true;
					}
				}
				break;		
			case 13:
				if(el.filtercol!="true")
				{
					shared_handleChange(el);
					event.cancelBubble=true;
				}
				break;
		}
	}

	function textbox_onactivate(ctrlInst)
	{
		el = event.srcElement;
		setfocusField(el);
		switch (el.mxpart)
		{
			case "textbox":
				if(el.readOnly==true)
				{
					if(getPart(ctrlInst, el.mxpart).tabIndex=="-1")
					{
						event.returnValue=false;
						event.cancelBubble=true;
					}
					else
					{
						el.style.backgroundColor=FIELD_FOCUS_READ_ONLY_COLOR;
					}
					return false;
				}
				el.style.backgroundColor=FIELD_FOCUS_COLOR;
				if(el.numeric=="numeric")
					el.style.textAlign="left";					
				break;
			case "detail":
				el.fireEvent("onmouseover");
				break;
		}
	}

	function textbox_ondeactivate(ctrlInst,part)
	{
		el = event.srcElement;
		part = el.mxpart;

		original = el.className.substr(0,ctrlInst.className.lastIndexOf(" "));
		switch (el.mxpart)
		{
			case "textbox":
				if(el.readOnly==true && getPart(ctrlInst, el.mxpart).tabIndex=="-1")
				{
					if(!undef(event))
					{
						event.returnValue=false;
						event.cancelBubble=true;
					}
					return false;
				}
				el.style.backgroundColor="";
				if(el.numeric=="numeric")
					el.style.textAlign="right";
				break;
			case "detail":
				el.fireEvent("onmouseout");
				break;
		}
		
	}


	function textbox_onclick(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "detail":
				if(!isTrue(ctrlInst.getAttribute("ontable")))
				{
				 	event.cancelBubble=true;
				}
				textbox_detailClick(ctrlInst);
				break;
		}
	}


	function textbox_onmouseover(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "control":
				break;
			case "detail":
			{
				el.className=el.className+" detailhighlight";
				break;
			}
		}
	}

	function textbox_onmouseout(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "textbox":
				break;
			case "detail":
				el.className=el.className.replace(" detailhighlight", "");
				break;
		}
	}
	
	function textbox_ondblclick(ctrlInst)
	{
	}

/**************** END Standard functions for textbox**********************/

/**************** BEGIN Standard functions for toolbarbutton**********************/

	function toolbarbutton_onkeypress(ctrlInst)
	{
		if(event.keyCode==KEYCODE_ENTER || event.keyCode==KEYCODE_SPACEBAR)
		{
			disabled = ctrlInst.disabled;
			if(undef(disabled) || disabled==false || disabled=="false" )
				sendEvent(ctrlInst.tbevent, ctrlInst.target);
		}
	}

	function toolbarbutton_onfocus(ctrlInst)
	{
		ctrlInst.over="true";
		toolbarbutton_setClass(ctrlInst);
	}

	function toolbarbutton_onblur(ctrlInst)
	{
		ctrlInst.over="false";
		toolbarbutton_setClass(ctrlInst);
	}

	function toolbarbutton_onmousedown(ctrlInst)
	{
		if(ctrlInst.disabled=="true" || ctrlInst.disabled==true)
			return false;
			
		if(ctrlInst.sticky=="false")
			ctrlInst.updown="down";
		else
		{
			if(ctrlInst.updown=="down")
				ctrlInst.updown="";
			else
				ctrlInst.updown="down";
		}
		toolbarbutton_setClass(ctrlInst);
		
	}

	function toolbarbutton_onmouseup(ctrlInst)
	{
		if(ctrlInst.disabled=="true" || ctrlInst.disabled==true)
			return false;
	
		if(ctrlInst.sticky=="false")
			ctrlInst.updown="";

		toolbarbutton_setClass(ctrlInst);
		toolbarbutton_handleClick(ctrlInst);
		ctrlInst.fireEvent("onmouseenter");
	}


	function toolbarbutton_onmouseenter(ctrlInst)
	{
		ctrlInst.over="true";
		ctrlInst.up = "true";
		toolbarbutton_setClass(ctrlInst);
	}


	function toolbarbutton_onmouseleave(ctrlInst)
	{
		ctrlInst.over = "false";

		if(ctrlInst.sticky=="false")
			ctrlInst.updown="";

		toolbarbutton_setClass(ctrlInst);
	}

	function toolbarbutton_autoClick(ctrlInst)
	{
		toolbarbutton_handleClick(ctrlInst,true);
	}

	function toolbarbutton_handleClick(ctrlInst,nonuser)
	{
		if(event==null || (event.button==1 || !undef(nonuser)))
		{
			eventValue = ctrlInst.eventValue;
			if(undef(eventValue))
				eventValue="";
			if(!ctrlInst.disabled)
				sendEvent(ctrlInst.tbevent, ctrlInst.target, eventValue);
		}
	}

	function toolbarbutton_setClass(ctrlInst)
	{
		cn = "";

		if(ctrlInst.updown=="down")
		{
			cn = " toolbarbuttondown";
			if(ctrlInst.sticky=="true")
				cn += " toolbarbuttonstuckdown";
		}		
		
		if(ctrlInst.over=="true")
			cn += " toolbarbuttonhighlight";


		ctrlInst.className = "toolbarbutton"+cn;
	}

/**************** END Standard functions for toolbarbutton**********************/

/**************** BEGIN Standard functions for toolbarcombobox**********************/

	function toolbarcombobox_setvalue(ctrlInst,part)
	{
		setValue(ctrlInst, part)
	}

	function toolbarcombobox_updateValue(ctrlInst,val)
	{
		fld = ctrlInst.firstChild;
		if(fld.value!=val)
			parent.addUpdateField(fld,val);
		fld.value=val;
	}

	function toolbarcombobox_updateReadOnly(ctrlInst,roBoolean)
	{
		var editable = ctrlInst.getAttribute("editable");
		if(editable=="true")
		{
			el = ctrlInst.firstChild;//getPart(ctrlInst, "textbox")
			if(roBoolean==true)
			{
				el.tabindex="-1";
				el.className = "input_parts text  "+datatype+" readonlytrue";
			}
			else
			{
				el.tabindex="0";
				el.className = "input_parts text  "+datatype+" readonlyfalse";
			}
			el.readOnly=roBoolean
		}	
	}

	function toolbarcombobox_showThisMenu(ctrlInst)
	{
		
	}

	function toolbarcombobox_onkeydown(ctrlInst)
	{
		el = event.srcElement;
	 	keyCode = event.keyCode;
	 	switch(keyCode)
	 	{
	 		case KEYCODE_TAB:
	 		case KEYCODE_ENTER:
	 		case KEYCODE_CTRL:
	 		case KEYCODE_DOWN_ARROW:
	 			break;
			default:
				event.returnValue=false;
				break;
	 	}
		showFieldHelp();
		part = getPartName(el);
		if(event.keyCode==KEYCODE_DOWN_ARROW || event.keyCode==KEYCODE_ENTER)
		{
			el.click();
		}
		else
		{
			event.cancelBubble=true;
			return false;
		}
	}

	function toolbarcombobox_handleMouseContext(ctrlInst)
	{
	 	event.cancelBubble=true;
		event.returnValue=false;
	}

	function toolbarcombobox_onactivate(ctrlInst)
	{
		el = event.srcElement;
		part = getPartName(el);
		setfocusField(el);
		switch (part)
		{
			case "textbox":
				var editable = ctrlInst.getAttribute("editable");
				if(editable=="true")
				{
					el.style.backgroundColor="#CCC18E";
				}	
				break;
		}
	}

	function toolbarcombobox_ondeactivate(ctrlInst)
	{
		el = event.srcElement;
		part = getPartName(el);
		if(el)
		{
			cn = el.className;
			if(cn!="")
				original = el.className.substr(0,el.className.lastIndexOf(" "));
			switch (part)
			{
				case "textbox":
					var editable = ctrlInst.getAttribute("editable");
					if(editable=="true")
					{	
						el.style.backgroundColor="";
					}	
					break;
			}
		}
	}


	function toolbarcombobox_onclick(ctrlInst)
	{
		el = event.srcElement;
		part = getPartName(el);
		sc = el.oneclick;
		var position = ctrlInst.getAttribute("position");
		if(sc)
		{
			sendEvent("firefirst", ctrlInst.id, position);
			event.returnValue=false;
			return;
		}
		if(part!="label")
		{
			var editable = ctrlInst.getAttribute("editable");
			var position = ctrlInst.getAttribute("position");
			var haschildren = ctrlInst.getAttribute("haschildren");
			if(editable=="true")
			{	
				y=(event.clientY-event.offsetY-2) + event.srcElement.clientHeight+2;
				x=(event.clientX-event.offsetX-2)+1;
			}
			else
			{
				y=(event.clientY-event.offsetY) + ctrlInst.clientHeight -3;
				x=(event.clientX - event.offsetX + event.srcElement.clientWidth) - ctrlInst.clientWidth + ctrlInst.offsetLeft;
			}
			fld = ctrlInst.firstChild;
			z=fld.clientWidth-17;
			if((editable=="true") || (haschildren=="true") )
			{
				getMenu(ctrlInst.id, x, y, z, position);
			}
			else
			{
				var eventtype =  ctrlInst.getAttribute("sendevent");
				sendEvent(eventtype, ctrlInst.id);
			}		
		}
		event.returnValue=false;	
	}

	function toolbarcombobox_onmouseover(ctrlInst)
	{
		var strEditable = ctrlInst.getAttribute("editable");
		if(strEditable!="true")
		{
			var labelpart = ctrlInst.firstChild;//getPart(ctrlInst, "textbox");
			var imagepart = getPart(ctrlInst, "comboboximage");
			if(!undef(labelpart) && !undef(imagepart))
			{
				labelpart.className += " highlighted";
				imagepart.className += " focused";
			}
		}	
	}
	
	function toolbarcombobox_onmouseout(ctrlInst)
	{
		var strEditable = ctrlInst.getAttribute("editable");
		if(strEditable!="true")
		{
			var labelpart = ctrlInst.firstChild;
			var imagepart = getPart(ctrlInst, "comboboximage");
			if(!undef(labelpart) && !undef(imagepart))
			{
				labelpart.className = "toolbar_combobox_field_readonly";
				imagepart.className = "toolbar_combobox_field_image";
			}
		}
	}

/**************** END Standard functions for toolbarcombobox**********************/

/**************** BEGIN Standard functions for tree**********************/

	function tree_onclick(ctrlInst)
	{
		var eventElement = library_getElementHavingEvent(ctrlInst, event.srcElement);
		var mxpart = eventElement.getAttribute("mxpart");
		switch(mxpart)
		{
			case "node": 
				tree_handleSelectNode(ctrlInst, eventElement); 
				break;
			default: tree_handleEvent(ctrlInst, eventElement); break; 
		}
	}
	
	function tree_ondblclick(ctrlInst)
	{
		var eventElement = library_getElementHavingEvent(ctrlInst, event.srcElement);
		var mxpart = eventElement.getAttribute("mxpart");
		switch(mxpart)
		{
			case "node":
				var mxevent = eventElement.getAttribute("mxevent");
				if(mxevent=="togglechildren")
				{
					tree_handleToggleChildren(ctrlInst, eventElement);
				}	 
				break;
			default: break; 
		}
	}
	
	function tree_onkeypress(ctrlInst)
	{		
		var eventElement = library_getElementHavingEvent(ctrlInst, event.srcElement);
		var keyCode =  event.keyCode;
		switch(keyCode)
		{
			case KEYCODE_ENTER:
				tree_handleEvent(ctrlInst, eventElement); break;
			default: break;
		}
	}
	
	function tree_onkeydown(ctrlInst)
	{
		var keyCode = event.keyCode;
		var eventElement = library_getElementHavingEvent(ctrlInst, event.srcElement);
		switch(keyCode)
		{
			case KEYCODE_LEFT_ARROW:
				var mxpart = eventElement.getAttribute("mxpart");
				while(mxpart!="node" && eventElement!=ctrlInst)
				{
					nodeElement = eventElement.parentElement;
					mxpart = eventElement.getAttribute("mxpart");
				}
				if(eventElement!=ctrlInst)
				{
					var mxevent=eventElement.getAttribute("mxevent");
					if(!tree_isChildrenExpanded(ctrlInst, eventElement) || (mxevent!="togglechildren"))
					{
						tree_highlightPreviousNode(ctrlInst, eventElement);
					}
					else
					{
						tree_handleEvent(ctrlInst, eventElement);
					}	
				}
				break;
			
			case KEYCODE_RIGHT_ARROW:
				var mxpart = eventElement.getAttribute("mxpart");
				while(mxpart!="node" && eventElement!=ctrlInst)
				{
					nodeElement = eventElement.parentElement;
					mxpart = eventElement.getAttribute("mxpart");
				}
				if(eventElement!=ctrlInst)
				{
					var mxevent=eventElement.getAttribute("mxevent");
					if(tree_isChildrenExpanded(ctrlInst, eventElement) || (mxevent!="togglechildren"))
					{
						tree_highlightNextNode(ctrlInst, eventElement);
					}
					else
					{
						tree_handleEvent(ctrlInst, eventElement);
					}
				}
				break; 
			case KEYCODE_UP_ARROW: 
				tree_highlightPreviousNode(ctrlInst, eventElement);
				cancelEventBubbling(); 
				break;			
			case KEYCODE_DOWN_ARROW:
				tree_highlightNextNode(ctrlInst, eventElement);
				cancelEventBubbling(); 
				break;	
			default: break;
		}
	}

	function tree_fnHandleRefreshChildren(ctrlInst, parentId, newChildren)
	{
		var childContainer = ctrlInst.document.getElementById(parentId + "_children");
		if(!undef(childContainer))
		{
			childContainer.innerHTML = newChildren.innerHTML;
			childContainer.style.display ="";
			tree_handleStateIcon(ctrlInst, childContainer.parentElement, "expanded");
		}
	}

	function tree_fnHandleRefreshTree(ctrlInst, newChildren)
	{
		var childContainer = ctrlInst.lastChild;
		if(!undef(childContainer))
		{
			childContainer.innerHTML = "";
			if(newChildren.childNodes.length>0)
			{
				childContainer.innerHTML = newChildren.innerHTML;
				childContainer.style.display ="";
			}
		}
	}
	
	function tree_fnHandlePathToTop(ctrlInst, newChildren)
	{
		var childContainer = ctrlInst.lastChild;
		if(!undef(childContainer))
		{
			childContainer.innerHTML = "";
			if(newChildren.childNodes.length>0)
			{
				for(var i=newChildren.childNodes.length-1; i>=0; i--)
				{
					childContainer.innerHTML = newChildren.childNodes[i].outerHTML;
					childContainer = childContainer.firstChild.lastChild;
					childContainer.style.display = "";
				}
				childContainer.style.display = "none";
			}
		}
	}
	
	function tree_fnHandleSelectNode(ctrlInst, nodeid)
	{
		var nodeElement = ctrlInst.document.getElementById(nodeid + "_nodename");
		var selectedNode = tree_getSelectedNode(ctrlInst);
		if(!undef(nodeElement))
		{
			if(!undef(selectedNode))
			{
				selectedNode.className = "nodename"; 
			}
			nodeElement.className = "nodename_selected";  
		}
	}

	function tree_handleEvent(ctrlInst, eventElement)
	{
		var mxevents = library_getMxEvents(ctrlInst, eventElement);
		for(var i=0; i<mxevents.length; i++)
		{
			var mxevent = mxevents[i];
			switch(mxevent)
			{
				case "togglechildren": tree_handleToggleChildren(ctrlInst, eventElement); break;
				case "selectnode": tree_handleSelectNode(ctrlInst, eventElement); break;
				case "selectrecord": tree_handleSelectRecord(ctrlInst, eventElement); break;
				default: break;
			}
		}
	}
		
	function tree_handleToggleChildren(ctrlInst, eventElement)
	{
		var childrencontainer = eventElement.getAttribute("childrencontainer");
		var container = tree_getElementFromAttrValue(ctrlInst, eventElement, "childrencontainer");
		if(!undef(container))
		{
			if(container.style.display=="none")
			{
				var objectname = container.parentElement.getAttribute("objectname");
				var keyvalue = container.parentElement.getAttribute("keyvalue");
				tree_handleStateIcon(ctrlInst, container.parentElement, "working");
				sendEvent("getchildren", ctrlInst.id, keyvalue, objectname);
			}
			else
			{
				tree_handleStateIcon(ctrlInst, container.parentElement, "collapsed");
				container.style.display ="none";
				var keyvalue = container.parentElement.getAttribute("keyvalue");
				var objectname = container.parentElement.getAttribute("objectname");
			}
		}
	}
		
	function tree_handleSelectNode(ctrlInst, eventElement)
	{	
		if(!undef(eventElement))
		{
			var keyvalue = eventElement.getAttribute("keyvalue");
			var objectname = eventElement.getAttribute("objectname");
			sendEvent("selectnode", ctrlInst.id, keyvalue, objectname);
		}
	}	
		
	function tree_handleSelectRecord(ctrlInst, eventElement)
	{
		if(!undef(eventElement))
		{
			var nodeElement = eventElement;
			var mxpart = nodeElement.getAttribute("mxpart");
			while(mxpart!="node" && nodeElement!=ctrlInst)
			{
				nodeElement = nodeElement.parentElement;
				mxpart = nodeElement.getAttribute("mxpart");
			}
			var objectname = nodeElement.getAttribute("objectname");
			var keyvalue = nodeElement.getAttribute("keyvalue");
			sendEvent("selectrecord", ctrlInst.id, keyvalue, objectname);
		}
	}
	
	function tree_getSelectedNode(ctrlInst)
	{
		var selectedNode = null;
		var nodes = ctrlInst.all.tags("SPAN");
		for(var i=0; i<nodes.length; i++)
		{
			if(nodes[i].className=="nodename_selected")
			{
				selectedNode = nodes[i];
			}
		}
		return selectedNode;
	}
	
	function tree_handleStateIcon(ctrlInst, srcElement, state)
	{
		var stateImage = ctrlInst.document.getElementById(srcElement.id + "_state_image");
		if(!undef(stateImage))
		{
			var imagePathAndSource = stateImage.src;
			var imagepath = imagePathAndSource.substr(0, imagePathAndSource.lastIndexOf("/"));
			var imageName = imagePathAndSource.substr(imagePathAndSource.lastIndexOf("/")+1);
			var imageLabel = "";
			switch(state)
			{
				case "expanded": 
					imageName = "node_expanded.gif";
					imageLabel = stateImage.getAttribute("openstr");
					break;
				case "collapsed": 
					imageName = "node_collapsed.gif";
					imageLabel = stateImage.getAttribute("closestr");
					break;
				case "working": 
					imageName = "node_working.gif"; 
					break;
			}
			stateImage.src = imagepath + "/" + imageName;
			stateImage.alt = imageLabel;
		}
	}
	
	function tree_highlightPreviousNode(ctrlInst, eventElement)
	{
		var mxpart = eventElement.getAttribute("mxpart");
		switch(mxpart)
		{
			case "stateimage":
				while(mxpart!="node"){
					eventElement = eventElement.parentElement;
					mxpart = eventElement.getAttribute("mxpart");
				}
			case "node":
				var nextNode = tree_getPreviousNode(ctrlInst, eventElement);
				if(!undef(nextNode)){nextNode.focus();}
				break;
			default: break; 
		}
	}
	
	function tree_highlightNextNode(ctrlInst, eventElement)
	{	
		var mxpart = eventElement.getAttribute("mxpart");
		switch(mxpart)
		{
			case "stateimage":
				while(mxpart!="node"){
					eventElement = eventElement.parentElement;
					mxpart = eventElement.getAttribute("mxpart");
				}
			case "node":
				var nextNode = tree_getNextNode(ctrlInst, eventElement);
				if(!undef(nextNode)){nextNode.focus();}
				break;
			default: break; 
		}
	}
	
	function tree_getNextNode(ctrlInst, eventElement)
	{
		var nextNode = null;
		if(eventElement.lastChild.style.display=="")
		{
			nextNode = eventElement.lastChild.firstChild;
		}
		else if(!undef(eventElement.nextSibling))
		{
			nextNode = eventElement.nextSibling;
		}
		else if(!undef(eventElement.parentElement.parentElement))
		{
			if(!undef(eventElement.parentElement.parentElement.nextSibling))
			{
				nextNode = eventElement.parentElement.parentElement.nextSibling;
			}
			else
			{
				//TODO: need to handle multi-level next node....last node of the level5....
				//		that happens to be the last node of all....
			}
		}
		return nextNode;
	}
	
	function tree_getPreviousNode(ctrlInst, eventElement)
	{
		var previousNode = null;
		if(!undef(eventElement.previousSibling))
		{
			if(eventElement.previousSibling.lastChild.style.display=="")
			{
				previousNode = eventElement.previousSibling.lastChild.lastChild;
			}
			else
			{
				previousNode = eventElement.previousSibling;
			}
		}
		else if(!undef(eventElement.parentElement.parentElement))
		{
			previousNode = eventElement.parentElement.parentElement;	
		}
		return previousNode;
	}
	
	function tree_isChildrenExpanded(ctrlInst, eventElement)
	{ 
		var childrenExpanded = false;
		var childrencontainer = eventElement.getAttribute("childrencontainer");
		var container = tree_getElementFromAttrValue(ctrlInst, eventElement, "childrencontainer");
		if(!undef(container))
		{
			if(container.style.display=="")
			{
				childrenExpanded = true;
			}
		}
		return childrenExpanded;
	}

	function tree_getElementFromAttrValue(ctrlInst, srcElement, attrName)
	{
		var retElement = null;
		if(!undef(srcElement) && !undef(attrName))
		{
			var attrValue = srcElement.getAttribute(attrName);
			if(!undef(attrValue))
			{
				retElement = ctrlInst.document.getElementById(attrValue);
			}
		}
		return retElement;
	}
/**************** END Standard functions for tree**********************/

/**************** BEGIN Standard functions for wallcalendar**********************/

	function wallcalendar_onclick(ctrlInst)
	{
		var eventElement = library_getElementHavingEvent(ctrlInst,event.srcElement);
		wallcalendar_handleEvent(ctrlInst, eventElement); 
	}
	
	function wallcalendar_onkeypress(ctrlInst)
	{		
		var eventElement = library_getElementHavingEvent(ctrlInst,event.srcElement);
		var keyCode =  event.keyCode;
		switch(keyCode)
		{
			case KEYCODE_ENTER:
				wallcalendar_handleEvent(ctrlInst,eventElement); break;
			default: break;
		}
	}
	
	function wallcalendar_handleEvent(ctrlInst,eventElement)
	{
		var mxevents = library_getMxEvents(ctrlInst,eventElement);
		for(var i=0; i<mxevents.length; i++)
		{
			var mxevent = mxevents[i];
			var mxvalue = eventElement.getAttribute("mxvalue");
			if(!undef(ctrlInst,mxevent))
			{
				target = eventElement.targetid;
				if(undef(ctrlInst,target))
					target = ctrlInst.id;
				
				switch(mxevent)
				{
					case "appshifts":
						var mxdate=eventElement.getAttribute("mxdate");
						sendEvent(mxevent, target, mxvalue);
						break;
					default:
						sendEvent(mxevent, target, mxvalue);
						break;
				}
			}	
		}
	}

	function wallcalendar_fnHandleRefreshCalendar(ctrlInst,newCalendar)
	{
		var containerElement = getPart(ctrlInst,"contents");
		if(!undef(ctrlInst,containerElement) && !undef(ctrlInst,newCalendar))
		{
			containerElement.innerHTML = newCalendar.innerHTML;
		}
	}

/**************** END Standard functions for wallcalendar**********************/

/**************** BEGIN Standard functions for whereclause**********************/

	function whereclause_setvalue(ctrlInst,part)
	{
		setValue(ctrlInst, part);
	}

	function whereclause_detailClick(ctrlInst)
	{
		x=event.clientX-event.offsetX-2;
		y=event.clientY-event.offsetY-2;
		getMenu(ctrlInst.id, x, y);
	}

	function whereclause_updateValue(ctrlInst,mxpart, val)
	{
		part =	getPart(ctrlInst, mxpart);
		if(part.value!=val)
			parent.addUpdateField(part,val);
		part.value=val
	}

	function whereclause_updateReadOnly(ctrlInst,mxpart, roBoolean)
	{
		el = getPart(ctrlInst, mxpart);
		if(roBoolean==true)
		{
			el.tabIndex="-1";
			el.className = "text input "+ctrlInst.displaytype+" readonlytrue";
		}
		else
		{
			el.tabIndex="0";
			el.className = "text input "+ctrlInst.displaytype+" readonlyfalse";
		}
		el.readOnly=roBoolean;
	}

	function whereclause_onkeypress(ctrlInst)
	{
		key=event.keyCode
		if(key==10 && event.ctrlKey==true)
		{
			getPart(ctrlInst, "detail").fireEvent("onclick");
		}
	}

	function whereclause_updateRequired(ctrlInst,mxpart, req)
	{
		getPart(ctrlInst, "required").src="../webclient/images/"+req+".gif";
	}

	function whereclause_onactivate(ctrlInst)
	{
		el = event.srcElement;
		setfocusField(el);
		switch (el.mxpart)
		{
			case "textbox":
				if(el.readOnly==true)
				{
					event.returnValue=false;
					event.cancelBubble=true;
					return false;
				}
			 	el.style.overflow="auto";
				el.style.backgroundColor="#CCC18E";
				el.select();
				break;
			case "detail":
				el.fireEvent("onmouseover");
				break;
		}
	}

	function whereclause_ondeactivate(ctrlInst)
	{
		el = event.srcElement;
		original = el.className.substr(0,el.className.lastIndexOf(" "));
		switch (el.mxpart)
		{
			case "textbox":
				if(el.readOnly==true)
				{
					event.returnValue=false;
					event.cancelBubble=true;
					return false;
				}
				el.style.overflow="hidden";
				el.style.backgroundColor="";
				break;
			case "detail":
				el.fireEvent("onmouseout");
				break;
		}
	}


	function whereclause_onclick(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "detail":
				if(!isTrue(ctrlInst.getAttribute("ontable")))
				{
				 	event.cancelBubble=true;
				}
				whereclause_detailClick(ctrlInst);
				break;		
		}
	}


	function whereclause_onmouseover(ctrlInst)
	{
		el = event.srcElement;
		switch (el.mxpart)
		{
			case "control":
				break;
			case "textbox":
				txt = el.innerText;
				if(txt.length>30)
					x = txt.substr(0,30)+"...";
				else
					x = txt;
				el.title=ctrlInst.label+" "+x;
				break;
			case "detail":
			{
				el.className=el.className+" detailhighlight";
				break;
			}
		}
	}

	function whereclause_onmouseout(ctrlInst)
	{
		el = event.srcElement;
		detail = el.className.substr(0,el.className.lastIndexOf(" "));
		switch (el.mxpart)
		{
			case "textbox":
				break;
			case "detail":
				el.className=detail;
				break;
		}
	}

	var currentControl = null;
	var dropTargetId;
	var dragSourceId;


	function mxd_getCurrentControl()
	{
	    return currentControl;
	}


	function mxd_getDropTargetId()
	{
	    return dropTargetId;
	}


	function mxd_getDragSourceId()
	{
	    return dragSourceId;
	}

	function mxd_onmousedown(ctrlInst)
	{
		var selectedControl = event.srcElement;
		
		selectedControl = window.top.getControl(selectedControl);
		if(undef(selectedControl))
			return;
		window.setTimeout("mxd_onmousedown_timed('"+selectedControl.id+"')", 50);
		window.event.cancelBubble = true;
	}	

	function mxd_onmousedown_timed(ctrlInstId)
	{
		ctrlInst = document.getElementById(ctrlInstId);
		if(undef(ctrlInst))
			return;
//		var selectedControl = event.srcElement;
		selectedControl = ctrlInst;
		var ontable = (selectedControl.getAttribute("ontable")=="true");
		if(undef(ctrlInst.controltype))
		{
			ctrlInst=getControl(event.srcElement);
		}
		if (selectedControl != currentControl)
		{
			if (currentControl != null)
			{
				currentControl.style.removeAttribute("backgroundColor");
				if(currentControl.controltype=="tab")
				{
					tab_designerUnselected(currentControl);
				}
				else if(currentControl.controltype=="tablecol")
				{
					var tableControl = library_getControlByType(currentControl, "table");
					if(!undef(tableControl)){
						var tablecolIndex = table_getColIndexFromId(tableControl, currentControl.id);
						if(tablecolIndex!=-1){
							mxd_table_selectColumn(tableControl, tablecolIndex, false);
						}
					}	
				}
				else if(currentControl.controltype=="dialog")
				{
					mxd_dialog_unselected(currentControl);
				}
			}
			
			if(ctrlInst.controltype=="tab")
			{
				tab_designerSelected(ctrlInst);
			}
			else if( (selectedControl.controltype=="tablecol") || ontable)
			{
				if(selectedControl.controltype!="tablecol"){
					var tablecolid = selectedControl.getAttribute("tablecolid");
					if(!undef(tablecolid)){
						selectedControl = ctrlInst.document.getElementById(tablecolid);
					}	
				}
				var tableControl = library_getControlByType(selectedControl, "table");
				if(!undef(tableControl)){
					var tablecolIndex = table_getColIndexFromId(tableControl, selectedControl.id);
					if(tablecolIndex!=-1){
						mxd_table_selectColumn(tableControl, tablecolIndex, true);
					}
				}	
			}
			else if(selectedControl.controltype=="dialog")
			{
				mxd_dialog_selected(selectedControl);
			}
			else
			{
				selectedControl.style.backgroundColor = DESIGNER_HIGHLIGHT.hex;
			}
			if(undef(currentControl) || (currentControl.id != selectedControl.id))
			{
				window.top.sendEvent("selectcontrol", "canvas", selectedControl.id);
			}
		}		
		currentControl = selectedControl;

	}

	function mxd_onmouseover(ctrlInst)
	{
		window.status = ctrlInst.controltype + ": " + ctrlInst.id;
		window.event.cancelBubble = true;
	}
		
	function mxd_ondragstart(ctrlInst)
	{
		var tmp = parent.getControl(event.srcElement);
		//if (tmp != currentControl)
		//{
		    dragSourceId = tmp.id;
		1
			// Set the effectAllowed on the source object.
			var oData = event.dataTransfer;
			oData.setData("TEXT", dragSourceId);
			oData.effectAllowed = "move";
		//}
		window.event.cancelBubble = true;
	}

	function mxd_ondragenter(ctrlInst)
	{
		// Set the dropEffect for the target object.
		var oData = event.dataTransfer;
		oData.dropEffect = "move";
		dropTargetId = ctrlInst.id;
		// need to cancel default action (along with ondragover) to cause ondrop to fire
		window.event.cancelBubble = true;
		window.event.returnValue = false;
	}

	function mxd_tab_ondragenter(ctrlInst)
	{
		window.event.cancelBubble = true;
		window.event.returnValue = false;
	}

	function mxd_tab_ondragover(ctrlInst)
	{
		dropTargetId=ctrlInst.id;
		window.event.cancelBubble = true;
		window.event.returnValue = false;
		if(ctrlInst.style.filter=="")
		{
			ctrlInst.style.filter="light();";
			ctrlInst.filters[0].addAmbient(DESIGNER_DRAGENTER.red, DESIGNER_DRAGENTER.green, DESIGNER_DRAGENTER.blue, 100);
			ctrlInst.style.borderLeft = DESIGNER_DRAGENTER_BORDER.toString();
		}
	}

	function mxd_tab_ondragleave(ctrlInst)
	{
		window.event.cancelBubble = true;
		window.event.returnValue = false;
		ctrlInst.style.borderLeft = "";
		ctrlInst.style.filter="";
	}

	function mxd_tab_ondrop(ctrlInst)
	{
		mxd_tab_ondragleave(ctrlInst);
	    var oData = event.dataTransfer;
		oData.dropEffect = "move";
		var sourceField = oData.getData("TEXT");
		
		if (sourceField.indexOf("designer_ctrl_") >= 0)
		{
		    // we are dragging an object off of the toolbox
		    var objectType = sourceField;
			window.top.sendEvent("insertcontrol", "canvas", dropTargetId, null, null, sourceField);
		}		
		else if (sourceField == dragSourceId)
		{
		    // we are dragging an existing object from one place to another
			window.top.sendEvent("movecontrol", "canvas", dropTargetId);
		}

		var tmp = window.top.getControl(event.srcElement);
		if (tmp != currentControl)
		{
			if(tmp.tagName=="TR")
			{
				tmp.style.backgroundColor = "";
				for(var i=0;i<tmp.children.length;i++)
				{
					tmp.children[i].style.borderTop = "";
				}
			}
		}
		window.event.cancelBubble = true;
		window.event.returnValue = false;
	}

	function mxd_tabgroup_ondragenter(ctrlInst)
	{
		window.event.cancelBubble = true;
		window.event.returnValue = false;
	}

	function mxd_tabgroup_ondragover(ctrlInst)
	{
		if(ctrlInst.style.filter=="")
		{
			ctrlInst.style.filter="light();";
			ctrlInst.filters[0].addAmbient(DESIGNER_DRAGENTER.red, DESIGNER_DRAGENTER.green, DESIGNER_DRAGENTER.blue, 100);
			ctrlInst.style.borderLeft = DESIGNER_DRAGENTER_BORDER.toString();
		}
	    // we are dragging an object off of the toolbox
		window.event.cancelBubble = true;
		window.event.returnValue = false;
	}

	function mxd_tabgroup_ondragleave(ctrlInst)
	{
		window.event.cancelBubble = true;
		window.event.returnValue = false;
		ctrlInst.style.borderLeft = "";
		ctrlInst.style.filter="";
	}

	function mxd_tabgroup_ondrop(ctrlInst)
	{
		where = "before";
		if(event.offsetX>getPart(ctrlInst,"tabcell").offsetWidth/2)
			where = "after";
		mxd_tab_ondragleave(ctrlInst);
	    var oData = event.dataTransfer;
		oData.dropEffect = "move";
		var sourceField = oData.getData("TEXT");
	    window.top.addCommInput("where",where);
		if (sourceField.indexOf("designer_ctrl_") >= 0)
		{
		    // we are dragging an object off of the toolbox
		    var objectType = sourceField;
			window.top.sendEvent("insertcontrol", "canvas", getControl(ctrlInst).id, null, null, sourceField);
		}		
		else if (sourceField == dragSourceId)
		{
		    // we are dragging an existing object from one place to another
			window.top.sendEvent("movecontrol", "canvas", getControl(ctrlInst).id);
		}
		window.event.cancelBubble = true;
		window.event.returnValue = false;
	}


	function mxd_ondragleave(ctrlInst)
	{
		if(ctrlInst.tagName=="TR")
		{
			for(var i=0;i<ctrlInst.children.length;i++)
			{
				ctrlInst.children[i].style.borderTop = "";
				ctrlClassName=ctrlInst.children[i].className;
				ctrlClassName = ctrlClassName.replace(" acceptdrop","");
				ctrlInst.children[i].className = ctrlClassName;
			}
		}
		else
		{
			ctrlClassName=ctrlInst.className;
			ctrlClassName = ctrlClassName.replace(" acceptdrop","");
			ctrlInst.className = ctrlClassName;
		}
		// need to cancel default action (along with ondragover) to cause ondrop to fire
		window.event.cancelBubble = true;
		window.event.returnValue = false;
	}

	function mxd_ondragover(ctrlInst)
	{
		// need to cancel default action (along with ondragenter) to cause ondrop to fire
		dropTargetId=ctrlInst.id;
		if(mxd_isvalidSourceAndTarget(currentControl, ctrlInst))
		{
			if(ctrlInst.tagName=="TR")
			{
				for(var i=0;i<ctrlInst.children.length;i++)
				{
					ctrlInst.children[i].style.borderTop = DESIGNER_DRAGENTER_BORDER;
					ctrlClassName=ctrlInst.children[i].className;
					if(ctrlClassName.indexOf(" acceptdrop")==-1)
					{
						ctrlClassName += " acceptdrop";
					}
					ctrlInst.children[i].className = ctrlClassName;
				}
			}
			else
			{
				ctrlClassName=ctrlInst.className;
				if(ctrlClassName.indexOf(" acceptdrop")==-1)
				{
					ctrlClassName += " acceptdrop";
				}
				ctrlInst.className = ctrlClassName;
			}
	    }
		window.event.cancelBubble = true;
		window.event.returnValue = false;
	}

	function mxd_ondrop(ctrlInst)
	{
		mxd_ondragleave(ctrlInst);
	    var oData = event.dataTransfer;
		oData.dropEffect = "move";
		var sourceField = oData.getData("TEXT");
		if (sourceField.indexOf("designer_ctrl_") >= 0)
		{
		    // we are dragging an object off of the toolbox
		    var objectType = sourceField;
		    
		    window.status = "dropped '" + dragSourceId + "' onto '" + dropTargetId + "'";
			window.top.sendEvent("insertcontrol", "canvas", dropTargetId, null, null, sourceField);
		}		
		else if (sourceField == dragSourceId)
		{

		    // we are dragging an existing object from one place to another
			window.top.sendEvent("movecontrol", "canvas", dropTargetId);
		}

		var tmp = window.top.getControl(event.srcElement);
		if (tmp != currentControl)
		{
			if(tmp.tagName=="TR")
			{
				tmp.style.backgroundColor = "";
				for(var i=0;i<tmp.children.length;i++)
				{
					tmp.children[i].style.borderTop = "";
				}
			}
		}
		window.event.cancelBubble = true;
		window.event.returnValue = false;
	}

	function mxd_ondragend(ctrlInst)
	{
		return;
	    window.status = "dropped '" + dragSourceId + "' onto '" + dropTargetId + "'";
		window.event.cancelBubble = true;
		window.top.sendEvent("movecontrol", "canvas", dropTargetId);
	}

	function mxd_done_rerendercontrol(original, newcontents, currentElementId)
	{
		if(!undef(original) && !undef(newcontents) )
		{
			if (original.id == newcontents.id)
			{
				switch(original.tagName)
				{
					case "TABLE":
					case "TBODY":
					case "TR":
						original.outerHTML = newcontents.outerHTML;
						break;
					default:
						original.innerHTML = newcontents.innerHTML;
						break;
				}
			}
			var currentElement = original.document.getElementById(currentElementId);
/*
			if(!undef(currentElement))
			{
				currentElement.fireEvent("onmousedown");
			}
			else{
				original.fireEvent("onmousedown");
			}
*/
		}	
	}

	function mxd_done_movecontrol(source, target, whereto)
	{
		var sourceControlType = source.getAttribute("controltype");
		var targetControlType = target.getAttribute("controltype");
		switch(sourceControlType)
		{
			case "tablecol": 
				mxd_table_movecolumn(source, target, whereto); 
				break;
			default: 
				target = window.top.getControl(target);
				if(sourceControlType!="section" && targetControlType=="section")
				{
					var sectionContainer = target.document.getElementById(target.id + SECTION_TABLE_SUFFIX);
					if(!undef(sectionContainer) && !undef(sectionContainer.firstChild)){
						target = sectionContainer.firstChild;
					}
				}
				target.insertAdjacentElement(whereto, source);
				break;
		}
	}

	function mxd_done_removecontrol(ctrlInst)
	{
		var controltype = ctrlInst.getAttribute("controltype");
		switch(controltype)
		{
			case "tablecol": mxd_table_removecolumn(ctrlInst); break;
			default: ctrlInst.removeNode(true); break;
		}
	}

	function toolbox_ondragstart(ctrlInst)
	{
		window.status = "toolbox_ondragstart: ctrlid="+ctrlInst.id;
		currentControl=ctrlInst;
		event.dataTransfer.setData("TEXT", ctrlInst.id);
	}

	function toolbox_ondragend(ctrlInst)
	{
	    window.status = "toolbox_ondragend";
	    var dropTarget = document.frames(1).mxd_getDropTargetId();
	}

	function toolbox_onmousedown(ctrlInst)
	{
	    currentControl = ctrlInst;
		window.status = "toolbox_onmousedown";
	}

	function toolbox_onmouseover(ctrlInst)
	{
		window.status = "toolbox_onmouseover";
	}

	function toolbox_ondrop(ctrlInst)
	{
	    alert("maximo.js dropped!")
	}

	function mxd_tab_ondragstart(ctrlInst)
	{
		mxd_onmousedown(ctrlInst);
	    dragSourceId = ctrlInst.id;
	
		// Set the effectAllowed on the source object.
		var oData = event.dataTransfer;
		oData.setData("TEXT", dragSourceId);
		oData.effectAllowed = "move";
		window.event.cancelBubble = true;
	}

	function mxd_tabbody_ondragstart(ctrlInst){mxd_ondragstart(ctrlInst);}
	function mxd_tabbody_ondragover(ctrlInst)
	{
		ctrl = ctrlInst;
		if(undef(ctrl))
			ctrlInst = getControl(event.srcElement);
		mxd_ondragover(ctrlInst);
	}
	function mxd_tabbody_ondragleave(ctrlInst)
	{
		ctrl = ctrlInst;
		if(undef(ctrl))
			ctrlInst = getControl(event.srcElement);
		mxd_ondragleave(ctrlInst);
	}
	function mxd_tabbody_ondragend(ctrlInst){mxd_ondragend(ctrlInst);}
	function mxd_tabbody_ondragenter(ctrlInst)
	{
		ctrl = ctrlInst;
		if(undef(ctrl))
			ctrlInst = getControl(event.srcElement);
		mxd_ondragenter(ctrlInst)
	}
	
	function mxd_tabbody_ondrop(ctrlInst)
	{
		ctrl = ctrlInst;
		if(undef(ctrl))
			ctrlInst = getControl(event.srcElement);
		mxd_tabbody_ondragleave(ctrlInst)
		dropTargetId=ctrlInst.tabname;
		mxd_ondrop(ctrlInst);
	}

	//*****************************************************************************
	// Predefined HTML EVENT HANDLERS FOR "section" CONTROL IN DESIGN MODE
	//*****************************************************************************
	function mxd_section_onmousedown(ctrlInst){mxd_onmousedown(ctrlInst);}
	function mxd_section_ondragstart(ctrlInst){mxd_ondragstart(ctrlInst);}
	function mxd_section_ondragenter(ctrlInst){mxd_ondragenter(ctrlInst);}
	function mxd_section_ondragover(ctrlInst){mxd_ondragover(ctrlInst);}
	function mxd_section_ondragleave(ctrlInst){mxd_ondragleave(ctrlInst);}
	function mxd_section_ondragend(ctrlInst){mxd_ondragend(ctrlInst);}
	function mxd_section_ondrop(ctrlInst)
	{
		where = "before";
		if(event.offsetY>ctrlInst.offsetHeight/2)
			where = "after";
		mxd_section_ondragleave(ctrlInst);
		if(mxd_isvalidSourceAndTarget(currentControl, ctrlInst))
		{
		    var oData = event.dataTransfer;
			oData.dropEffect = "move";
			var sourceField = oData.getData("TEXT");
			if (sourceField == dragSourceId)
			{
			    // we are dragging an existing object from one place to another
				window.top.addCommInput("where",where);
				window.event.cancelBubble = true;
				window.event.returnValue = false;
			("8199")
				window.top.sendEvent("movecontrol", "canvas", dropTargetId);
			}
			else if (sourceField.indexOf("designer_ctrl_") >= 0)
			{
			    // we are dragging an object off of the toolbox
			    var objectType = sourceField;
				window.event.cancelBubble = true;
				window.event.returnValue = false;
				window.top.addCommInput("where",where);				
				window.top.sendEvent("insertcontrol", "canvas", dropTargetId, null, null, sourceField);
			}
		}
	}
	

	//*****************************************************************************
	// Predefined HTML EVENT HANDLERS FOR "sectioncol" CONTROL IN DESIGN MODE
	//*****************************************************************************
	function mxd_sectioncol_ondragenter(ctrlInst){mxd_ondragenter(ctrlInst);}
	function mxd_sectioncol_ondragover(ctrlInst){mxd_ondragover(ctrlInst);}
	function mxd_sectioncol_ondragleave(ctrlInst){mxd_ondragleave(ctrlInst);}
	function mxd_sectioncol_ondragend(ctrlInst){mxd_ondragend(ctrlInst);}
	function mxd_sectioncol_ondrop(ctrlInst)
	{
		mxd_ondragleave(ctrlInst);
		if(mxd_isvalidSourceAndTarget(currentControl, ctrlInst))
		{
		    var oData = event.dataTransfer;
			oData.dropEffect = "move";
			var sourceField = oData.getData("TEXT");
			if (sourceField == dragSourceId)
			{
			    // we are dragging an existing object from one place to another
			    window.status = "dropped '" + dragSourceId + "' onto '" + dropTargetId + "'";
			("8234")
				window.top.sendEvent("movecontrol", "canvas", dropTargetId);
			}
			else if (sourceField.indexOf("designer_ctrl_") >= 0)
			{
			    // we are dragging an object off of the toolbox
			    var objectType = sourceField;
			    
			    window.status = "dropped '" + dragSourceId + "' onto '" + dropTargetId + "'";
				window.top.sendEvent("insertcontrol", "canvas", dropTargetId, null, null, sourceField);
			}
		}	
		window.event.cancelBubble = true;
		window.event.returnValue = false;
	}

	function mxd_dialog_selected(ctrlInst)
	{
		ctrlInst.style.filter="light();";
		ctrlInst.filters[0].addAmbient(DESIGNER_HIGHLIGHT.red, DESIGNER_HIGHLIGHT.green, DESIGNER_HIGHLIGHT.blue, 100);	
	}

	function mxd_dialog_unselected(ctrlInst)
	{
		ctrlInst.style.filter="";	
	}

	function mxd_dialog_ondrop(ctrlInst)
	{
		mxd_ondragleave(ctrlInst);
	    var oData = event.dataTransfer;
		oData.dropEffect = "move";
		var sourceField = oData.getData("TEXT");
		if (sourceField.indexOf("designer_ctrl_") >= 0)
		{
		    // we are dragging an object off of the toolbox
		    var objectType = sourceField;
		    
		    window.status = "dropped '" + dragSourceId + "' onto '" + dropTargetId + "'";
			window.top.sendEvent("insertcontrol", "canvas", dropTargetId, null, null, sourceField);
		}		
		else if (sourceField == dragSourceId)
		{

		    // we are dragging an existing object from one place to another
			window.top.sendEvent("movecontrol", "canvas", dropTargetId);
		}

		var tmp = window.top.getControl(event.srcElement);
		if (tmp != currentControl)
		{
			if(tmp.tagName=="TR")
			{
				tmp.style.backgroundColor = "";
				for(var i=0;i<tmp.children.length;i++)
				{
					tmp.children[i].style.borderTop = "";
				}
			}
		}
		window.event.cancelBubble = true;
		window.event.returnValue = false;
	}

	//*****************************************************************************
	// Predefined HTML EVENT HANDLERS FOR "table" CONTROL IN DESIGN MODE
	//*****************************************************************************
	function mxd_table_onmousedown(ctrlInst){mxd_onmousedown(ctrlInst);}
	function mxd_table_ondragstart(ctrlInst){mxd_ondragstart(ctrlInst);}
	function mxd_table_ondragenter(ctrlInst){mxd_ondragenter(ctrlInst);}
	function mxd_table_ondragover(ctrlInst){mxd_ondragover(ctrlInst);}
	function mxd_table_ondragleave(ctrlInst){mxd_ondragleave(ctrlInst);}
	function mxd_table_ondrop(ctrlInst)
	{
		var oData = event.dataTransfer;
		oData.dropEffect = "move";
		var sourceField = oData.getData("TEXT");
		if (sourceField.indexOf("designer_ctrl_") >= 0)
		{
		    // we are dragging an object off of the toolbox
		    var objectType = sourceField;
		    if(objectType.indexOf("TABLECOL")!=-1)
		    {
		    	var tablebody = ctrlInst.document.getElementById(ctrlInst.id + TABLE_CONTENT_SUFFIX);
		    	if(!undef(tablebody))
		    	{
        			var tablebodyid = tablebody.getAttribute("tablebodyid");
        			if(!undef(tablebodyid))
        			{
        				dropTargetId = tablebodyid;
        			}
        		}	
		    }
		}
		mxd_ondrop(ctrlInst);		
	}
	function mxd_table_selectColumn(ctrlInst, colIndex, select)
	{
		var headerRow = table_getHeaderRow(ctrlInst);
		var filterRow = table_getFilterRow(ctrlInst);
		var dataRows = table_getDataRows(ctrlInst);
		if(!undef(headerRow))
		{
			headerRow.cells[colIndex].style.backgroundColor = (select)?DESIGNER_HIGHLIGHT.hex:"";
		}
		if(!undef(filterRow))
		{
			filterRow.cells[colIndex].style.backgroundColor = (select)?DESIGNER_HIGHLIGHT.hex:"";
		}
		for(var i=0; i<dataRows.length; i++)
		{
			dataRows[i].cells[colIndex].style.backgroundColor = (select)?DESIGNER_HIGHLIGHT.hex:"";
		}
	}

	function mxd_table_removecolumn(tablecol)
	{
		var tablecolid = tablecol.id;
		var tableCtrl = tablecol;
		while(tableCtrl.getAttribute("controltype")!="table")
		{
			tableCtrl = tableCtrl.parentElement;
			if(undef(tableCtrl)){break;}
		}
		if(!undef(tableCtrl))
		{
			var tablcolColl = tableCtrl.all.tags("TD");
			for(var i=0; i<tablcolColl.length; i++)
			{
				var columnid = tablcolColl[i].getAttribute("tablecolid");
				if(columnid==tablecolid)
				{
					tablcolColl[i].removeNode(true);
					i--;
				}
			}
		}
	}
	
	function mxd_table_movecolumn(sourcecol, targetcol, whereto)
	{
		var sourceTablecolId = sourcecol.id;
		var targetTablecolId = targetcol.id; 
		var tableCtrl = targetcol; 
		while(tableCtrl.getAttribute("controltype")!="table")
		{
			tableCtrl = tableCtrl.parentElement;
			if(undef(tableCtrl)){break;}
		}
		if(!undef(tableCtrl))
		{
			table_fnHandleReorderColumn(tableCtrl, sourceTablecolId, targetTablecolId);
		}
	}

	//*****************************************************************************
	// Predefined HTML EVENT HANDLERS FOR "tablecol" CONTROL IN DESIGN MODE
	//*****************************************************************************
	function mxd_tablecol_onmousedown(tablecol)
	{
		var selectedControl = event.srcElement;
		var tablecolId = tablecol.getAttribute("tablecolid");

		var tableControl;
		var colIndex;
		
		selectedControl = tablecol.document.getElementById(tablecolId);
		tableControl = library_getControlByType(selectedControl, "table");
		if(!undef(selectedControl))
		{
			if (selectedControl != currentControl)
			{
				if (currentControl != null)
				{
					var mxpart = currentControl.getAttribute("mxpart");
					if(mxpart == "header_col")
					{
						var prevTablecolId = currentControl.getAttribute("tablecolid"); 
						var prevColIndex = table_getColIndexFromId(tableControl, prevTablecolId);
						if(prevColIndex!=-1)
						{
							mxd_table_selectColumn(tableControl, prevColIndex, false);
						}	
					}
					else
					{
						currentControl.style.removeAttribute("backgroundColor");
						if(currentControl.tagName=="TR")
						{
							for(var i=0;i<currentControl.children.length;i++)
							{
								currentControl.children[i].style.border="";
							}
						}
					}	
				}
				
				var colIndex = table_getColIndexFromId(tableControl, tablecolId);
				if(colIndex!=-1)
				{
					mxd_table_selectColumn(tableControl, colIndex, true);
				}
				window.status = "selected control = tablecol :  " + selectedControl.id;
				window.top.sendEvent("selectcontrol", "canvas", selectedControl.id);
			}
			currentControl = selectedControl;
		}
		window.event.cancelBubble = true;
	}	
	function mxd_tablecol_ondragstart(tablecol)
	{
		var tmp = event.srcElement;
		while(tmp.getAttribute("controltype")!= "tablecol"){
			tmp = tmp.parentElement;
			if(undef(tmp)){break;}
		}
		if(!undef(tmp))
		{
		    dragSourceId = tmp.id;
		
			// Set the effectAllowed on the source object.
			var oData = event.dataTransfer;
			oData.setData("TEXT", dragSourceId);
			oData.effectAllowed = "move";
		}
		window.event.cancelBubble = true;
	}
	function mxd_tablecol_ondragenter(ctrlInst){mxd_ondragenter(ctrlInst);}
	function mxd_tablecol_ondragover(ctrlInst)
	{
		mxd_ondragover(ctrlInst);
		if(ctrlInst.className.indexOf(" tablecol_acceptdrop_left")==-1 && mxd_isvalidSourceAndTarget(currentControl, ctrlInst))		
		{
			ctrlInst.className = ctrlInst.className + " tablecol_acceptdrop_left";
		}
	}
	function mxd_tablecol_ondragleave(ctrlInst)
	{
		mxd_ondragleave(ctrlInst);
		cName = ctrlInst.className;
		cName = cName.replace(" tablecol_acceptdrop_left", "");
		ctrlInst.className = cName;
	}
	
	function mxd_tablecol_ondrop(ctrlInst)
	{
		mxd_ondragleave(ctrlInst);
		if(mxd_isvalidSourceAndTarget(currentControl, ctrlInst))
		{
		    var oData = event.dataTransfer;
			oData.dropEffect = "move";
			var sourceField = oData.getData("TEXT");
			if (sourceField == dragSourceId)
			{
			    // we are dragging an existing object from one place to another
				window.top.sendEvent("movecontrol", "canvas", dropTargetId);
			}
			else if (sourceField.indexOf("designer_ctrl_") >= 0)
			{
			    // we are dragging an object off of the toolbox
			    var objectType = sourceField;
			    
			    window.status = "dropped '" + dragSourceId + "' onto '" + dropTargetId + "'";
				window.top.sendEvent("insertcontrol", "canvas", dropTargetId, null, null, sourceField);
			}
			mxd_tablecol_ondragleave(ctrlInst);
		}
		window.event.cancelBubble = true;
		window.event.returnValue = false;
	}


	//*****************************************************************************
	// Helper function used for handling DESIGN MODE EVENTS for controls
	//*****************************************************************************
	function mxd_isvalidSourceAndTarget(sourcecontrol, targetcontrol)
	{
		var validSourceAndTarget = false;
		if(sourcecontrol!=null && targetcontrol!=null)
		{
			var srcControlType = sourcecontrol.getAttribute("controltype");
			var targetControlType = targetcontrol.getAttribute("controltype");
			switch(targetControlType)
			{
				default: 
					validSourceAndTarget = true; 
					break;
			}
		}
		return validSourceAndTarget;
	}

	function mxd_rerendercontrol(eventTarget, renderControlId, dropTargetId, whereToDrop, srcParentId)
	{
		var canvasdoc = top.document.getElementById("canvas").contentWindow.document;
		if(canvasdoc)
		{
			commframedoc = canvasdoc.getElementById("commframe").contentWindow.document;
			hiddenForm = commframedoc.getElementById("hiddenform");
			
			newInput = commframedoc.createElement("<input type='hidden' >");
			newInput.name = "rerenderid";
			newInput.value = renderControlId;
			hiddenForm.appendChild(newInput);
			
			if(srcParentId!=renderControlId)
			{
				newInput = commframedoc.createElement("<input type='hidden' >");
				newInput.name = "srcparentid";
				newInput.value = srcParentId;
				hiddenForm.appendChild(newInput);
			}

			inputs = hiddenForm.elements;
			inputs.namedItem("event").value = "rerendercontrol";
			inputs.namedItem("targetid").value = eventTarget;
			hiddenForm.submit();
			disableDoc();
		}

	}

/**************** END Standard functions for whereclause**********************/

function appbar_onmouseout(ctrlInst){}
function appbar_onmouseover(ctrlInst){}
function combobox_ondblclick(ctrlInst){}
function combobox_onpropertychange(ctrlInst){}
function combobox_setvalue(ctrlInst){}
function expbutton_onactivate(ctrlInst){}
function expbutton_onkeydown(ctrlInst){}
function glnavigator_onmouseout(ctrlInst){}
function glnavigator_onkeydown(ctrlInst){}
function glnavigator_onmouseover(ctrlInst){}
function multicolumntextbox_ondblclick(ctrlInst){}
function multilinetextbox_setvalue(ctrlInst){}
function multiparttextbox_ondblclick(ctrlInst){}
function multiparttextbox_onpropertychange(ctrlInst){}
function popup_oncontentready(ctrlInst){}
function toolbarcombobox_onpropertychange(ctrlInst){}
function wallcalendar_onmouseout(ctrlInst){}
function wallcalendar_onkeydown(ctrlInst){}
function wallcalendar_onmouseover(ctrlInst){}