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(container){
this.drawers=[];
this.container=$(container);
},

addDrawer:function(newDrawer){},

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(onFire,delay){
this.triggerTimeout=setTimeout(onFire,delay);
},

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:1,
triggerDelay:0,





initialize:function(contentElement,handleElement,bureau,options){

this.contentElement=contentElement;
this.handle=handleElement;
this.bureau=bureau;

var triggerEvent='click';

if(options!=null&&typeof(options)!='undefined'){
this.beforeOpen=options.beforeOpen;
this.afterOpen=options.afterOpen;
this.beforeClose=options.beforeClose;
this.afterClose=options.afterClose;


if(typeof(options.triggerEvent)!='undefined'){
triggerEvent=options.triggerEvent;
}

if(typeof(options.triggerDelay)!='undefined'){
this.triggerDelay=options.triggerDelay;
}

if(typeof(options.transitionDuration)!='undefined'){
this.transitionDuration=options.transitionDuration;
}
}

if(AC.Detector.isiPhone()){
this.transitionDuration=1;
triggerEvent='click';
}

Element.addClassName(this.contentElement,'last');

var fireTrigger=function(evt){

Event.stop(evt);

if(this.triggerDelay>0){
var onFire=this.trigger.bind(this);
bureau.scheduleTrigger(onFire,this.triggerDelay);
}else{
this.trigger();
}
}

Event.observe(this.handle,triggerEvent,fireTrigger.bind(this),false);
Event.observe(this.handle,'mouseout',bureau.clearTrigger.bind(bureau),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(newDrawer){

Element.addClassName(newDrawer.contentElement,'last');
Element.addClassName(newDrawer.handle,'last');

if(this.hasDrawers()){

var lastDrawer=this.getLastDrawer();

lastDrawer.setNextDrawer(newDrawer);
newDrawer.setPreviousDrawer(lastDrawer);
}else{
Element.addClassName(newDrawer.contentElement,'first');
Element.addClassName(newDrawer.handle,'first');
}

this.listenForEvent(newDrawer,'beforeOpen',false,function(evt){
var drawer=evt.event_data.data;
this.open(drawer);
});

this.listenForEvent(newDrawer,'afterOpen',false,function(evt){
var drawer=evt.event_data.data;
this.acknowledgeOpened(drawer);
});

this.listenForEvent(newDrawer,'beforeClose',false,function(evt){
var drawer=evt.event_data.data;
this.close(drawer);
});

this.listenForEvent(newDrawer,'afterClose',false,function(evt){
var drawer=evt.event_data.data;
this.acknowledgeClosed(drawer);
});



if(!Element.hasClassName(newDrawer.contentElement,'open')){
newDrawer.initiateClose();
}else{
this.currentDrawer=newDrawer;
}

this.drawers.push(newDrawer);
},

open:function(drawer){

if(this.isLocked){
return;
}

this.isLocked=true;








if(Element.getStyle(this.container,'position')=='relative'){

var dimensions=Element.getDimensions(this.container);
Element.setStyle(this.container,{height:dimensions.height+"px"});

this.wedgeDrawersAfter(drawer);






var minHeight=Element.getStyle(drawer.contentElement,'min-height');

if(minHeight){
Element.setStyle(drawer.contentElement,{
'min-height':'0px',
height:minHeight})
}
}


if(this.currentDrawer){
this.currentDrawer.initiateClose();
}

drawer.open(minHeight);
},

acknowledgeOpened:function(drawer){
this.currentDrawer=drawer;

if(Element.getStyle(this.container,'position')=='relative'){
if(!AC.Detector.isIEStrict()){
Element.setStyle(this.container,{height:"auto"});
}
this.unwedgeDrawers();
}

this.isLocked=false;
},

close:function(drawer){

if(Element.getStyle(this.container,'position')=='relative'){
var minHeight=Element.getStyle(drawer.contentElement,'min-height');

if(minHeight){
Element.setStyle(drawer.contentElement,{
height:minHeight,
'min-height':'0px'});
}
}

drawer.close(minHeight);
},

acknowledgeClosed:function(drawer){
if(drawer==this.currentDrawer){
this.currentDrawer=null;
}
},

wedgeDrawersAfter:function(drawerBeingOpened){

var wedgeDrawer=function(drawer,offset){
Element.setStyle(drawer.handle,{
position:'absolute',
bottom:offset+'px'})
}

var drawer=this.getLastDrawer();
var offset=0;

while(drawer!=this.currentDrawer&&drawer!=drawerBeingOpened){
wedgeDrawer(drawer,offset);
offset+=drawer.handle.getHeight();
drawer=drawer.previousDrawer;
}

},

unwedgeDrawers:function(){
for(var i=this.drawers.length-1;i>=0;i--){
Element.setStyle(this.drawers[i].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(drawer){
this.nextDrawer=drawer;
Element.removeClassName(this.contentElement,'last');
Element.removeClassName(this.handle,'last');
},

setPreviousDrawer:function(drawer){
this.previousDrawer=drawer;
},

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(minHeight){

this.isTransitioning=true;


Element.addClassName(this.contentElement,'open');
Element.addClassName(this.handle,'open');

var afterFinish=function(){
this.isOpen=true;
if(minHeight){
Element.setStyle(this.contentElement,{'min-height':minHeight});
if(!AC.Detector.isIEStrict()){
Element.setStyle(this.contentElement,{'height':'auto'});
}
}
this.dispatchEvent('afterOpen',this);
this.isTransitioning=false;
}.bind(this);

if(AC.Detector.isiPhone()){
this.contentElement.show();
afterFinish();
}else{
new Effect.BlindDown(this.contentElement,{
duration:this.transitionDuration,
afterFinish:afterFinish});
}
},

initiateClose:function(force){

if(this.isTransitioning||!this.isOpen){
return;
}

this.dispatchEvent('beforeClose',this);
},

close:function(minHeight){

this.isTransitioning=true;

var afterFinish=function(){
this.isOpen=false;
Element.removeClassName(this.contentElement,'open');
Element.removeClassName(this.handle,'open');
if(minHeight){
Element.setStyle(this.contentElement,{'min-height':minHeight});
if(!AC.Detector.isIEStrict()){
Element.setStyle(this.contentElement,{'height':'auto'});
}
}
this.dispatchEvent('afterClose',this);
this.isTransitioning=false;
}.bind(this);

if(AC.Detector.isiPhone()){
this.contentElement.hide();
afterFinish();
}else{
new Effect.BlindUp(this.contentElement,{
duration:this.transitionDuration,
afterFinish:afterFinish});
}


}


});


AC.ShingleBureau=Class.create();
Object.extend(Object.extend(AC.ShingleBureau.prototype,AC.Bureau.prototype),{

drawerDuration:1,

addDrawer:function(newDrawer){


if(this.hasDrawers()){

var lastDrawer=this.getLastDrawer();

lastDrawer.setNextDrawer(newDrawer);
newDrawer.setPreviousDrawer(lastDrawer);
newDrawer.closedOffset=lastDrawer.closedOffset+lastDrawer.getHandleHeight()-10;
}else{
Element.addClassName(newDrawer.contentElement,'first');
newDrawer.closedOffset=0-newDrawer.getHeight()+newDrawer.getHandleHeight()-10;
newDrawer.indicateVisible();
}


this.drawers.push(newDrawer);
},

getWidth:function(){
return Element.getWidth(this.container);
},

getHeight:function(){
return Element.getHeight(this.container);
},

moveDrawer:function(drawer,x,y){
new Effect.Move(drawer,{
x:x,
y:y,
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(force){

if(this.isOpen&&!force){
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(force){

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(drawer){
this.previousDrawer=drawer;

this.indicateObscured();

this.openedOffset=this.previousDrawer.openedOffset+this.previousDrawer.getHandleHeight()-10;
Element.setStyle(this.contentElement,{top:this.openedOffset+"px"});
},

setNextDrawer:function(drawer){
this.nextDrawer=drawer;

Element.removeClassName(this.contentElement,'last');

if(this.previousDrawer!=null){
this.previousDrawer.setNextDrawer(this);
}


zIndex=parseInt(Element.getStyle(this.contentElement,'zIndex'));
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(newDrawer){
this.drawers.push(newDrawer);
newDrawer.handle.addClassName('obscured');
Element.hide(newDrawer.contentElement);
},

openingDrawer:function(drawer){
if(this.currentDrawer!=null){
this.currentDrawer.close();
}

this.currentDrawer=drawer;
}

});

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 afterTransition=function(){
Element.show(this.contentElement);
}.bind(this);






if(typeof(this.afterOpen)=='function'){
this.bureau.locked=true;
afterTransition=this.afterOpen.bind(this);
}

this.bureau.openingDrawer(this);

if(typeof(this.beforeOpen)=='function'){
this.beforeOpen();
}

this.isOpen=true;
Element.removeClassName(this.handle,'obscured');

new Effect.Appear(this.contentElement,{
afterFinish:afterTransition,
duration:this.transitionDuration,
queue:{scope:'sectionalscope'}});


},

close:function(){

if(typeof(this.beforeClose)=='function'){
this.beforeClose();
}

this.isOpen=false;
Element.addClassName(this.handle,'obscured');


var afterTransition=function(){
if(typeof(this.afterClose)=='function'){
this.afterClose();
}

}.bind(this)

new Effect.Fade(this.contentElement,{
afterFinish:afterTransition,
duration:this.transitionDuration,
queue:{scope:'sectionalscope'}});

},

reportFinishedOpening:function(){
this.bureau.locked=false;
}

});