var mouseCheckInt
var updateScrubberInt
var scrollLeftRightInt
var scrollUpDownInt
var _root_xmouse
var _root_ymouse
var curScrollPanel=null
var scrollPanelArr=new Array()


function startDrag(s,e) {
	
	this.mouse_down=1
	sender=s
	me=this
	
	var key=s.name.split("_")[0]
	obj=scrollPanelArr[key]
	
	obj.click_x=e.getPosition(s).x	
	obj.click_y=e.getPosition(s).y	
	
	if(obj.scrollTween) {
		obj.scrollTween.stop()
	}	

	obj.mouseCheckInt=setInterval("mouseChecker(sender,me,obj)",10)	
	s.captureMouse()
}


function endDrag(s,e) {
	this.mouse_down=0
	var key=s.name.split("_")[0]
	var obj=scrollPanelArr[key]	
	clearInterval(obj.mouseCheckInt)
	s.releaseMouseCapture()
}


function mouseChecker(s,me,obj) {

	if(me.mouse_down) {

		if(obj.direction=="H") {
			new_val=_root_xmouse-obj.world_offset+obj.local_offset-obj.click_x
			calc_scroll_end=obj.track_length+obj.local_offset-s.width
			//equates to...
			//var calc_right_edge=(obj.track_length+obj.world_offset)-(obj.world_offset-obj.local_offset)-s.width
		
			val=((new_val-obj.start_scroll)/(obj.track_length-s.width))*100
			per=val/100
			canvas_prop="Canvas.Left"
		}
		else {
			new_val=_root_ymouse-obj.world_offset+obj.local_offset-obj.click_y
			calc_scroll_end=obj.track_length+obj.local_offset-s.height
		
			val=((new_val-obj.start_scroll)/(obj.track_length-s.height))*100
			per=val/100
			canvas_prop="Canvas.Top"			
		}
		
		if(new_val>obj.start_scroll && new_val<calc_scroll_end) {
			s[canvas_prop]=new_val
			s.findName(obj.container)[canvas_prop]=((obj.content_length - obj.mask_length)*per)*-1
		}
		else if(new_val<=obj.start_scroll) {
			s[canvas_prop]=obj.start_scroll
			s.findName(obj.container)[canvas_prop]=0
		}
		else if(new_val>=calc_scroll_end) {
			s[canvas_prop]=calc_scroll_end
			s.findName(obj.container)[canvas_prop]=-obj.content_length+obj.mask_length
		}
		
	}
	else {
		clearInterval(obj.mouseCheckInt)
		s.releaseMouseCapture()
	}
}





function pressTrackBar(s,e,diff) {

	
	key=s.name.split("_")[0]

	var obj=scrollPanelArr[key]
	var time_to_scroll
	var click_x
	var click_y
	var click_prop
	var scrubber_prop
	var new_val
	
	var	scrubber=s.findName(key+"_Scrubber")
	
	if(e) { // if event came from trackbar press
		click_x=e.getPosition(s).x
		click_y=e.getPosition(s).y
	
		time_to_scroll = 2.0  //on track bar press - time for scroll bar animation
	}
	else { //else event came from mouse wheel
	
		time_to_scroll = 0.0001  //on mouse wheel scroll - time for scroll bar animation
		
		var scroll_amount=6
		
		if(diff>0) {
			click_y=(scrubber["Canvas.Top"]-obj.local_offset)-scroll_amount
		}
		else {	
			click_y=(scrubber["Canvas.Top"]-obj.local_offset+scrubber.height)+scroll_amount
		}
				
		
		if(click_y<0) {
			click_y=0
		}
		else if(click_y>obj.track_length) {
			click_y=obj.track_length
		}
	}
	
	
	if(obj.direction=="H") {
		click_prop=click_x
		canvas_prop="Canvas.Left"
		scrubber_prop=scrubber.width
	}
	else {
		click_prop=click_y
		canvas_prop="Canvas.Top"
		scrubber_prop=scrubber.height
	}
	
	//handles muliptle trackbar clicks
	if(obj.scrollTween) {
		obj.scrollTween.stop()
	}
	
	if(click_prop < scrubber[canvas_prop]) {
		obj.scrollTween = new Tween(new Object(),'st',Tween.strongEaseOut,scrubber[canvas_prop],(click_prop+obj.local_offset),time_to_scroll)
	}
	else {
		obj.scrollTween = new Tween(new Object(),'st',Tween.strongEaseOut,scrubber[canvas_prop],(click_prop-scrubber_prop+obj.local_offset),time_to_scroll)
	}
	
	obj.scrollTween.onMotionChanged = function(event){
		scrubber[canvas_prop] = event.target._pos
		
		new_val=event.target._pos

		if(obj.direction=="H") {
			val=((new_val-obj.start_scroll)/(obj.track_length-scrubber.width))*100
			canvas_prop="Canvas.Left"
		}
		else {
			val=((new_val-obj.start_scroll)/(obj.track_length-scrubber.height))*100
			canvas_prop="Canvas.Top"
		}
		var per=val/100
		s.findName(obj.container)[canvas_prop]=((obj.content_length - obj.mask_length)*per)*-1	
		
	}

	obj.scrollTween.start()

}


function scrollerArrowPress(s) {

	sender=s
	
	var key=s.name.split("_")[0]
	var obj=scrollPanelArr[key]
	
	if(obj.scrollTween) {
		obj.scrollTween.stop()
	}	
	
	if(obj.direction=="H") {
		//scrollLeftRightInt=setInterval("scrollLeftRight(sender,me)",10)
	}
	else {
		obj.scrollUpDownInt=setInterval("scrollUpDown(sender)",10)
	}
	
	s.captureMouse()
}


function scrollerArrowRelease(s,e) {

	var key=s.name.split("_")[0]
	var obj=scrollPanelArr[key]

	clearInterval(obj.scrollUpDownInt)
	
	s.releaseMouseCapture()
}




function scrollUpDown(s) {

	var key=s.name.split("_")[0]
	var btn_name=s.name.split("_")[1]
	var obj=scrollPanelArr[key]
	
	scrubber=s.findName(key+"_Scrubber")
	
	var scroll_amount=obj.scroll_amount
	
	if(btn_name=="Up") {
	
		var pre_check=scrubber["Canvas.Top"]-scroll_amount
		
		if(pre_check>obj.local_offset) {
			scrubber["Canvas.Top"]=scrubber["Canvas.Top"]-scroll_amount
		}
		else {
			scrubber["Canvas.Top"]=obj.local_offset
		}
	}
	else {
		
		var calc_bottom_edge=obj.track_length+obj.local_offset-scrubber.height
		
		var pre_check=scrubber["Canvas.Top"]+scroll_amount
		
		if(pre_check<calc_bottom_edge) {
			scrubber["Canvas.Top"]=scrubber["Canvas.Top"]+scroll_amount
		}
		else {
			scrubber["Canvas.Top"]=calc_bottom_edge
		}
	}
	
	updatePanel(scrubber["Canvas.Top"],s,obj)
}

function updatePanel(new_val,s,obj) {

	var scroll_width=s.findName(obj.container).width
	key=s.name.split("_")[0]
	
	scrubber=s.findName(key+"_Scrubber")
	
	//duplicate code as in "mouseChecker", should consolidate into new function
	if(obj.direction=="H") {

		val=((new_val-obj.start_scroll)/(obj.track_length-scrubber.width))*100
		canvas_prop="Canvas.Left"
	}
	else {
		val=((new_val-obj.start_scroll)/(obj.track_length-scrubber.height))*100
		canvas_prop="Canvas.Top"
	}
	var per=val/100
	s.findName(obj.container)[canvas_prop]=((obj.content_length - obj.mask_length)*per)*-1
}

function whenMouseMoves(s, e) {
	
    _root_xmouse = e.getPosition(null).x
    _root_ymouse = e.getPosition(null).y
    
    //window.status=_root_xmouse+" - "+_root_ymouse
}

function createScrollablePanel(canvasName,xpos,ypos,wid,hgt,dir,XamlInsert, XamlHeight,bg_color) {

	this.name=canvasName
	this.xpos=xpos
	this.ypos=ypos
	this.width=wid
	this.XamlHeight=XamlHeight
	this.height=hgt
	this.XamlInsert=XamlInsert
	this.direction=dir

	this.bg_color="transparent"
	if(bg_color) {
		this.bg_color=bg_color
	}
	
	this.container=canvasName+"_contentContainer"
	this.local_offset=12 //12 for spacing from top
	this.world_offset=ypos+this.local_offset 
	this.track_length=hgt-24 //22 because scroll arrows are 10px tall *2 + 1px spacing for each
	this.start_scroll=this.local_offset 
	this.scroll_amount=6 
	this.scrollbar_content_spacing=10
	this.scrollTween=null
	this.padding=6
	
	this.scrubber_color="#31BFFF"
	this.trackbar_color="#001B28"
	this.arrow_color="#31BFFF"
	this.arrow_button_color="#31BFFF"
	
	this.mask_length=this.height
	this.content_length=0


	scrollPanelArr[this.name]=this
		
	this.createPanel=createPanel
	this.createScroller=createScroller
	
	this.createPanel()
	this.createScroller()
			
}

function createPanel() {

	var xaml_str='<Canvas Name="'+this.name+'_contentHolder" Canvas.Top="'+this.ypos+'" Canvas.Left="'+this.xpos+'" MouseEnter="scrollPanelOver" MouseLeave="scrollPanelOut"> '
	xaml_str+=' <Rectangle Fill="'+this.bg_color+'" Height="'+this.height+'" Width="'+this.width+'"></Rectangle>'
	xaml_str+=' <Canvas.Clip>'
	xaml_str+='   <RectangleGeometry Name="'+this.name+'_contentHolderClip" Rect="0,0,'+this.width+','+this.height+'" />'
	xaml_str+=' </Canvas.Clip>'
	xaml_str+=' <Canvas Name="'+this.name+'_contentContainer" Canvas.Top="0" Canvas.Left="0" > '
	
	//
	//Here is where the XAML should be replaced instead of the TEXTBLOCK
	//
	xaml_str+='  <Canvas Canvas.Left="'+this.padding+'" Name="'+this.name+'_contentContainerText" Height="'+this.XamlHeight+'" Width="'+(this.width-(this.padding*2))+'">' + this.XamlInsert + '</Canvas>'
	//
	//
	
	xaml_str+=''
	xaml_str+=' </Canvas>'
	xaml_str+='</Canvas>'

	xamlTags=plugin.content.createFromXaml(xaml_str)
	main.children.add(xamlTags)
	
	//This is the length of the CANVAS Container that it's trying to find.
	//We'll need a Naming convention for the initial CANVAS that is being put into the thing
	this.content_length=Math.ceil(main.findName(this.name+"_contentContainerText"));
}


function createScroller() {

	var xaml_str='<Canvas Name="'+this.name+'_scrollerContainer" Canvas.Top="'+this.ypos+'" Canvas.Left="'+(this.xpos+this.width+this.scrollbar_content_spacing)+'">'
		xaml_str+=' <Canvas Name="'+this.name+'_Up" MouseLeftButtonDown="scrollerArrowPress" MouseLeftButtonUp="scrollerArrowRelease"> '
		xaml_str+='   <Rectangle Fill="'+this.arrow_button_color+'" Width="7" Height="10" />'
		xaml_str+='   <Path Data="M 0,0 L3,3 -3,3z" Fill="'+this.arrow_color+'" Canvas.Left="3" Canvas.Top="4" />'
		xaml_str+=' </Canvas>'
		xaml_str+=' <Canvas Name="'+this.name+'_Down" MouseLeftButtonDown="scrollerArrowPress" MouseLeftButtonUp="scrollerArrowRelease" Canvas.Top="'+(this.height-10)+'"> '
		xaml_str+='  <Rectangle Fill="'+this.arrow_button_color+'" Width="7" Height="10" /> '
		xaml_str+='  <Path Data="M 0,0 L3,-3 -3,-3z" Fill="'+this.arrow_color+'" Canvas.Left="3" Canvas.Top="6" />'
		xaml_str+=' </Canvas>'
		xaml_str+=' <Rectangle Name="'+this.name+'_TrackBarVisual" Fill="'+this.trackbar_color+'" Height="'+(this.height-22)+'" Width="7" Canvas.Top="11" /> '
		xaml_str+=' <Rectangle Name="'+this.name+'_TrackBar" MouseLeftButtonDown="pressTrackBar" Fill="transparent" Height="'+(this.height-23)+'" Width="7" Canvas.Top="12" /> '
		xaml_str+=' <Rectangle Name="'+this.name+'_Scrubber" MouseLeftButtonDown="startDrag" MouseLeftButtonUp="endDrag" Fill="'+this.scrubber_color+'" Height="50" Width="7" Canvas.Top="12" Canvas.Left="0" /> '
		//xaml_str+=''
		xaml_str+='</Canvas>'
		
	xamlTags=plugin.content.createFromXaml(xaml_str)
	main.children.add(xamlTags)	
	
	var tfRef=main.findName(this.name+"_contentContainerText")
	showHideScrollBar(tfRef,this)	
}



function showHideScrollBar(tf,sp) {

	var scroller_name=sp.name
	var scrubberRef=main.findName(scroller_name+"_Scrubber")

	//hide scroll bar if content isnt big enough to scroll
	if(tf.Height<=sp.mask_length) {
		main.findName(scroller_name+"_scrollerContainer").visibility="Collapsed"
	}
	else {
		main.findName(scroller_name+"_scrollerContainer").visibility="Visible"
		sp.content_length=Math.ceil(tf.Height)
		
		scrubberRef.height= Math.ceil( (sp.mask_length/sp.content_length) * sp.track_length)
		if(scrubberRef.height<12) {
			scrubberRef.height=13
		}
	}

	//reset scrubber bar and canvas to inital spots	
	scrubberRef["Canvas.Top"]=sp.local_offset
	tf.findName(sp.container)["Canvas.Top"]=0

}



function scrollPanelOver(s,e) {

	var sp_name=s.name.split("_")[0]
	curScrollPanel=sp_name

}

function scrollPanelOut(s,e) {
	curScrollPanel=null
}


// MouseWheel code from http://adomas.org/javascript-mouse-wheel/

if (window.addEventListener) {
    // DOMMouseScroll is for mozilla.
	window.addEventListener('DOMMouseScroll', mouseWheelChange,true)
}
// IE/Opera.
window.onmousewheel = document.onmousewheel = mouseWheelChange



function mouseWheelChange(event) {

    var delta = 0;
    if (!event) { // For IE.
        event = window.event;
    }

    if (event.wheelDelta) { //IE/Opera.
        delta = event.wheelDelta
        // In Opera 9, delta differs in sign as compared to IE.
        if (window.opera) {
            delta = -delta;
        }
    }
    else if (event.detail) { // Mozilla case.
        // In Mozilla, sign of delta is different than in IE.
        delta = -event.detail
        
    }
	
	if(curScrollPanel) {

		var s=main.findName(curScrollPanel+"_TrackBar")
		var e=null	
	
		pressTrackBar(s,e,delta)
	}
	
    event.returnValue = false;
}