/* <gslb_version version="V1.0.4" /> */
/* Copyright © GalaSoft Laurent Bugnion 2007 */

//*****************************************************************************
//* gslb.fadednode.js
//*****************************************************************************
//* Control name            : FadedNode
//* Tested Targets          : Firefox 2, Internet Explorer 7
//* Language/Compiler       : ECMAScript V3
//* Author                  : Laurent Bugnion (LBu)
//* Created                 : 05.01.2007
//*****************************************************************************
//* Description: see constructor
//* Last Base Level: BL0003
//*****************************************************************************

//*****************************************************************************
//* Imports *******************************************************************
//*****************************************************************************

//*****************************************************************************
//* Constructor ***************************************************************
//*****************************************************************************

// Create namespace
if ( !window.gslb )
{
  window.gslb = {};
}

// ----------------------------------------------------------------------------
/// <summary>
/// Allows transitioning smoothly from one opacity level to an other for
/// DOM nodes. Supports CSS filter (IE) and CSS opacity (Mozilla, Firefox).
/// </summary>
/// <param name="nNode" type="Node">The DOM node to which the transitions
/// will be applied</param>
/// <param name="oOptions" type="Object">An Options object, constructed using literal notation.
/// All values are optional.
/// <br />iMinimum: The minimum level of opacity applied to the Node. Default: 0%.
/// <br />iMaximum: The maximum level of opacity applied to the Node. Default: 100%.
/// <br />iDeltaFade: The amount added or removed to the opacity on each iteration
/// during transitions (fading/unfading). Default: 1%.
/// <br />iTimerMilliseconds: The duration of one iteration (in milliseconds)
/// during transition (fading/unfading). Default: 10 milliseconds.
/// <br />bRemoveAfterFade: If true, when the node reaches the minimum level of
/// opacity, it will be removed (ie display : none), so that underlying controls
/// can be actioned. This is mostly useful when the minimum level is 0. To enable
/// this functionality, the Node must have CSS display set in its style. Default: true.
gslb.FadedNode = function( nNode, oOptions )
{
  if ( !nNode
    || !nNode.style == null
    || ( !nNode.style.filter == null
      && !nNode.style.opacity == null ) )
  {
    throw "Impossible to create faded node, please check the documentation";
  }

  //***************************************************************************
  //* Attributes **************************************************************
  //***************************************************************************

  this.m_nNode = nNode;
  
  this.m_bFading = false;
  this.m_bUnfading = false;
  this.m_iStart = gslb.FadedNode.getOpacity( nNode );
  this.m_iFadeFactor = this.m_iStart;

  // Options
  
  this.m_iMinimumFadeFactor = 0;
  this.m_iMaximumFadeFactor = 100;
  this.m_iDeltaFade = 1;
  this.m_iTimer = 10;
  this.m_bRemoveAfterFade = false;
  
  this.setOptions( oOptions );
}

//*****************************************************************************
//* Enums *********************************************************************
//*****************************************************************************

//*****************************************************************************
//* Constants *****************************************************************
//*****************************************************************************

/// <summary type="string">
/// This class's name.
/// </summary>
gslb.FadedNode._NAME = "gslb.FadedNode";
/// <summary type="string">
/// This class's version.
/// </summary>
gslb.FadedNode._VERSION = "V1.0.4";
/// <summary type="string">
/// This class's date.
/// </summary>
gslb.FadedNode._DATE = "17.11.2007";

//*****************************************************************************
//* Static attributes *********************************************************
//*****************************************************************************

//*****************************************************************************
//* Static methods ************************************************************
//*****************************************************************************

// Utilities ------------------------------------------------------------------

// ----------------------------------------------------------------------------
/// <summary>
/// Utility method, gets the opacity level from a given DOM Node.
/// </summary>
/// <param name="nNode" type="Node">A DOM node with either opacity (Mozilla,
/// Firefox) or filter (IE) set.</param>
/// <return type="int">The current level of opacity set in CSS in %.</return>
gslb.FadedNode.getOpacity = function( nNode )
{
  if ( !nNode
    || !nNode.style
    || ( !nNode.style.filter
      && !nNode.style.opacity ) )
  {
    return 100;
  }
  
  if ( nNode.style.filter )
  {
    return parseInt( nNode.style.filter.substring( nNode.style.filter.indexOf( "=" ) + 1 ), 10 );
  }
  
  if ( nNode.style.opacity )
  {
    return parseFloat( nNode.style.opacity ) * 100;
  }
}

// ----------------------------------------------------------------------------
/// <summary>
/// Utility method, sets the opacity level to a given DOM Node.
/// </summary>
/// <param name="nNode" type="Node">A DOM node with either opacity (Mozilla,
/// Firefox) or filter (IE) set.</param>
/// <param name="iOpacityPercents">The new level of opacity in %.</param>
gslb.FadedNode.setOpacity = function ( nNode, iOpacityPercents )
{
  if ( iOpacityPercents < 0 )
  {
    iOpacityPercents = 0;
  }
  if ( iOpacityPercents > 100 )
  {
    iOpacityPercents = 100;
  }
  
  if ( nNode.style.filter != null )
  {
    nNode.style.filter = "alpha(opacity=" + iOpacityPercents + ");";
  }
  if ( nNode.style.opacity != null )
  {
    nNode.style.opacity = iOpacityPercents / 100;
  }
}

//*****************************************************************************
//* Methods *******************************************************************
//*****************************************************************************

// Status ---------------------------------------------------------------------

// ----------------------------------------------------------------------------
/// <summary>
/// Returns true if the Node reached the minimum level of opacity
/// </summary>
gslb.FadedNode.prototype.isFaded = function()
{
  return ( this.m_iFadeFactor == this.m_iMinimumFadeFactor );
}

// ----------------------------------------------------------------------------
/// <summary>
/// Returns true if the Node reached the maximum level of opacity
/// </summary>
gslb.FadedNode.prototype.isUnfaded = function()
{
  return ( this.m_iFadeFactor == this.m_iMaximumFadeFactor );
}

// Fading ---------------------------------------------------------------------

// ----------------------------------------------------------------------------
/// <summary>
/// Starts a transition from the maximum level of opacity to the minimum level.
/// Note: If the Node already reached the minimum level of opacity, or if a
/// transition is currently running, this method is not active.
/// </summary>
/// <param name="fnOnTransitionEnd" type="Function">A function to be executed
/// when the transition is finished. Can also be null.</param>
gslb.FadedNode.prototype.fade = function( fnOnTransitionEnd )
{ 
  if ( this.m_bFading
    || this.m_bUnfading
    || this.m_iFadeFactor == this.m_iMinimumFadeFactor )
  {
    if ( fnOnTransitionEnd )
    {
      fnOnTransitionEnd();
    }
    return;
  }
  this.m_fnOnTransitionEnd = fnOnTransitionEnd;
  this.fading();
}

// ----------------------------------------------------------------------------
/// <summary>
/// Internal method only.
/// </summary>
gslb.FadedNode.prototype.fading = function()
{ 
  if ( this.m_iFadeFactor > this.m_iMinimumFadeFactor )
  {
    this.m_bFading = true;
    this.m_iFadeFactor -= this.m_iDeltaFade;
  }
  else
  {
    this.m_bFading = false;
    if ( this.m_bRemoveAfterFade
      && this.m_nNode.style.display )
    {
      // Avoid that the underneath controls are blocked by the invisible layer.
      this.m_nNode.style.display = "none";
    }
  }
  
  gslb.FadedNode.setOpacity( this.m_nNode, this.m_iFadeFactor );

  if ( this.m_bFading )
  {
    var that = this;
    setTimeout( function () { that.fading(); }, this.m_iTimer );
  }
  else
  {
    if ( this.m_fnOnTransitionEnd )
    {
      this.m_fnOnTransitionEnd();
      this.m_fnOnTransitionEnd = null;
    }
  }
}

// ----------------------------------------------------------------------------
/// <summary>
/// Starts a transition from the minimum level of opacity to the maximum level.
/// Note: If the Node already reached the maximum level of opacity, or if a
/// transition is currently running, this method is not active.
/// </summary>
/// <param name="fnOnTransitionEnd" type="Function">A function to be executed
/// when the transition is finished. Can also be null.</param>
gslb.FadedNode.prototype.unfade = function( fnOnTransitionEnd )
{ 
  if ( this.m_bUnfading
    || this.m_bFading
    || this.m_iFadeFactor == this.m_iMaximumFadeFactor )
  {
    if ( fnOnTransitionEnd )
    {
      fnOnTransitionEnd();
    }
    return;
  }
  if ( this.m_nNode.style.display )
  {
    this.m_nNode.style.display = "block"
  }
  this.m_fnOnTransitionEnd = fnOnTransitionEnd;
  this.unfading();
}

// ----------------------------------------------------------------------------
/// <summary>
/// Internal method only.
/// </summary>
gslb.FadedNode.prototype.unfading = function()
{ 
  if ( this.m_iFadeFactor < this.m_iMaximumFadeFactor )
  {
    this.m_bUnfading = true;
    this.m_iFadeFactor += this.m_iDeltaFade;
  }
  else
  {
    this.m_bUnfading = false;
  }
  
  gslb.FadedNode.setOpacity( this.m_nNode, this.m_iFadeFactor );
  
  if ( this.m_bUnfading )
  {
    var that = this;
    setTimeout( function () { that.unfading(); }, this.m_iTimer );
  }
  else
  {
    if ( this.m_fnOnTransitionEnd )
    {
      this.m_fnOnTransitionEnd();
      this.m_fnOnTransitionEnd = null;
    }
  }
}

// ----------------------------------------------------------------------------
/// <summary>
/// Sets the new level of opacity for this faded node. The level is applied with a transition.
/// Note: It is possible to set the new opacity outside of the range defined by the options for this node.
/// </summary>
/// <param name="iOpacityPercents" type="int">The new level of opacity in %.</param>
/// <param name="fnOnTransitionEnd" type="Function">A function to be executed
/// when the transition is finished. Can also be null.</param>
gslb.FadedNode.prototype.setOpacity = function( iOpacityPercents, fnOnTransitionEnd )
{
  if ( iOpacityPercents > this.m_iFadeFactor )
  {
    // Unfading required
    var iCurrentMaximum = this.m_iMaximumFadeFactor;
    var bCurrentRemoveAfterFade = this.m_bRemoveAfterFade;
    this.m_iMaximumFadeFactor = iOpacityPercents;
    this.m_bRemoveAfterFade = false;
    // Use closure to reset the maximum and minimum
    var that = this;
    this.unfade( function()
      {
        that.resetOptions( this.m_iMinimumFadeFactor,
          iCurrentMaximum,
          bCurrentRemoveAfterFade );

        if ( fnOnTransitionEnd )
        {
          fnOnTransitionEnd();
        }
      } );
  }

  if ( iOpacityPercents < this.m_iFadeFactor )
  {
    // Fading required
    var iCurrentMinimum = this.m_iMinimumFadeFactor;
    var bCurrentRemoveAfterFade = this.m_bRemoveAfterFade;
    this.m_iMinimumFadeFactor = iOpacityPercents;
    this.m_bRemoveAfterFade = false;
    // Use closure to reset the maximum and minimum
    var that = this;
    this.fade( function()
      {
        that.resetOptions( iCurrentMinimum,
          that.m_iMaximumFadeFactor,
          bCurrentRemoveAfterFade );

        if ( fnOnTransitionEnd )
        {
          fnOnTransitionEnd();
        }
      } );
  }
}

// ----------------------------------------------------------------------------
/// <summary>
/// Internal method only.
/// </summary>
gslb.FadedNode.prototype.resetOptions = function( iMinimum, iMaximum, bRemoveAfterFade )
{
  this.m_iMinimumFadeFactor = iMinimum;
  this.m_iMaximumFadeFactor = iMaximum;
  this.m_bRemoveAfterFade = bRemoveAfterFade;
}

// Setter/Getter for options --------------------------------------------------

// ----------------------------------------------------------------------------
/// <summary>
/// Sets the options for this instance.
/// </summary>
/// <param name="oOptions">An Options object, constructed using literal notation.
/// All values are optional.
/// <br />iMinimum: The minimum level of opacity applied to the Node. Default: 0%.
/// <br />iMaximum: The maximum level of opacity applied to the Node. Default: 100%.
/// <br />iDeltaFade: The amount added or removed to the opacity on each iteration
/// during transitions (fading/unfading). Default: 1%.
/// <br />iTimerMilliseconds: The duration of one iteration (in milliseconds)
/// during transition (fading/unfading). Default: 10 milliseconds.
/// <br />bRemoveAfterFade: If true, when the node reaches the minimum level of
/// opacity, it will be removed (ie display : none), so that underlying controls
/// can be actioned. This is mostly useful when the minimum level is 0. To enable
/// this functionality, the Node must have CSS display set in its style. Default: true.
gslb.FadedNode.prototype.setOptions = function( oOptions )
{
  if ( oOptions )
  {
    if ( oOptions.iMinimum != null )
    {
      this.m_iMinimumFadeFactor = oOptions.iMinimum;
    }

    if ( oOptions.iMaximum != null )
    {
      this.m_iMaximumFadeFactor = oOptions.iMaximum;
    }

    if ( oOptions.iDeltaFade != null )
    {
      this.m_iDeltaFade = oOptions.iDeltaFade;
    }
    
    if ( oOptions.iTimerMilliseconds != null )
    {
      this.m_iTimer = oOptions.iTimerMilliseconds;
    }
    
    if ( oOptions.bRemoveAfterFade != null )
    {
      this.m_bRemoveAfterFade = oOptions.bRemoveAfterFade;
    }
  }
}