/*
Script: moostick dot js
A Mootools-powered, unobtrusive, Javascript news ticker library. /mouthful
About:
<Moostick> will take in any type of li-containing element and turn it into
an animated news ticker, fading between each headline at a set interval.
Version:
- Version: 1.0
Homepage:
- Moostick @ tekArtist <http://tekartist.org/labs/mootools/moostick/>
Requirements:
- Cascading Style Sheets (CSS): <http://www.w3.org/Style/CSS/>
- Javascript: <http://en.wikipedia.org/wiki/JavaScript>
- MooTools: <http://mootools.net/>
Copyright:
copyright (c) 2007 Stephane Daury: <http://stephane.daury.org/>
License: 
MIT License <http://www.opensource.org/licenses/mit-license.php>
Copyright (c) 2007 Stephane Daury <http://stephane.daury.org/>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
Notes: Procedural code
Safety check    - Moostick checks that MooTools is present to avoid
errors and prompts to either cancel or be redirected
to the MooTools site for more info.
Auto start mode - Moostick auto-starts by default, unless passed init=0
in the script's query string for more selective
interaction. <MstkHelpers> must be implemented before
this step.
*/
if(typeof(window['MooTools']) == 'undefined'){
// See: <Procedural code>
var mstkRedirect = 'http:/www.mootools.net/';
if(confirm('Moostick requires the MooTools JavaScript framework.\n'
+ 'Be sure to include it before Moostick.\n\n'
+ 'Click OK for more info, or Cancel to load the page without it.')){
top.location.href = redirect;
}
} else {
/*
Class: MstkHelpers 
(singleton) Utility class containing helper methods that will be helpful in other
classes.
Notes:
- Can be used before "ondomready" or "onload" are achieved, and is
currently required by the auto-start procedure.
- Can be used directly or have its methods implemented other Classes.
Example:
(start code)
alert(MstkHelpers.qsVar('myKey'));
(end)
*/
var MstkHelpers = {
// Group: Public Methods
/*
Method: qsVar
Query string helper for the Moostick script (NOT the document
that included it). Takes a query string key, and returns the
value, or false if not found.    
Arguments:
key - the key (key=val) to search for, as string.
Returns:
val - the key's value as string or false if not found.
*/
qsVar: function(key){
var val = false;
if(key.length > 0){
$ES('script').each(function(s){
if(s.src.match('moostick.js?')){
var uriParts = s.src.split('?');
if(uriParts[1]){
uriParts[1].split('&').each(function(keyPair){
var tmp = keyPair.split('=');
if(tmp[1] && tmp[0] == key)
val = tmp[1];
});
}
}
});
}
return val;
},
/*
Method: checkArray
Checks if the sent value is an array or convert it. Very useful
when you do not know if you are dealing with an single element
through $()/$E()/etc or multiple elements through $$()/$E()/etc.
Arguments:
val - the value to check
Returns:
val - the sent value if already an array, or a single-item array.
*/
checkArray: function(val){
if(!val[0])
return [val];
else
return val;
}
} // end MstkHelpers
// See: <Procedural code>
if(MstkHelpers.qsVar('init') !== 'false'){
window.addEvent('domready', function() {
MstkInit.go(false, true);
});
}
/*
Class: MstkInit
(singleton) A multi-list utility wrapper for the Moostick class and processes.
Notes:
- Used in auto-start mode to scan the DOM for targeted elements.
- Also supports concept of safe v. fast mode, like <MooStick>.
- When opting to turn off auto-start, it is advised to instantiate
the <Moostick> class directly with a single known list. On the other
hand, MstkInit will let you pass multiple ones, such as when dealing
with css classes instead of ids, etc.    
Example:
(start code)
// Enable Moostick on any element with "my-custom-class" css class.
MstkInit.go($$('.my-custom-class'), true);
(end)
*/
var MstkInit = {
// Group: Public Properties
/*
Property: lists
One or more list (ul, ol...) from $(), $$(), etc.
If passed as false, MstkInit will try to search the
DOM for list with an id of moostick, or lists with
a class of moostick.
*/
lists        : false,
/*
Property: autoStart
Boolean. Should the constructor launch the DOM
modification process, or just set the properties.
*/
autoStart    : false,
/*
Property: interval
Passthru variable. See: <Moostick.interval>.
*/
interval     : 3500,
/*
Property: fxOptions
Passthru variable. See: <Moostick.fxOptions>.
*/
fxOptions    : {},
/*
Property: trust4Speed
Set to true to bypass element validation, for increased
rendering speed, but only if you're absolutely sure
about the <MstkInit.lists> you passed in.
*/
trust4Speed  : false,
/*
Property: trustOpacity
Passthru variable. See: <Moostick.trustOpacity>.
*/
trustOpacity : false,
// Group: Public Methods
/*
Method: go
Sets the default properties and launches the Moostick modification
process if in auto-start mode.
Arguments:
lists        - See: <MstkInit.lists>
autoStart    - See: <MstkInit.autoStart>
interval     - See: <MstkInit.interval>
fxOptions    - See: <MstkInit.fxOptions>
trust4Speed  - See: <MstkInit.trust4Speed>
trustOpacity - See: <MstkInit.trustOpacity>
*/
go: function(lists, autoStart, interval, fxOptions, trust4Speed, trustOpacity) {
this.lists        = (!lists)
? this.lists
: lists;
this.autoStart    = (autoStart === true)
? autoStart
: this.autoStart;
this.interval     = (!interval) || (interval.toInt() < 500)
? this.interval
: interval.toInt();
this.fxOptions    = ((!fxOptions) || (typeof(fxOptions) != 'object'))
? this.fxOptions
: fxOptions;
this.trust4Speed  = (trust4Speed === true)
? trust4Speed
: this.trust4Speed;
this.trustOpacity = (trustOpacity === true)
? trustOpacity
: this.trustOpacity;
if(this.autoStart === true){
if(this.trust4Speed === true){
// Kamikaze mode!
this._fastMode();
}
else{
// Cautious mode
this._safeMode();
}
}
},
// Group: Private Methods
/*
Method: _fastMode
AKA the Kamikaze mode. Instantiate a <Moostick> object for each
<MstkInit.lists>, without any validation, besides making sure
we have an array to loop on.
*/
_fastMode: function(){
this.lists = MstkHelpers.checkArray(this.lists);
this.lists.each(function(list){
new Moostick(
list,
this.autoStart,
this.interval,
this.fxOptions,
this.trust4Speed,
this.trustOpacity
)
}, this);
},
/*
Method: _safeMode
AKA the cautious mode. First validates the passed <MstkInit.lists>
or tries to auto-discover targeted DOM elements with "moostick"
as an id or class, then calls <Moostick> for each list.
*/
_safeMode: function(){
if(this.lists === false){
var defaultLists = false;
// Scan for a list with the recommended default id
if($('moostick'))
defaultLists = [$('moostick')];
// Or can for (a) list(s) with the recommended default class
else if($$('.moostick'))
defaultLists = $$('.moostick');
this.lists = (!defaultLists) ? false : defaultLists;
}
if(this.lists){
//this.lists = MstkHelpers.checkArray(this.lists);
this.lists.each(function(list){
new Moostick(
list,
this.autoStart,
this.interval,
this.fxOptions,
this.trust4Speed,
this.trustOpacity
)
}, this);
}
}
} // end MstkInit
/*
Class: Moostick
Modifies the presentation and behaviour of li-containing elements to
act as pseudo news tickers, and extends their DOM with itself
(eg: myUL.moostick) for easy manipulation.
Example: Programming
(start code)
// Auto-discovery mode, looking for li-containing elements with
// an id (single) or class of "moostick", then auto-starts.
new Moostick();
$('moostick').moostick.stopTick();
// Instantiate Moostick for the "my-custom-id" element. Do
// not auto-start. Fade every 5 seconds, for 1/2 second.
// Trust the list I sent, but handle the opacity assignment.
var myList = new Moostick(
$('my-custom-id'),
false,
5000,
{duration: 500},
true,
false
);
myList.startTick();
(end)
*/
var Moostick = Class({
// Group: Public Properties
/*
Property: version
Moostick release version
*/
version         : '1.0',
/*
Property: list
A single list (ul, ol...) from $(), $E(), etc.
This is the element to which Mostick will attach
itself. EG: myUL.moostick.stopTick();
*/
list         : {},
/*
Property: autoStart
Boolean. Should the constructor launch the DOM
modification process, or just set the properties.
*/
autoStart    : false,
/*
Property: interval
Defines duration for which each headline is
displayed including transition time, which
can be adjusted through <Moostick.fxOptions>.
*/
interval     : 3500,
/*
Property: fxOptions
MooTools effect options for the opacity change used
in the transition. See the MooTools docs for details.
<http://docs.mootools.net/Effects/Fx-Base.js#Fx.Base>
*/
fxOptions    : {},
/*
Property: trust4Speed
Set to true to bypass element validation, for
increased rendering speed, but only if you're
absolutely sure about the <Moostick.list> you
passed in. See also: <Moostick.trustOpacity>.
*/
trust4Speed  : false,
/*
Property: trustOpacity
Set to true to bypass element styles validation,
for increased rendering speed, but only if you're
absolutely sure about the <Moostick.list> you sent.
When ON, we do not loop through each li to set
the opacity to 0, therefore assuming you dealt
with it in your stylesheets.
*/
trustOpacity : false,
// Group: Private Properties
/*
Property: _firstRun
True if the first time we run.
*/
_firstRun    : true,
/*
Property: _elSched
Element schedule object.
*/
_elSched     : null,
/*
Property: _fx
Opacity change effect.
*/
_fx: false,
// Group: Public Methods
/*
Method: initialize
MooTools pseudo constructor. Sets the default properties and
launches the Moostick modification process if in auto-start mode.
Arguments:
list         - See: <Moostick.list>
autoStart    - See: <Moostick.autoStart>
interval     - See: <Moostick.interval>
fxOptions    - See: <Moostick.fxOptions>
trust4Speed  - See: <Moostick.trust4Speed>
trustOpacity - See: <Moostick.trustOpacity>
*/
initialize: function(list, autoStart, interval, fxOptions, trust4Speed, trustOpacity) {
this.list         = ((!list) || (typeof(list) != 'object'))
? this.list
: list;
this.autoStart    = (autoStart === true)
? autoStart
: this.autoStart;
this.interval     = (!interval) || (interval.toInt() < 500)
? this.interval
: interval.toInt();
this.fxOptions    = ((!fxOptions) || (typeof(fxOptions) != 'object'))
? this.fxOptions
: fxOptions;
this.trust4Speed  = (trust4Speed === true)
? trust4Speed
: this.trust4Speed;
this.trustOpacity = (trustOpacity === true)
? trustOpacity
: this.trustOpacity;
this.list.moostick = this;
if(this.autoStart === true){
if(this.trust4Speed === true){
// Kamikaze mode!
this._fastMode();
}
else{
// Cautious mode
this._safeMode();
}
}
},
/*
Method: startTick
Calls <Moostick.initialize> on-demand, always in auto-start mode.
Arguments:
lists        - See: <Moostick.list>
interval     - See: <Moostick.interval>
fxOptions    - See: <Moostick.fxOptions>
trust4Speed  - See: <Moostick.trust4Speed>
trustOpacity - See: <Moostick.trustOpacity>
See also:
<Moostick.stopTick>, <Moostick.pauseTick>
and <Moostick.resumeTick>.
*/
startTick: function(list, interval, fxOptions, trust4Speed, trustOpacity){
this.initialize(list, true, interval, fxOptions, trust4Speed, trustOpacity);
},
/*
Method: stopTick
Stops the ticker completely, including the attached mouse events.
See also:
<Moostick.startTick>.
*/
stopTick: function(){
// TODO: figure out why removeEvent isn't working here
this.list.$events.mouseenter = false;
this.list.$events.mouseleave = false;
this.pauseTick();
},
/*
Method: pauseTick
Pauses the ticker.
See also:
<Moostick.resumeTick> and <Moostick.stopTick>.
*/
pauseTick: function(){
this._elSched = $clear(this._elSched);
},    
/*
Method: resumeTick
Un-pauses the ticker.
See also:
<Moostick.pauseTick> and <Moostick.stopTick>.
*/
resumeTick: function(){
this._schedule();
},
// Group: Private Methods
/*
Method: _fastMode
AKA the Kamikaze mode. Bypasses all element validation.
*/
_fastMode: function(){
this._liHandler();
this._schedule();
},
/*
Method: _safeMode
AKA the cautious mode. Validates the passed <Moostick.list> and
tries to apply arbitray default styles before lauching the ticker.
*/
_safeMode: function(){
if(this.list){
if($ES('li', this.list)){
var items = $ES('li', this.list);
// Assign proprietary CSS class if not already assigned
if(this.list.hasClass('moostick')) {
// Test for an indication of existing style assignements,
var noStyle = false;
if( this.list.getStyle('overflow') != 'hidden'
|| items[0].getStyle('display') != 'block'
|| items[0].getStyle('list-style-type') != 'none'){
// we'll assume (!) no compatible style has been applied
noStyle = true;
}
if(noStyle){                
this.list.setStyles({
'display' : 'block',
'margin'  : 0,
'overflow': 'hidden'
});
this._liHandler({
'display'        : 'block',
'list-style-type': 'none',
'padding'        : 0
});
}
else{
this._liHandler();
}
// We should now have a *more* trustworthy environment
this._schedule();
}
}
}
},
/*
Method: _setMouseEvents
Sets the mouse events to pause the ticker when the mourse
cursor enters the display area. Greatly helps with usability,
while still remaining unobstrusive. Uses MooTools' mouseenter
and mouseenter.
*/
_setMouseEvents: function(){  
this.list.addEvents({
'mouseenter': function(){
this.moostick.pauseTick();
},
'mouseleave': function(){
this.moostick.resumeTick();
}
});
},
/*
Method: _liHandler
Loops through the list's li elements to set the styles and opacity. 
Arguments:
styles - See <http://docs.mootools.net/Native/Element.js#Element.setStyles>
*/
_liHandler: function(styles){
// Verify styles value and format
if((!styles) || (typeof(styles) != 'object')) styles = false;
// no need to even loop if no styles were sent and trusting opacity
if((this.trustOpacity !== true) || (styles !== false)){
$ES('li', this.list).each(function(li){
// Apply styles before forcing opacity
if(styles !== false) li.setStyles(styles);
// Turn off all li but first
if(this.trustOpacity !== true)
li.setOpacity(0);
});
}
},
/*
Method: _schedule
Prepares for and schedules <Moostick._run>.
Also sets up <Moostick._setMouseEvents>. 
*/
_schedule: function(){
if(!this._elSched){
// Define if we should fade the first item in or not.
var firstItem = $E('li', this.list);
if(firstItem.getStyle('opacity') != 1)
this._fadeIn(firstItem);
else if(this._firstRun === true)
this._fadeIn(firstItem);
// Schedule <Moostick._run>
this._elSched = this._run.periodical(
this.interval,
this,
this.list
);
// Set <Moostick._setMouseEvents>
listEvents = this.list.$events;
if(!listEvents)
this._setMouseEvents();
else if((!listEvents.mouseenter) && (!listEvents.mouseleave))
this._setMouseEvents();
}
},
/*
Method: _run
Moostick transition: move first to last, fade new first in
then set opacity on new last to 0.
*/
_run: function(){
var items = $ES('li', this.list);
// If we have at least 2
if(items[1]){
// Move first to last
items[0].injectAfter(items.getLast());
// Fade new first in
this._fadeIn(items[1]);
// Set new last off, for future fade in
$ES('li', this.list).getLast().setOpacity(0);
}
},
/*
Method: _fadeIn
Handles the MooTools opacity effect, from 0 to 1
Arguments:
item - li element to apply the effect to. 
*/
_fadeIn: function(item){
this._fx = item.effect('opacity', this.fxOptions).start(0,1);
this._firstRun = false;
}
}); // end Moostick

}