/************************************************************
* Ultimate RollOver v3.4
* Auteur : Xavier CANY & Robin CASTANIER
* Started on 6/nov/1998 - Last Update on 10/mar/2000
* 9 Mars 2000 - Ajout de la gestion Layer et Series
* 10 Mars 2000 - Ajout des RollOver a images communes 
*
* function ro_Change( bImgId, vMode )
* function ro_Load( bImgId, vNbState, bRollSerie, bLayerName )
* function ro_LoadDifferentName( bImgId, bImgImgFileName, vNbState, bRollSerie, bLayerName )
* function ro_ResetSerie( bRollSerie )
* function ro_Reset()
* function ro_Lock( bImgId, vState )
*
*
**************************************************************/

MAX_ROLLS = 20;          // Nombre max de rolls dans la page
MAX_STATES_IN_IMAGE= 4;  // Nombre d'etats par defaut par Roll si pas de ro_Load.
NONE = "";

// Tableau des RollOvers
var vRollsCount = 0;
var aRolls = new Array( MAX_ROLLS );
ROLLID = 0;      // ID du rollover
ROLLSERIE = 1;   // Nom de la serie du rollover
ROLLLAYER = 2;   // Nom du layer du rollover
ROLLOFFSET = 3;  // Offset de demmarage des images des etats du rollover

// Tableau des Series/Locks
var vSeriesCount = 0;
var aSeries = new Array( MAX_ROLLS );
LOCKSERIE = 0;   // Nom de la serie
LOCKIMG = 1;     // ID de l'image lockee de la serie
LOCKSTATE = 2;   // Valeur de reinitialisation de l'image lockee


/************************************************************
Nom : ro_Change
Fonction : Change une image dans un "roll over"
Variable : bImgId = nom de l'image
           vMode = indice de l'image
Date : 6 Novembre 1998 
       22 Janvier 1999 - probleme explorer (var i)
**************************************************************/
function ro_Change( bImgId, vMode )
{
  var i, j;


  for (i=0; i<vRollsCount; i++)
    if (aRolls[i][ROLLID] == bImgId)
    {
      // Si c 'est locke je me casse
      j = 0; while (aSeries[j][LOCKSERIE] != aRolls[i][ROLLSERIE]) j++;
       
      if (bImgId == aSeries[j][LOCKIMG]) return;

      if (aRolls[i][ROLLLAYER] != "" && document.layers)
        oSource = eval('document.layers[aRolls[i][ROLLLAYER]].document.images[bImgId]');
      else
        oSource = eval('document.images[bImgId]');

      oSource.src = aRolls[i][vMode+ROLLOFFSET].src;
      return;
    }
  ro_Load( bImgId, MAX_STATES_IN_IMAGE, NONE, NONE );
  document.images[bImgId].src = aRolls[vRollsCount-1][vMode+ROLLOFFSET].src;
}


/************************************************************
Nom : ro_Load
Fonction : Precharge les images d'un "roll over"
NB: A appeler APRES la declaration des images.
Variable : bImgId = nom de l'image
           vNbState = nombre d'etats du Roll
           bRollSerie = nom de la serie de Rolls, permet les ro_Lock multiples
           bLayerName = nom du layer, laisser vide si aucun
Date : 10 Novembre 1999
**************************************************************/
function ro_Load( bImgId, vNbState, bRollSerie, bLayerName )
{
  ro_LoadDifferentName( bImgId, bImgId, vNbState, bRollSerie, bLayerName );
}

/************************************************************
Nom : ro_LoadDifferentName
Fonction : Precharge les images d'un "roll over"
NB: A appeler APRES la declaration des images.
Variable : bImgId = nom de l'image
           vNbState = nombre d'etats du Roll
           bRollSerie = nom de la serie de Rolls, permet les ro_Lock multiples
           bLayerName = nom du layer, laisser vide si aucun
Date : 10 Mars 2000
**************************************************************/
function ro_LoadDifferentName( bImgId, bImgFileName, vNbState, bRollSerie, bLayerName )
{
  var i;
  var bFound = false;

  

  if (bRollSerie == "") bRollSerie = 'DEFAULT';

  // Cherche et cre une nouvelle serie
  for (i = 0; i < vSeriesCount; i++)
    if (aSeries[i][LOCKSERIE] == bRollSerie) { bFound = true; break; }

  if (!bFound)
  {
    aSeries[i] = new Array(3);
    aSeries[i][LOCKSERIE] = bRollSerie;
    aSeries[i][LOCKIMG] = NONE;
    aSeries[i][LOCKSTATE] = -1;
    vSeriesCount++;
  }

  if (bLayerName != "" && document.layers)
   {
	
    oSource = eval( 'document.layers[bLayerName].document.images[bImgId]' );
	
   }
  else
    oSource = eval( 'document.images[bImgId]' );

  aRolls[vRollsCount] = new Array(vNbState-1 + ROLLOFFSET);
  aRolls[vRollsCount][ROLLID] = bImgId;
  aRolls[vRollsCount][ROLLSERIE] = bRollSerie;
  aRolls[vRollsCount][ROLLLAYER] = bLayerName;
 
  for (i = 0; i < vNbState; i++)
  {


    aRolls[vRollsCount][i+ROLLOFFSET] = new Image;
    aRolls[vRollsCount][i+ROLLOFFSET].src =
      oSource.src.substring( 0, oSource.src.lastIndexOf("/") )
      + "/" + bImgFileName + "_" + i + ".gif";
	
	
  }

  if (++vRollsCount >= MAX_ROLLS) alert( "OverFlow! Augmenter MAX_ROLLS" );
}

/************************************************************
Nom : ro_ResetSerie
Variable :
           bRollSerie = nom de la serie de Rolls, permet les ro_Lock multiples
Fonction : Reset un roll-over dans son etat initial
Date : 9 Mars 2000
**************************************************************/
function ro_ResetSerie( bRollSerie )
{
  var i;
  
  for (i=0; i<vSeriesCount; i++)
   if (aSeries[i][LOCKSERIE] == bRollSerie)
   {
     if (aSeries[i][LOCKIMG] != NONE)
     {
       bTemp = aSeries[i][LOCKIMG];
       aSeries[i][LOCKIMG] = NONE;
       ro_Change( bTemp, aSeries[i][LOCKSTATE] );
     }
     return;
   }
  
  alert( "Mauvais nom de Serie: " + bRollSerie );  
}

/************************************************************
Nom : ro_Reset
Fonction : Reset un roll-over dans son etat initial
Date : 2 Decembre 1998
**************************************************************/
function ro_Reset()
{
  var i;
  
  for (i=0; i<vSeriesCount; i++)
   ro_ResetSerie( aSeries[i][LOCKSERIE] );
}

/************************************************************
Nom : ro_Lock
Fonction : Bloque une image dans un "roll over"
Variable : bImgId = nom de l'image
           vNb = indice de l'image pour l'unlock
Date : 10 Novembre 1998
**************************************************************/
function ro_Lock( bImgId, vState )
{
 var i;
 
 // Quelle est la serie associee
 for (i=0; i<vRollsCount; i++)
  if (aRolls[i][ROLLID] == bImgId)
  {
    mySerie = aRolls[i][ROLLSERIE];
    break;  
  }
  
 // si c'est pas NONE ni moi qui suis locke, je reset la serie
 i = 0;
 while (aSeries[i][LOCKSERIE] != mySerie) i++;

 if (aSeries[i][LOCKIMG] != NONE && aSeries[i][LOCKIMG] != bImgId)
   ro_ResetSerie( mySerie );

 // Je me locke
 aSeries[i][LOCKIMG] = bImgId;
 aSeries[i][LOCKSTATE] = vState;
 
}