// |¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// |  ## WINDOWS AJAX ##
// |  FICHIER	->	winObject.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 la définition de l'objet WIN et ses méthodes
// |________________________________________

var windows = new Array();
load('WinObject', 0.2);

// ----------------------------------------
// Prototypage de toutes les méthodes de l'objet win
// La plupart ne sont pas utilisées, mais sont présentes par souci de complétude
// ----------------------------------------

win.prototype.loadText	= win_load_text;
win.prototype.loadFile	= win_load_page;
win.prototype.setIcon	= win_set_icon_m;

win.prototype.focus		= win_focus_m;
win.prototype.close		= win_close_m;
win.prototype.open		= win_open_m;
win.prototype.toggle	= win_toggle_m;
win.prototype.ontop		= win_ontop_m;

win.prototype.refresh	= win_refresh_m;
win.prototype.reduce	= win_reduce_m;
win.prototype.restore	= win_restore_m;
win.prototype.maximize	= win_maximize_m;
win.prototype.close		= win_close_m;
	
// ----------------------------------------
// OBJET WIN : Pseudo-objet permettant de créer des fenêtres en nombre illimité..
// - id		: Identifiant de la fenêtre (null pour laisser le script choisir)
// - title	: Titre de la fenêtre (apparait dans la barre de titre et la barre des taches)
// - width	: Largeur de la fenêtre ('auto' pour automatique)
// - height	: Hauteur de la fenêtre ('auto' pour automatique)
// - left	: Position X de la fenêtre (-1 pour 'par défaut', 'center' pour centrée)
// - top	: Position Y de la fenêtre (-1 pour 'par défaut', 'center' pour centrée)
// - flag	: Apparence de la fenêtre (additionnez les valeurs des options)
//				1 : Menubar présente
//				2 : Statusbar présente
//				4 : Fenêtre de contenu
//				8 : Fenêtre maximizable
//				16 : Fenêtre réductible
//				32 : Fenêtre visible à l'ouverture
// ----------------------------------------

function win(id, title, width, height, left, top, flag)
{
	// ----------------------------------------
	// On vérifie qu'il n'existe pas déjà une ou plusieurs fenêtres
	// ayant le même ID que la fenêtre que l'on souhaite créer
	// ----------------------------------------
	
	if (id != null)
	{
		var idsave = id;
		var k = 2;
		while (windows[id])
		{
			id = idsave+k;
			k++;
		}
	}
	else
		id = 'window'+defaultID++;
	windows[id] = new Array();
	
	// ----------------------------------------
	// Définition de l'aspect de la fenêtre et de ses options
	// Chaque chiffre du nombre binaire correspond à l'état d'activation de chaque élément
	// ----------------------------------------
	
	flag = flag.toString(2).pad(6, '0', 0);
	var flagindex = flag.length;
	
	if (flag[--flagindex] == 1) windows[id]['putMenubar'] = true;
	else windows[id]['putMenubar'] = false;
	if (flag[--flagindex] == 1) windows[id]['putStatusbar'] = true;
	else windows[id]['putStatusbar'] = false;
	if (flag[--flagindex] == 1) windows[id]['putContent'] = true;
	else windows[id]['putContent'] = false;
	if (flag[--flagindex] == 1) windows[id]['putMaximize'] = true;
	else windows[id]['putMaximize'] = false;
	if (flag[--flagindex] == 1) windows[id]['putReduce'] = true;
	else windows[id]['putReduce'] = false;
	if (flag[--flagindex] == 1) windows[id]['startVisible'] = true;
	else windows[id]['startVisible'] = false;
	
	// ----------------------------------------
	// Si aucune position n'est spécifiée à la création de l'objet
	// On le place en cascade sur l'écran (façon Windows)
	// ----------------------------------------
	
	if (left == -1)
		left = getNextDefaultPosX();
	if (top == -1)
		top = getNextDefaultPosY();
	if ((top == 'center') && (parseInt(height) > 0))
		top = parseInt((window.innerHeight/2)-(height/2));
	if ((left == 'center') && (parseInt(width) > 0))
		left = parseInt((window.innerWidth/2)-(width/2));
		
	// ----------------------------------------
	// Définition de toutes les variables d'état de la fenêtre
	// Sa taille, sa position, une sauvegarde de sa position lors de l'agrandissement, etc..
	// ----------------------------------------
	
	windows[id]['win']				= this;
	windows[id]['closed']			= false;
	windows[id]['extrasize']		= 0;
	
	windows[id]['width']			= width;
	windows[id]['height']			= height;
	windows[id]['top']				= top;
	windows[id]['left']				= left;
	
	windows[id]['restoreWidth']		= width;
	windows[id]['restoreHeight']	= height;
	windows[id]['restoreTop']		= top;
	windows[id]['restoreLeft']		= left;
	
	// ----------------------------------------
	// - Création du button représentant le programme dans la barre des tâches
	// (un simple DIV avec l'icone et le titre de la fenêtre)
	// ----------------------------------------
	
	if (windows[id]['startVisible'])
	{
		var taskbar_program				= document.createElement('div');
		var taskbar_program_text		= document.createTextNode(title);
		
		taskbar_program.setAttribute	('class', 'program');
		taskbar_program.setAttribute	('id', 'program_'+id);
		
		taskbar_program.appendChild		(taskbar_program_text);
		taskbar.appendChild				(taskbar_program);
		
		taskbar_program.onmouseup		= win_toggle_e;
		taskbar_program.oncontextmenu	= taskbar_program_oncontextmenu;
		taskbar_program.onmousedown		= taskbar_program_onmousedown;
		taskbar_program.onmouseout		= taskbar_program_onmouseout;
		taskbar_program.style.backgroundImage = 'url(index/images/icones/program.png)';
		
		controlTaskbarWidth(taskbar_program);
	}
	
	// ----------------------------------------
	// Création du squelette de la fenêtre (composée de DIVs)
	// On créé tous les éléments séparément et on les assemble au fur et à mesure
	// - Création du containeur principal (le handle de la fenêtre)
	// ----------------------------------------
	
	var container			= document.createElement('div');
	windows[id]['handler']	= container;
	this.handler			= container;
	this.id					= id;
	this.iswindow			= true;
	
	container.setAttribute	('id', id);
	container.setAttribute	('class', 'window');
	container.onmousedown	= win_focus_e;
	
	// ----------------------------------------
	// - Création de la barre de titre et de son container
	// - Création des boutons et du texte du titre de la fenêtre
	// ----------------------------------------
	
	var titlebar_container				= document.createElement('div');
	var titlebar						= document.createElement('div');
	var titlebar_closebutton			= document.createElement('div');
	var titlebar_title					= document.createElement('div');
	var titlebar_title_text				= document.createTextNode(title);
	var titlebar_title_icon				= document.createElement('img');
	
	titlebar_container.setAttribute		('class', 'titlebar_container');
	titlebar.setAttribute				('class', 'titlebar');
	titlebar.setAttribute				('name', 'titlebar');
	titlebar_closebutton.setAttribute	('class', 'close');
	titlebar_title.setAttribute			('class', 'title');
	titlebar_title_icon.setAttribute	('src', 'index/images/icones/program.png');
	titlebar_title_icon.setAttribute	('class', 'icon16');
	
	titlebar_title.onmousedown			= titlebar_onmousedown;
	titlebar_closebutton.onmousedown	= push_closebutton;
	titlebar_closebutton.onmouseout		= unpush_closebutton;
	titlebar_closebutton.onmouseup		= unpush_closebutton;
	titlebar_closebutton.onclick		= win_close_e;
	titlebar_title_icon.oncontextmenu	= titlebar_icon_oncontextmenu;
	titlebar_title_icon.onclick			= titlebar_icon_oncontextmenu;
	titlebar_title_icon.ondblclick		= win_close_e;
	
	titlebar_container.appendChild		(titlebar);
	titlebar.appendChild				(titlebar_closebutton);
	container.appendChild				(titlebar_container);
	
	// ----------------------------------------
	// Création du bouton d'agrandissement de la fenêtre
	// (uniquement s'il a été explicitement demandé dans les options de la fenêtre)
	// ----------------------------------------
	
	if (windows[id]['putMaximize'])
	{
		var titlebar_maximizebutton				= document.createElement('div');
		titlebar_maximizebutton.setAttribute	('class', 'maximize');
		titlebar.appendChild					(titlebar_maximizebutton);
		
		titlebar_maximizebutton.onmousedown		= push_maximizebutton;
		titlebar_maximizebutton.onmouseout		= unpush_maximizebutton;
		titlebar_maximizebutton.onmouseup		= unpush_maximizebutton;
		titlebar_maximizebutton.onclick			= win_maximize_e;
		titlebar_title.ondblclick				= win_maximize_e;
		
		windows[id]['titlebar_maximizebutton']	= titlebar_maximizebutton;
	}
	
	// ----------------------------------------
	// Création du bouton de réduction de la fenêtre
	// (uniquement s'il a été explicitement demandé dans les options de la fenêtre)
	// ----------------------------------------
	
	if (windows[id]['putReduce'])
	{
		var titlebar_reducebutton				= document.createElement('div');
		titlebar_reducebutton.setAttribute		('class', 'reduce');
		titlebar.appendChild					(titlebar_reducebutton);
		
		titlebar_reducebutton.onmousedown		= push_reducebutton;
		titlebar_reducebutton.onmouseout		= unpush_reducebutton;
		titlebar_reducebutton.onmouseup			= unpush_reducebutton;
		titlebar_reducebutton.onclick			= win_reduce_e;
		
		windows[id]['titlebar_reducebutton']	= titlebar_reducebutton;
	}

	titlebar.appendChild				(titlebar_title);
	titlebar_title.appendChild			(titlebar_title_icon);
	titlebar_title.appendChild			(titlebar_title_text);
	this.titlebar						= titlebar;
	
	windows[id]['titlebar']				= titlebar;
	windows[id]['titlebar_title']		= titlebar_title;
	windows[id]['titlebar_title_icon']	= titlebar_title_icon;
	windows[id]['titlebar_title_text']	= title;
	windows[id]['titlebar_closebutton']	= titlebar_closebutton;
	
	
	// ----------------------------------------
	// - Création de l'éventuelle barre de menu et son containeur
	// Si on veut y ajouter des éléments par la suite > Méthodes
	// ----------------------------------------
	
	if (windows[id]['putMenubar'])
	{
		var menubar_container			= document.createElement('div');
		var menubar						= document.createElement('div');
		
		menubar_container.setAttribute	('class', 'menubar_container');
		menubar.setAttribute			('class', 'menubar');
		menubar.setAttribute			('name', 'menubar');
		
		container.appendChild			(menubar_container);
		menubar_container.appendChild	(menubar);
		
		windows[id]['extrasize'] +=
			parseInt(document.defaultView.getComputedStyle(menubar, null).getPropertyValue("height"))+
			parseInt(document.defaultView.getComputedStyle(menubar, null).getPropertyValue("padding-top"))+
			parseInt(document.defaultView.getComputedStyle(menubar, null).getPropertyValue("padding-bottom"))+
			parseInt(document.defaultView.getComputedStyle(menubar_container, null).getPropertyValue("padding-top"))+
			parseInt(document.defaultView.getComputedStyle(menubar_container, null).getPropertyValue("padding-bottom"));
	}
	
	// ----------------------------------------
	// - Création de l'espace de contenu (texte, images, etc..) et de son containeur
	// Pour charger du contenu à l'intérieur > Méthodes
	// ----------------------------------------
	
	var content_container	= document.createElement('div');
	var content				= document.createElement('div');
	var content_padder		= document.createElement('div');
	
	if (windows[id]['putContent'])
		var contentClass = 'content';
	else
		var contentClass = 'workspace';
	
	content_container.setAttribute	('class', 'content_container');
	content.setAttribute			('class', contentClass);
	content.setAttribute			('name', 'content');
	content_padder.setAttribute		('class', 'padder');
	
	this.content					= content_padder;
	this.content_container			= content_container;
	
	container.appendChild			(content_container);
	content_container.appendChild	(content);
	content.appendChild				(content_padder);
	
	// ----------------------------------------
	// - Création de l'eventuelle barre de status, son containeur et le handle pour resize
	// Pour y ajouter des élements 'bloc' > Méthode
	// ----------------------------------------
	
	var statusbar_container				= document.createElement('div');
	statusbar_container.setAttribute	('class', 'statusbar_container');
	container.appendChild				(statusbar_container);

	windows[id]['extrasize'] +=+
		parseInt(document.defaultView.getComputedStyle(statusbar_container, null).getPropertyValue("padding-top"))+
		parseInt(document.defaultView.getComputedStyle(statusbar_container, null).getPropertyValue("padding-bottom"))+
		parseInt(document.defaultView.getComputedStyle(statusbar_container, null).getPropertyValue("border-bottom-width"));
			
	if (windows[id]['putStatusbar'])
	{
		var statusbar				= document.createElement('div');
		var resize					= document.createElement('div');
		windows[id]['statusbar']	= statusbar;
		
		statusbar.setAttribute		('class', 'statusbar');
		statusbar.setAttribute		('name', 'statusbar');
		resize.setAttribute			('class', 'resize');
		resize.setAttribute			('name', 'resize');
		
		statusbar_container.appendChild	(statusbar);
		statusbar.appendChild		(resize);
		
		resize.onmousedown	= resize_onmousedown;
		resize.onmouseup	= resize_onmousedown;
		
		windows[id]['extrasize'] +=
			parseInt(document.defaultView.getComputedStyle(statusbar, null).getPropertyValue("height"))+
			parseInt(document.defaultView.getComputedStyle(statusbar, null).getPropertyValue("padding-top"))+
			parseInt(document.defaultView.getComputedStyle(statusbar, null).getPropertyValue("padding-bottom"));
	}
	
	// ----------------------------------------
	// Calcul de l'extra-size occupée par les différentes barres
	// (mauvaise gestion du CSS = code pourri et vieux hacks)
	// ----------------------------------------
	
	var titlebar_height	=
		parseInt(document.defaultView.getComputedStyle(titlebar, null).getPropertyValue("height"))+
		parseInt(document.defaultView.getComputedStyle(titlebar, null).getPropertyValue("padding-top"))+
		parseInt(document.defaultView.getComputedStyle(titlebar, null).getPropertyValue("padding-bottom"))+
		parseInt(document.defaultView.getComputedStyle(titlebar_container, null).getPropertyValue("padding-top"))+
		parseInt(document.defaultView.getComputedStyle(titlebar_container, null).getPropertyValue("padding-bottom"))+
		parseInt(document.defaultView.getComputedStyle(titlebar_container, null).getPropertyValue("border-top-width"));

	var content_height	=
		parseInt(document.defaultView.getComputedStyle(content_container, null).getPropertyValue("padding-top"))+
		parseInt(document.defaultView.getComputedStyle(content_container, null).getPropertyValue("padding-bottom"));
	
	windows[id]['extrasize'] += titlebar_height+content_height;

	// ----------------------------------------
	// Affectation des styles variables à la fenêtre (taille, position, etc...)
	// Et insertion de la fenêtre dans le flux HTML
	// ----------------------------------------
	
	increment_current_zIndex();
	container.style.zIndex = current_zIndex;
	
	if (width == 'auto') container.style.width = width;
	else container.style.width = width+'px';
	if (height == 'auto') container.style.height = height;
	else container.style.height = height+'px';
	
	if (!windows[id]['startVisible'])
	{
		container.style.display	= 'none';
		windows[id]['closed']	= true;
	}
	
	container.style.top		= top+'px';
	container.style.left	= left+'px';
	
	body_.appendChild(container);
	
	// ----------------------------------------
	// Définition de toutes les méthodes de l'objet win
	// La plupart de ces méthodes ne sont pas utilisées, mais tout de même présentes
	// ----------------------------------------
	
	this.loadText	= win_load_text;
	this.loadFile	= win_load_page;
	this.setIcon	= win_set_icon_m;
	
	this.focus		= win_focus_m;
	this.close		= win_close_m;
	this.open		= win_open_m;
	this.toggle		= win_toggle_m;
	this.ontop		= win_ontop_m;
	
	this.refresh	= win_refresh_m;
	this.reduce		= win_reduce_m;
	this.restore	= win_restore_m;
	this.maximize	= win_maximize_m;
	this.close		= win_close_m;

	debug('<b>LOAD:</b> '+id+'('+flag+')');
}

load('Méthodes', 0.3);

// ----------------------------------------
// Méthode et Fonction de passage d'une fenêtre à l'avant plan définitivement
// Cette méthode sert à faire passer une fenêtre au dessus de toutes les autres définitivement
// ----------------------------------------

function win_ontop_m()
{
	win_ontop(this.handler);
}
function win_ontop(target)
{
	if ((!target.className) || (target.className != 'window'))
		return;
	target.style.zIndex = 30000;
}

// ----------------------------------------
// Méthode, EventHandler et Fonction d'apparition/disparition d'une fenêtre
// Cette méthode sert à faire apparaître ou disparaître la fenêtre en fonction de son état actuel
// ----------------------------------------

function win_toggle_m()
{
	win_toggle(this.handler);
}
function win_toggle_e()
{
	var id = this.id.split('_')[1];
	win_toggle(document.getElementById(id));
}
function win_toggle(target)
{
	if ((!target.className) || (target.className != 'window'))
		return;
	
	var visible = target.style.display;
	
	if (windows[target.id]['closed'])
	{
		win_open(target);
	}
	if (target.id == active_window)
	{
		win_reduce(target)
	}
	else
	{
		if (visible == 'none')
		{
			show(target);
			win_focus(target);
		}
		else
		{
			win_focus(target);
		}
	}
}

// ----------------------------------------
// Méthode, EventHandler et Fonction d'ouverture d'une fenêtre
// Simule le lancement d'une 'application' en sortant une fenêtre de son état de veille
// ----------------------------------------

function win_open_m()
{
	win_open(this.handler);
}
function win_open(target)
{
	if ((!target.className) || (target.className != 'window'))
		win_create(target);
		
	//debug(windows[target.id]['closed']);
	if (windows[target.id]['closed'])
	{
		show(target.id);
		windows[target.id]['closed']		= false;
		
		var newTop							= getNextDefaultPosX();
		var newLeft							= getNextDefaultPosY();
		target.style.left					= newTop+'px';
		target.style.top					= newLeft+'px';
		windows[target.id]['top']			= newTop;
		windows[target.id]['left']			= newLeft;
		windows[target.id]['restoreTop']	= newTop;
		windows[target.id]['restoreLeft']	= newLeft;
		
		var taskbar_program					= document.createElement('div');
		var taskbar_program_text			= document.createTextNode(windows[target.id]['titlebar_title_text']);
		
		taskbar_program.setAttribute		('class', 'program');
		taskbar_program.setAttribute		('id', 'program_'+target.id);
		
		taskbar_program.appendChild			(taskbar_program_text);
		taskbar.appendChild					(taskbar_program);
		
		taskbar_program.onmouseup			= win_toggle_e;
		taskbar_program.oncontextmenu		= taskbar_program_oncontextmenu;
		taskbar_program.onmousedown			= taskbar_program_onmousedown;
		taskbar_program.onmouseout			= taskbar_program_onmouseout;
		controlTaskbarWidth					(taskbar_program);
		
		/*
		if (windows[target.id]['titlebar_title_icon'])
			win_set_icon(target, windows[target.id]['titlebar_title_icon']);
		else
			win_set_icon(target, 'index/images/icones/program.png');
		*/
		debug('<b>OPENING:</b> window('+target.id+')');
	}
	win_focus(target);
}

// ----------------------------------------
// Méthode, EventHandler et Fonction de fermeture d'une fenêtre
// Simule la fermeture d'une fenêtre en la mettant en état de veille (display: none)
// ----------------------------------------

function win_close_m()
{
	win_close(this.handler);
}
function win_close_e()
{
	win_close(findWindowHandler(this));
	closeContextMenus();
}
function win_close(target)
{
	if ((!target.className) || (target.className != 'window'))
		return;
	
	if (!windows[target.id]['closed'])
	{
		windows[target.id]['closed'] = true;
		win_loose_focus(target);
		hide(target.id);
		var taskbar_program_handle = document.getElementById('program_'+target.id);
		taskbar.removeChild(taskbar_program_handle);
		
		debug('<b>CLOSING:</b> window('+target.id+')');
	}
}

// ----------------------------------------
// Méthode, EventHandler et Fonction de rafraichissement d'une fenêtre
// Pour rafraichir les fenêtres contenant une iframe (berk!) vers du contenu externe
// ----------------------------------------

function win_refresh_m()
{
	win_refresh(this.handler);
}
function win_refresh_e()
{
	win_refresh(findWindowHandler(this));
}
function win_refresh(target)
{
	if ((!target.className) || (target.className != 'window'))
		return;
	
	if (!windows[target.id]['closed'])
	{
		windows[target.id]['iframe'].src = windows[target.id]['iframe'].src;
		debug('<b>REFRESH:</b> window('+target.id+')');
	}
}

// ----------------------------------------
// Méthode, EventHandler et Fonction d'agrandissement d'une fenêtre
// Augmente la taille d'une fenêtre jusqu'à ce qu'elle fasse tout la taille disponible
// Les fonctions de déplacement et redimensionnement sont désactivées
// ----------------------------------------

function win_maximize_m()
{
	win_maximize(this.handler);
}
function win_maximize_e()
{
	win_maximize(findWindowHandler(this));
}
function win_maximize(target)
{
	if ((!target.className) || (target.className != 'window') || (!windows[target.id]['titlebar_maximizebutton']))
		return;
	
	windows[target.id]['titlebar_title'].ondblclick = win_restore_e;
	windows[target.id]['titlebar_title'].onmousedown = null;
	windows[target.id]['titlebar_maximizebutton'].className = 'restore';
	windows[target.id]['titlebar_maximizebutton'].onmousedown = push_restorebutton;
	windows[target.id]['titlebar_maximizebutton'].onmouseout = unpush_restorebutton;
	windows[target.id]['titlebar_maximizebutton'].onmouseup = unpush_restorebutton;
	windows[target.id]['titlebar_maximizebutton'].onclick = win_restore_e;
	
	target.style.top	= 0;
	target.style.left	= 0;
	target.style.width	= '100%';
	target.style.height	= (window.innerHeight-document.getElementById('taskbar').offsetHeight-windows[target.id]['extrasize'])+'px';
	
	debug('<b>MAXIMIZE:</b> window('+target.id+')');
}

// ----------------------------------------
// Méthode, EventHandler et Fonction de restoration d'une fenêtre
// Réduit la taille d'une fenêtre à sa taille d'origine (avant un agrandissement)
// Les fonctions de déplacement et redimensionnement sont résactivées
// ----------------------------------------

function win_restore_m()
{
	win_restore(this.handler);
}
function win_restore_e()
{
	win_restore(findWindowHandler(this));
}
function win_restore(target)
{
	if ((!target.className) || (target.className != 'window') || (!windows[target.id]['titlebar_maximizebutton']))
		return;
	
	windows[target.id]['titlebar_title'].ondblclick = win_maximize_e;
	windows[target.id]['titlebar_title'].onmousedown = titlebar_onmousedown;
	windows[target.id]['titlebar_maximizebutton'].className = 'maximize';
	windows[target.id]['titlebar_maximizebutton'].onmousedown = push_maximizebutton;
	windows[target.id]['titlebar_maximizebutton'].onmouseout = unpush_maximizebutton;
	windows[target.id]['titlebar_maximizebutton'].onmouseup = unpush_maximizebutton;
	windows[target.id]['titlebar_maximizebutton'].onclick = win_maximize_e;
	
	target.style.top	= windows[target.id]['restoreTop']+'px';
	target.style.left	= windows[target.id]['restoreLeft']+'px';
	target.style.width	= windows[target.id]['restoreWidth']+'px';
	target.style.height	= windows[target.id]['restoreHeight']+'px';
	
	debug('<b>RESTORE:</b> window('+target.id+')');
}

// ----------------------------------------
// Méthode, EventHandler et Fonction de réduction d'une fenêtre
// Fait simplement disparaître la fenêtre et passer le focus à la fenêtre suivante
// ----------------------------------------

function win_reduce_m()
{
	win_reduce(this.handler);
}
function win_reduce_e()
{
	win_reduce(findWindowHandler(this));
}
function win_reduce(target)
{
	if ((!target.className) || (target.className != 'window'))
		return;
	
	hide(target);
	win_loose_focus(target);
}

// ----------------------------------------
// Méthode, EventHandler et Fonction de focus d'une fenêtre
// Place la fenêtre donnée à l'avant plan et change son aspect pour refleter son état
// ----------------------------------------

function win_focus_m()
{
	win_focus(this.handler);
}
function win_focus_e()
{
	win_focus(this);
}
function win_focus(target)
{
	if ((!target.className) || (target.className != 'window'))
		return;
	
	target.style.zIndex = current_zIndex;
	increment_current_zIndex();
	debug('<b>FOCUS:</b> window('+target.id+')');
	
	for (win_ in windows)
	{
		if (!win_['closed'])
		{
			var program_win = document.getElementById('program_'+win_);
			if (program_win)
			{
				if (win_ != target.id)
				{
					windows[win_]['titlebar'].className = 'titlebar_inactive';
					program_win.className = 'program';
				}
				else
				{
					windows[win_]['titlebar'].className = 'titlebar';
					program_win.className = 'program_active';
					active_window = win_;
				}
				controlTaskbarWidth(program_win);
			}
		}
	}
}

// ----------------------------------------
// Méthode, EventHandler et Fonction de perte de focus d'une fenêtre
// La fenêtre donnée perd son focus et passe donc au second plan
// La fenêtre qui récupère le focus est l'avant-dernière ayant été utilisée
// ----------------------------------------

function win_loose_focus(target)
{
	if ((!target.className) || (target.className != 'window'))
		return;
	
	var zIndex_max = 0;
	var window_ontop = null;
	
	for (win_ in windows)
	{
		if ((!windows[win_]['closed']) && (win_ != target.id) && (document.getElementById(win_).style.zIndex > zIndex_max) && (document.getElementById(win_).style.display != 'none'))
		{
			zIndex_max = document.getElementById(win_).style.zIndex;
			window_ontop = win_;
		}
	}
	
	if (document.getElementById(window_ontop))
		win_focus(document.getElementById(window_ontop));
	else if (active_window)
	{
		//debug(active_window.id);
		document.getElementById('program_'+active_window).className = 'program';
		active_window = null;
	}
	debug('<b>BLUR:</b> window('+target.id+')');
}

// ----------------------------------------
// Méthode de chargement de texte dans une fenêtre
// Place une chaine de caractères à l'intérieur d'une fenêtre
// ----------------------------------------

function win_load_text(text)
{
	this.content_container.removeChild(this.content_container.firstChild);
	var div = document.createElement('div');
	var div2 = document.createElement('div');
	
	if (windows[this.id]['putContent']) var contentClass = 'content';
	else var contentClass = 'workspace';
	
	div.setAttribute('class', contentClass);
	div.setAttribute('name', 'content');
	div2.setAttribute('class', 'padder');
	div2.innerHTML	= text;
	
	div.appendChild	(div2);
	this.content_container.appendChild	(div);
}

// ----------------------------------------
// Méthode de chargement d'une page complète dans une fenêtre
// La méthode est complexe et requiert ou bien de l'Ajax ou bien une iframe
// En général, une iframe est conseillée pour ouvrir une page externe (collision de styles)
// ----------------------------------------

function win_load_page(page, framed)
{
	if (navigator.appName.indexOf('Microsoft') == 1)
		var ajax = new ActiveXObject("Microsoft.XMLHTTP");
	else
		var ajax = new XMLHttpRequest();
	
	// ----------------------------------------
	// Méthode de l'iframe
	// Le but est d'aller chercher la page demandée et de l'afficher directement dans une iframe
	// C'est utile en cas de page externe, ou de colision de balises/styles
	// C'est aussi compliqué parce qu'il faut tout simplement détruire puis reconstruire l'arbre DOM de la fenêtre
	// ----------------------------------------
	
	if (framed)
	{
		this.content_container.removeChild	(this.content_container.firstChild);
		var iframe = document.createElement	('iframe');
		iframe.setAttribute					('src', page);
		windows[this.id]['iframe']			= iframe;
		windows[this.id]['iframe_location']	= page;
		
		if (windows[this.id]['putContent']) var contentClass = 'content_framed';
		else var contentClass = 'workspace_framed';
		
		iframe.setAttribute					('class', contentClass);
		iframe.setAttribute					('name', 'content');
		this.content_container.appendChild	(iframe);
		
		if (windows[this.id]['putStatusbar'])
		{
			var refresh = document.createElement('div');
			var refresh_a = document.createElement('a');
			var refresh_img = document.createElement('img');
			var refresh_a_text = document.createTextNode(' Rafraichir');
			
			refresh.setAttribute		('class', 'bloc');
			refresh_a.setAttribute		('href', '#');
			refresh_a.onclick			= win_refresh_e;
			refresh_img.setAttribute	('src', 'index/images/layer/refresh.gif');
			refresh_img.setAttribute	('class', 'icon');
			
			refresh_a.appendChild		(refresh_img);
			refresh_a.appendChild		(refresh_a_text);
			refresh.appendChild			(refresh_a);
			windows[this.id]['statusbar'].appendChild(refresh);
		}
	}
	// ----------------------------------------
	// Méthode de l'AJAX
	// Si la page est assez simple, ne contient que du texte par exemple, et aucun style particulier associé
	// On peut aller la chercher directement en AJAX.. m'enfin c'est surtout là pour faire beau quoi..
	// ----------------------------------------
	
	else
	{
		var ajax_target = this;
		//ajax.open('get', 'index/modules/'+page+'.php');
		ajax.open('get', page);
		ajax.onreadystatechange = function read_ajax_response()
		{
			switch (ajax.readyState)
			{
				case 1:
					ajax_target.content.innerHTML = loading_string;
					break;
				case 2:
					break;
				case 3:
					break;
				case 4:
					//ajax.status contient 200, 404, ...
					//ajax.statusText contient OK, NOT FOUND, ...
					var reponse = ajax.responseText;
					ajax_target.loadText(reponse);
					ajax_target = null;
					break;	
			}
		};
		ajax.send(null);
	}
}

// ----------------------------------------
// Méthode et Fonction de changement de l'icone d'une fenêtre
// Change l'icône d'une fenêtre et de son handler dans la barre des tâches
// ----------------------------------------

function win_set_icon_m(icon)
{
	win_set_icon(this.handler, icon);
}
function win_set_icon(target, icon)
{
	if ((!target.className) || (target.className != 'window'))
		return;
	
	windows[target.id]['icon'] = icon;
	windows[target.id]['titlebar_title_icon'].src = icon;
	if (document.getElementById('program_'+target.id))
		document.getElementById('program_'+target.id).style.backgroundImage = 'url('+icon+')';
}