/**
 * @author BBXP
 */
if (typeof(AC) == "undefined") {
	AC = {}
}
AC.Bureau = Class.create();
	Object.extend(AC.Bureau.prototype, Event.Listener);
Object.extend(AC.Bureau.prototype, {
	drawers : null,
	container : null,
	triggerTimeout : null,
	initialize : function(A) {
		this.drawers = [];
		this.container = $(A)
	},
	addDrawer : function(A) {
	},
	getDrawerCount : function() {
		return this.drawers.length
	},
	hasDrawers : function() {
		return (this.drawers.length > 0)
	},
	getFirstDrawer : function() {
		return this.drawers[0] || null
	},
	getLastDrawer : function() {
		return this.drawers[this.drawers.length - 1] || null
	},
	scheduleTrigger : function(B, A) {
		this.triggerTimeout = setTimeout(B, A)
	},
	clearTrigger : function() {
		clearTimeout(this.triggerTimeout)
	}
});
AC.Drawer = Class.create();
Object.extend(AC.Drawer.prototype, Event.Publisher);
Object.extend(AC.Drawer.prototype, {
	bureau : null,
	contentElement : null,
	handle : null,
	indicator : null,
	isOpen : true,
	beforeOpen : null,
	afterOpen : null,
	beforeClose : null,
	afterClose : null,
	transitionDuration : 0.3,
	triggerDelay : 0,
	initialize : function(F, D, B, C) {
		this.contentElement = $(F);
		this.handle = $(D);
		this.bureau = B;
		var E = "click";
		if (C !== null && typeof(C) != "undefined") {
			this.beforeOpen = C.beforeOpen;
			this.afterOpen = C.afterOpen;
			this.beforeClose = C.beforeClose;
			this.afterClose = C.afterClose;
			if (typeof(C.triggerEvent) != "undefined") {
				E = C.triggerEvent
			}
			if (typeof(C.triggerDelay) != "undefined") {
				this.triggerDelay = C.triggerDelay
			}
			if (typeof(C.transitionDuration) != "undefined") {
				this.transitionDuration = C.transitionDuration
			}
		}
		if (AC.Detector.isiPhone()) {
			this.transitionDuration = 0;
			E = "click"
		}
		Element.addClassName(this.contentElement, "last");
		var A = function(G) {
			if (AC.Detector.isiPhone()
					&& (this.isOpen && (this.isVisible === true))
					&& this.handle.tagName.match(/a/i)) {
				return
			}
			Event.stop(G);
			if (this.triggerDelay > 0) {
				var H = this.trigger.bind(this);
				B.scheduleTrigger(H, this.triggerDelay)
			} else {
				this.trigger()
			}
		};
		Event.observe(this.handle, E, A.bind(this), false);
		Event.observe(this.handle, "mouseout", B.clearTrigger.bind(B), false)
	},
	toggle : function() {
	},
	open : function() {
	},
	close : function() {
	}
});
AC.SlidingBureau = Class.create();
Object.extend(AC.SlidingBureau.prototype, AC.Bureau.prototype);
Object.extend(AC.SlidingBureau.prototype, {
	isLocked : false,
	addDrawer : function(B) {
		Element.addClassName(B.contentElement, "last");
		Element.addClassName(B.handle, "last");
		if (this.hasDrawers()) {
			var A = this.getLastDrawer();
			A.setNextDrawer(B);
			B.setPreviousDrawer(A)
		} else {
			Element.addClassName(B.contentElement, "first");
			Element.addClassName(B.handle, "first")
		}
		this.listenForEvent(B, "beforeOpen", false, function(C) {
			var D = C.event_data.data;
			this.open(D)
		});

		this.listenForEvent(B, "afterOpen", false, function(C) {
			var D = C.event_data.data;
			this.acknowledgeOpened(D)
		});
		this.listenForEvent(B, "beforeClose", false, function(C) {
			var D = C.event_data.data;
			this.close(D)
		});
		this.listenForEvent(B, "afterClose", false, function(C) {
			var D = C.event_data.data;
			this.acknowledgeClosed(D)
		});
		if (!Element.hasClassName(B.contentElement, "open")) {
			B.initiateClose()
		} else {
			this.currentDrawer = B
		}
		this.drawers.push(B)
	},
	open : function(A) {
		if (this.isLocked) {
			return
		}
		this.isLocked = true;
		var C = 0;
		if (Element.getStyle(this.container, "position") == "relative") {
			var B = Element.getDimensions(this.container);
			Element.setStyle(this.container, {
				height : B.height + "px"
			});
			this.wedgeDrawersAfter(A);
			C = Element.getStyle(A.contentElement, "min-height");
			if (C) {
				Element.setStyle(A.contentElement, {
					"min-height" : "0px",
					height : C
				})
			}
		}
		if (this.currentDrawer) {
			this.currentDrawer.initiateClose()
		}
		A.open(C)
	},
	acknowledgeOpened : function(A) {
		this.currentDrawer = A;
		if (Element.getStyle(this.container, "position") == "relative") {
			if (!AC.Detector.isIEStrict()) {
				Element.setStyle(this.container, {
					height : "auto"
				})
			}
			this.unwedgeDrawers()
		}
		this.isLocked = false
	},
	close : function(A) {
		var B = 0;
		if (Element.getStyle(this.container, "position") == "relative") {
			B = Element.getStyle(A.contentElement, "min-height");
			if (B) {
				Element.setStyle(A.contentElement, {
					height : B,
					"min-height" : "0px"
				})
			}
		}
		A.close(B)
	},
	acknowledgeClosed : function(A) {
		if (A == this.currentDrawer) {
			this.currentDrawer = null
		}
	},
	wedgeDrawersAfter : function(D) {
		var A = function(E, F) {
			Element.setStyle(E.handle, {
				position : "absolute",
				bottom : F + "px"
			})
		};
		var B = this.getLastDrawer();
		var C = 0;
		while (B != this.currentDrawer && B != D) {
			A(B, C);
			C += B.handle.getHeight();
			B = B.previousDrawer
		}
	},
	unwedgeDrawers : function() {
		for (var A = this.drawers.length - 1; A >= 0; A--) {
			Element.setStyle(this.drawers[A].handle, {
				position : "static"
			})
		}
	}
});
AC.SlidingDrawer = Class.create();
Object.extend(AC.SlidingDrawer.prototype, AC.Drawer.prototype);
Object.extend(AC.SlidingDrawer.prototype, {
	isOpen : true,
	isTransitioning : false,
	setNextDrawer : function(A) {
		this.nextDrawer = A;
		Element.removeClassName(this.contentElement, "last");
		Element.removeClassName(this.handle, "last")
	},
	setPreviousDrawer : function(A) {
		this.previousDrawer = A
	},
	trigger : function() {
		this.toggle()
	},
	toggle : function() {
		if (!this.isOpen) {
			this.initiateOpen()
		}
	},
	initiateOpen : function() {
		if (this.isTransitioning || this.isOpen) {
			return
		}
		this.dispatchEvent("beforeOpen", this)
	},
	open : function(C) {
		this.isTransitioning = true;
		if (typeof(this.beforeOpen) == "function") {
			this.beforeOpen(this)
		}
		Element.addClassName(this.contentElement, "open");
		Element.addClassName(this.handle, "open");
		var B = function() {
			this.isOpen = true;
			if (C) {
				Element.setStyle(this.contentElement, {
					"min-height" : C
				});
				if (!AC.Detector.isIEStrict()) {
					Element.setStyle(this.contentElement, {
						"height" : "auto"
					})
				}
			}
			this.dispatchEvent("afterOpen", this);
			this.isTransitioning = false;
			if (typeof(this.afterOpen) == "function") {
				this.afterOpen(this)
			}
		}.bind(this);
		if (AC.Detector.isiPhone()) {
			this.contentElement.show();
			B()
		} else {
			var A = new Effect.BlindDown(this.contentElement, {
				duration : this.transitionDuration,
				afterFinish : B
			})
		}
	},
	initiateClose : function(A) {
		if (this.isTransitioning || !this.isOpen) {
			return
		}
		this.dispatchEvent("beforeClose", this)
	},
	close : function(C) {
		this.isTransitioning = true;
		if (typeof(this.beforeClose) == "function") {
			this.beforeClose(this)
		}
		var B = function() {
			this.isOpen = false;
			Element.removeClassName(this.contentElement, "open");
			Element.removeClassName(this.handle, "open");
			if (C) {
				Element.setStyle(this.contentElement, {
					"min-height" : C
				});
				if (!AC.Detector.isIEStrict()) {
					Element.setStyle(this.contentElement, {
						"height" : "auto"
					})
				}
			}
			this.dispatchEvent("afterClose", this);
			this.isTransitioning = false;
			if (typeof(this.afterClose) == "function") {
				this.afterClose(this)
			}
		}.bind(this);
		if (AC.Detector.isiPhone()) {
			this.contentElement.hide();
			B()
		} else {
			var A = new Effect.BlindUp(this.contentElement, {
				duration : this.transitionDuration,
				afterFinish : B
			})
		}
	}
});
AC.ShingleBureau = Class.create();
Object.extend(Object.extend(AC.ShingleBureau.prototype, AC.Bureau.prototype), {
	drawerDuration : 0.5,
	addDrawer : function(B) {
		if (this.hasDrawers()) {
			var A = this.getLastDrawer();
			A.setNextDrawer(B);
			B.setPreviousDrawer(A);
			B.closedOffset = A.closedOffset + A.getHandleHeight() - 10
		} else {
			Element.addClassName(B.contentElement, "first");
			B.closedOffset = 0 - B.getHeight() + B.getHandleHeight() - 10;
			B.indicateVisible()
		}
		this.drawers.push(B)
	},
	getWidth : function() {
		return Element.getWidth(this.container)
	},
	getHeight : function() {
		return Element.getHeight(this.container)
	},
	moveDrawer : function(C, A, D) {
		var B = new Effect.Move(C, {
			x : A,
			y : D,
			mode : "absolute",
			transition : Effect.Transitions.sinoidal,
			duration : this.drawerDuration
		})
	}
});
AC.ShingleDrawer = Class.create();
Object.extend(Object.extend(AC.ShingleDrawer.prototype, AC.Drawer.prototype), {
	openedOffset : 0,
	closedOffset : 0,
	previousDrawer : null,
	nextDrawer : null,
	isVisible : false,
	trigger : function() {
		if (!this.isVisible) {
			this.open(true);
			this.indicateVisible()
		}
	},
	toggle : function() {
		if (!this.isOpen) {
			this.open();
			this.indicateVisible()
		} else {
			this.close()
		}
	},
	open : function(A) {
		if (this.isOpen && !A) {
			return
		}
		if (this.previousDrawer !== null) {
			this.previousDrawer.close();
			this.previousDrawer.indicateObscured()
		}
		if (this.nextDrawer !== null) {
			this.nextDrawer.open();
			this.nextDrawer.indicateObscured()
		}
		this.indicateVisible();
		this.isOpen = true;
		this.bureau.moveDrawer(this.contentElement, 0, this.openedOffset)
	},
	close : function(A) {
		if (!this.isOpen) {
			return
		}
		if (this == this.bureau.getLastDrawer()) {
			return
		}
		if (this.previousDrawer !== null) {
			this.previousDrawer.close()
		}
		this.bureau.moveDrawer(this.contentElement, 0, this.closedOffset);
		this.indicateObscured();
		this.isOpen = false
	},
	setPreviousDrawer : function(A) {
		this.previousDrawer = A;
		this.indicateObscured();
		this.openedOffset = this.previousDrawer.openedOffset
				+ this.previousDrawer.getHandleHeight() - 10;
		Element.setStyle(this.contentElement, {
			top : this.openedOffset + "px"
		})
	},
	setNextDrawer : function(A) {
		this.nextDrawer = A;
		Element.removeClassName(this.contentElement, "last");
		if (this.previousDrawer !== null) {
			this.previousDrawer.setNextDrawer(this)
		}
		zIndex = parseInt(Element.getStyle(this.contentElement, "zIndex"), 10);
		Element.setStyle(this.contentElement, {
			"zIndex" : zIndex + 1
		})
	},
	indicateObscured : function() {
		Element.addClassName(this.contentElement, "obscured");
		this.isVisible = false
	},
	indicateVisible : function() {
		this.isVisible = true;
		Element.removeClassName(this.contentElement, "obscured")
	},
	getHandleWidth : function() {
		return Element.getWidth(this.handle)
	},
	getHandleHeight : function() {
		return Element.getHeight(this.handle)
	},
	getWidth : function() {
		return Element.getWidth(this.contentElement)
	},
	getHeight : function() {
		return Element.getHeight(this.contentElement)
	}
});
AC.SectionBureau = Class.create();
Object.extend(AC.SectionBureau.prototype, AC.Bureau.prototype);
Object.extend(AC.SectionBureau.prototype, {
	currentDrawer : null,
	locked : false,
	addDrawer : function(A) {
		this.drawers.push(A);
		Element.addClassName(A.handle, "obscured");
		Element.hide(A.contentElement)
	},
	openingDrawer : function(A) {
		if (this.currentDrawer !== null) {
			this.currentDrawer.close()
		}
		this.currentDrawer = A
	}
});
AC.SectionDrawer = Class.create();
Object.extend(AC.SectionDrawer.prototype, AC.Drawer.prototype);
Object.extend(AC.SectionDrawer.prototype, {
	isOpen : false,
	trigger : function() {
		this.toggle()
	},
	toggle : function() {
		if (!this.isOpen) {
			this.open()
		}
	},
	open : function() {
		if (this.bureau.locked) {
			return
		}
		var B = function() {
			Element.show(this.contentElement)
		}.bind(this);
		if (typeof(this.afterOpen) == "function") {
			this.bureau.locked = true;
			B = this.afterOpen.bind(this)
		}
		this.bureau.openingDrawer(this);
		if (typeof(this.beforeOpen) == "function") {
			this.beforeOpen()
		}
		this.isOpen = true;
		Element.removeClassName(this.handle, "obscured");
		var A = new Effect.Appear(this.contentElement, {
			afterFinish : B,
			duration : this.transitionDuration,
			queue : {
				scope : "sectionalscope"
			}
		})
	},
	close : function() {
		if (typeof(this.beforeClose) == "function") {
			this.beforeClose()
		}
		this.isOpen = false;
		Element.addClassName(this.handle, "obscured");
		var A = function() {
			if (typeof(this.afterClose) == "function") {
				this.afterClose()
			}
		}.bind(this);
		var B = new Effect.Fade(this.contentElement, {
			afterFinish : A,
			duration : this.transitionDuration,
			queue : {
				scope : "sectionalscope"
			}
		})
	},
	reportFinishedOpening : function() {
		this.bureau.locked = false
	}
})