if (!jQueryMaj) {
	"use strict";

	// Init the majestri namespace.
	var jQueryMaj = true;
	
	// extend maj and jQuery using an anonymous function to ensure variable scope safety.
	// this also allows us to change the maj namespace if we ever want to.
	(function(maj,$){
		// Global variables available to maj library and jQuery maj plugin.
		var mbImageLinkClickAttached = false;
		var moBrowseImage;
		var moPhotoAlbums = [];
		var moCloneMaps = [];

		var moBlankImageMap = {url:'',title:''};
		var moBlankNumberMap = {defaultValue:0,minValue:0,maxValue:null};
		var moBlankCloneMap = {id:-1,internalKey:0,keys:[],$state:null,callback:null};
		var moBlankImageFileUploadMap = {gridFeatures: 0, uploadFinishedCallback: null};
		var moBlankContentMap = {url:'', preReadyCallback:null, postReadyCallback:null};
		var moRadioButtonGroups = [];

		var miModalZIndex=1000;
		var miNextId=0;

		var moExistingCssHrefs, moExistingJavaScriptUrls;

		var moModalWindows = [];


		//------------------------------------------------------------------------------
		// START: jQuery maj Plugin
		//------------------------------------------------------------------------------
		var jQueryMethods = {
			init: function(options) {},

					// Creats a new unique id.
			createId: function() {
				var lsNewId;
				for (;;) {
					miNextId++;
					lsNewId='cid'+miNextId;
					if (!$('#'+lsNewId).length) return lsNewId;
				}
			},

			checkBox: function(checkedClass) {
				// Find other checked Radio Buttons with same name.
				var $loThis = this;
				var $loCheckBox = this.find('input[type="checkbox"]');
				var lcDefCheckedClass = 'checked'; //const


				// Set up the default checked class if none is specified.
				if (!checkedClass) {
					checkedClass = lcDefCheckedClass;
				}

				var mToggleCollapsiblePanel = function() {
					// Check if our Radio Button has a sibling that represents a collapsible section dependent on this Radio Button.
					var $loPanel = $loThis.siblings('.collapsible');
					if ($loPanel.length) {
						$loPanel.toggle();
					}
				}

				$loThis.find('.yesNoPanel > *:not(input), .majLabel').bind('click.maj.checkBox', function(e) {
					e.preventDefault();
					$loCheckBox.click();
					$loCheckBox.focus();
					//$loCheckBox.attr('checked', !$loCheckBox.attr('checked'));
					//$loThis.toggleClass(checkedClass, $loCheckBox.is(':checked'));
					//mToggleCollapsiblePanel();
				});
				
				var mProcessCheckBox = function() {
					$loThis.toggleClass(checkedClass, $loCheckBox.is(':checked'));
					mToggleCollapsiblePanel();
				};

				$loCheckBox.bind('change.maj.checkBox', function() {
					mProcessCheckBox();
				});
				
				mProcessCheckBox();
				
				return this;
			},

			radioButton: function(checkedClass) {
				// Find other checked Radio Buttons with same name.
				var $loThis = this;
				var $loRadioButton = this.find('input[type="radio"]');
				var lcDefCheckedClass = 'checked'; //const

				// Set up the default checked class if none is specified.
				if (!checkedClass) {
					checkedClass = lcDefCheckedClass;
				}

				var mToggleCollapsiblePanel = function() {
					// Check if our Radio Button has a sibling that represents a collapsible section dependent on this Radio Button.
					return;
					var $loPanel = $loThis.siblings('.collapsible');
					if ($loPanel.length) {
							$loPanel.toggle();
					}
				}

				// Show the panel if our Radio Button is on.
				if (!$loRadioButton.is(':checked')) {
					mToggleCollapsiblePanel();
				}

				$loRadioButton.bind('click.maj.radioButton', function() {
					// Find the Radio button that was previously selected and change its label style and hide its collapsible panel (if applicable).
					var $loOldLabel = $(document).find(':radio:not(:checked)').closest('.majStandardCtl').find('.majFieldLabel.checked');
					
					// If there is no "old" label found, then the user has clicked on the already selected Radio Button.
					if(!$loOldLabel.length) {
						return;
					}
					
					if ($loOldLabel.length) {
							$loOldLabel.toggleClass(checkedClass);
							var $loContainer = $loOldLabel.parents('.majStandardCtl');
							var $loOldPanel = $loContainer.siblings('.collapsible');
							if ($loOldPanel.length) {
									//$loOldPanel.toggle();
							}
					}

					$loThis.toggleClass(checkedClass, $loRadioButton.is(':checked'));

					mToggleCollapsiblePanel();
				});
			},

			// Pops up a modal window to browse a set of image links.
			// initialUrl: specifies the url of the image to show initially.
			// imageLinks: array of array - inner array structure is [imageUrl, title, description].	If not specified, this array is automatically built by finding the elements matching the a.imageLink selector.
			browseImage: function(map) {
				return this.maj('browseImages',[map],0);
			},

			// Pops up a modal window to browse a set of image links.
			// imageLinks: array of array - inner array structure is [imageUrl, title, description].
			// startIndex: specifies the indx of the first image to browse.
			browseImages: function(imageMaps,startIndex) {
				var $loWindow;

				if (moBrowseImage) {
					$loWindow = moBrowseImage.$window;
				} else {
					// Wire up the common infrastructure to support the image popup.
					// * Create and append the elements that represent the popup to the end of the body tag (initially hidden).
					// * Grab global references to the various elements within the image popup.
					// * Wire up the Prev and Next event handlers.
					moBrowseImage={};
					$loWindow = $().maj('newModalWindow')
												 .append(	'<div class="imageBox"></div>' +
																	'<div class="majPanel horizontal widthFull paddingTB5">' +
																		'<a class="prev" href="#">Previous</a>' +
																		'<h4 class="title"></h4>' +
																		'<a class="next" href="#">Next</a>' +
																	'</div>');

					moBrowseImage.$window = $loWindow;
					moBrowseImage.$title = $loWindow.find('.title');
					moBrowseImage.$descr = $loWindow.find('.descr');
					moBrowseImage.index = 0;
					moBrowseImage.length = 0;
					moBrowseImage.imageMaps=[];

					moBrowseImage.$imageBox = $loWindow.find('.imageBox').click(function(e){
						e.preventDefault();
						moBrowseImage.showImage(1);
					});

					moBrowseImage.$prev = $loWindow.find('.prev').click(function(e) {
						e.preventDefault();
						moBrowseImage.showImage(-1);
					});

					moBrowseImage.$next = $loWindow.find('.next').click(function(e) {
						e.preventDefault();
						moBrowseImage.showImage(1);
					});

					moBrowseImage.showImage = function(offset) {
						if (maj.isNumber(offset)) {
							var liNewIndex=this.index+maj.math.round(offset);
							if (liNewIndex<0 || liNewIndex>=this.length) {
								return;
							}
							this.index=liNewIndex;
						}

						var lbShowPrev,lbShowNext;
						lbShowPrev=lbShowNext=false;

						var loImageMap=this.imageMaps[this.index];
						if (loImageMap) {
							lbShowNext=(this.index<this.length-1);
							lbShowPrev=(this.index>0);
							
							this.$imageBox.maj('lateLoadImage',loImageMap,false);

							var lsTitle = loImageMap.title;
							if (this.imageMaps.length>1) {
								lsTitle=lsTitle + ' (' + (this.index+1) + ' of ' + this.length + ')';
							}
							moBrowseImage.$title.text(lsTitle);
						}

						if (moBrowseImage.length<=1) {
							moBrowseImage.$prev.hide();
							moBrowseImage.$next.hide();
						} else {
							moBrowseImage.$prev.show().maj('toggleDisabled',!lbShowPrev);
							moBrowseImage.$next.show().maj('toggleDisabled',!lbShowNext);
						}

						if (lbShowNext) {
							moBrowseImage.$imageBox.addClass('cursorPointer');
						} else {
							moBrowseImage.$imageBox.removeClass('cursorPointer');
						}
					};
				}

				//if (!$loWindow.maj('isVisible')) {
					$loWindow.maj('center').show();// jqmShow();
				//}

				if (!startIndex || startIndex<0) {
					startIndex=0;
				} else if (startIndex>=imageMaps.length) {
					startIndex=imageMaps.length-1;
				}

				moBrowseImage.index=startIndex;
				moBrowseImage.imageMaps=imageMaps;
				moBrowseImage.length=imageMaps.length;
				moBrowseImage.showImage();
				moBrowseImage = undefined;

				return this;
			},

			// Determines whether the specfied element is visible.
			isVisible: function() {
				return this.is(':visible');
			},

			// Provides functionality that allows an image to be display in a popup window.
			// map.url: defines the url of the image to be displayed.	If empty then the href of the closest anchor is used.
			// map.title: defines a title for the image.
			// map.descr: defines a description of the image.
			imageLink: function(map) {
				if (!mbImageLinkClickAttached) {
					mbImageLinkClickAttached=true;
					$('a.imageLink').live('click.maj.imageLink', function(e) {
						e.preventDefault();
						var $this=$(this);
						var lsUrl=$this.attr('href');
						if (!lsUrl) {
							return;
						}

						var loImageMap=$this.data('maj.imageMap');
						if (!loImageMap) {
							loImageMap=moBlankImageMap;
						} else if (maj.isNumber(loImageMap.albumId)) {
							// image is part of a photo album, so let's browse all images in the album.
							return $this.maj('browseImages',moPhotoAlbums[loImageMap.albumId],loImageMap.albumIndex);
						}
						return $this.maj('browseImage',loImageMap);
					});
				}

				var $loAnchor=this.closest('a.imageLink');
				if ($loAnchor.length) {
					if (map.url) {
						$loAnchor.attr('href', map.url);
					} else {
						map.url=$loAnchor.attr('href');
					}
				} else {
					// Let's create an anchor.
					$loAnchor = this.wrap('<a class="imageLink" href="' + map.url + '"></a>').parent();
				}
				$loAnchor.data('maj.imageMap', map);

				return this;
			},

			scrollIntoView: function() {
				if (this.length) {
					try {
						this[0].scrollIntoView(true);
					} catch(err) {
					}
				}

				return this;
			},


			// Centers an element (using absolute positioning) relative to the brower window.
			center: function (animate) {
				var $loWindow = $(window);
				var $loMain = $('#mainContent');
				
				
				var liScrollTop = $loWindow.scrollTop();
				var liScrollLeft = $loWindow.scrollLeft();

				/*
				if (!this.is(':visible')) {
					this.css({'position': 'absolute', 'top': liScrollTop+'px', 'left': liScrollLeft+'px', 'visibility': 'hidden', 'display': 'block'});
				}
				*/

				var liTop = maj.math.round(($loWindow.height()-this.outerHeight())/2);
				var liLeft = maj.math.round(($loWindow.width()-this.outerWidth())/2);

				$loWindow.scrollTop(liScrollTop);
				$loWindow.scrollLeft(liScrollLeft);

				if (liTop<0) {
					liTop=0;
				}

				if (liLeft<0) {
					liLeft=0;
				}

				liTop+=liScrollTop;
				//liLeft+=liScrollLeft;
				
				if ($loMain.length) {
					// tweak for IOS
					liLeft = maj.math.round(($loMain.width()-this.outerWidth())/2) + $loMain.offset().left;
				};

				var loStyle = {top:(liTop + 'px'), left:(liLeft + 'px')};
				if (animate) {
					this.css({'position': 'absolute', 'visibility': 'visible', 'display': 'block'}).animate(loStyle);
				} else {
					loStyle.position = 'absolute';
					loStyle.visibility = 'visible';
					this.css(loStyle);
				}
				
				return this;
			},

			// Replaces oldClass on matching elements with newClass.
			// oldClass: an old class to be removed from matching elements.
			// newClass: a new class to be added to matching elements.
			swapClass: function(oldClass, newClass) {
				if (oldClass===newClass) {
					return;
				}

				return this.removeClass(oldClass).addClass(newClass);
			},

			// Modifies the visibility of matching elements by adding the relevant visiblity class.
			// exp: expression defining whether visibility it true (visible) or false (hidden).
			toggleVisibility: function(exp) {
				if (exp) {
					return this.maj('swapClass', 'visHidden', 'visVisible');
				} else {
					return this.maj('swapClass', 'visVisible', 'visHidden');
				}
			},

			toggleDisabled: function(exp) {
				return this.toggleClass('disabled', exp);
			},

			// Provides a mechanism for images to be loaded late
			// map.url: the url of the image to late load.
			// map.text: the altText of the iamge to be loaded.
			// map.descr: a description of the image.
			// map.largeUrl: a url to a larger version of the image that will appear in a popup when the image container is clicked.
			lateLoadImage: function(map,browsable) {
				if (!map || !map.url) {
					return this;
				}

				var $loContainer=this;
				var $loImage=this.find('img.lateLoad');

        if (!$loImage.length) {
          $loImage=$(new Image()).addClass('lateLoad').appendTo($loContainer);
					$loImage.bind('load.maj.lateLoadImage', function(e) {
            var liLeft = maj.math.round(($loContainer.width()-this.width)/2);
            var liTop = maj.math.round(($loContainer.height()-this.height)/2);
						$loImage.css({'margin-left':liLeft+'px', 'margin-top':liTop+'px'}).show();
            $loContainer.removeClass('loading');

					}).bind('error.maj.lateLoadImage', function(e) {
            $loContainer.maj('swapClass', 'loading', 'broken');

          }).hide().appendTo($loContainer);
				}

        var lsUrl=maj.sizedImageUrl(map.url,$loContainer.width(),$loContainer.height());
				if ($loImage.attr('src')!=lsUrl) {
					$loImage.hide();
          $loContainer.maj('swapClass', 'broken', 'loading');
				}

				$loImage.attr({src:lsUrl,alt:map.title});

				if (browsable) {
          $loContainer.maj('imageLink',map);
				}

				return this;
			},

			// Adds an image to an existing photo album (or sets up a new one).
			// imageMap: map of the image to add to the photo alubm.
			addToPhotoAlbum: function(imageMaps) {
				if (!$.isArray(imageMaps)) {
					imageMaps=[imageMaps];
				}

				liAlbumId=this.data('maj.photoAlbum.id');
				var loImageMaps;
				if (maj.isNumber(liAlbumId)) {
					var loImageMaps = moPhotoAlbums[liAlbumId];
				}

				if ($.isArray(loImageMaps)) {
					for (var liIdx=0; liIdx<imageMaps.length; liIdx++) {
						loImageMaps.unshift(imageMaps[liIdx]);
					}
				} else {
					loImageMaps = imageMaps;
				}

				return this.maj('photoAlbum',loImageMaps);
			},

			// Sets up a photoAlbum the auto fills all image boxes with late loaded images as defined in the imageMaps array.
			// imageMaps: array of array - inner array structure is [imageUrl, altText, largerImageUrl]
			photoAlbum: function(imageMaps) {
				if (!$.isArray(imageMaps)) {
					imageMaps=[imageMaps];
				}

				var $this=$(this);
				var $loImageBoxes=$this.find('.imageBox');
				var liImageBoxes = $loImageBoxes.length;
				var liStartIdx = 0;
				var $loPrev, $loNext, $loImagesShowing, $loImagesTotal;
	
				var liAlbumId=this.data('maj.photoAlbum.id');
				var lbExistingAlbum = maj.isNumber(liAlbumId);
				if (lbExistingAlbum) {
					// Update the album with the latest.
					moPhotoAlbums[liAlbumId]=imageMaps;
				} else {
					liAlbumId=moPhotoAlbums.length;
					moPhotoAlbums.push(imageMaps);
					this.data('maj.photoAlbum.id', liAlbumId);
				}

				var loFillPage = function(startIndex) {
					var liEndIdx = Math.min(imageMaps.length, startIndex+liImageBoxes)-1;
					var loImageMap;
					var liImageBoxIdx=0;
					var $loImageBox;

					if ($loImagesShowing) {
						var loText = [startIndex+1];
						if (liEndIdx>startIndex) {
							loText.push('to');
							loText.push(liEndIdx+1);
						}
						$loImagesShowing.html(loText.join(' '));
					}

					for (var liIdx=startIndex; liIdx<=liEndIdx; liIdx++) {
						loImageMap = imageMaps[liIdx];
						loImageMap.albumId=liAlbumId; //let all that care know that we belong to an album.
						loImageMap.albumIndex=liIdx; // they may also want to know where this image map is in the album.

						$loImageBox=$($loImageBoxes[liImageBoxIdx]);
						$loImageBox.maj('toggleVisibility', true)
											 .maj('lateLoadImage', loImageMap, true);
						liImageBoxIdx++;
					}
					
					var lbNextVisible = (liIdx<imageMaps.length);
					if (!lbNextVisible) {
						for (;liImageBoxIdx<liImageBoxes;liImageBoxIdx++) {
							$loImageBox=$($loImageBoxes[liImageBoxIdx]);
							$loImageBox.maj('toggleVisibility', false);
						}
					}

					if ($loNext) {
						$loNext.maj('toggleDisabled', !lbNextVisible);
					}

					if ($loPrev) {
						$loPrev.maj('toggleDisabled', startIndex<=0);
					}
				}

				var lsNamespace='.maj.photoAlbum';

				$loPrev = this.find('.prev').unbind('click'+lsNamespace).bind('click'+lsNamespace, function(e) {
					e.preventDefault();

					var liNewStartIdx = liStartIdx-liImageBoxes;
					if (liNewStartIdx<0) {
						liNewStartIdx = 0
					}
					if (liNewStartIdx!=liStartIdx) {
						liStartIdx = liNewStartIdx;
						loFillPage(liStartIdx);
					}
				});

				$loNext = this.find('.next').unbind('click'+lsNamespace).bind('click'+lsNamespace, function(e) {
					e.preventDefault();

					var liNewStartIdx = liStartIdx+liImageBoxes;
					if (liNewStartIdx>=imageMaps.length) {
						return;
					}

					liStartIdx=liNewStartIdx;
					loFillPage(liStartIdx);
				});

				$loImagesShowing = this.find('.imagesShowing');
				$loImagesTotal = this.find('.imagesTotal');
				if ($loImagesTotal.length) {
					$loImagesTotal.html(imageMaps.length);
				}

				var lbSomeImages = (imageMaps.length>0);
				this.find('.some').toggle(lbSomeImages);
				this.find('.none').toggle(!lbSomeImages);
				if (lbSomeImages) {
					$loNext.show();
					$loPrev.show();
				} else {
					$loNext.hide();
					$loPrev.hide();
				}

				loFillPage(liStartIdx);
			},

			// Loads content from a url the into matching elements.
			// map.url:
			// map.preReadyCallback:
			// map.postReadyCallback:
			loadContent: function(map) {
				var $this=this;
				var loAjaxRequest = maj.ajax.createRequest();
				loAjaxRequest.open("POST", map.url, true);
				loAjaxRequest.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
				loAjaxRequest.onreadystatechange = function() {

					if (loAjaxRequest.readyState === 4) {
						if ($.isFunction(map.preReadyCallback)) {
							map.preReadyCallback(loAjaxRequest);
						}

						if (loAjaxRequest.responseText.length) {
								$this.append(loAjaxRequest.responseText);
						} else {
						}

						if ($.isFunction(map.postReadyCallback)) {
							map.postReadyCallback(loAjaxRequest);
						}
					}

				}
				loAjaxRequest.send();
			},

			// Turns an input into a colour picker.
			// NB: To use this function the calling page must link to farbtastic.js
			// colourPickerSelector: selector identifying the colour picker element.
			// containerSelector: selector identifying the container of the colour picker and input - this is used for the auto hide/show on focus in/out.
			colourPicker: function() {
				var $loContainer=this.find('div.colourPicker');
				if (!$loContainer.length) {
					return this;
				}

				var $loInput = this.find('input.colourPicker');
				if (!$loInput.length) {
					return this;
				}

				$loContainer.farbtastic($loInput);

				this.focusin(function(e) {
					$loContainer.show();
				}).focusout(function(e) {
					$loContainer.hide();
				});
			},

			fileUploader: function(map) {
				if (!map) {
					map = moBlankImageFileUploadMap;
				}

				var $loUploader = this.find('.uploader');
				var loMap = {
					'uploadServiceUrl': '',
					'uploadServiceData': {},
					'uploadText': 'Upload a File',
					'fileDescr': 'Files',
					'fileExt': '*.*',
					'uploadFinishedCallback': null,
					'uploadSizeLimit': 4000000 //bytes - asp.net limit is about 4MB, this gives us some buffer.
				};

				loMap = $.extend(loMap, map);

				$loUploader.uploadify({
					'uploader': 'Plugins/jquery.uploadify/uploadify.allglyphs.swf',
					'script': loMap.uploadServiceUrl,
					'scriptData': loMap.uploadServiceData,
					'fileDesc': loMap.fileDescr,
					'fileExt': loMap.fileExt,
					'buttonText': loMap.uploadText,
//					'hideButton': true,
//					'wmode': 'transparent',
					'removeComplete': 'true',
					'cancelImg': 'images/ico16/close.png',
					'sizeLimit': loMap.uploadSizeLimit,
					'onComplete': function(event, ID, fileObj, response, data) {
						//$loUploader.uploadifyClearQueue();
						if ($.isFunction(loMap.uploadFinishedCallback)) {
							loMap.uploadFinishedCallback(response);
						}
					},
					'onError': function(file,errorCode,errorMsg) {
						alert(errorMsg + ' ' + errorCode);
					},
					'auto': true
				});

				return this;

			},


			// map.gridFeatures - the features to apply to the grid row returned on sucessful upload of an image.
			// map.uploadPath - url of the path to upload to.
			imageFileUploader: function(map) {
				if (!map) {
					map = moBlankImageFileUploadMap;
				}

				var $loUploader = this.find('.uploader');

				$loUploader.uploadify({
					'uploader': 'Plugins/jquery.uploadify/uploadify.allglyphs.swf',
					'script': 'UploadImage.aspx?gridFeatures=' + map.gridFeatures,
					'fileDesc': 'Image Files',
					'fileExt': '*.gif;*.jpg;*.jpeg;*.png',
					'buttonText': 'Upload an Image',
//					'hideButton': true,
//					'wmode': 'transparent',
					'removeComplete': 'true',
					'cancelImg': 'images/ico16/close.png',
					'sizeLimit': 4000000, //bytes - asp.net limit is about 4MB, this gives us some buffer.
					'onComplete': function(event, ID, fileObj, response, data) {
						//$loUploader.uploadifyClearQueue();

						if ($.isFunction(map.uploadFinishedCallback)) {
							map.uploadFinishedCallback(response);
						}

					},
					'onError': function(file,errorCode,errorMsg) {
						alert(errorMsg + ' ' + errorCode);
					},
					'auto': true
				});

				return this;
			},

			// Sets a textbox (input) up for use with numeric values. 
			// map.decimalPlaces,
			// map.defaultValue
			// map.minValue
			// map.maxValue
			numberTextBox: function(map) {
				if (!map) {
					map=moBlankNumberMap;
				}

				var lnDefaultValue=map.defaultValue;
				var lnMinValue=map.minValue;
				var lnMaxValue=map.maxValue;

				if (maj.isNumber(lnMinValue)) {
					lnMinValue=maj.math.round(lnMinValue, map.decimalPlaces);
				}

				if (maj.isNumber(lnMaxValue)) {
					lnMaxValue=maj.math.round(lnMaxValue, map.decimalPlaces);
				}

				if (!lnDefaultValue) {
					lnDefaultValue=this.val();
				}
				lnDefaultValue=maj.math.parseNumber(lnDefaultValue, map.decimalPlaces, 0);
				lnDefaultValue=maj.placeInRange(lnDefaultValue,lnMinValue,lnMaxValue)


				var loCleanseValueCallback = function() {
					var $this=$(this);
					var lnVal=maj.math.parseNumber($this.val(), map.decimalPlaces, lnDefaultValue);

					if ((lnMinValue && lnVal<lnMinValue) || (lnMaxValue && lnVal>lnMaxValue)) {
						lnVal = lnDefaultValue;
					} else {
						lnDefaultValue=lnVal; // change defaultValue so next time round we just revert to the current value.
					}

					$this.val(lnVal);
				}
				
				loCleanseValueCallback(); // Initial call to cleanse any existing value.
				this.bind('blue.maj.numberTextbox', loCleanseValueCallback);
			},

			urlTextBox: function() {
				$loInput = this.find('input');
				$loCheckLink = this.find('a');
				
				var mSetupCheckLink = function() {
					var lsVal = $loInput.val();
					var lbShow = (lsVal.length>0);
					if (lbShow) {
						$loCheckLink.attr('href', lsVal);
						$loCheckLink.fadeIn();
					} else {
						$loCheckLink.toggle(false);
					};
				};
				
				$loInput.bind('keyup.maj.urlTextBox', mSetupCheckLink)
								.bind('blur.maj.urlTextBox', mSetupCheckLink)
								.bind('click.maj.urlTextBox', mSetupCheckLink);
								
				mSetupCheckLink();
				
				return this;
			},

			datePicker: function() {
				var $loDay = this.find('.day select');
				var $loMonth = this.find('.month select');
				var $loYear = this.find('.year select');

				var $loMessage = this.find('.message');

				var loFormatDayOptionsCallback = function() {
					var liMonth = maj.math.parseNumber($loMonth.val(), 0, 1);
					liMonth = maj.placeInRange(liMonth, 1, 12);

					var liMaxDays;

					switch (liMonth) {
						case 11: case 4: case 6: case 9: // 30 days has Sep, Apr, Jun and Nov
							liMaxDays = 30;
							break;
						case 2:
							var liYear = maj.math.parseNumber($loYear.val());
							if ((liYear % 4)===0) {
								liMaxDays=29; //29 days in Feb for a leap year.
							} else {
								liMaxDays=28;
							};
							break;
						default:
							liMaxDays=31;
					};

					var $loDayChildren = $loDay.children();
					$loDayChildren.slice(27).removeClass('notApplicable');
					if (liMaxDays<31) {
						$loDayChildren.slice(liMaxDays).addClass('notApplicable');
					}
				}

				var loValidateDateCallback = function() {
					var liDay = maj.math.parseNumber($loDay.val());
					var liMonth = maj.math.parseNumber($loMonth.val());
					var liYear = maj.math.parseNumber($loYear.val());
					if (!maj.isValidDate(liDay, liMonth, liYear)) {
						$loMessage.fadeIn();
					} else {
						$loMessage.fadeOut();
					}
				}

				var loValidateAndFormatCallback = function() {
					loValidateDateCallback();
					loFormatDayOptionsCallback();
				}

				loFormatDayOptionsCallback(); // Call to style the days initially.
				loValidateDateCallback(); // Call to validate the date initially.

				var lsEvtNs='.maj.datePicker';
				$loDay.bind('blur'+lsEvtNs, loFormatDayOptionsCallback).bind('change'+lsEvtNs, loValidateDateCallback);
				$loMonth.bind('blur'+lsEvtNs, loFormatDayOptionsCallback).bind('change'+lsEvtNs, loValidateDateCallback);
				$loYear.bind('blur'+lsEvtNs, loValidateAndFormatCallback).bind('change'+lsEvtNs, loValidateDateCallback);
			},

			prefixIdsAndNames: function(prefix) {
				var loElem;
				for (var liIdx = 0; liIdx < this.length; liIdx++) {
					loElem = this[liIdx];

					if (loElem.id !== undefined) {
						loElem.id = prefix + loElem.id;

						// Only elements with an id may possess a name.
						if (loElem.name !== undefined) {
							loElem.name = prefix + loElem.name;
						}
					}

					$(loElem.childNodes).maj('prefixIdsAndNames', prefix);
				}
			},

			// Helper class for managing the cloning of a set of elements.
			// processCloneCallback (optional) - function to execute on the cloned element (and it's children).
			clonable: function(processCloneCallback,stateSelector) {
				var $loState = $(stateSelector); // $('input .clonable.state');
				var liInternalKey = 0;
				var loKeys = [];
				
				// Setup the keys from those that may be stored in the state input element.
				var loKeysFromState = $loState.val().split(',');
				var lsKey;

				for (var liIdx=0; liIdx<loKeysFromState.length; liIdx++) {
					lsKey = loKeysFromState[liIdx];
					if (lsKey.length) {
						loKeys.push(lsKey);
						liInternalKey = Math.max(liInternalKey, maj.math.parseNumber(lsKey,0,0));

						if ($.isFunction(processCloneCallback)) {
							processCloneCallback(lsKey, $('#' + lsKey + '_' + this.children()[0].id));
						}
					}
				}

				var loCloneMap = {id:moCloneMaps.length,internalKey:liInternalKey,keys:loKeys,$state:$loState,callback:processCloneCallback};
				this.data('maj.cloneMap', loCloneMap);
			},

			addClone: function(key) {
				var loCloneMap=this.data('maj.cloneMap');
				if (!loCloneMap) {
					return;
				}

				if (!key) {
					key = ++loCloneMap.internalKey;
				}

				var $loClone = $(this.children()).clone();
				$loClone.maj('prefixIdsAndNames', key + '_');
				$loClone.hide();

				this.before($loClone);
				loCloneMap.keys.push(key);
				loCloneMap.$state.val(loCloneMap.keys.join());

				if ($.isFunction(loCloneMap.callback)) {
					loCloneMap.callback(key, $loClone);
				}

				$loClone.slideDown();
			},

			scrollingContainer: function() {
				var lcCardWidth = 189; //const
				var lcGlobeWidth = 16;

				var $loMyMembership = $('#pnlMyMembership');
				var $loActiveContextStrip = $('.activeStrip');
				var $loInactiveContextStrip = $('.inactiveStrip');
				var liNumberCards = $('.member', this).length;
				this.css("width", (liNumberCards * lcCardWidth) + "px");
				$loInactiveContextStrip.css("width", (liNumberCards * lcGlobeWidth) + "px");

				var loMoveCallback = function(multiplier) {
					$loMyMembership.stop(true, true);

					var liCardMarginLeft = $loMyMembership.css('margin-left');
					liCardMarginLeft = parseInt(liCardMarginLeft.substring(0, liCardMarginLeft.length - 2));
					if (liCardMarginLeft === 0 && multiplier > 0) {
						return;
					} else if ((liCardMarginLeft === (lcCardWidth * ((liNumberCards - 4) * multiplier))) && (multiplier < 0)) {
						return;
					}
					liCardMarginLeft += (lcCardWidth * multiplier);
					$loMyMembership.animate({ 'margin-left': liCardMarginLeft + 'px' }, 500);

					// Move the active balls.
					var liStripMarginLeft = $loActiveContextStrip.css('margin-left');
					liStripMarginLeft = parseInt(liStripMarginLeft.substring(0, liStripMarginLeft.length - 2));
					liStripMarginLeft += (lcGlobeWidth * multiplier * -1);

					$loActiveContextStrip.css('margin-left', liStripMarginLeft + 'px');
				};

				$('a.moveLeft').click(function() {
					loMoveCallback(1);
				});

				$('a.moveRight').click(function() {
					loMoveCallback(-1);
				});
			},

			repeatingSectionContainer: function() {
				var $loThis = this;
				var mAddSectionCallback = function(response) {
					//var $loNewSection = $();
					var loResponse = JSON.parse(response);
					var $loSection = $loThis.find('.repeatContainer');
					$loSection.append(loResponse.HTMLFragments['section']);
				}
				
				var $loTriggers = this.find('.trigger');
				$loTriggers.bind('click.maj.repeat', function() {
					var loParameters = {};
					var $loCounter = $loThis.find('input[name="' + $loThis.attr('id') + '_majSectionCounter"]');
					loParameters.nextCounter = parseInt($loCounter.val()) + 1;
					$loCounter.val(loParameters.nextCounter);
					var loOptions = {
						url: 'DynamicSectionRenderer.aspx',
						successCallback: mAddSectionCallback,
						failureCallback: function() { alert("Failed"); },
						parameters: loParameters
					}
					maj.ajax.submitJob(loOptions);							
				});
			},

			////////////////////////////////
			/* AUTO-SUGGEST FUNCTIONALITY */
			// settings.adaptorType
			// settings.providerType
			// settings.rendererType
			// settings.providerId
			////////////////////////////////
			autoSuggestControl: function(settings) {
					var $loThis = $(this);
					var $loSearchTextBox = this.find('input:not([type="hidden"])');
					var $loCodeTextBox = this.find('input[type="hidden"]');
					var $loSuggestionContainer = $loThis.find('.suggestionContainer');
					
					settings.adaptorType = 0;
					settings.providerType = 0;
					settings.rendererType = 0;

					// Get an instance of the provider we are using.
					$loSearchTextBox.bind('keyup', function(event) { mHandleKeyUp(event); });
					$loSearchTextBox.bind('blur', function() {
						//$loSuggestionContainer.html('');
					});

					var mHandleKeyUp = function(event) {
							switch (event.keyCode) {
									case 38:
											// Up Arrow
											if (loAdaptor) {
													alert("Up Arrow");
											}
											break;
									case 40:
											// Down Arrow
											if (loAdaptor) {
													alert("Down Arrow");
											}
											break;
									case 27:
											$loSearchTextBox.blur();
											break;
									case 13:
											if (loAdaptor) {
													alert('Enter');
											}
											break;
									default:
											resetTimer();
							}
					}

					// Logic to track the KeyUp event and work out when to submit it.
					var miTimer = 0;
					var resetTimer = function() {
						clearTimeout(miTimer);
						miTimer = setTimeout(function() { fetchSuggestions(); }, 300);
					}

					var fetchSuggestions = function() {
						var lsSearchValue = $loSearchTextBox.val();

						var mHandleResponseCallback = function(response) {
							var loResponse = JSON.parse(response);
							var lsSuggestionHTML = loResponse.HTMLFragments['suggestionHTML'];
							$loSuggestionContainer.html(lsSuggestionHTML);
							$loSuggestionContainer.maj('toggleVisibility', true);
							
							var $loSuggestions = $loSuggestionContainer.find('.suggestion');
							$loSuggestions.bind('click.maj.suggestion', function() {
								$loSearchTextBox.val($(this).text());
								if($loCodeTextBox.length) {
									$loCodeTextBox.val($(this).find('.data-element').text());
								}
							});
						}

						var loOptions = {
								url: "svcSuggestionProvider.aspx",
								successCallback: mHandleResponseCallback,
								failureCallback: mHandleResponseCallback,
								parameters: { providerId: settings.providerId, searchText: lsSearchValue }
						}
						maj.ajax.submitJob(loOptions);								
					};
			},

			// Makes the passed element the top most element (by adjusting it's z-index).
			// the starting top-most z-index is 1000.
			makeTopMost: function() {
				var liElemZIndex = maj.math.parseNumber(this.css('z-index'));
				miModalZIndex = Math.max(miModalZIndex, liElemZIndex);
				this.css('z-index', miModalZIndex);
				miModalZIndex++;
				return this;
			},
			
			////////////////////////////////////////////////////////////////
			/* MODAL FORM INVOCATION */
			// This method is designed to be bound to a link or button
			// in order to show a modal form.
			// The settings class should look like this:
			//		pageURL:
			//		parameters:
			////////////////////////////////////////////////////////////////

			//---------------------------------------------------------------------
			// Closes the top-most modal window (if any).
			//---------------------------------------------------------------------
			closeModalWindow: function(supressCallback) {
				var loModalWindow = moModalWindows.pop();
				if (loModalWindow) {
					loModalWindow.$window.remove();
					loModalWindow.$blind.remove();

					if (!supressCallback && $.isFunction(loModalWindow.closeCallback)) {
						loModalWindow.closeCallback();
					}
				}

				return this;
			},

			//---------------------------------------------------------------------------------------------------------------------------------------------------------------
			// Creates an returns a new element (wrapped with jQuery) representing the shell of a modal window.  Simple append the detail of the window to this new element.
			// Settings are:
			//   hidden: if true, then new modal window is hidden by default.
			//   closeCallback: a function to be invoked when the close event is triggered.  Callback signature is function().
			//   closeOnBlindClick: close the modal window when the blind behind is clicked.
			//---------------------------------------------------------------------------------------------------------------------------------------------------------------
			newModalWindow: function(settings) {
				if (!settings) settings = {};

				// Create an instance of the modal window (i.e. the element that blocks the main page).
				var $loBody = $('body');
				var $loModalBlind = $('<div class="modalBlind"></div>').css({'min-height':$loBody.outerHeight()+'px'}).maj('makeTopMost').toggle(false).appendTo($loBody).fadeIn();

				// Create a new modal page that will sit on top of the main page.
				var loHtml = [];
				loHtml.push('<div class="modalWindow">');
				loHtml.push('<div>'); // Container div, help create the transparent border provided by the parent div.

				// Header div
				loHtml.push('<div class="header horizontal paddingLR10 paddingTB5">');
				loHtml.push('<h3 style="margin-top:1px;"></h3>');
				loHtml.push('<a class="close" href="#"></a>');
				loHtml.push('</div>');

				// Placeholder for dynamic content
				loHtml.push('<div class="content padding10"></div>');

				loHtml.push('</div>'); // container div
				loHtml.push('</div>'); // modal window div

				/*
				var $loModalWindow = $('<div class="modalWindow">' +
																'<div class="header"><a class="close" href="#" style="text-align:right;">Close</a></a>' +
															'</div>').maj('makeTopMost');
				*/

				var $loModalWindow = $(loHtml.join('')).maj('makeTopMost');

				if (settings.title) {
					$loModalWindow.find('.header > h3').text(settings.title);
				}

				// Register this modal window.
				moModalWindows.push({
					'$blind': $loModalBlind,
					'$window': $loModalWindow,
					'closeCallback': settings.closeCallback
				});

				$loModalWindow.data('maj.modalWindow.blind', $loModalBlind[0]);

				if ($.isFunction(settings.closeCallback)) {
					// Associate the callback to be invoked on close with the modal window.
					$loModalWindow.data('maj.modalWindow.closeCallback', settings.closeCallback);
				}

				if (settings.hidden) {
					$loModalWindow.hide();
				}

				$loModalWindow.appendTo($loBody);

				if (settings.content) {
					$loModalWindow.find('.content').append(settings.content);
				}

				if (settings.closeOnBlindClick) {
					$loModalBlind.bind('click.maj.modalWindow.close', function(e) {
						e.preventDefault();
						$().maj('closeModalWindow');
					});
				}

				$loModalWindow.delegate('.close, #Cancel', 'click.maj.modalWindow.close', function(e) { // ToDo: remove #Cancel selector.
					e.preventDefault();
					$().maj('closeModalWindow');
				});

				return $loModalWindow;
			},

			busyBlind: function() {
				var $loBlind = this.maj('shadowElement', 'busy');
				$loBlind.append('<div class="working"></div>');
				return $loBlind.fadeIn('fast');
			},

			//-------------------------------------------------------------------------------------------
			// Shows a new modal window with content loaded from the URL specified in settings.pageURL.
			// Settings are:
			//   pageURL: the url of the modal 'page' to load.  This will actually be a JSON message.
			//   parameters: any parameters to send to the pageURL to be loaded.
			//   postModalCallback: the method to invoke when we are successfully 'done'.
			//-------------------------------------------------------------------------------------------
			showModalWindow: function(settings) {
				var $loThis = this;

				// Function responsible for rendering the modal window with the response returned from the Ajax call.
				var mRenderModalWindow = function(rawResponse) {
					var loResponse = $.parseJSON(rawResponse);
					
					// if no modalHTML is returned but a value has been posted back, then skip
					// rendering this modal and return to the standard postModalCallback.
					if (!loResponse.HTMLFragments.modalHTML) { // && loResponse.HTMLFragments.value) {
						if ($.isFunction(settings.postModalCallback)) {
							settings.postModalCallback(loResponse);
						};
						return;
					};
					
					// Append any extra Css and JavaScript required.
					$('head').maj('appendCssHrefs', loResponse.CssHrefs)
									 .maj('appendJavaScriptUrls', loResponse.JavaScriptUrls);

					// Create the modal window and wire-up events.
					var loModalSettings = {
						'hidden' : true,
						'title': loResponse.Title,
						'content': loResponse.HTMLFragments.modalHTML,
						'closeOnBlindClick': settings.closeOnBlindClick
					};
					var $loModalWindow = $().maj('newModalWindow', loModalSettings); // new modal window shell is hidden by default.

					var loPosSettings = {};
					if ($loThis.length) {
						loPosSettings.top = $loThis.offset().top;
					}
					$loModalWindow.maj('positionAbsolute', loPosSettings).maj('center').show();

					if (!settings.parameters) {
						settings.parameters={};
					}

					// Wire up a handler for when the 'done' action is invoked.
					$loModalWindow.delegate('.done, #cmdDone', 'click.maj.modalWindow.done', function(e) { // ToDo: remove #cmdDone selector.

						// Some smarts to ensure we invoke legitimate anchors.
						$loAnchor = $(e.target).closest('a');
						if ($loAnchor.length && !$loAnchor.is('.done')) {
							lsHRef = $loAnchor.attr('href');
							if (lsHRef && lsHRef!='#') return; // found an anchor with a proper href, let's follow it.
						};

						e.preventDefault();

						var $loBusyBlind = $loModalWindow.find('.content').first().maj('busyBlind');

						// Create a bunch of post-back variables from all the elements within the modal window that have a 'name' attribute.
						var $loInputFields = $loModalWindow.find('*[name]');
						$loInputFields.each(function() {
							var $loInputField = $(this);
							var lsVal = $loInputField.val();
							if (lsVal && $loInputField.is(':checkbox,:radio') && !$loInputField.is(':checked')) {
								lsVal = undefined;
							};

							if (lsVal!==undefined) {
								settings.parameters[$loInputField.attr('name')] = lsVal;
							}
						});

						// Function to invoke when the Ajax Post has completed.
						var mOnPostSuccess = function(rawResponse) {
							$loBusyBlind.remove();
							$loModalWindow.maj('closeModalWindow', true);

							var loResponse = $.parseJSON(rawResponse);
							if (!loResponse.Status && loResponse.HTMLFragments.modalHTML) {
								mRenderModalWindow(rawResponse);
								return;
							};
							
							if ($.isFunction(settings.postModalCallback)) {
								settings.postModalCallback(loResponse);
							}
						};

						// Post the modal page back to the server.
						maj.ajax.submitJob({
							url: settings.pageURL,
							successCallback: mOnPostSuccess,
							failureCallback: mOnPostSuccess, //ToDo: this case should be handled differently.
							parameters: settings.parameters
						});
					});
				};

				// Request the modal page from the server.
				var loParameters = $.extend(true, {}, settings.parameters);
				loParameters['majsysModalLoad'] = true;

				maj.ajax.submitJob({
					url: settings.pageURL,
					successCallback: mRenderModalWindow,
					failureCallback: mRenderModalWindow, //ToDo: really should show something different on failure.
					commonCallback: settings.commonCallback,
					parameters: loParameters
				});
			},

			//-----------------------------------------------------------------------------------------------------------------------------------------
			// Positions an element as absolute releative to given co-ordinates.
			// Settings are:
			//   left: the absolute left co-ordinate to position the prompt window.  If this is missing, the prompt window is centered to the browser.
			//   center: the absoluate center co-ordinate to position the prompt window.
			//
			//   top: the absolute top co-ordinate to position the prompt window.  If this is missing, the prompt window is centered to the browser.
			//   middle: the absoluate middle co-ordinate to position the prompt window.
			//
			//   width:
			//   maxWidth:
			//   minWidth:
			//-----------------------------------------------------------------------------------------------------------------------------------------
			positionAbsolute: function(settings) {
				if (!settings) {
					settings = {};
				}

				var loStyle = { 'position': 'absolute' };

				var liLeft = settings.left;
				if (!maj.isNumber(liLeft) && maj.isNumber(settings.center)) {
					liLeft=settings.center - maj.math.round(this.outerWidth()/2);
				}
				if (maj.isNumber(liLeft)) {
					loStyle.left = Math.max(liLeft,0) + 'px';
				}

				var liTop = settings.top;
				if (!maj.isNumber(liTop) && maj.isNumber(settings.middle)) {
					liTop = settings.middle - maj.math.round(this.outerHeight()/2);
				}
				if (maj.isNumber(liTop)) {
					loStyle.top = Math.max(liTop,0) + 'px';
				}

				if (settings.width) {
					loStyle.width=settings.width+'px';
				}
				if (settings.maxWidth) {
					loStyle.maxWidth=settings.maxWidth+'px';
				}
				if (settings.minWidth) {
					loStyle.minWidth=settings.minWidth+'px';
				}

				return this.maj('center').css(loStyle);
			},

			// Shows a prompt.
			// Settings are:
			//   title:
			//   message:
			//
			//   okAction: JSON object - {text, callback, cssClass}
			//   cancelAction: JSON object - {text, callback, cssClass}
			//
			//   commonCallback: callback called when any action is invoked.  This is always called AFTER any specific action callbacks.

			//   any settings accepted by positionAbsolute.
			showPrompt: function(settings) {
				if (!settings) {
					settings = {};
				}

				var loContents = [];
				loContents.push('<div class="majPanel vertical cMarginTB5"><span style="font-size:14px; text-align:center;">');
				loContents.push(settings.message); // ToDo: need to HTML encoded this gear.
				loContents.push('</span><div style="text-align: center;" class="widthFull cMargin5 marginT20">');

				if (settings.okAction) {
					loContents.push('<a href="#" class="action button ok ',settings.okAction.cssClass,'">');
					loContents.push(settings.okAction.text);  // ToDo: need to HTML encoded this gear.
					loContents.push('</a>');
				}

				if (settings.cancelAction) {
					loContents.push('<a href="#" class="button close ', settings.cancelAction.cssClass, '">');
					loContents.push(settings.cancelAction.text);  // ToDo: need to HTML encoded this gear.
					loContents.push('</a>');
				}

				loContents.push('</div></div>');

				var mCloseCallback = function() {
					if ((settings.cancelAction) && $.isFunction(settings.cancelAction.callback)) {
						settings.cancelAction.callback();
					}

					if ($.isFunction(settings.commonCallback)) {
						settings.commonCallback();
					}
				};

				if (!settings.title) {
					settings.title = 'Wait a minute...';
				}

				var $loContents = $(loContents.join(''));
				var $loModalWindow = $().maj('newModalWindow', { 'hidden': true, 'closeCallback': mCloseCallback, 'closeOnBlindClick': true, 'title': settings.title, 'content': $loContents });

				$loModalWindow.maj('positionAbsolute', settings).show();

				$loContents.delegate('.action', 'click.maj.showPrompt', function(e) {
					e.preventDefault();
					$loModalWindow.maj('closeModalWindow', true);

					var $loAction = $(this);
					if ($loAction.is('.ok') && $.isFunction(settings.okAction.callback)) {
						settings.okAction.callback();
					}

					if ($.isFunction(settings.commonCallback)) {
						settings.commonCallback();
					}
					
				});
			},

			////////////////////////////////////////////////////////////////
			/* STATE DATA MANAGEMENT																			 */
			// This method is designed to be bound to a link or button
			// in order to show a modal form.
			// The settings class should look like this:
			//		pageURL:
			//		parameters:
			////////////////////////////////////////////////////////////////
			stateData: function() {
				var $loStateControl = this.find('#majData')[0];
				if ($loStateControl) {
					var lsJSONText = maj.base64Encoder.decode($loStateControl.val());
					if (lsJSONText.length > 0) {
						maj.viewState = $.parseJSON(lsJSONText); //eval(lsJSONText);
					}
				}

				$(document).bind('submit', function() {
					if (!($loStateControl)) {
						$loStateControl = $('<input type="text" id="majData" name="majData" />').appendTo("form");
					}
					var lsJSONText = maj.viewStateData.toJSON();
					$loStateControl.val(maj.base64Encoder.encode(lsJSONText));
					alert($loStateControl.val());
				});
			},
			
			////////////////////////////////////////////////////////////////
			/* MENU EDITOR PLUGIN 																					*/
			// This functionality is used to control the interaction between
			// the modal form for creating/editing menu items and the main page
			// that at times will render two representations of the menu.
			////////////////////////////////////////////////////////////////
			mainMenuEditor: function(settings) {
				var $loThis = this;
				var $loActiveMenu;
				var $loActiveDropdown;

				// Call method to refresh the menu control.
				var mMenuUpdateCallback = function(response) {
					if ($loActiveMenu) {
						var lsTopItemKey = $loActiveMenu.find('.data-element').filter(':first').text();
					}
					var $loMenu = $(response.HTMLFragments[settings.menuLocation + 'MenuHTML']);
					$loThis.replaceWith($loMenu);
					$loMenu.maj('mainMenuEditor', settings);
					if (lsTopItemKey) {
						var $loMatchKey = $loMenu.find('.data-element:contains(' + lsTopItemKey + ')')
						var $loCurrentMenu = $loMatchKey.siblings('h3');
						if ($loCurrentMenu.length) {
							$loCurrentMenu.click();
						}
					}
				}
				
				// Method to bundle up state and invoke the Menu Item editor modal.
				var mInvokeMenuItemModal = function($menuItem) {
	        var loParameters = {};
					loParameters['allowHierarchy'] = settings.allowHierarchy;
					loParameters['menuLocation'] = settings.menuLocation;
					loParameters['majData'] = $menuItem.find('.data-element').filter(':first').text();
					$menuItem.maj('showModalWindow', { 'pageURL': 'MenuItem.aspx', 'parameters': loParameters, 'postModalCallback': mMenuUpdateCallback });
				}

				// Functioning Correctly. Hide/Show Dropdown Menu.
				$loThis.delegate('.menuItem h3, .menuItem > .blind', 'click', function() {
					var $loTopMenu = $(this).parent('.menuItem');
					var $loDropdown = $loTopMenu.children('.dropDown');
					if ($loDropdown.length) {
						if ($loActiveDropdown && $loActiveDropdown[0] !== $loDropdown[0]) {
							$loActiveDropdown.toggle();
						}
						$loDropdown.toggle();
						$loActiveDropdown = $loDropdown;
						$loActiveMenu = $loTopMenu;
						$loActiveMenu.find('a').toggleClass('topMenuActive');
						if (!$loActiveDropdown.is(":visible")) {
							$loActiveDropdown = null;
							$loActiveMenu = null;
						}
					}
				});

				// EDIT BUTTON CLICK.
				$loThis.delegate('.edit', 'click', function() {
					// Attempt to identify which element in the menu editor has been invoked.
					var $loMenuItem = $(this).parents('.menuItem').filter(':first');
					mInvokeMenuItemModal($loMenuItem);

					// We need to return false here to ensure that event propagation does not occur to a top level menu item.
					return false;
				});

				// DELETE BUTTON CLICK.
				$loThis.delegate('.delete', 'click', function() {
					var mDeleteCallback = function(response) {
						var loResponse = JSON.parse(response);
						mMenuUpdateCallback(loResponse);
					}
					var $loMenuItem = $(this).parents('.menuItem').filter(':first');
					var lsElementData = $loMenuItem.find('.data-element').filter(':first').text();
					var loElementData = JSON.parse(maj.base64Encoder.decode(lsElementData));
					var loParameters = {};
					loParameters['menuItemId'] = loElementData['menuItemId'];
					loParameters['parentMenuItemId'] = loElementData['parentMenuItemId'];
					loParameters['menuLocation'] = settings.menuLocation;
					var loOptions = {
						url: 'svcDeleteMenuItem.aspx',
						successCallback: mDeleteCallback,
						failureCallback: function() { alert("Failed"); },
						parameters: loParameters
					}
					maj.ajax.submitJob(loOptions);

					// We need to return false here to ensure that event propagation does not occur to a top level menu item.
					return false;
				});

				// ADD BUTTON CLICK.
				$loThis.delegate('.add', 'click', function() {
					var $loMenuItem = $(this).parents('.menuItem').filter(':first');
					mInvokeMenuItemModal($loMenuItem);
				});

				// SWAP MENU ITEMS.
				$loThis.delegate('.swapHoriz, .swapVert', 'click', function() {
					var $loSourceMenuItem = $(this).parents('.menuItem').filter(':first');
					var $loSwapMenuItem = $loSourceMenuItem.next();

					var mSwapItemCallback = function(response) {
						var loResponse = JSON.parse(response);
						mMenuUpdateCallback(loResponse);
					}

					var lsElementData1 = $loSourceMenuItem.find('.data-element').filter(':first').text();
					var loElementData1 = JSON.parse(maj.base64Encoder.decode(lsElementData1));
					var lsElementData2 = $loSwapMenuItem.find('.data-element').filter(':first').text();
					var loElementData2 = JSON.parse(maj.base64Encoder.decode(lsElementData2));

					var loParameters = {};
					loParameters['menuLocation'] = settings.menuLocation;
					loParameters['menuItemId1'] = loElementData1['menuItemId'];
					loParameters['parentMenuItemId1'] = loElementData1['parentMenuItemId'];
					loParameters['seqNo1'] = loElementData1['seqNo'];
					loParameters['menuItemId2'] = loElementData2['menuItemId'];
					loParameters['parentMenuItemId2'] = loElementData2['parentMenuItemId'];
					loParameters['seqNo2'] = loElementData2['seqNo'];

					// Set up the AJAX call for the reordering.
					var loOptions = {
						url: 'svcSwapMenuItems.aspx',
						successCallback: mSwapItemCallback,
						failureCallback: function() { alert("Failed"); },
						parameters: loParameters
					}
					maj.ajax.submitJob(loOptions);
				});

				// Highlighting possible top level menu items to switch on mouseover of icon.
				$loThis.delegate('.swapVert', 'mouseover mouseout', function() {
					var $loSourceMenuItem = $(this).parents('.menuItem').filter(':first');
					var $loSwapMenuItem = $loSourceMenuItem.next();
					var $loSourceMenuLink = $loSourceMenuItem.find('> a:not(.swapVert)');
					var $loSwapMenuLink = $loSwapMenuItem.find('> a:not(.swapVert)');

					$loSourceMenuLink.toggleClass('readyForSwap');
					$loSwapMenuLink.toggleClass('readyForSwap');
				});

				// Highlighting possible top level menu items to switch on mouseover of icon.
				$loThis.delegate('.swapHoriz', 'mouseover mouseout', function() {
					var $loSourceMenuItem = $(this).parents('.menuItem').filter(':first');
					var $loSwapMenuItem = $loSourceMenuItem.next();
					var $loSourceMenuLink = $loSourceMenuItem.find('h3 a:not(.swapHoriz)');
					var $loSwapMenuLink = $loSwapMenuItem.find('h3 a:not(.swapHoriz)');

					$loSourceMenuLink.toggleClass('readyForSwap');
					$loSwapMenuLink.toggleClass('readyForSwap');
				});

				// TOGGLE AVAILABILITY CLICK
				$loThis.delegate('.toggle', 'click', function() {
					var $loMenuItem = $(this).parents('.menuItem').filter(':first');

					var mToggleItemCallback = function(response) {
						var loResponse = JSON.parse(response);
						mMenuUpdateCallback(loResponse);
					}

					var lsElementData = $loMenuItem.find('.data-element').filter(':first').text();
					var loElementData = JSON.parse(maj.base64Encoder.decode(lsElementData));
					var loParameters = {};
					loParameters['menuItemId'] = loElementData['menuItemId'];
					loParameters['parentMenuItemId'] = loElementData['parentMenuItemId'];
					loParameters['activate'] = ($loMenuItem.is('.off') ? true : false);

					// Set up the AJAX call for the reordering.
					var loOptions = {
						url: 'svcToggleMenuItem.aspx',
						successCallback: mToggleItemCallback,
						failureCallback: function() { alert("Failed"); },
						parameters: loParameters
					}
					maj.ajax.submitJob(loOptions);
					return false;
				});
				
				// Show/Hide Swap Icon logic
				var mSetSwappableState = function() {
					var $loMenuItems = $loThis.find('.menuItem.swappable');
					if($loMenuItems.length) {
						$loMenuItems.each(function() {
							var $loMenuItem = $(this);
							var $loNextItem = $loMenuItem.next();
							if(!$loNextItem.length) {
								$loMenuItem.find('.swapHoriz, .swapVert').hide();
								return;
							}
							if(!$loNextItem.is('.swappable')) {
								$loMenuItem.find('.swapHoriz, .swapVert').hide();
								return;
							}
						});
					}
				}();
      },

			////////////////////////////////
			/* EXCLUSIVE ELEMENT SELECT */
			// This class manages a set of elements where only one element
			// can be active at a time.
			// settings.elementClickCallback
			// settings.elementHoverCallback
			// settings.toggleClassName
			// settings.innerClass
			////////////////////////////////
			exclusiveElementActive: function(settings) {
				var $loActiveElement;
				this.bind('mouseover', function() {
					var $loSuggestion = $(event.target).closest('.suggestion')
					if ($loActiveElement === $loSuggestion) {
						return;
					}
					if ($.isFunction(settings.elementHoverCallback)) {
						settings.elementHoverCallback($loSuggestion.text());
					}
					$loActiveElement = $loSuggestion;
				});
				this.bind('click', function() {
					var $loSuggestion = $(event.target).closest('.suggestion');
					if ($.isFunction(settings.elementClickCallback)) {
						settings.elementClickCallback($loSuggestion.text());
					}
				});
			},
			
			bounds: function() {
				var loPos = this.position();
				var loOffset = this.offset();
				return {width: this.width(), height: this.height(), left: loPos.left, top: loPos.top, outerWidth: this.outerWidth(), outerHeight: this.outerHeight(), absoluteTop:loOffset.top, absoluteLeft: loOffset.left};
			},
			
			animateSwap: function(swapElem, moveUp, onCompleteCallback) {
				var $loSwapElem = $(swapElem);
				var liMyNewTop, liSwapNewTop;
				var loMyOffset = this.offset();
				var loSwapOffset = $loSwapElem.offset();
				var liMyHeight = this.outerHeight();
				var liSwapHeight = $loSwapElem.outerHeight();

				if (moveUp) {
					liMyNewTop = loSwapOffset.top;
					liSwapNewTop = loSwapOffset.top + liMyHeight + (loMyOffset.top - (loSwapOffset.top + liSwapHeight));
				} else {
					liMyNewTop = loMyOffset.top + liSwapHeight + (loSwapOffset.top - (loMyOffset.top + liMyHeight));
					liSwapNewTop = loMyOffset.top;
				};

				//var $loSwapShadow = $loSwapWithEditor.maj('shadowElement');
				var $loMyShadow = this.maj('shadowElement');
				var liExecCount = 0;

				var mActualSwap = function() {
					$loMyShadow.remove();
					if ($.isFunction(onCompleteCallback)) {
						onCompleteCallback();
					};
				};
				
				var mFadeOut = function() {
					$loMyShadow.fadeOut({'duration': 'fast', 'complete':mActualSwap });
				};

				$loMyShadow.fadeIn('fast').animate({ 'top': liMyNewTop }, { 'duration': 'fast', 'complete': mFadeOut});
				return this;
			},
			

			swap: function(swapElementSelector) {
				if (this.length!==1) return this;

				var $loSwapElem = $(swapElementSelector);
				if ($loSwapElem.length!==1) return this;

				var loThisBounds = this.maj('bounds');
				var loSwapElemBounds = $loSwapElem.maj('bounds');

				// First thing we do is wrap this element and the swap element in a div of the same size.
				var $loThisPlaceholder=this.data('maj.placeholder');
				var $loSwapPlaceholder=$loSwapElem.data('maj.placeholder');
				var lbRemoveThisPlaceholder=($loThisPlaceholder);
				var lbRemoveSwapPlaceholder=($loSwapPlaceholder);

				if (!lbRemoveThisPlaceholder) {
					$loThisPlaceholder=this;
				}

				if (!lbRemoveSwapPlaceholder) {
					$loSwapPlaceholder=$loSwapElem;
				}

				var $loNewThisPlaceholder = $('<div style="width:'+loThisBounds.outerWidth+'px;height:'+loThisBounds.outerHeight+'px;"></div>').insertBefore($loSwapPlaceholder);
				this.data('maj.placeholder', $loNewThisPlaceholder);

				var $loNewSwapPlaceholder = $('<div style="width:'+loSwapElemBounds.outerWidth+'px;height:'+loSwapElemBounds.outerHeight+'px;"></div>').insertBefore($loThisPlaceholder);
				$loSwapElem.data('maj.placeholder', $loNewSwapPlaceholder);

				if (this.css('position')!=='absolute') {
					this.css({'position':'absolute', 'width':loThisBounds.width+'px', 'height':loThisBounds.height+'px', 'top':loThisBounds.top+'px', 'left':loThisBounds.left+'px'});
				}

				if ($loSwapElem.css('position')!=='absolute') {
					$loSwapElem.css({'position':'absolute', 'width':loSwapElemBounds.width+'px', 'height':loSwapElemBounds.height+'px', 'top':loSwapElemBounds.top+'px', 'left':loSwapElemBounds.left+'px'});
				}

				if (lbRemoveThisPlaceholder) {
					$loThisPlaceholder.remove();
				}

				if (lbRemoveSwapPlaceholder) {
					$loSwapPlaceholder.remove();
				}

				// Now let's animate the swap.
				var loThisPlaceholderBounds=$loNewThisPlaceholder.maj('bounds');
				var loSwapPlaceholderBounds=$loNewSwapPlaceholder.maj('bounds');

				var liNewTop=loThisBounds.top+(loThisPlaceholderBounds.absoluteTop-loThisBounds.absoluteTop);
				var liNewLeft=loThisBounds.left;
				this.animate({'top':liNewTop+'px', 'left':liNewLeft+'px'});

				var liNewTop=loSwapElemBounds.top+(loSwapPlaceholderBounds.absoluteTop-loSwapElemBounds.absoluteTop);
				var liNewLeft=loSwapElemBounds.left;
				$loSwapElem.animate({'top': liNewTop + 'px', 'left':liNewLeft+'px'});

				return this;
			},

			movable: function() {
				var $loMoveUp = this.find('.moveUp');
				var $loMoveDown = this.find('.moveDown');
				var $loMoveLeft = this.find('.moveLeft');
				var $loMoveRight = this.find('.moveRight');
				var $loDelete = this.find('.delete');

				this.data('maj.canMoveLeft', $loMoveLeft.length>0)
				    .data('maj.canMoveRight', $loMoveRight.length>0)
				    .data('maj.canMoveUp', $loMoveUp.length>0)
				    .data('maj.canMoveDown', $loMoveDown.length>0);

				var miCompareLeft = function(x,y) {
					return x.currentBounds.absoluteLeft-y.currentBounds.absoluteLeft;
				};

				var miCompareTop = function(x,y) {
					return x.currentBounds.absoluteTop-y.currentBounds.absoluteTop;
				};

				var $this = this;
				var moGetMovableElements = function(moveDirection,comparerCallback) {
					var loMovableElements = [];
					var $loElement;
					$this.parent().children().each(function(index, element) {
						$loElement = $(element);
						if ($loElement.data('maj.canMove'+moveDirection)) {
							element.currentBounds=$loElement.maj('bounds');
							loMovableElements.push(element);
						}
					});

					if ($.isFunction(comparerCallback)) {
						loMovableElements.sort(comparerCallback);
					}
					return loMovableElements;
				};

				var mInitVertMoveLinks = function(movableElement, isTopMost, isBottomMost, isLeftMost, isRightMost) {
					var $loMovableElement=$(movableElement);
					$loMovableElement.find('.moveUp').maj('toggleDisabled', isTopMost);
					$loMovableElement.find('.moveDown').maj('toggleDisabled', isBottomMost);
				};

				var mInitHorizMoveLinks = function(movableElement, isLeftMost, isRightMost) {
					var $loMovableElement=$(movableElement);
					$loMovableElement.find('.moveLeft').maj('toggleDisabled', isLeftMost);
					$loMovableElement.find('.moveRight').maj('toggleDisabled', isRightMost);
				};

				var mMoveThis = function(moveDirection, offset, comparerCallback, initMoveLinksCallback) {
					if (offset==0) return;

					var loMovableElements = moGetMovableElements(moveDirection, comparerCallback);
					var loThisElem=$this[0];
					var liThisIdx=loMovableElements.indexOf(loThisElem);
					if (liThisIdx<0) return;

					var liSwapIdx=liThisIdx+offset;
					var loSwapElem=loMovableElements[liSwapIdx];
					if (!loSwapElem) return;

					$this.maj('swap', loSwapElem);

					if ($.isFunction(initMoveLinksCallback)) {
						initMoveLinksCallback(loThisElem, liSwapIdx==0, liSwapIdx==(loMovableElements.length-1));
						initMoveLinksCallback(loSwapElem, liThisIdx==0, liThisIdx==(loMovableElements.length-1));
					}
				};

				$loMoveLeft.bind('click.maj.moveLeft', function(e) {
					e.preventDefault();
					mMoveThis('Left', -1, miCompareLeft, mInitHorizMoveLinks);
				});

				$loMoveRight.bind('click.maj.moveRight', function(e) {
					e.preventDefault();
					mMoveThis('Right', 1, miCompareLeft, mInitHorizMoveLinks);
				});

				$loMoveUp.bind('click.maj.moveUp', function(e) {
					e.preventDefault();
					mMoveThis('Up', -1, miCompareTop, mInitVertMoveLinks);
				});

				$loMoveDown.bind('click.maj.moveDown', function(e) {
					e.preventDefault();
					mMoveThis('Down', 1, miCompareTop, mInitVertMoveLinks);
				});

				$loDelete.bind('click.maj.delete', function(e) {
					e.preventDefault();
					var $loThisPlaceholder=$this.data('maj.placeholder');
					$this.remove();
					if ($loThisPlaceholder) {
						// ToDo: need to offset any absolute positioned movable gear below this guy by the outer height of this.
						$loThisPlaceholder.remove();
					}
				});

			},

			checkBoxList: function() {
				var loSelectAllCheckBox = this.find('.selectAll input[type="checkbox"]')[0];
				if (!loSelectAllCheckBox) return this;

				var $loCheckBoxes = $(this.find('input[type="checkbox"]'));
				var lbInCallback = false;

				var loManageCheckBoxesCallback = function(selectAllMode) {
					if (lbInCallback) return;
					lbInCallback=true;

					var lbAllSelected = true;
					$loCheckBoxes.each(function(index, element) {
						if (element!=loSelectAllCheckBox) {
							if (selectAllMode) {
								//element.checked=loSelectAllCheckBox.checked;
								if (element.checked!=loSelectAllCheckBox.checked) {
									element.checked=loSelectAllCheckBox.checked;
									$(element).triggerHandler('change');
								}

							} else {
								lbAllSelected = (lbAllSelected && element.checked);
							}
						}
					});

					if (!selectAllMode && loSelectAllCheckBox.checked!=lbAllSelected) {
						//loSelectAllCheckBox.checked=lbAllSelected;
						if (loSelectAllCheckBox.checked!=lbAllSelected) {
							loSelectAllCheckBox.checked=lbAllSelected;
							$(loSelectAllCheckBox).triggerHandler('change');
						};
					}

					lbInCallback=false;
				};

				$loCheckBoxes.bind('change.maj.CheckBoxList', function(e) {
					// Setups the state of either the select all checkbox or it's children
					// depending on which checkbox has changed.
					var lbSelectAllMode = (this==loSelectAllCheckBox);
					loManageCheckBoxesCallback(lbSelectAllMode);
				});

				// Setup the initial state of the select all checkbox.
				var lbSelectAllMode = loSelectAllCheckBox.checked;
				loManageCheckBoxesCallback(lbSelectAllMode);

				return this;
			},

			removable: function() {
				var $loCloseTrigger = this.find('.close,.remove');
				var $loThis = this;
				$loCloseTrigger.bind('click.maj.removable', function(e) {
					e.preventDefault();
					$loThis.slideUp(function() { $(this).remove(); });

				});
			},

			collapsible: function(toggleOnHover) {
				var $loTrigger = this.find('.collapseTrigger');
				var $loCollapsible = this.find('.collapsible');
				var $loArrows = this.find('.majImageButton.up,.majImageButton.down,.majImageButton.left,.majImageButton.right');
				var loArrowDirections = ['left', 'right', 'up', 'down'];

				var loToggleCollapsibleCallback = function(visible) {
					if (visible!==undefined && visible==$loCollapsible.is(':visible')) return;

					$loCollapsible.toggle();

					$loArrows.each(function(index, element) {
						var $loArrow = $(element);
						var lsOldClass, lsNewClass;

						for (var liIdx=0; liIdx<loArrowDirections.length; liIdx++) {
							lsOldClass=loArrowDirections[liIdx];
							if ($loArrow.hasClass(lsOldClass)) {

								if ((liIdx % 2)==0) {
									lsNewClass=loArrowDirections[liIdx+1];
								} else {
									lsNewClass=loArrowDirections[liIdx-1];
								};

								$loArrow.maj('swapClass', lsOldClass, lsNewClass);
								break;
							}
						}
					});
				};

				$loTrigger.bind('click.maj.collapsible', function(e) {
					loToggleCollapsibleCallback();
				});

				if (toggleOnHover) {
					this.bind('mouseenter.maj.collapsible', function(e) {
						loToggleCollapsibleCallback(true);
					});
					
					this.bind('mouseleave.maj.collapsible', function(e) {
						loToggleCollapsibleCallback(false);
					});
				};

				return this;
			},

			// Appends the array of css hrefs to the selected element (if the hrefs don't already exist anywhere on the page).
			appendCssHrefs: function(cssHrefs) {
				if (!$.isArray(cssHrefs)) return this;

				var loExisting = moExistingCssHrefs;
				if (!loExisting) {
					loExisting = [];

					// First let's find all the existing Css
					var $loExisting = $('link[type="text/css"]');

					var loExisting = [];
					$loExisting.each(function(index, elem) {
						loExisting[$(elem).attr('href')]=1;
					});
				}

				var lsNewHtml = '';
				var lsHref;
				for (var liIdx=0; liIdx<cssHrefs.length; liIdx++) {
					lsHref=cssHrefs[liIdx];
					if (!loExisting[lsHref]) {
						loExisting[lsHref]=1;
						lsNewHtml += '<link type="text/css" rel="stylesheet" href="' + lsHref + '" media="screen" />';
					}
				}

				if (lsNewHtml.length) {
					this.append(lsNewHtml);
				}

				moExistingCssHrefs=loExisting;

				return this;
			},

			// Appends the array of css hrefs to the selected element (if the hrefs don't already exist anywhere on the page).
			appendJavaScriptUrls: function(javaScriptUrls) {
				if (!$.isArray(javaScriptUrls)) return this;

				var loExisting = moExistingJavaScriptUrls;
				if (!loExisting) {
					loExisting = [];

					// First let's find all the existing JavaScript Urls
					var $loExisting = $('script[type="text/javascript"]');

					var lsUrl;
					$loExisting.each(function(index, elem) {
						lsUrl=$(elem).attr('src');
						if (lsUrl && lsUrl.length) {
							loExisting[lsUrl]=1;
						}
					});
				}

				var lsNewHtml = '';
				for (var liIdx=0; liIdx<javaScriptUrls.length; liIdx++) {
					lsUrl=javaScriptUrls[liIdx];
					if (!loExisting[lsUrl]) {
						loExisting[lsUrl]=1;
						lsNewHtml += '<script type="text/javascript" src="' + lsUrl + '"></script>';
					}
				}

				if (lsNewHtml.length) {
					this.append(lsNewHtml);
				}

				moExistingJavaScriptUrls=loExisting;

				return this;
			},

			searchableTable: function(rowTerminology, rowsTerminology, maxRowsToDisplay) {
				var $loSearch = this.find('input[type="search"]');
				var $loSummary = this.find('.searchResultSummary');
				var $loPageLinks = this.find('.paginator a');
				var $loThis = this;
				var lsLowerLastSearchText;
				var liPageIdx = 0;

				if (!rowTerminology) {
					rowTerminology = 'row';
				}

				if (!rowsTerminology) {
					rowsTerminology = rowTerminology + 's';
				}

				var mbRowHasMatch = function($voRow, vsLowerSearchText) {
					if (!vsLowerSearchText.length) return true;
					
					var $loCells = $voRow.find('td:not(.noSearch)');

					var lbHasMatch = false;

					$loCells.each(function(index, elem) {
						if ($(elem).text().toLowerCase().indexOf(vsLowerSearchText)>=0) {
							lbHasMatch = true;
							return false;
						}
					});

					return lbHasMatch;
				};

				var msFetchLowerSearchText;
				if ($loSearch.length) {
					msFetchLowerSearchText = function() {
						return $loSearch.val().toLowerCase();
					};
				} else {
					msFetchLowerSearchText = function() {
						return '';
					};
				};

				var mFilterTable = function(viPageNumber) {
					var lsLowerSearchText = msFetchLowerSearchText();

					var lbFirstSearch = (lsLowerLastSearchText===undefined);

					// nothing to do if the last search is the same as the new search.
					//if (!lbFirstSearch && lsLowerLastSearchText==lsLowerSearchText) return;

					// If the new search text contains the last search text, then we only need to search visible rows.
					var lbOnlySearchRowsThatCurrentlyMatch = (lsLowerSearchText.indexOf(lsLowerLastSearchText)>=0);

					// If the new search text is a substring of the last search text, then visible rows must already match.
					var lbVisibleRowsMatch = (!lbFirstSearch && lsLowerLastSearchText.indexOf(lsLowerSearchText)>=0);
					lsLowerLastSearchText = lsLowerSearchText;

					var $loTableBody = $loThis.find('table').first().find('tbody').first();
					var $loTableRows = $loTableBody.find('>tr:not(.noData)');

					// Set a min height on the 'grid' container element to ensure the page doesn't jump around.
					$loThis.css('min-height', $loThis.height() + 'px');
					$loTableBody.toggle(false);

					var liTotalRows = $loTableRows.length;
					var liMatchedRows = 0;
					var lbMatch, lbRowMatches;
					var $loMatchingRows = [];

					$loTableRows.each(function(index, elem) {
						var $loTableRow = $(elem);

						lbRowMatches = !$loTableRow.data('noMatch');
						if (!lbOnlySearchRowsThatCurrentlyMatch || lbRowMatches) {
							lbMatch = (lbRowMatches && lbVisibleRowsMatch) || mbRowHasMatch($loTableRow, lsLowerSearchText);
							$loTableRow.data('noMatch', !lbMatch);
							if (lbMatch) {
								liMatchedRows++;
								$loMatchingRows.push($loTableRow);
							} else {
								$loTableRow.toggle(false);
							}
						}
					});

					if (viPageNumber===undefined) {
						// let's lookup the current active page number.
						viPageNumber = maj.math.parseNumber($loPageLinks.filter('.active').first().data('pageNumber'));
					}

					var liMaxPageNumber = Math.ceil(liMatchedRows / maxRowsToDisplay)-1;
					if (liMaxPageNumber<0) {
						liMaxPageNumber=0;
					}
					if (viPageNumber > liMaxPageNumber) {
						viPageNumber = liMaxPageNumber;
					}
					var liFirstRowIdx= viPageNumber * maxRowsToDisplay;
					var liLastRowIdx = liFirstRowIdx + maxRowsToDisplay;

					if (!maxRowsToDisplay) {
						liFirstRowIdx = 0;
						liLastRowIdx = liMatchedRows-1;
					}

					for (var liRowIdx=0; liRowIdx<$loMatchingRows.length; liRowIdx++) {
						var $loTableRow = $loMatchingRows[liRowIdx];
						/*
						var lbMatchedRow = !$loTableRow.data('noMatch'); 
						lbShowRow = lbMatchedRow && (liRowIdx>=liFirstRowIdx && liRowIdx<=liLastRowIdx);
						*/
						lbShowRow = (liRowIdx>=liFirstRowIdx && liRowIdx<=liLastRowIdx);
						$loTableRow.toggle(lbShowRow);
					};

					var loText = [];
					var $loTable = $loThis.find('table:first');
					
					var mSetControlStripBorder = function(viPx) {
						$loThis.find('.controlStrip').css('border-bottom-width', viPx + 'px');
					};

					if (liTotalRows==0) {
						//$loTable.toggle(false);
						$loSearch.toggle(false);
						mSetControlStripBorder(1);
						
						loText.push('There are no ', rowsTerminology, '.');

					} else {
						$loTable.toggle(true);
						$loSearch.toggle(true);
						
						if (liMatchedRows) {
							mSetControlStripBorder(0);
						} else {
							mSetControlStripBorder(1);
						};

						loText.push('Showing ');
						if (liTotalRows==liMatchedRows) {
							loText.push('all (', liTotalRows, ') ', rowsTerminology);
						} else {
							loText.push(liMatchedRows, ' (of ',liTotalRows, ') ');
							if (liMatchedRows==1) {
								loText.push(rowTerminology);
							} else {
								loText.push(rowsTerminology);
							}
						}
					}
					$loSummary.text(loText.join(''));

					var liRunningRowCount = 0;
					$loPageLinks.each(function(index, elem) {
						$(elem).toggle(liMatchedRows>liRunningRowCount);
						liRunningRowCount += maxRowsToDisplay;
					});
					$loPageLinks.closest('tr').toggle(liMatchedRows>maxRowsToDisplay);

					$loTableBody.toggle(true);
					$loThis.css('min-height', 'initial'); // take off the min-height we set earlier.
				}

				// Delay the filter slightly so that we don't waste client resources filtering when the user has not finished typing.
				var loFilterTimeout;
				var mDelayedFilterTable = function() {
					if (loFilterTimeout) {
						clearTimeout(loFilterTimeout);
					}
					loFilterTimeout = setTimeout(mFilterTable, 250);
				};

				$loPageLinks.each(function(index, elem) {
					$(elem).data('pageNumber', index);
				});

				$loPageLinks.bind('click.searchableTable', function(e) {
					e.preventDefault();
					var loPageLink = this;
					$loPageLinks.each(function(index, elem) {
						$(elem).toggleClass('active', elem==loPageLink);
					});
					mFilterTable();
				});

				$loSearch.bind('keyup.maj.searchableTable', mDelayedFilterTable)
								 .bind('blur.maj.searchableTable', mFilterTable)
								 .bind('click.maj.searchableTable', mFilterTable);

				// Perform initial filter of the newly bound table.
				mFilterTable();

				if (this.length) {
					this[0].refresh = mFilterTable;
				};
				return this;
			},

			toggleSwitch: function() {
				var $loThis = this;
				this.bind('click.maj.toggleSwitch', function(e) {
					var lbOn = !$loThis.is('.on'); 
					$loThis.toggleClass('on', lbOn);
					$loThis.find('.on').toggle(lbOn);
					$loThis.find('.off').toggle(!lbOn);
					$loThis.find('input[type="checkbox"]').attr('checked', lbOn);
				});
			},

			removeElement: function(onCompleteCallback) {
				var $loThis = this;

				this.maj('shadowElement', 'fadeOut').fadeIn(function() {
					$loThis.remove();
					$(this).remove();
					if ($.isFunction(onCompleteCallback)) {
						onCompleteCallback();
					};
				});
			},

			highlightElement: function(classes, onCompleteCallback) {
				this.maj('shadowElement', classes).fadeIn('slow').fadeOut('slow', function() {
					$(this).remove();
					if ($.isFunction(onCompleteCallback)) {
						onCompleteCallback();
					};
				});
			},

			shadowElement: function(classes, inflatePx) {
				if (!maj.isNumber(inflatePx)) {
					if (this.is('tr')) {
						inflatePx = -1;
					} else {
						inflatePx = 0;
					};
				};

				var loOffset = this.offset();
				var $loShadow = $('<div class="shadowElement ' + classes + '" style="left:' + (loOffset.left-inflatePx) + 'px; top:' + (loOffset.top-inflatePx) + 'px; width:' + (this.outerWidth()+inflatePx) + 'px; height: ' + (this.outerHeight()+inflatePx) + 'px;"></div>');
				$loShadow.maj('makeTopMost').hide();
				$('body').append($loShadow);
				return $loShadow;
			},

			// settings:
			// * editMessage
			// * addMessage
			// * data
			// * pageUrl
			designableLabel: function(settings) {
				var $loThis = this;
				var $loLabel = this.children('span');
				var $loLink = this.children('.action.edit, .action.add');

				if (!settings) {
					settings = {};
				}

				if (!settings.editMessage) {
					settings.editMessage = 'edit';
				}

				if (!settings.addMessage) {
					settings.addMessage = settings.editMessage;
				}

				if (!$.isPlainObject(settings.data)) {
					settings.data = {};
				}

				var mInitLabel = function(newValue) {
					var lbLabelVisible = $loLabel.is(':visible');
					var lbNewValue = (newValue!=undefined);
					var lbHasValue;

					if (lbNewValue) {
						if (newValue.indexOf('<br')>=0) {
							$loLabel.html(newValue);
						} else {
							$loLabel.text(newValue);
						};
						lbHasValue = (newValue.length>0);
					} else {
						lbHasValue = ($loLabel.text().length>0);
					}

					$loLabel.toggle(lbHasValue);

					if (lbHasValue) {
						$loLink.text(settings.editMessage);
						if (lbNewValue) {
							$loLabel.maj('highlightElement', 'done');
						}
						$loLink.maj('swapClass', 'add', 'edit');
					} else {
						$loLink.text(settings.addMessage);
						$loLink.maj('swapClass', 'edit', 'add');
					}
				};

				mInitLabel();

				$loLink.bind('click.maj.designableLabel', function(e) {
					e.preventDefault();

					if ($loLink.is('.disabled, .working')) return;
					$loLink.toggleClass('working', true);

					var loParams = [];
					loParams['majData'] = settings.data;

					$loThis.maj('showModalWindow', {
						'pageURL': settings.pageUrl,
						'parameters': loParams,
						'postModalCallback': function(response) {
							mInitLabel(response.HTMLFragments['value']);
						},
						'commonCallback': function() {
							$loLink.toggleClass('working', false);
						}
					});
				});
				return this;
			},
			
			
			designable2: function(settings) {
				var $loThis = this;
				var $loActionLinks = this.find('.edit, .add, .delete');

				var loDefSettings = {
					data: {}
				};
				
				settings = $.extend(loDefSettings, settings);

				$loActionLinks.bind('click.maj.designable', function(e) {
					e.preventDefault();
					
					var $loClickElem = $(this);
					var lbIsEdit = $loClickElem.is('.edit');
					var lbIsAdd = $loClickElem.is('.add');
					var lbIsDel = $loClickElem.is('.delete');

					var lsActionClass;
					if (lbIsEdit) {
						lsActionClass='edit';
					} else if (lbIsAdd) {
						lsActionClass='add';
					} else if (lbIsDel) {
						lsActionClass='delete';
					};
					
					var $loActionLink = $loThis.find('.action.' + lsActionClass);
					if (!$loActionLink.length) {
						$loActionLink = $loClickElem;
					};

					if ($loActionLink.is('.disabled, .working')) return;
					$loActionLink.toggleClass('working', true);

					var lsPageUrl = $loThis.data(lsActionClass + 'url');
					if (lbIsAdd && !lsPageUrl) {
						lsPageUrl = $loThis.data('editurl');
					};

					var loParams = [];
					loParams['majData'] = settings.data;

					$loThis.maj('showModalWindow', {
						'pageURL': lsPageUrl,
						'parameters': loParams,
						'closeOnBlindClick': lbIsDel,
						'postModalCallback': function(response) {
							var lsFollowUrl = response.Data['followUrl'];
							if (lsFollowUrl) {
								window.location = lsFollowUrl;
								return;
							};
							
							var $loReplaceElem;
							for (var lsKey in response.HTMLFragments) {
								if (lsKey=='value') {
									$loReplaceElem = $loThis;
								} else {
									$loReplaceElem = $('#' + lsKey);
								};
								
								$loNewElem = $(response.HTMLFragments[lsKey]);
								$loReplaceElem.replaceWith($loNewElem)
								$loNewElem.maj('highlightElement', 'done');
							};
						
						},
						'commonCallback': function() {
							$loActionLink.toggleClass('working', false);
						}
					});
				});

				return this;
			},




			// settings:
			// * editMessage
			// * addMessage
			// * data
			// * addPageUrl
			// * editPageUrl
			// * deletePageUrl
			designable: function(settings) {
				var $loThis = this;
				var $loElem = this.find('.designable');
				var $loActionLinks = this.find('.action.edit, .action.add, .action.delete');
				var $loEditLink = $loActionLinks.filter('.action.edit, .action.add');
				var $loDeleteLink = $loActionLinks.filter('.action.delete');

				var loDefSettings = {
					'editMessage': 'edit',
					'addMessage': 'add',
					'data': {},
					'addPageUrl': '',
					'editPageUrl': '',
					'deletePageUrl': ''
				}

				settings = $.extend(loDefSettings, settings);

				var mInitElem = function(newHtml) {
					if (newHtml!==undefined) {
						if ($loElem.length) {
							$loElem.replaceWith(newHtml);
						} else {
							$loThis.prepend(newHtml);
						}
						$loElem = $loThis.find('.designable');

						if ($loElem.length) {
							$loElem.maj('highlightElement', 'done');
						}
					}

					if ($loElem.length && !$loElem.is('.blank')) {
						$loEditLink.text(settings.editMessage);
						$loEditLink.maj('swapClass', 'add', 'edit');
						$loDeleteLink.toggle(true);
					} else {
						$loEditLink.text(settings.addMessage);
						$loEditLink.maj('swapClass', 'edit', 'add');
						$loDeleteLink.toggle(false);
					}
				};

				mInitElem();

				$loActionLinks.bind('click.maj.designable', function(e) {
					e.preventDefault();

					var $loActionLink = $(this);

					if ($loActionLink.is('.disabled, .working')) return;
					$loActionLink.toggleClass('working', true);

					var loParams = [];
					loParams['majData'] = settings.data;

					var lsPageUrl;
					var lbCloseOnBlindClick;
					if ($loActionLink.is('.delete')) {
						lsPageUrl = settings.deletePageUrl;
						lbCloseOnBlindClick = true;
					} else {
						if (settings.addPageUrl && $loActionLink.is('.add')) {
							lsPageUrl = settings.addPageUrl;
						} else {
							lsPageUrl = settings.editPageUrl;
						};
						lbCloseOnBlindClick = false;
					};

					$loThis.maj('showModalWindow', {
						'pageURL': lsPageUrl,
						'parameters': loParams,
						'closeOnBlindClick': lbCloseOnBlindClick,
						'postModalCallback': function(response) {
							var lsFollowUrl = response.Data['followUrl'];
							if (lsFollowUrl) {
								window.location = lsFollowUrl;
								return;
							};
						
							var lsValue = response.HTMLFragments['value'];
							if (lsValue==undefined) {
								lsValue = '';
							}
							mInitElem(lsValue);
						},
						'commonCallback': function() {
							$loActionLink.toggleClass('working', false);
						}
					});
				});

				return this;
			},

			postBackGrid: function() {
				var $loThis = this;

				this.delegate('tbody .done', 'click.maj.postBackGrid', function(e) {
					var $loRow = $(this);
					if (!$loRow.is('tr')) {
						$loRow = $loRow.closest('tr');
					}

					$loThis.find('input.rowData').each(function(index, elem) {
						var $loInput = $(this);
						$loInput.val($loRow.data($loInput.data('rowdatakey')));
					});
				});

			},

			tabControl: function(activeTabIndex) {
				var $loActiveTabHeader;
				var $loThis = this;
				var $loActiveTabHeader = $(window.location.hash).closest('.tabHeader');
				if (!$loActiveTabHeader.length) {
					activeTabIndex = Math.max(maj.math.parseNumber(activeTabIndex), 0);
					$loActiveTabHeader = this.find('.tabHeader:eq(' + activeTabIndex + ')');
					if (!$loActiveTabHeader.length) {
						$loActiveTabHeader = this.find('.tabHeader:eq(0)');
					};
				};

				var mToggle = function($voTabHeader, vbActive) {
					var $loInactive = $voTabHeader.find('.inactive');
					var $loActive = $voTabHeader.find('.active');
					var liFadeTime;

					if (vbActive==undefined) {
						vbActive = (!$voTabHeader.data('active'));
						liFadeTime = 250;
					} else {
						liFadeTime = 0;
					};

					$voTabHeader.data('active', vbActive);
					if (vbActive) {
						$loActive.css('visibility', 'inherit');
					} else {
						$loActive.css('visibility', 'hidden');
					};
					$loInactive.toggle(!vbActive);

					var $loTabPage = $voTabHeader.data('tabpage');
					if (vbActive) {
						$loTabPage.fadeIn(liFadeTime);
					} else {
						$loTabPage.toggle(false);
					};
				};

				var $loTabPages = this.children('div').children('div');
				this.find('.tabHeader').each(function(index, elem) {
					var $loTabHeader = $(elem);
					$loTabHeader.data('tabpage', $loThis.find('>div>div:eq(' + index + ')'));

					mToggle($(elem), $loActiveTabHeader[0]==elem);
				});

				this.find('.tabHeader > .inactive').bind('click', 'majOrg.tab', function(e) {
					e.preventDefault();

					var $loTabHeader = $(this).closest('.tabHeader');
					if ($loTabHeader.data('active')==1) return;

					var $loPageCnt = $loThis.find('>div');

					if ($loActiveTabHeader) {
						if ($loActiveTabHeader[0]==$loTabHeader[0]) return;

						// try to prevent some of the jumping around.
						$loPageCnt.css('min-height', $loPageCnt.height() + 'px');

						mToggle($loActiveTabHeader);
					};
					$loActiveTabHeader = $loTabHeader;

					mToggle($loTabHeader);

					$loPageCnt.css('min-height', 'inherit');
				});

				return this;
			},

			designableGrid: function(settings) {
				var loDefSettings = {
					'data': {},
					'newPageUrl': '',
					'addPageUrl': '',
					'editPageUrl': '',
					'deletePageUrl': '',
					'moveUpPageUrl': '',
					'moveDownPageUrl': ''
				};

				settings = $.extend(loDefSettings, settings);

				var $loThis = $(this);

				$loThis.delegate('tbody .edit, tbody .action.delete, tbody .action.moveUp, tbody .action.moveDown, .add', 'click.maj.designableGrid', function(e) {
				
					/*
					// Some smarts to ensure we invoke legitimate anchors.
					$loAnchor = $(e.target).closest('a');
					if ($loAnchor.length) {
						lsHRef = $loAnchor.attr('href');
						if (lsHRef && lsHRef!=='#') return; // found an anchor with a proper href, let's follow it.
					};
					*/
				
					e.preventDefault();

					var $loActionLink = $(this);
					var lbBusy = $loActionLink.is('.disabled, .working') || ($loActionLink.find('.working').length>0) ;

					if (lbBusy) return;

					var $loBusyLinks = $loActionLink;
					var $loTr = $loActionLink.closest('tr');
					var lbDeleteAction = $loActionLink.is('.delete');
					var lbEditAction = $loActionLink.is('.edit');
					var lbAddAction = $loActionLink.is('.add');
					var lbMoveUpAction = $loActionLink.is('.moveUp');
					var lbMoveDownAction = $loActionLink.is('.moveDown');

					if (lbEditAction && $loTr.length) {
						$loBusyLinks = $loTr.find('.edit');
					};

					$loBusyLinks.toggleClass('working', true);

					if (!lbBusy && $loActionLink.is('.edit') && !settings.editPageUrl) {
						var lsHref = $loActionLink.attr('href');
						if (lsHref && lsHref!=='#') {
							window.location = lsHref;
						};
						return; // let the default action apply.
					};

					var lsPageUrl = '';
					var lbCloseOnBlindClick = false;

					if (lbDeleteAction) {
						lsPageUrl = settings.deletePageUrl;
						lbCloseOnBlindClick = true;
					} else if (lbEditAction) {
						lsPageUrl = settings.editPageUrl;
					} else if (lbAddAction) {
						if (!$loThis.find('table > tbody > tr').length && settings.newPageUrl) {
							lsPageUrl = settings.newPageUrl;
						} else {
							lsPageUrl = settings.addPageUrl;
							if (!lsPageUrl) {
								lsPageUrl = settings.editPageUrl;
							};
						};
					} else if (lbMoveUpAction) {
						lsPageUrl = settings.moveUpPageUrl;
					} else if (lbMoveDownAction) {
						lsPageUrl = settings.moveDownPageUrl;
					};

					loData = $.extend({}, settings.data);
					loData = $.extend(loData, $loTr.data());

					var loParams = [];
					loParams['majData'] = loData;

					$loThis.maj('showModalWindow', {
						'pageURL': lsPageUrl,
						'parameters': loParams,
						'closeOnBlindClick': lbCloseOnBlindClick,
						'postModalCallback': function(response) {
							var $loNewTable = $(response.HTMLFragments['table']);
							if ($loNewTable.length) {
							
								var lReplaceTable = function() {
									$loThis.css('min-height', $loThis.height() + 'px');
									$loThis.find('table:first > tbody:first').replaceWith($loNewTable.children('tbody:first')); // .find('tbody:first'));
									$loThis.css('min-height', 'initial');

									var lRefreshGrid = $loThis[0].refresh;
									if ($.isFunction(lRefreshGrid)) {
										lRefreshGrid();
									};
									
									var liHighlightRowIndex = response.Data['highlightRowIndex'];
									var liEditRowIndex = response.Data['editRowIndex'];

									if (liHighlightRowIndex == undefined) {
										liHighlightRowIndex = liEditRowIndex;
									};

									if (liHighlightRowIndex !== undefined) {
										$loThis.find('tbody:first > tr:not(.noData):eq(' + liHighlightRowIndex + ')').maj('highlightElement', 'done');
									};
									
									if (liEditRowIndex !== undefined) {
										$loThis.find('tbody:first > tr:not(.noData):eq(' + liEditRowIndex + ') .edit:first').click();
									};
									
									var lsFollowUrl = response.Data['followUrl'];
									if (lsFollowUrl) {
										window.location = lsFollowUrl;
										return;
									};
									
								};

								if (lbDeleteAction) {
									$loActionLink.closest('tr').maj('removeElement', lReplaceTable);
									
								} else if (lbMoveUpAction || lbMoveDownAction) {
									var $loRow = $loActionLink.closest('tr');
									var $loSwapRow;
									if (lbMoveUpAction) {
										$loSwapRow = $loRow.prev();
									} else {
										$loSwapRow = $loRow.next();
									};
									$loRow.maj('animateSwap', $loSwapRow, lbMoveUpAction, lReplaceTable);
									
								} else {
									lReplaceTable();
								}

							};

							

						},
						'commonCallback': function() {
							$loBusyLinks.toggleClass('working', false);
						}
					});

				});

				return this;
			},


			// data-src - if specified, the image specified at this source will be late loaded (assuming it differs from the current image source).
			// data-popup - deternubes
			fancyImage: function() {
				// Only works with images.
				if (!this.is('img')) return this;

				// get the meta-data that describes this image and it's features.
				// Image Source - the current source assigned to the image.
				// Late Load Image Source - the source of the image to late load.
				// Popup Image Source - the source of the image to popup.
				var lsImgSrc = this.attr('src');
				var lsLateLoadImgSrc = this.data('src');
				var lbLateLoad = (lsLateLoadImgSrc && lsLateLoadImgSrc!==lsImgSrc);
				
				var lsPopupImgSrc = this.data('popup-src');
				if (!lsPopupImgSrc && this.data('popup')) {
					if (lbLateLoad) {
						lsPopupImgSrc = lsLateLoadImgSrc
					} else {
						lsPopupImgSrc = lsImgSrc
					}
				}

				var liOuterWidth = this.outerWidth();
				var liOuterHeight = this.outerHeight();
				var $this=this;

				if (lbLateLoad) {
					// wire up image late loading logic.
					if (lsImgSrc!='images/controls/blank.gif') {
						this.attr({'src':'images/controls/blank.gif', 'width':this.width(), 'height':this.height()});
					}

					this.maj('swapClass', 'broken', 'loading');

					var $loImage = $(new Image());

					$loImage.bind('load.maj.fancyImage', function(e) {

						// maintain the total size of the image.
						var liLeft = maj.math.round((liOuterWidth-$loImage.width)/2);
						var liTop = maj.math.round((liOuterHeight-$loImage.height)/2);
						$this.removeClass('loading');
						$this.css({'margin-left':liLeft+'px', 'margin-top':liTop+'px'});
						$this.attr('src',lsLateLoadImgSrc);

					}).bind('error.maj.fancyImage', function(e) {

						$this.maj('swapClass', 'loading', 'broken');

					}).attr('src', lsLateLoadImgSrc);
				}

/*
        if (!$loImage.length) {
          $loImage=$(new Image()).addClass('lateLoad').appendTo($loContainer);
					$loImage.bind('load.maj.lateLoadImage', function(e) {
            var liLeft = maj.math.round(($loContainer.width()-this.width)/2);
            var liTop = maj.math.round(($loContainer.height()-this.height)/2);
						$loImage.css({'margin-left':liLeft+'px', 'margin-top':liTop+'px'}).show();
            $loContainer.removeClass('loading');

					}).bind('error.maj.lateLoadImage', function(e) {
            $loContainer.maj('swapClass', 'loading', 'broken');

          }).hide().appendTo($loContainer);
				}

        var lsUrl=maj.sizedImageUrl(map.url,$loContainer.width(),$loContainer.height());
				if ($loImage.attr('src')!=lsUrl) {
					$loImage.hide();
          $loContainer.maj('swapClass', 'broken', 'loading');
				}
*/

			},

			addToCart: function() {
				var $loThis = $(this);

				$loThis.delegate('.addtocart, td', 'click.maj.addToCart', function(e) {
					
					var $loLink = $(this);
					if (!$loLink.is('.addtocart')) {
						$loLink = $loLink.find('.addtocart');
						if (!$loLink.length) return;
					};
					
					e.preventDefault();

					if ($loLink.is('.working')) return;
					$loLink.toggleClass('working', true);
					
					var $loTr = $loLink.closest('tr');
					var loData = $.extend({}, $loTr.data())
					var loParams = [];
					loParams['majData'] = loData;
					
					$loThis.maj('showModalWindow', {
						'pageURL': 'AddToCart.aspx',
						'parameters': loParams,
						'closeOnBlindClick': false,
						'postModalCallback': function(response) {
							var $loNewCart = $(response.HTMLFragments['cart']);
							if ($loNewCart.length) {
								var $loOldCart = $('#majCart');
								$loOldCart.replaceWith($loNewCart);
							};
						},
						'commonCallback': function() {
							$loLink.toggleClass('working', false);
						}
					});
					
				});
			},
			
			modalButton: function(settings) {
				var $loThis = $(this);
				var loParams = [];
				$loThis.bind('click.maj.modalButton', function(e) {
					e.preventDefault();
					$loThis.maj('showModalWindow', {
						'pageURL': 'ManualPayment.aspx',
						'parameters': loParams,
						'closeOnBlindClick': false,
						'postModalCallback': function(response) {
							var lsFollowUrl = response.Data['followUrl'];
							if (lsFollowUrl) {
								window.location = lsFollowUrl;
								return;
							};
						},
						'commonCallback': function() {
							//$loBusyLinks.toggleClass('working', false);
						}
					});
				});
			},
			
			notificationAddressBar: function(settings) {
				var $loThis = $(this);
				$loThis.delegate('#cmdAddAddresses', 'click.maj.notificationAddressBar', function(e) {
					e.preventDefault();

					var loData = $.extend({}, settings);
					loData['majData'] = $loThis.find('input[type="hidden"]').val();
					
					$loThis.maj('showModalWindow', {
						'pageURL': 'AddressBook.aspx',
						'parameters': loData,
						'closeOnBlindClick': false,
						'postModalCallback': function(response) {
							var $loNewBar = $(response.HTMLFragments['addressBar']);
							if ($loNewBar.length) {
								$loThis.html($loNewBar[0].innerHTML);
								//$loThis.maj('notificationAddressBar', settings);
							};
						},
						'commonCallback': function() {
							//$loBusyLinks.toggleClass('working', false);
						}
					});
				});
			}
		};


		$.fn.maj = function(method) {
			// Method calling logic
			var loMethod = jQueryMethods[method];
			if (loMethod) {
				return loMethod.apply( this, Array.prototype.slice.call(arguments,1));
			} else if (typeof method === 'object' || ! method) {
				return jQueryMethods.init.apply(this,arguments);
			} else {
				$.error('Method ' +	method + ' does not exist on jQuery.maj');
			}		
		};
		//------------------------------------------------------------------------------
		// END: jQuery maj Plugin
		//------------------------------------------------------------------------------


	})(maj,jQuery);
}