// |¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// |  ## WINDOWS AJAX ##
// |  FICHIER	->	fonctions.js
// |  AUTEUR	->	Grevet Nicolas
// |  DATE		->	Avril 2006
// |  WHAT?		->	Moteur d'affichage et de gestion pour les fenêtres et menus
// |  				Reproduit une partie de l'API Windows (très succintement)
// |				Ce fichier contient toutes les fonctions utiles au fonctionnement du bureau
// |________________________________________

var debugwin				= document.getElementById('debug');
var loading					= document.getElementById('loading');
var loading_what			= document.getElementById('loading_what');
var loading_bar				= document.getElementById('loading_bar');

// ----------------------------------------
// Définition de toutes les références utiles au fonctionnement
// Bien souvent de simples raccourcis bien pratiques
// ----------------------------------------

debug('<b style="color: #ff0;">LOADING STARTED</b>');
load('Références', 0);

var desktop					= document;
var taskbar					= document.getElementById('taskbar');
var taskbar_resize			= document.getElementById('taskbar_resize');
var startbutton				= document.getElementById('startbutton');
var startmenu				= document.getElementById('startmenu');
var startmenulist			= document.getElementById('startmenulist');
var quicklaunch				= document.getElementById('quicklaunch');
var systray					= document.getElementById('systray');
var hourdate				= document.getElementById('hourdate');
var program_contextmenu		= document.getElementById('program_contextmenu');
var wallpaper				= document.getElementById('wallpaper');
var megacontainer			= document.getElementById('megacontainer');

var startmenu_li			= startmenulist.getElementsByTagName('li');
var startmenu_ul			= startmenulist.getElementsByTagName('ul');
var startmenu_link			= startmenulist.getElementsByTagName('a')[0];
var body_					= document.getElementsByTagName('body')[0];

var separators				= document.getElementsByName('sep');
var resize_controls			= document.getElementsByName('resize');
var titlebars				= document.getElementsByName('titlebar');
var contents				= document.getElementsByName('content');
var menubars				= document.getElementsByName('menubar');

// ----------------------------------------
// Définition de toutes les variables nécessaires au fonctionnement
// Booléennes, références, numéraires.. des variables quoi..
// ----------------------------------------

var resizing_vertical		= false;
var resizing_horizontal		= false;
var resizing_taskbar		= false;
var desktopHasThePriority	= false;

var resizing_target			= null;
var moving_target			= null;
var moving_titlebar			= null;
var active_window			= null;
var pushed_program			= null;
var program_active_target	= null;

var mouseX					= 0;
var mouseY					= 0;
var i						= 0;
var j						= 0;
var maxLoopControl			= 25;
var max_submenus			= 0;
var debug_nb				= 0;
var current_zIndex			= 10;
var taskbarSize				= 2;
var opacitymax				= 0.6;

var defaultTaskbarHeight	= parseInt(document.defaultView.getComputedStyle(taskbar, null).getPropertyValue("height"));
var loading_img				= '<img src="index/images/layer/load.gif" class="icon" alt="[wait]" />';
var loading_string			= loading_img+' Chargement...';

var defaultPosX				= 20;
var defaultPosY				= 20;
var defaultID				= 1;

// ----------------------------------------
// Définition des évènements basiques du bureau
// Le clic sur le menu démarrer, sur le bureau, etc...
// ----------------------------------------

startbutton.onclick			= startbutton_onclick;
taskbar_resize.onmousedown	= taskbar_resize_onmousedown;
desktop.onmouseup			= desktop_onmouseup;
desktop.onmousemove			= saveMouseCoords;
megacontainer.oncontextmenu	= desktop_oncontextmenu;

// ----------------------------------------
// PUSH_***BUTTON : Change l'image du bouton *** d'une fenêtre lorsque l'on clique dessus
// Doit être appelé uniquement lors d'un évènement sur le bouton en lui même
// ----------------------------------------

load('Fonctions', 0.1);

function push_closebutton()
{
	if (this)
		this.className = 'close_pushed';
}
function push_maximizebutton()
{
	if (this)
		this.className = 'maximize_pushed';
}
function push_restorebutton()
{
	if (this)
		this.className = 'restore_pushed';
}
function push_reducebutton()
{
	if (this)
		this.className = 'reduce_pushed';
}
function push_startbutton()
{
	startbutton.style.backgroundImage = 'url(index/images/layer/start_pushed.png)';
}

// ----------------------------------------
// UNPUSH_***BUTTON : Change l'image du bouton *** d'une fenêtre lorsque l'on le relache
// Doit être appelé uniquement lors d'un évènement sur le bouton en lui même
// ----------------------------------------

function unpush_closebutton()
{
	if (this)
		this.className = 'close';
}
function unpush_maximizebutton()
{
	if (this)
		this.className = 'maximize';
}
function unpush_restorebutton()
{
	if (this)
		this.className = 'restore';
}
function unpush_reducebutton()
{
	if (this)
		this.className = 'reduce';
}
function unpush_startbutton()
{
	startbutton.style.backgroundImage = 'url(index/images/layer/start.png)';
}

// ----------------------------------------
// DEBUG : Fonction de débugage (permet un affichage rapide de diverses valeurs)
// Sous-entend l'existence d'un bloc dans l'objet debugwin...
// ----------------------------------------

function debug(text)
{
	debugwin.innerHTML = text+'<br />'+debugwin.innerHTML.substr(0, 2000);
}

// ----------------------------------------
// SAVEMOUSECOORDS : Permet la sauvegarde à tout moment de la position de la souris
// Doit uniquement être appelé lors d'un évènement de la souris
// ----------------------------------------

function saveMouseCoords(ev)
{
	if (!ev)
		ev = window.event;
	
	if ((ev.pageX) || (ev.pageY))
	{
		mouseX = ev.pageX;
		mouseY = ev.pageY;
	}
	else if ((ev.clientX) || (ev.clientY))
	{
		mouseX = ev.clientX+document.body.scrollLeft;
		mouseY = ev.clientY+document.body.scrollTop;
	}
}

// ----------------------------------------
// TASKBAR_RESIZE_ONMOUSEDOWN : Déclenche le redimensionnement de la barre des tâches
// en cliquant sur son bord supérieur (ne doit être appelé que depuis un évènement sur un l'élement taskbar_resize)
// ----------------------------------------

function taskbar_resize_onmousedown()
{
	resizing_taskbar = true;
	taskb_resize();
}

// ----------------------------------------
// RESIZE_ONMOUSEDOWN : Déclenche le redimensionnement d'une fenêtre en cliquant sur son coin inférieur droit
// Ne doit être appelé que depuis un évènement sur un élement d'une fenêtre
// ----------------------------------------

function resize_onmousedown()
{
	resizing_vertical	= true;
	resizing_horizontal	= true;
	resizing_target		= findWindowHandler(this);
	var decalX			= resizing_target.offsetLeft+resizing_target.offsetWidth-mouseX;
	var decalY			= resizing_target.offsetTop+resizing_target.offsetHeight-mouseY;
	
	debug('<b>RESIZE:</b> window('+resizing_target.id+') Xshift='+decalX+', Yshift='+decalY);
	win_resize(decalX, decalY);
}

// ----------------------------------------
// FINDWINDOWHANDLER : Retrouve le bloc containeur d'une fenêtre à partir d'un élement situé à l'intérieur
// Une référence à un élément de la fenêtre doit être passé à la fonction
// ----------------------------------------

function findWindowHandler(obj)
{
	var loopControl = maxLoopControl;
	while ((obj.className != 'window') && (loopControl > 0))
	{
		obj = obj.parentNode;
		loopControl--;
	}
	return obj;
}

// ----------------------------------------
// TITLEBAR_ONMOUSEDOWN : Déclenche le déplacement d'une fenêtre en cliquant sur sa barre de titre
// Ne doit être appelé que depuis un évènement sur un élement d'une fenêtre
// ----------------------------------------

function titlebar_onmousedown()
{	
	moving_target	= findWindowHandler(this);
	var decalX		= mouseX-moving_target.offsetLeft;
	var decalY		= mouseY-moving_target.offsetTop;
	
	debug('<b>MOVE:</b> window('+moving_target.id+') Xshift='+decalX+', Yshift='+decalY);
	win_move(decalX, decalY);
}

// ----------------------------------------
// WIN_MOVE : Déplace une fenêtre en fonction des coordonnées de la souris
// La fonction se rappelle elle-même jusqu'à ce que plus aucun élément ne soit situé dans moving_target
// ----------------------------------------

function win_move(decalX, decalY)
{
	if (moving_target)
	{	
		moving_target.style.top = (mouseY-decalY)+'px';
		moving_target.style.left = (mouseX-decalX)+'px';		
		setTimeout("win_move("+decalX+", "+decalY+")", 25);
	}
}

// ----------------------------------------
// WIN_RESIZE : Redimensionne une fenêtre en fonction de la position de la souris
// La fonction se rappelle elle-même jusqu'à ce que plus aucun élément ne soit situé dans resizing_target
// ----------------------------------------

function win_resize(decalX, decalY)
{
	if (resizing_target)
	{
		if (resizing_vertical)
			resizing_target.style.height = (mouseY-(resizing_target.offsetTop)+decalY)+'px';
		if (resizing_horizontal)
			resizing_target.style.width = (mouseX-(resizing_target.offsetLeft)+decalX)+'px';
		
		setTimeout("win_resize("+decalX+", "+decalY+")", 50);
	}
}

// ----------------------------------------
// TASKBAR_RESIZE : Redimensionne la barre des tâches en fonction de la position de la souris
// La fonction se rappelle elle-même jusqu'à ce que plus aucun élément ne soit situé dans taskbar_resize
// ----------------------------------------

function taskb_resize()
{
	if (resizing_taskbar)
	{
		var temp_height = window.innerHeight-mouseY;
		var taskb_height = taskbarSize;
		
		if ((temp_height >= defaultTaskbarHeight) && ((temp_height == defaultTaskbarHeight) || (((temp_height-defaultTaskbarHeight)%25) < 10)))
			taskbarSize = parseInt((temp_height-defaultTaskbarHeight)/25)+1;
		
		if (taskb_height != taskbarSize)
			resizeTaskbar();
		
		setTimeout("taskb_resize()", 100);
	}
}
function taskbar_resize_stop()
{
	resizing_taskbar = false;
}

// ----------------------------------------
// WIN_MOVE_STOP : Arrête le déplacement d'un fenêtre en supprimant la référence dans moving_target
// Sauvegarde également les nouvelles coordonnées de la fenêtre pour l'agrandissement et la restauration
// ----------------------------------------

function win_move_stop()
{
	if (moving_target)
	{
		debug('<b>MOVE:</b> Stop');
		windows[moving_target.id]['restoreTop'] = parseInt(moving_target.style.top);
		windows[moving_target.id]['restoreLeft'] = parseInt(moving_target.style.left);
		moving_target = null;
	}
}

// ----------------------------------------
// WIN_RESIZE_STOP : Arrête le redimensionnement d'une fenêtre en supprimant la référence dans resizing_target
// Sauvegarde également la nouvelle taille de la fenêtre pour l'agrandissement et la restauration
// ----------------------------------------

function win_resize_stop()
{
	if (resizing_target)
	{
		debug('<b>RESIZE:</b> Stop');
		windows[resizing_target.id]['restoreWidth'] = parseInt(resizing_target.style.width);
		windows[resizing_target.id]['restoreHeight'] = parseInt(resizing_target.style.height);
		resizing_target		= null;
		resizing_vertical	= false;
		resizing_horizontal	= false;
	}
}

// ----------------------------------------
// ***_LI_ONMOUSEOVER : Appele la fonction hide*** pour fermer les sous-menus
// Cette fonction ne peut être appelée qu'après un évènement sur un élement LI d'un menu ***
// ----------------------------------------

function startmenu_li_onmouseover()
{
	hideStartMenus(this.className);
}
function menubar_li_onmouseover()
{
	hideMenubars(this.className);
}

// ----------------------------------------
// ***_EXPANDLI_ONMOUSEOVER : Fonction d'affichage d'un sous-menu lorsque la souris passe sur un élement dépliable
// Cette fonction ne peut être appelée qu'après un évènement sur un élement LI d'un menu ***
// ----------------------------------------

function startmenu_expandli_onmouseover()
{
	hideStartMenus(this.parentNode.className);
	var ul_name = this.name;
	show(ul_name);
}
function menubar_expandli_onclick()
{
	if (!desktopHasThePriority)
	{
		hideMenubars(this.parentNode.className);
		var ul_name = this.name;
		show(ul_name);
		giveThePriorityToTheDesktop();
	}
}
function menubar_expandli_onmouseover()
{
	hideMenubars(this.parentNode.className);
	var ul_name = this.name;
	show(ul_name);
}

// ----------------------------------------
// STARTBUTTON_ONCLICK : Fonction appelée lorsque l'utilisateur clique sur le bouton "Démarrer"
// La fonction appelle le menu démarrer et donne le onclick au bureau pour refermer le menu
// ----------------------------------------

function startbutton_onclick()
{
	push_startbutton();
	if (!desktopHasThePriority)
	{
		show('startmenu');
		giveThePriorityToTheDesktop();
	}
}

// ----------------------------------------
// GIVETHEPRIORITYTOTHEDESKTOP : Cette fonction donne la priorité au bureau sur le onclick
// Cela permet de refermer les menus ouverts (menu démarrer et barres de menu)
// ----------------------------------------

function giveThePriorityToTheDesktop()
{
	desktopHasThePriority = true;
	setTimeout("desktop.onclick = desktop_onclick", 10);
}

// ----------------------------------------
// DESKTOP_ONCLICK : Fonction appelée lors d'un clic de l'utilisateur sur le bureau
// La fonction repousse tous les boutons, cache le menu démarrer, et ses sousmenus (ainsi que les barres de menu)
// ----------------------------------------

/*
function desktop_onmousedown()
{
	for (win_ in windows)
	{
		if ((windows[win_]['iframe']) && (!windows[win_]['closed']))
		{
			var iframe = windows[win_]['iframe'];
			var target = findWindowHandler(iframe);
			var targetX = windows[win_]['left'];
			var targetY = windows[win_]['top'];
			var targetW = windows[win_]['width'];
			var targetH = windows[win_]['height'];
			if ((mouseX > targetX) && (mouseX < targetX+targetW) && (mouseY > targetY) && (mouseY < targetY+targetH))
				debug('<b>FOCUS:</b> window('+target.id+') X='+targetX+' Y='+targetY+' W='+targetW+' H='+targetH);
		}
	}
}
*/
function desktop_onclick()
{
	desktop.onclick = null;
	unpush_startbutton();
	hide('startmenu');
	
	hideStartMenus(0);
	hideMenubars(0);
	
	desktopHasThePriority = false;
}

// ----------------------------------------
// DESKTOP_ONMOUSEUP : Lors des drag 'n drop, cette fonction permet de stopper les déplacements
// Par exemple lors des redimensionnements et des changements de position d'une fenêtre
// ----------------------------------------

function desktop_onmouseup()
{
	win_resize_stop();
	win_move_stop();
	taskbar_resize_stop();
	closeContextMenus();
}

function desktop_oncontextmenu()
{
	debug('<i>desktop_oncontextmenu()</i> ?');
	return false;
}

// ----------------------------------------
// SHOWHIDE : Cache une fenêtre si elle est visible ou affiche une fenêtre si elle est cachée
// On peut passer un ID ou une référence sur un objet à la fonction
// ----------------------------------------

function showhide(target)
{
	if (document.getElementById(target))
		target = document.getElementById(target);
	else if ((!target.className) || (target.className != 'window'))
		return;
	
	if (target.style.display == 'none')
		show(target);
	else
		hide(target);
}

// ----------------------------------------
// SHOW : Affiche une fenêtre préalablement masquée
// On peut passer un ID ou une référence sur un objet à la fonction
// ----------------------------------------

function show(target)
{
	if (document.getElementById(target))
		target = document.getElementById(target);
	else if ((!target.className) || (target.className != 'window'))
		return;
	
	target.style.display = 'block';
}

// ----------------------------------------
// SHOW : Cache une fenêtre visible
// On peut passer un ID ou une référence sur un objet à la fonction
// ----------------------------------------

function hide(target)
{
	if (document.getElementById(target))
		target = document.getElementById(target);
	else if ((!target.className) || (target.className != 'window'))
		return;
	
	target.style.display = 'none';
}

// ----------------------------------------
// HIDESTARTMENUS : Ferme les sous-menus ouverts lors du passage sur un nouvel élément du menu démarrer
// Attention, la fonction est assez gourmande en ressources
// ----------------------------------------

function hideStartMenus(id)
{
	i = 0;
	var objets = startmenu.getElementsByTagName('ul');
	while (i < objets.length)
	{
		if (objets[i].name)
		{
			var objname = objets[i].name;
			var menulevel = objname.split('_')[1];
			if (menulevel >= id)
				objets[i].style.display = 'none';
		}
		i++;
	}
}

// ----------------------------------------
// HIDEMENUBARS : Ferme les sous-menus ouverts lors du passage sur un nouvel élément d'une barre de menu
// Attention, la fonction est assez gourmande en ressources
// ----------------------------------------

function hideMenubars(id)
{
	i = 0;
	while (i < menubars.length)
	{
		j = 0;
		var uls = menubars[i].getElementsByTagName('ul');
		while (j < uls.length)
		{
			if (uls[j].name)
			{
				var objname		= uls[j].name;
				var menulevel	= objname.split('_')[1];
				
				if (menulevel >= id)
					uls[j].style.display = 'none';
			}
			j++;
		}
		i++;
	}
}

// ----------------------------------------
// REFRESHDATE : Rafraichi l'heure et la date situées dans la barre des tâches
// La fonction se rappelle elle-même toutes les 30 secondes
// ----------------------------------------

function refreshDate(recursive)
{
	var dateObj = new Date();
	var hour = dateObj.getHours().toString();
	var min = dateObj.getMinutes().toString();
	var dayName = getDayName(dateObj.getDay());
	var day = dateObj.getDate().toString();
	var monthName = getMonthName(dateObj.getMonth());
	var month = dateObj.getMonth().toString();
	var year = dateObj.getFullYear().toString();
	
	hourdate.innerHTML = hour.pad(2, '0', 0)+':'+min.pad(2, '0', 0);
	if (taskbarSize > 1)
		hourdate.innerHTML = hourdate.innerHTML+'<br />'+dayName;
	if (taskbarSize > 2)
		hourdate.innerHTML = hourdate.innerHTML+'<br />'+day.pad(2, '0', 0)+'/'+month.pad(2, '0', 0)+'/'+year;
		
	hourdate.title = dayName+' '+day+' '+monthName+' '+year;
	if (recursive)
		setTimeout("refreshDate(true)", 30000);
}

// ----------------------------------------
// GETDAYNAME : Retourne le nom du jour en fonction de son numéro dans la semaine
// Les indices des jours doivent aller de 0 à 6
// ----------------------------------------

function getDayName(index)
{
	var days = Array('dimanche', 'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi');
	return days[index];
}

// ----------------------------------------
// GETMONTHNAME : Retourne le nom du mois en fonction de son numéro dans l'année
// Les indices des mois doivent aller de 0 à 11
// ----------------------------------------

function getMonthName(index)
{
	var months = Array('janvier', 'mars', 'avril', 'mai', 'juin', 'juillet', 'août', 'septembre', 'octobre', 'novembre', 'décembre');
	return months[index];
}

// ----------------------------------------
// INCREMENT_CURRENT_ZINDEX : Incrémente la valeur courante du zIndex maximal des fenêtres
// Quand le zIndex arrive à 100000, il passe au dessu de celui de la barre des tâches, on le remet donc à 10
// ----------------------------------------

function increment_current_zIndex()
{
	current_zIndex++;
	if (current_zIndex > 9999)
		current_zIndex = 10;
}

// ----------------------------------------
// Jonas Raoni Soares Silva
// http://www.joninhas.ath.cx
// ----------------------------------------

String.prototype.pad = function(l, s, t)
{
	return s || (s = " "), (l -= this.length) > 0 ? (s = new Array(Math.ceil(l / s.length)
		+ 1).join(s)).substr(0, t = !t ? l : t == 1 ? 0 : Math.ceil(l / 2))
		+ this + s.substr(0, l - t) : this;
};

// ----------------------------------------
// GETNEXTDEFAULTPOS* : Retourne la prochaine position pour une fenêtre placée automatiquement
// Les fenêtres sont placées en cascade au fur et à mesure qu'elles s'ouvrent
// ----------------------------------------

function getNextDefaultPosX()
{
	defaultPosX += 20;
	if (defaultPosX > 200)
		defaultPosX = 20;
	return defaultPosX;
}
function getNextDefaultPosY()
{
	defaultPosY += 20;
	if (defaultPosY > 200)
		defaultPosY = 20;
	return defaultPosY;
}

// ----------------------------------------
// CONTROLTASKBARWIDTH : Fonction de contrôle de la largeur d'un handler de la barre des tâches
// On évite les handlers trop large qui prennent tout l'espace vital déjà réduit
// ----------------------------------------

function controlTaskbarWidth(program)
{
	if (!program.className)
		program = document.getElementById(program);
	
	if ((program) && (parseInt(program.offsetWidth) > 150))
		program.style.width = '150px';
	else if (program)
		program.style.width = 'auto';
}

// ----------------------------------------
// CMPERFORMACTION : EventHandler permettant de réaliser les actions lors d'un clic sur un menu contextuel
// Ne doit être appelé que depuis un lien d'un menu contextuel d'un programme de la barre des tâches
// ----------------------------------------

function CMPerformAction(action, from)
{
	if (program_active_target)
	{
		switch (action)
		{
			case 'close':
				win_close(program_active_target); break;
			case 'maximize':
				win_maximize(program_active_target); break;
			case 'reduce':
				win_reduce(program_active_target); break;
			case 'restore':
				win_restore(program_active_target); break;
		}
	}
	hide(from.parentNode.id);
	program_active_target = null;
}

// ----------------------------------------
// CLOSECONTEXTMENUS : Fonction permettant de fermer tous les menus contextuels ouverts
// Il faut par contre lister tous les menus contextuels existants à l'intérieur
// ----------------------------------------

function closeContextMenus()
{
	hide('program_contextmenu');
	program_active_target = null;
}

// ----------------------------------------
// TASKBAR_PROGRAM_ONCONTEXTMENU : EventHandler permettant de gérer le clic droit sur un programme de la barre des tâches
// Ne doit être appelé que depuis un bouton de programme de la barre des tâches
// ----------------------------------------

function taskbar_program_oncontextmenu()
{
	show('program_contextmenu');
	program_contextmenu.style.top = (mouseY-program_contextmenu.offsetHeight)+'px';
	program_contextmenu.style.left = mouseX+'px';
	program_active_target = document.getElementById(this.id.split('_')[1]);
	
	return false;
}

// ----------------------------------------
// TITLEBAR_ICON_ONCONTEXTMENU : EventHandler permettant de gérer le clic droit sur une icone d'un programme ouvert
// Ne doit être appelé que depuis une icône contenue dans une barre de titre
// ----------------------------------------

function titlebar_icon_oncontextmenu()
{
	show('program_contextmenu');
	program_contextmenu.style.top = (mouseY+1)+'px';
	program_contextmenu.style.left = (mouseX+1)+'px';
	program_active_target = findWindowHandler(this);
	
	return false;
}

// ----------------------------------------
// TASKBAR_PROGRAM_ONMOUSEDOWN : EventHandler permettant de faire un effet enfoncé sur un bouton quand on clic dessus
// Ne doit être appelé que depuis un bouton de la barre des tâches
// ----------------------------------------

function taskbar_program_onmousedown()
{
	pushed_program = this;
	this.className = 'program_pushed';
}

// ----------------------------------------
// TASKBAR_PROGRAM_ONMOUSEOUT : EventHandler permettant de supprimer l'effet enfoncé sur un bouton quand on s'en éloigne 
// Ne doit être appelé que depuis un bouton de la barre des tâches
// ----------------------------------------

function taskbar_program_onmouseout()
{
	if ((this == pushed_program) && (this.className != 'program_active'))
		this.className = 'program';
}

// ----------------------------------------
// RESIZETASKBAR : Fonction permettant de redimensionner la barre des tâches en fonction du nombre de lignes demandées
// Le nombre de lignes demandées est situé dans la variable taskbarSize
// ----------------------------------------

function resizeTaskbar()
{
	var taskbar_height = defaultTaskbarHeight+((taskbarSize-1)*25);
	taskbar.style.height = taskbar_height+'px';
	
	var systray_height = taskbar_height-
		parseInt(document.defaultView.getComputedStyle(systray, null).getPropertyValue("margin-top"))-
		parseInt(document.defaultView.getComputedStyle(systray, null).getPropertyValue("margin-bottom"))-
		parseInt(document.defaultView.getComputedStyle(systray, null).getPropertyValue("padding-top"))-
		parseInt(document.defaultView.getComputedStyle(systray, null).getPropertyValue("padding-bottom"));
	systray.style.height = systray_height+'px';
	
	var quicklaunch_height = taskbar_height-
		parseInt(document.defaultView.getComputedStyle(quicklaunch, null).getPropertyValue("margin-top"))-
		parseInt(document.defaultView.getComputedStyle(quicklaunch, null).getPropertyValue("margin-bottom"))-
		parseInt(document.defaultView.getComputedStyle(quicklaunch, null).getPropertyValue("padding-top"))-
		parseInt(document.defaultView.getComputedStyle(quicklaunch, null).getPropertyValue("padding-bottom"));
	quicklaunch.style.height = systray_height+2+'px';
	//quicklaunch.style.height = (taskbarSize*22)+'px';
	
	var firstIteration = true;
	for (i = 0; i < separators.length; i++)
	{
		if (firstIteration)
		{
			firstIteration = false;
			var separator_height = taskbar_height-2-
				parseInt(document.defaultView.getComputedStyle(separators[i], null).getPropertyValue("margin-top"))-
				parseInt(document.defaultView.getComputedStyle(separators[i], null).getPropertyValue("margin-bottom"))-
				parseInt(document.defaultView.getComputedStyle(separators[i], null).getPropertyValue("padding-top"))-
				parseInt(document.defaultView.getComputedStyle(separators[i], null).getPropertyValue("padding-bottom"));
		}
		separators[i].style.height = separator_height+'px';
	}
	
	startmenu.style.bottom = taskbar_height-
		parseInt(document.defaultView.getComputedStyle(startbutton, null).getPropertyValue("margin-top"))+'px';
	refreshDate(false);
}

// --------------------------------------------------
// FADESCREEN : Assombri et rééclairci l'écran
// (marche surement pas sous IE.. mais bon.. normal quoi.
// --------------------------------------------------

function fadeScreen(id, finalOpacity)
{
	var fade = document.getElementById(id);
	if (!fade)
		return;
	
	if (fade.style.display == 'none')
	{
		fade.style.opacity = 0;
		fadeOpacity(id, finalOpacity);
	}
	else
	{
		fade.style.opacity = opacitymax;
		unfadeOpacity(id);
	}
}

// --------------------------------------------------
// FADEOPACITY : Assombri progressivement l'écran (façon WinXP à la fermeture)
// (marche surement pas sous IE.. mais bon.. normal quoi.
// --------------------------------------------------

function fadeOpacity(id, finalOpacity)
{
	var fade = document.getElementById(id);
	if (!fade)
		return;
	
	if (fade.style.display != 'block')
	{
		fade.style.opacity = 0;
		show(fade.id);
	}
	if (parseFloat(fade.style.opacity) <= finalOpacity)
	{
		var opacity = fade.style.opacity
		fade.style.opacity = parseFloat(opacity)+0.075;
		fade.style.filter = 'alpha(opacity='+(parseFloat(opacity)+0.075)*100+')';
		setTimeout("fadeOpacity("+id+", "+finalOpacity+")", 75);
	}
}

// --------------------------------------------------
// UNFADEOPACITY : Fait disparaître un effet de "fade" de l'écran
// La disparition est directe alors que l'apparition est progressive
// --------------------------------------------------

function unfadeOpacity(id)
{
	hide(id);
}

// --------------------------------------------------
// LOAD : Permet de manipuler la barre de chargement affichée au chargement de la page
// Le premier argument permet de spécifier ce qu'on charge, et le deuxième où on en est a peu près
// --------------------------------------------------

function load(what, where)
{
	loading_what.innerHTML	= loading_img+' <b>Chargement:</b> '+what+'...';
	loading_bar.style.width	= parseInt(where*100)+'%';
	loading_bar.innerHTML	= parseInt(where*100)+'%';
	//debug('<b>LOAD:</b> '+what);
}

// --------------------------------------------------
// CLOSE_SESSION : Permet d'initialiser la fermeture de session
// Pas encore terminé...
// --------------------------------------------------

function close_session()
{
	//fadeOpacity('fadelogout', opacitymax);
	reduceAll();
	logout.open();
	//logout.ontop();
}

// --------------------------------------------------
// REDUCEALL : Permet de réduire toutes les fenêtres ouvertes
// Le premier argument permet de spécifier ce qu'on charge, et le deuxième où on en est a peu près
// --------------------------------------------------

function reduceAll()
{
	for (win_ in windows)
	{
		if (!windows[win_]['closed'])
			windows[win_]['win'].reduce();
	}
}