Subversion Repositories Sites.obs-saisons.fr

/*

 * jQuery UI Accordion 1.8.5

 *

 * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)

 * Dual licensed under the MIT or GPL Version 2 licenses.

 * http://jquery.org/license

 *

 * http://docs.jquery.com/UI/Accordion

 *

 * Depends:

 *	jquery.ui.core.js

 *	jquery.ui.widget.js

 */

(function( $, undefined ) {

$.widget( "ui.accordion", {

	options: {

		active: 0,

		animated: "slide",

		autoHeight: true,

		clearStyle: false,

		collapsible: false,

		event: "click",

		fillSpace: false,

		header: "> li > :first-child,> :not(li):even",

		icons: {

			header: "ui-icon-triangle-1-e",

			headerSelected: "ui-icon-triangle-1-s"

		},

		navigation: false,

		navigationFilter: function() {

			return this.href.toLowerCase() === location.href.toLowerCase();

		}

	},

	_create: function() {

		var self = this,

			options = self.options;

		self.running = 0;

		self.element

			.addClass( "ui-accordion ui-widget ui-helper-reset" )

			// in lack of child-selectors in CSS

			// we need to mark top-LIs in a UL-accordion for some IE-fix

			.children( "li" )

				.addClass( "ui-accordion-li-fix" );

		self.headers = self.element.find( options.header )

			.addClass( "ui-accordion-header ui-helper-reset ui-state-default ui-corner-all" )

			.bind( "mouseenter.accordion", function() {

				if ( options.disabled ) {

					return;

				}

				$( this ).addClass( "ui-state-hover" );

			})

			.bind( "mouseleave.accordion", function() {

				if ( options.disabled ) {

					return;

				}

				$( this ).removeClass( "ui-state-hover" );

			})

			.bind( "focus.accordion", function() {

				if ( options.disabled ) {

					return;

				}

				$( this ).addClass( "ui-state-focus" );

			})

			.bind( "blur.accordion", function() {

				if ( options.disabled ) {

					return;

				}

				$( this ).removeClass( "ui-state-focus" );

			});

		self.headers.next()

			.addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" );

		if ( options.navigation ) {

			var current = self.element.find( "a" ).filter( options.navigationFilter ).eq( 0 );

			if ( current.length ) {

				var header = current.closest( ".ui-accordion-header" );

				if ( header.length ) {

					// anchor within header

					self.active = header;

				} else {

					// anchor within content

					self.active = current.closest( ".ui-accordion-content" ).prev();

				}

			}

		}

		self.active = self._findActive( self.active || options.active )

			.addClass( "ui-state-default ui-state-active" )

			.toggleClass( "ui-corner-all ui-corner-top" );

		self.active.next().addClass( "ui-accordion-content-active" );

		self._createIcons();

		self.resize();

		// ARIA

		self.element.attr( "role", "tablist" );

		self.headers

			.attr( "role", "tab" )

			.bind( "keydown.accordion", function( event ) {

				return self._keydown( event );

			})

			.next()

				.attr( "role", "tabpanel" );

		self.headers

			.not( self.active || "" )

			.attr({

				"aria-expanded": "false",

				tabIndex: -1

			})

			.next()

				.hide();

		// make sure at least one header is in the tab order

		if ( !self.active.length ) {

			self.headers.eq( 0 ).attr( "tabIndex", 0 );

		} else {

			self.active

				.attr({

					"aria-expanded": "true",

					tabIndex: 0

				});

		}

		// only need links in tab order for Safari

		if ( !$.browser.safari ) {

			self.headers.find( "a" ).attr( "tabIndex", -1 );

		}

		if ( options.event ) {

			self.headers.bind( options.event.split(" ").join(".accordion ") + ".accordion", function(event) {

				self._clickHandler.call( self, event, this );

				event.preventDefault();

			});

		}

	},

	_createIcons: function() {

		var options = this.options;

		if ( options.icons ) {

			$( "<span></span>" )

				.addClass( "ui-icon " + options.icons.header )

				.prependTo( this.headers );

			this.active.children( ".ui-icon" )

				.toggleClass(options.icons.header)

				.toggleClass(options.icons.headerSelected);

			this.element.addClass( "ui-accordion-icons" );

		}

	},

	_destroyIcons: function() {

		this.headers.children( ".ui-icon" ).remove();

		this.element.removeClass( "ui-accordion-icons" );

	},

	destroy: function() {

		var options = this.options;

		this.element

			.removeClass( "ui-accordion ui-widget ui-helper-reset" )

			.removeAttr( "role" );

		this.headers

			.unbind( ".accordion" )

			.removeClass( "ui-accordion-header ui-accordion-disabled ui-helper-reset ui-state-default ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )

			.removeAttr( "role" )

			.removeAttr( "aria-expanded" )

			.removeAttr( "tabIndex" );

		this.headers.find( "a" ).removeAttr( "tabIndex" );

		this._destroyIcons();

		var contents = this.headers.next()

			.css( "display", "" )

			.removeAttr( "role" )

			.removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active ui-accordion-disabled ui-state-disabled" );

		if ( options.autoHeight || options.fillHeight ) {

			contents.css( "height", "" );

		}

		return $.Widget.prototype.destroy.call( this );

	},

	_setOption: function( key, value ) {

		$.Widget.prototype._setOption.apply( this, arguments );

		if ( key == "active" ) {

			this.activate( value );

		}

		if ( key == "icons" ) {

			this._destroyIcons();

			if ( value ) {

				this._createIcons();

			}

		}

		// #5332 - opacity doesn't cascade to positioned elements in IE

		// so we need to add the disabled class to the headers and panels

		if ( key == "disabled" ) {

			this.headers.add(this.headers.next())

				[ value ? "addClass" : "removeClass" ](

					"ui-accordion-disabled ui-state-disabled" );

		}

	},

	_keydown: function( event ) {

		if ( this.options.disabled || event.altKey || event.ctrlKey ) {

			return;

		}

		var keyCode = $.ui.keyCode,

			length = this.headers.length,

			currentIndex = this.headers.index( event.target ),

			toFocus = false;

		switch ( event.keyCode ) {

			case keyCode.RIGHT:

			case keyCode.DOWN:

				toFocus = this.headers[ ( currentIndex + 1 ) % length ];

				break;

			case keyCode.LEFT:

			case keyCode.UP:

				toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];

				break;

			case keyCode.SPACE:

			case keyCode.ENTER:

				this._clickHandler( { target: event.target }, event.target );

				event.preventDefault();

		}

		if ( toFocus ) {

			$( event.target ).attr( "tabIndex", -1 );

			$( toFocus ).attr( "tabIndex", 0 );

			toFocus.focus();

			return false;

		}

		return true;

	},

	resize: function() {

		var options = this.options,

			maxHeight;

		if ( options.fillSpace ) {

			if ( $.browser.msie ) {

				var defOverflow = this.element.parent().css( "overflow" );

				this.element.parent().css( "overflow", "hidden");

			}

			maxHeight = this.element.parent().height();

			if ($.browser.msie) {

				this.element.parent().css( "overflow", defOverflow );

			}

			this.headers.each(function() {

				maxHeight -= $( this ).outerHeight( true );

			});

			this.headers.next()

				.each(function() {

					$( this ).height( Math.max( 0, maxHeight -

						$( this ).innerHeight() + $( this ).height() ) );

				})

				.css( "overflow", "auto" );

		} else if ( options.autoHeight ) {

			maxHeight = 0;

			this.headers.next()

				.each(function() {

					maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );

				})

				.height( maxHeight );

		}

		return this;

	},

	activate: function( index ) {

		// TODO this gets called on init, changing the option without an explicit call for that

		this.options.active = index;

		// call clickHandler with custom event

		var active = this._findActive( index )[ 0 ];

		this._clickHandler( { target: active }, active );

		return this;

	},

	_findActive: function( selector ) {

		return selector

			? typeof selector === "number"

				? this.headers.filter( ":eq(" + selector + ")" )

				: this.headers.not( this.headers.not( selector ) )

			: selector === false

				? $( [] )

				: this.headers.filter( ":eq(0)" );

	},

	// TODO isn't event.target enough? why the separate target argument?

	_clickHandler: function( event, target ) {

		var options = this.options;

		if ( options.disabled ) {

			return;

		}

		// called only when using activate(false) to close all parts programmatically

		if ( !event.target ) {

			if ( !options.collapsible ) {

				return;

			}

			this.active

				.removeClass( "ui-state-active ui-corner-top" )

				.addClass( "ui-state-default ui-corner-all" )

				.children( ".ui-icon" )

					.removeClass( options.icons.headerSelected )

					.addClass( options.icons.header );

			this.active.next().addClass( "ui-accordion-content-active" );

			var toHide = this.active.next(),

				data = {

					options: options,

					newHeader: $( [] ),

					oldHeader: options.active,

					newContent: $( [] ),

					oldContent: toHide

				},

				toShow = ( this.active = $( [] ) );

			this._toggle( toShow, toHide, data );

			return;

		}

		// get the click target

		var clicked = $( event.currentTarget || target ),

			clickedIsActive = clicked[0] === this.active[0];

		// TODO the option is changed, is that correct?

		// TODO if it is correct, shouldn't that happen after determining that the click is valid?

		options.active = options.collapsible && clickedIsActive ?

			false :

			this.headers.index( clicked );

		// if animations are still active, or the active header is the target, ignore click

		if ( this.running || ( !options.collapsible && clickedIsActive ) ) {

			return;

		}

		// switch classes

		this.active

			.removeClass( "ui-state-active ui-corner-top" )

			.addClass( "ui-state-default ui-corner-all" )

			.children( ".ui-icon" )

				.removeClass( options.icons.headerSelected )

				.addClass( options.icons.header );

		if ( !clickedIsActive ) {

			clicked

				.removeClass( "ui-state-default ui-corner-all" )

				.addClass( "ui-state-active ui-corner-top" )

				.children( ".ui-icon" )

					.removeClass( options.icons.header )

					.addClass( options.icons.headerSelected );

			clicked

				.next()

				.addClass( "ui-accordion-content-active" );

		}

		// find elements to show and hide

		var toShow = clicked.next(),

			toHide = this.active.next(),

			data = {

				options: options,

				newHeader: clickedIsActive && options.collapsible ? $([]) : clicked,

				oldHeader: this.active,

				newContent: clickedIsActive && options.collapsible ? $([]) : toShow,

				oldContent: toHide

			},

			down = this.headers.index( this.active[0] ) > this.headers.index( clicked[0] );

		this.active = clickedIsActive ? $([]) : clicked;

		this._toggle( toShow, toHide, data, clickedIsActive, down );

		return;

	},

	_toggle: function( toShow, toHide, data, clickedIsActive, down ) {

		var self = this,

			options = self.options;

		self.toShow = toShow;

		self.toHide = toHide;

		self.data = data;

		var complete = function() {

			if ( !self ) {

				return;

			}

			return self._completed.apply( self, arguments );

		};

		// trigger changestart event

		self._trigger( "changestart", null, self.data );

		// count elements to animate

		self.running = toHide.size() === 0 ? toShow.size() : toHide.size();

		if ( options.animated ) {

			var animOptions = {};

			if ( options.collapsible && clickedIsActive ) {

				animOptions = {

					toShow: $( [] ),

					toHide: toHide,

					complete: complete,

					down: down,

					autoHeight: options.autoHeight || options.fillSpace

				};

			} else {

				animOptions = {

					toShow: toShow,

					toHide: toHide,

					complete: complete,

					down: down,

					autoHeight: options.autoHeight || options.fillSpace

				};

			}

			if ( !options.proxied ) {

				options.proxied = options.animated;

			}

			if ( !options.proxiedDuration ) {

				options.proxiedDuration = options.duration;

			}

			options.animated = $.isFunction( options.proxied ) ?

				options.proxied( animOptions ) :

				options.proxied;

			options.duration = $.isFunction( options.proxiedDuration ) ?

				options.proxiedDuration( animOptions ) :

				options.proxiedDuration;

			var animations = $.ui.accordion.animations,

				duration = options.duration,

				easing = options.animated;

			if ( easing && !animations[ easing ] && !$.easing[ easing ] ) {

				easing = "slide";

			}

			if ( !animations[ easing ] ) {

				animations[ easing ] = function( options ) {

					this.slide( options, {

						easing: easing,

						duration: duration || 700

					});

				};

			}

			animations[ easing ]( animOptions );

		} else {

			if ( options.collapsible && clickedIsActive ) {

				toShow.toggle();

			} else {

				toHide.hide();

				toShow.show();

			}

			complete( true );

		}

		// TODO assert that the blur and focus triggers are really necessary, remove otherwise

		toHide.prev()

			.attr({

				"aria-expanded": "false",

				tabIndex: -1

			})

			.blur();

		toShow.prev()

			.attr({

				"aria-expanded": "true",

				tabIndex: 0

			})

			.focus();

	},

	_completed: function( cancel ) {

		this.running = cancel ? 0 : --this.running;

		if ( this.running ) {

			return;

		}

		if ( this.options.clearStyle ) {

			this.toShow.add( this.toHide ).css({

				height: "",

				overflow: ""

			});

		}

		// other classes are removed before the animation; this one needs to stay until completed

		this.toHide.removeClass( "ui-accordion-content-active" );

		this._trigger( "change", null, this.data );

	}

});

$.extend( $.ui.accordion, {

	version: "1.8.5",

	animations: {

		slide: function( options, additions ) {

			options = $.extend({

				easing: "swing",

				duration: 300

			}, options, additions );

			if ( !options.toHide.size() ) {

				options.toShow.animate({

					height: "show",

					paddingTop: "show",

					paddingBottom: "show"

				}, options );

				return;

			}

			if ( !options.toShow.size() ) {

				options.toHide.animate({

					height: "hide",

					paddingTop: "hide",

					paddingBottom: "hide"

				}, options );

				return;

			}

			var overflow = options.toShow.css( "overflow" ),

				percentDone = 0,

				showProps = {},

				hideProps = {},

				fxAttrs = [ "height", "paddingTop", "paddingBottom" ],

				originalWidth;

			// fix width before calculating height of hidden element

			var s = options.toShow;

			originalWidth = s[0].style.width;

			s.width( parseInt( s.parent().width(), 10 )

				- parseInt( s.css( "paddingLeft" ), 10 )

				- parseInt( s.css( "paddingRight" ), 10 )

				- ( parseInt( s.css( "borderLeftWidth" ), 10 ) || 0 )

				- ( parseInt( s.css( "borderRightWidth" ), 10) || 0 ) );

			$.each( fxAttrs, function( i, prop ) {

				hideProps[ prop ] = "hide";

				var parts = ( "" + $.css( options.toShow[0], prop ) ).match( /^([\d+-.]+)(.*)$/ );

				showProps[ prop ] = {

					value: parts[ 1 ],

					unit: parts[ 2 ] || "px"

				};

			});

			options.toShow.css({ height: 0, overflow: "hidden" }).show();

			options.toHide

				.filter( ":hidden" )

					.each( options.complete )

				.end()

				.filter( ":visible" )

				.animate( hideProps, {

				step: function( now, settings ) {

					// only calculate the percent when animating height

					// IE gets very inconsistent results when animating elements

					// with small values, which is common for padding

					if ( settings.prop == "height" ) {

						percentDone = ( settings.end - settings.start === 0 ) ? 0 :

							( settings.now - settings.start ) / ( settings.end - settings.start );

					}

					options.toShow[ 0 ].style[ settings.prop ] =

						( percentDone * showProps[ settings.prop ].value )

						+ showProps[ settings.prop ].unit;

				},

				duration: options.duration,

				easing: options.easing,

				complete: function() {

					if ( !options.autoHeight ) {

						options.toShow.css( "height", "" );

					}

					options.toShow.css({

						width: originalWidth,

						overflow: overflow

					});

					options.complete();

				}

			});

		},

		bounceslide: function( options ) {

			this.slide( options, {

				easing: options.down ? "easeOutBounce" : "swing",

				duration: options.down ? 1000 : 200

			});

		}

	}

});

})( jQuery );