/*start bwf*/
if (typeof BWF == "undefined") {    
    var BWF = {};
}
BWF.init = function() {};
BWF.lang = {    
    isArray: function(obj) { // frames lose type, so test constructor string
        if (obj && obj.constructor &&
                   obj.constructor.toString().indexOf('Array') > -1) {
            return true;
        } else {
            return BWF.lang.isObject(obj) && obj.constructor == Array;
        }
    },
    isBoolean: function(obj) {
        return typeof obj == 'boolean';
    },    
    isFunction: function(obj) {
        return typeof obj == 'function';
    },
    isNull: function(obj) {
        return obj === null;
    },
    isNumber: function(obj) {
        return typeof obj == 'number' && isFinite(obj);
    },
    isObject: function(obj) {
        return obj && (typeof obj == 'object' || BWF.lang.isFunction(obj));
    },
    isString: function(obj) {
        return typeof obj == 'string';
    },
    isUndefined: function(obj) {
        return typeof obj == 'undefined';
    },
    hasOwnProperty: function(obj, prop) {
        if (Object.prototype.hasOwnProperty) {
            return obj.hasOwnProperty(prop);
        }

        return !BWF.lang.isUndefined(obj[prop]) &&
                obj.constructor.prototype[prop] !== obj[prop];
    },
    extend: function(subc, superc, overrides) {
        if (!superc||!subc) {
            throw new Error("BWF.lang.extend failed, please check that " +
                            "all dependencies are included.");
        }
        var F = function() {};
        F.prototype=superc.prototype;
        subc.prototype=new F();
        subc.prototype.constructor=subc;
        subc.superclass=superc.prototype;
        if (superc.prototype.constructor == Object.prototype.constructor) {
            superc.prototype.constructor=superc;
        }

        if (overrides) {
            for (var i in overrides) {
                subc.prototype[i]=overrides[i];
            }
        }
    },
    augment: function(r, s) {
        if (!s||!r) {
            throw new Error("BWF.lang.augment failed, please check that " +
                            "all dependencies are included.");
        }
        var rp=r.prototype, sp=s.prototype, a=arguments, i, p;
        if (a[2]) {
            for (i=2; i<a.length; i=i+1) {
                rp[a[i]] = sp[a[i]];
            }
        } else {
            for (p in sp) {
                if (!rp[p]) {
                    rp[p] = sp[p];
                }
            }
        }
    },
    elementExists : function( id ){
				var d = $(id);
				if (d) {
					return 1;
				} else {
					return 0;
				}
    }
};


BWF.init();
/*end bwf*/

/*start framework*/
BWF.Validator = Class.create();
BWF.Validator.prototype	= {
	type		:	"all",
	initialize	: function( validators ) {
		validators[ this.type ] = this;
	},
	doValidate	: function( input ) {
		return "";
	},
	validate	: function( input , errordiv ) {
		var errorMsg		= this.doValidate( input );
		errordiv.innerHTML	= errorMsg;
		return ( errorMsg.length == 0 );
	}
};
BWF.NumberValidator	= Class.create();
Object.extend( BWF.NumberValidator.prototype , BWF.Validator.prototype );
Object.extend( BWF.NumberValidator.prototype , {
		type		: "number",
		doValidate	: function( input ) {
			var numberpattern	= /(^\d+$)|(^\d+\.\d+$)/;
			if ( numberpattern.test( input ) ) {
				return "";
			} else {				
				return "NUMBER";
			}
		}
	}
);
BWF.EmailValidator	= Class.create();
Object.extend( BWF.EmailValidator.prototype , BWF.Validator.prototype );
Object.extend( BWF.EmailValidator.prototype , {
		type		: "email",
		doValidate	: function( input ) {
			var emailpattern	= /^.+@.+\..{2,3}$/;
			if ( emailpattern.test( input ) ) {
				return "";
			} else {
				return "INVALID EMAIL";
			}
		}
	}
);
BWF.EmptyValidator = Class.create();
Object.extend( BWF.EmptyValidator.prototype , BWF.Validator.prototype );
Object.extend( BWF.EmptyValidator.prototype , {	
        type: "empty",   
        doValidate: function( input ) {
           if ( input != "" ) {
              return "";
           } else {
              return "REQUIRED";
           }
        }
   }
);
BWF.DateValidator = Class.create();
Object.extend( BWF.DateValidator.prototype, BWF.Validator.prototype);
Object.extend( BWF.DateValidator.prototype, {
  type: "date",
   doValidate: function(input) {
    var value = Date.parse(input);
    if(value <= 0) {
      return "'" + input + "' is not a date.";
    } else {
      return "";
    }
  }
});
BWF.ValidationFramework	= Class.create();
BWF.ValidationFramework.prototype	= {
	validators		: 0,
	crossValidators : 0,
	validateInput	: function( input ) {
		var retval = true;
		type		 = input.getAttribute("valid");
		errorDivName = input.getAttribute("name") + "_err";
		if ( type == null || errorDivName == null) {
			//
		} else {
			valid = this.validate( type, input.value, $(errorDivName) );

			if( !valid ) {
				retval = false;
			}
		}
		return retval;
	},
	validateForm	: function( form ) {
		var retval	= true;
		for( var i = 0; i < form.length; i++ ) {
			currentInput = form[i];
			type		 = currentInput.getAttribute("valid");
			errorDivName = currentInput.getAttribute("name") + "_err";
			if ( type == null || errorDivName == null) {
				continue;
			} else {
				valid = this.validate( type, currentInput.value, $(errorDivName) );
				if( !valid ) {
					retval = false;
				}
			}
		}
		for(i = 0;
		    i < this.crossValidators.length; i++) {
		  this.crossValidators[i].clearErrors();
		}
		if (retval) {
		  for(i = 0; i < this.crossValidators.length; i++)  {
		    valid = this.crossValidators[i].validate();
		    if(!valid) {
		      retval = false;
		    }
		  }
		}
		return retval;
	},
	validate	: function( type, input, errordiv ) {
		var validator = this.validators[type];
	    if(!validator) {
	      alert("No validator for type '" + type + "'.");
	      return "";
	    }
	    return validator.validate(input, errordiv);
	},
	initialize	: function() {
		this.validators 	 = [];
    	this.crossValidators = [];
		new BWF.Validator( this.validators );
		new BWF.NumberValidator( this.validators );
		new BWF.DateValidator( this.validators );
		new BWF.EmptyValidator( this.validators );
		new BWF.EmailValidator( this.validators );
	}
};
BWF.CrossValidator = Class.create();
Object.extend(BWF.CrossValidator.prototype, {
    type: "none",
    crossError: 0,
    crossInputs: 0,
    initialize: function(framework,
                         p_crossInputs,
                         p_crossError) {
      framework.crossValidators.push(this);
      this.crossError = p_crossError;
      this.crossInputs = p_crossInputs;
    },
    validate: function() {
      errorMsg = this.doValidate(
        this.crossInputs);
      this.crossError.innerHTML = errorMsg;
      return (errorMsg.length == 0);
    },
    clearErrors: function() {
      this.crossError.innerHTML = "";
    }
});
BWF.DateRangeCrossValidator =
  Class.create();
Object.extend(BWF.DateRangeCrossValidator.prototype,
              BWF.CrossValidator.prototype);
Object.extend(BWF.DateRangeCrossValidator.prototype, {

  doValidate: function(inputs) {
    var startDate = Date.parse(inputs[0].value);
    var endDate = Date.parse(inputs[1].value);
    if (startDate > endDate) {
      return "The start date cannot be after the end date.";
    } else {
      return "";
    }
  }
});
/*end framework*/

/*start xb*/
/*The Ultimate addEvent function by Stephen Stchur Copyright (c) Microsoft Corporation.  All rights reserved. Description: Cross-browser eventing library Requires: Nothing
License: (Ms-PL):  http://www.codeplex.com/gimme/license */
var xb = {};
(function()
{
	var GUIDCounter = 0;
	var evtHash = {};
	var pseudoEvents =
	{
		'mouseenter': function(_fn, _useCapture, _listening)
		{
			var f = mouseEnter(_fn);
			_listening ? xb.addEvent(this, 'mouseover', f, _useCapture, false) : xb.removeEvent(this, 'mouseover', f, _useCapture, false);
			f = null;		
		},		
		'mouseleave': function(_fn, _useCapture, _listening)
		{
			var f = mouseEnter(_fn);
			_listening ? xb.addEvent(this, 'mouseout', f, _useCapture, false) : xb.removeEvent(this, 'mouseout', f, _useCapture, false);
			f = null;		
		}
	};	
	xb.Helper =
	{
		getObjectGUID: getObjectGUID,
		storeHandler: storeHandler,
		retrieveHandler: retrieveHandler,
		isAnAncestorOf: isAnAncestorOf,
		mouseEnter: mouseEnter
	};	
	xb.addEvent = function()
	{
		if (typeof document.addEventListener !== 'undefined')
		{
			return w3c_addEvent;
		}
		else if (typeof document.attachEvent !== 'undefined')
		{
			return ie_addEvent;
		}
		else
		{
			// no modern event support I guess :-( (you could use DOM 0 here if you really wanted to)
			return function() {};
		}		
		function w3c_addEvent(_elem, _evtName, _fn, _useCapture, _directCall)
		{
			var eventFn = pseudoEvents[_evtName];
						
			if (typeof eventFn === 'function' && _directCall !== false)
			{
				eventFn.call(_elem, _fn, _useCapture, true);
			}
			else
			{
				_elem.addEventListener(_evtName, _fn, _useCapture);
			}
		}		
		function ie_addEvent(_elem, _evtName, _fn, _useCapture, _directCall)
		{
			var eventFn = pseudoEvents[_evtName];
					
			if (typeof eventFn === 'function' && _directCall !== false)
			{
				eventFn.call(_elem, _fn, _useCapture, true);
			}
			else
			{
				// create a key to identify this element/event/function combination
				var key = generateHandlerKey(_elem, _evtName, _fn);
				
				// if this element/event/combo has already been wired up, just return
				var f = evtHash[key];
				if (typeof f !== 'undefined')
				{
					return;
				}
				
				// create a helper function to fix IE's lack of standards support
				f = function(e)
				{
					// map .target to .srcElement
					e.target = e.srcElement;
					
					// map .relatedTarget to either .toElement or .fromElement
					if (_evtName == 'mouseover') { e.relatedTarget = e.fromElement; }
					else if (_evtName == 'mouseout') { e.relatedTarget = e.toElement; }
						
					e.preventDefault = function() { e.returnValue = false; };
					e.stopPropagation = function() { e.cancelBubble = true; };

					// call the actual function, using entity (the element) as the 'this' object
					_fn.call(_elem, e);
					
					// null out these properties to prevent memory leaks
					e.target = null;
					e.relatedTarget = null;
					e.preventDefault = null;
					e.stopPropagation = null;
					e = null;
				};				
				// add the helper function to the event hash
				evtHash[key] = f;
				// hook up the event (IE style)
				_elem.attachEvent('on' + _evtName, f);				
				key = null;
				f = null;
			}
		}
	}();	
	xb.removeEvent = function()
	{
		if (typeof document.removeEventListener !== 'undefined')
		{
			return w3c_removeEvent;
		}
		else if (typeof document.detachEvent !== 'undefined')
		{
			return ie_removeEvent;
		}
		else
		{
			// no modern event support I guess :-(
			return function() {};
		}		
		function w3c_removeEvent(_elem, _evtName, _fn, _useCapture, _directCall)
		{
			var eventFn = pseudoEvents[_evtName];
						
			if (typeof eventFn === 'function' && _directCall !== false)
			{
				eventFn.call(_elem, _fn, _useCapture, false);
			}
			else
			{
				_elem.removeEventListener(_evtName, _fn, _useCapture);
			}
		}		
		function ie_removeEvent(_elem, _evtName, _fn, _useCapture, _directCall)
		{
			var eventFn = pseudoEvents[_evtName];
						
			if (typeof eventFn === 'function' && _directCall !== false)
			{
				eventFn.call(_elem, _fn, _useCapture, false);
			}
			else
			{
				var key = generateHandlerKey(_elem, _evtName, _fn);
				var f = evtHash[key];
				if (typeof f !== 'undefined')
				{
					// unhook the event and delete the element from the event hash
					_elem.detachEvent('on' + _evtName, f);
					delete evtHash[key];
				}
				// prevent IE memory leaks
				key = null;
				f = null;
			}			
			return this;
		}
	
	}();
	xb.defineEvent = function(_evtName, _logicFn)
	{
		pseudoEvents[_evtName] = _logicFn;
	};	
	// Helper Functions
	function storeHandler(_key, _handler)
	{
		evtHash[_key] = _handler;
	}	
	function retrieveHandler(_key)
	{
		return evtHash[_key];
	}	
	function generateHandlerKey(_elem, _evtName, _handler)
	{
		return '{' + getObjectGUID(_elem) + '/' + _evtName + '/' + getObjectGUID(_handler) + '}';	
	}	
	function isAnAncestorOf(_ancestor, _descendant, _generation)
	{
		if (_ancestor === _descendant) { return false; }		
		var gen = 0;
		while (_descendant && _descendant != _ancestor)
		{
			gen++;
			_descendant = _descendant.parentNode;
		}		
		_generation = _generation || gen;
		return _descendant === _ancestor && _generation === gen;		
	}	
	function mouseEnter(_fn)
	{	
		var key = xb.Helper.getObjectGUID(_fn);
		var f = evtHash[key];
		if (typeof f === 'undefined')
		{
			f = evtHash[key] = function(_evt)
			{
				var relTarget = _evt.relatedTarget;
				if (this === relTarget || isAnAncestorOf(this, relTarget)) { return; }		
				_fn.call(this, _evt);
			};
		}
		return f;	
	}	
	function getObjectGUID(_elem)
	{
		if (_elem === window)
		{
			return 'theWindow';
		}
		else if (_elem === document)
		{
			return 'theDocument';
		}
		else if (typeof _elem.uniqueID !== 'undefined')
		{
			return _elem.uniqueID;
		}
		var ex = '__$$GUID$$__';
		if (typeof _elem[ex] === 'undefined')
		{
			_elem[ex] = ex + GUIDCounter++;
		}
		return _elem[ex];
	}
})();
/*end xb*/

/*start scheduling functions*/
		   var selected_classes = new Array();
		   var alternate_classes = new Array();
		   var validator = new BWF.ValidationFramework();
		   
		   function review_courses(content)
		   {
		      var the_form = $('schedule_form').serialize(true);		      			      
			      
			  var results = new Ajax.Updater(content,'/scheduling/review-courses/',
			  {
			     parameters:the_form,
			     onComplete:function()
			     {
			        if($('concurrent').innerHTML == "y")
			        {			         		
			           $('confirm').hide();  //hide confirm button, there are concurrent classes
			           $('print').hide();  //hide print button, there are concurrent classes
			        }
			        
			        var location = $('campus').value;
			        
			        //refresh course list with session vars to check selected courses			        
			        var refresh_courses = new Ajax.Request('/scheduling/view-courses/campus/'+location,{
		               evalJS:true,
		               onLoading: function(){$('loading').show();},
		               onComplete:function(transport){
		                  $('loading').hide();		               
		               }
	                });
	                
	                $('campus').selectedIndex = 0;
	                $('campus').style.display = 'none';
	                $('course_content').innerHTML = '';                
			     }
			  });
		   }
		   
		   
		   function todays_date()
		   {
		      var today = new Date();
			  var dd = today.getDate();
			  var mm = today.getMonth()+1;//January is 0!
			  var yyyy = today.getFullYear();
			  if(dd<10){dd='0'+dd}
			  if(mm<10){mm='0'+mm}
			  today = mm+'/'+dd+'/'+yyyy;			  
			  return today;
		   }
		   
		   
		   function print_it()
		   {
		      var disp_setting="toolbar=no,location=no,directories=no,menubar=no,scrollbars=yes,width=650, height=600, left=100, top=25";
              var content = document.getElementById("review_content").innerHTML;              
              
              var today = todays_date();
              
              var student_info = 'Student: '+$('fname').value+' '+$('lname').value+'<br />Date of schedule submission: '+today;
                            
              var page_copy = '<html><head><title>Jones College Course Schedule</title><link rel="stylesheet" type="text/css" href="/css/print.css" /></head><body onLoad="self.print()"><div id="header"><img src="/images/print_logo.jpg" /></div>'+content+student_info+'</body></html>';

              var docprint=window.open("","",disp_setting);
			  docprint.document.open();			  
			  docprint.document.write(page_copy);
			  docprint.document.close();
			  docprint.focus();			  
		   }
		   
		   
		   function submit_it()
	       {
	          var the_form = $('schedule_form').serialize(true);             	
	             	
	          var results = new Ajax.Request('/scheduling/save',{
	             parameters:the_form,
		         evalJSON:true,
		         onComplete:function(transport) {
			        var response = transport.responseText;
			        
			        window.location="/scheduling/export-courses/s/"+response;
		         }
	          });	             
	       }
	       
	       function remove_course(the_id,type)
	       {	          
	          if(type == 'alt')  //remove row from dom, remove course from form field
	          {	          
	             alternate_classes.splice(alternate_classes.indexOf(the_id),1);
	             $('alternate_ids').value = alternate_classes.join(",");             
	          }
	          else if(type == 'course')
	          {
	             selected_classes.splice(selected_classes.indexOf(the_id),1);
	             $('course_ids').value = selected_classes.join(",");
	          }
	          
	          var row = 'row_' + the_id;
	          $(row).remove();
	          
	          //console.log('removed row '+row);
	          
	          var content = $('review_content');

	          review_courses(content);
	       }	       
	       
	       function clear_course(the_id,type)
	       {
	          if(type == 'alt')  //remove alt course from form field
	          {	          
	             alternate_classes.splice(alternate_classes.indexOf(the_id),1);
	             $('alternate_ids').value = alternate_classes.join(",");             
	          }
	          else(type == 'course')  //remove course from form field
	          {
	             selected_classes.splice(selected_classes.indexOf(the_id),1);
	             $('course_ids').value = selected_classes.join(",");
	          }
	       }
		
		   function toggle_course(the_event){		   	  
		   	
		   	  try  //see if click was on a checkbox
		   	  {
		         var elt = Event.findElement(the_event, 'input').id;  //id of clicked checkbox
		   	  }
		      catch(err)  //click wasn't a checkbox, don't run rest of function
			  {
			     var error = true;   
			  }

		      
			  if(!error)  //click was a checkbox
			  {		      
			      if($(elt).checked == true)  //assign clicked id to opposite so for loop works
			      {
			         $(elt).checked = false;			         
			         
			         if( elt.include('id') )  //clicked element is course
			         {
			         	var type = 'course';
			         	
			         	if(selected_classes.length == 5)  //can only select up to 5 classes
			            {
			         	   alert('5 classes is the maximum');
			         	   return;
			            }
			            
			            var the_class = elt.gsub('id_',''); //id to match on with 'id_' removed
			            
			            var str_param = 'input.course_' + the_class;
			            var str_param_corr = 'input.alt_' + the_class;  //corresponding set
			         }
			         else  //clicked element is alternate
			         {
			         	var type = 'alternate';
			         	
			         	if(alternate_classes.length == 3)  //can only select up to 3 alternates
			            {
			         	   alert('3 alternates is the maximum');
			         	   return;
			            }
			            
			            var the_class = elt.gsub('alt_',''); //id to match on with 'alt_' removed
			            
			            var str_param = 'input.alt_' + the_class;
			            var str_param_corr = 'input.course_' + the_class;  //corresponding set
			         }			         
			         
			      }
			      else
			      {
			         $(elt).checked = true;
			         
			         if( elt.include('id') )  //clicked element is course
					 {
					    var type = 'course';   
								            
					    var the_class = elt.gsub('id_',''); //id to match on with 'id_' removed
								            
					    var str_param = 'input.course_' + the_class;
					    var str_param_corr = 'alt.course_' + the_class;  //corresponding set
					 }
					 else  //clicked element is alternate
					 {
					    var type = 'alternate';   
								            
					     var the_class = elt.gsub('alt_',''); //id to match on with 'alt_' removed
								            
					     var str_param = 'input.alt_' + the_class;
					     var str_param_corr = 'course.course_' + the_class;  //corresponding set
					 }
			      }
	              
	              var course_id = the_class.substr(0,the_class.length-2);  //number of course, ex: 11	               	  
	              var str_length = str_param.length;               	  
	              var str_length_corr = str_param_corr.length;
	               	  
	              str_param = str_param.substr(0,str_length - 2);  //the id, ex: 11_
	              str_param_corr = str_param_corr.substr(0,str_length_corr - 2);  //the corresponding id, ex: 11_
	               	  
	              var matched_ids = $$(str_param);  //array of matching ids
	              var matched_ids_corr = $$(str_param_corr);  //array of matching ids
	              
	              var is_checked;
	              
	              if( $(matched_ids[0]).checked == true )  //is first element checked?
	              {
	                 is_checked = false;	                    
	              }
	              else
	              {
	                 is_checked = true;	              	 	              	 	
	              }
	              
	              for(i=0;i<matched_ids.length;i++)  //toggle checkboxes of matched ids
	              {	              	 
	                 $(matched_ids[i]).checked = is_checked;
	                 
	                 try
	                 {
	                 	$(matched_ids_corr[i]).checked = !is_checked;
	                 }
	                 catch(err)
	                 {
	                 	
	                 }
	              }
	              
	              if(is_checked)  //add to selected_classes array
	              {
	              	  if(type == 'course')
	              	  {
	                     selected_classes.push(course_id);  //add current course to end of array
	                     $('course_ids').value = selected_classes.join(",");	                     
	                     
	                     if( alternate_classes.include(course_id) ) //course exists in alternate list so remove it
	                     {
	                     	alternate_classes.splice(alternate_classes.indexOf(course_id),1);
	                     	$('alternate_ids').value = alternate_classes.join(",");
	                     }
	              	  }
	              	  else
	              	  {
	              	     alternate_classes.push(course_id);  //add current course to end of array
	                     $('alternate_ids').value = alternate_classes.join(",");	                     
	                     
	                     if( selected_classes.include(course_id) ) //course exists in selected list so remove it
	                     {
	                     	selected_classes.splice(selected_classes.indexOf(course_id),1);
	                     	$('course_ids').value = selected_classes.join(",");
	                     }
	              	  }
	              }
	              else  //remove current course from array
	              {	                 	
	                 if(type == 'course')
	              	  {
	                     selected_classes.splice(selected_classes.indexOf(course_id),1);
	                     $('course_ids').value = selected_classes.join(",");	                     
	                     
	                     if( alternate_classes.include(course_id) ) //course exists in alternate list so remove it
	                     {
	                     	alternate_classes.splice(alternate_classes.indexOf(course_id),1);
	                     	$('alternate_ids').value = alternate_classes.join(",");
	                     }
	              	  }
	              	  else
	              	  {
	              	     alternate_classes.splice(alternate_classes.indexOf(course_id),1);
	                     $('alternate_ids').value = alternate_classes.join(",");	                     
	                     
	                     if( selected_classes.include(course_id) ) //course exists in selected list so remove it
	                     {
	                     	selected_classes.splice(selected_classes.indexOf(course_id),1);
	                     	$('course_ids').value = selected_classes.join(",");
	                     }
	              	  }	              	
	              }
       
			  }
		   }		
		
		   document.observe("dom:loaded", function() {
		   	 
              Event.observe('campus','change', function() {
              	var location = $('campus').value;             	
              	                 
               var results = new Ajax.Updater('course_content','/scheduling/view-courses/campus/'+location,{
		            evalJSON:true,
		            onLoading: function(){$('loading').show();},
		            onComplete:function(transport){
		               $('loading').hide();		               
		            }
	             });
               });               

               var d = document.getElementById('course_content');  //event listener for form table
			    xb.addEvent(d, 'click', toggle_course, false);
			    
			   Event.observe('schedule_form','submit',function(event) {
			      Event.stop(event);
			      
			      if(selected_classes.length == 0)  //no classes selected
			      {
			      	alert('Select your classes.');
			      	return;
			      }
			      
			      
			      if (typeof event.target != "undefined") {
                     if (!validator.validateForm(event.target)) {
              	        alert('Complete all required fields.');
              	        Effect.ScrollTo('hdr');
              	        return;                                 
                     }
                  } else {
                     if (!validator.validateForm(event.srcElement)) {
              	        alert('Complete all required fields.');
              	        Effect.ScrollTo('hdr');
              	        return;                        
                     }
                  }
                  
                  if( ($('type[1]').checked == false) && ($('type[2]').checked == false) && ($('type[3]').checked == false) )
                  {
                     alert('Select student type');
                     Effect.ScrollTo('hdr');
              	     return;
                  }
			      
			      
			      var review = $('review');
			      var content = $('review_content');
			      
			      Effect.ScrollTo('hdr');
			      review.appear();		      
			      
			      review_courses(content);
			         
	             });	             
	             
	             var radios = document.getElementById('radio_buttons');  //event listener for radio buttons
			     xb.addEvent(radios, 'click', toggle_radios, false);
			     
			     function toggle_radios(the_event)
			     {
			     	if( (the_event.target.id == 'type[2]') || (the_event.target.id == 'type[3]') )
	             	{
	             		$('admissions_buttons').show();
	             	}
	             	else
	             	{
	             		$('admissions_buttons').hide();
	             	}
			     }
	             
	             
	             Event.observe('clear','click',function() {
	             	var form = $('schedule_form');
	             	
	                for(i=0;i<form.length;i++)
	                {
	                   if(form[i].type=="checkbox")
	                   {	                      
	                      if(form[i].checked == true)
	                      {
	                      	 form[i].checked = false;
	                      	 
	                      	 var the_id = '';
	                      	 
	                         /*if( form[i].id.include('id') )  //course
	                         {
	                         	the_id = form[i].id.gsub('id_','');  //remove id_
	                         	the_id = the_id.substr(0,the_id.length - 2);  //remove last 2 chars
	                         	
	                         	clear_course(the_id,'course');
	                         }
	                         else //alternate
	                         {
	                         	the_id = form[i].id.gsub('alt_','');  //remove id_
	                         	the_id = the_id.substr(0,the_id.length - 2);  //remove last 2 chars
	                         	
	                         	clear_course(the_id,'alt');
	                         }*/
	                      }
	                   }  //if checkbox
	                }  //for
	                //unset session vars
	                var results = new Ajax.Request('/scheduling/clear-session');
	                $('course_ids').value = '';
	                $('alternate_ids').value = '';
	                selected_classes.length = 0;
		            alternate_classes.length = 0;
	             });
			   });			
/*end scheduling functions*/