//://////////////////////////////////////////////
//:: Name
//:: FileName inc_string
//:: Copyright (c) 2006 MOW Corp.
//://///////////////////////////////////////////
/*
Bibliotheque de fonctions de gestion des strings

Ce script est une bibliotheque.
Il contient des fonctions additionnelles a celles
de Bioware pour gerer les strings.

*/
//://///////////////////////////////////////////
//:: Created By: Marco & un peut tout le monde ^^
//:: Created On: 10/09/2006
//://///////////////////////////////////////////

////////////////////////////////////////////////
//DECLARATIONS DES FONCTIONS & DES PROCEDURES//
//////////////////////////////////////////////

//Retourne une string en fonction du separateur et de la position du separateur dans la string
//Retourne la chaine situee avant la position du separateur.
string GetSubStringBySeparator(string sString, string sSeparator, int nSeparator);

//Insere sString dans sDestination a la position nSeparateur de sSeparateur
//Retourne la nouvelle chaine ou une chaine vide en cas d'erreur.
string InsertStringBySeparator(string sDestination, string sString, string sSeparator,int nSeparator);

//Insere & REMPLACE la ligne qui etait a l'indice nSeparator par sString dans sDestination
string ReplaceStringBySeparator(string sDestination, string sString, string sSeparator, int nSeparator);

//Complete la string sStringToComplete avec le caractere sCaractereUseToComplete jusqu'a ce
//que sStringToComplete mesure nMaxSize
string CompleteString(string sStringToComplete, string sCaractereUseToComplete, int nMaxSize);

//Remplace une morceau de sString par sStringToReplace d'une longueur egale a celle
//de sStringToReplace a partir de nPosition dans sString
string ReplaceString(string sString, string sStringToReplace, int nPosition);

//Supprime le caractere sStringToDelete de la chaine sString
//Retourne la nouvelle sString.
string SupprimeUnString(string sString, string sStringToDelete);

//Cette fonction recherche toutes les occurences de sOldStr dans
//sStr et les remplace par des sNewStr, puis elle renvoie la chaîne
//de caractère modifiée.
//NON TESTE
string ReplaceStringByString(string sOldStr, string sNewStr, string sStr);

////////////////////////////////////////////////////
//IMPLEMENTATION DES FONCTIONS & DES PROCEDURES /
//////////////////////////////////////////////////


string GetSubStringBySeparator(string sString, string sSeparator, int nSeparator)
{
string sWorkingString = sString;
int nPosSeparator, nLong;
int nCount = 1;
while(sWorkingString != "")
{ //trouve le 1er separateur a partir de la gauche.
nPosSeparator = FindSubString(sWorkingString, sSeparator);
if (nPosSeparator == -1)
{
return ""; //erreur, on renvoi une chaine vide.
}
else
{
if (nCount == nSeparator)//on est sur le bon separateur
{ //on renvoit le resultat
return GetStringLeft(sWorkingString,(nPosSeparator));
}
else
{
nLong = (GetStringLength(sWorkingString)-nPosSeparator);
sWorkingString = GetSubString(sWorkingString, nPosSeparator+1, nLong);
nCount++;
}
}
}
return ""; //erreur, on renvoi une chaine vide.
}

//******************************************************************************

string InsertStringBySeparator(string sDestination, string sString, string sSeparator,int nSeparator)
{
string sWorkingString = sDestination;
string sTampon = "";
int nPosSeparator, nLong;

if (nSeparator == 1) //si la position d'insertion est 1
{//on se prend pas la tete
return sString+sDestination;
}

int nCount = 1;
while(sWorkingString != "")
{ //trouve le 1er separateur a partir de la gauche.
nPosSeparator = FindSubString(sWorkingString, sSeparator);
if (nPosSeparator == -1)
{
//si on trouve pas le separateur c'est qu'on est au bout donc on fait un ajout
//On part du principe que la chaine est correctement formatee donc pas de traitement d'erreur
//si la nCount = nSeparator, alors c'est que l'insertion doit etre en fait un simple
//ajout de ligne !!!
if (nCount == (nSeparator))
{
return sDestination+sString;
} //Note : On gere cette possibilite pour pouvoir coder les fonctions de tri.
}
else
{
if (nCount == nSeparator)//on est sur le bon separateur
{
return sTampon+sString+sWorkingString;
}
else
{
nLong = (GetStringLength(sWorkingString)-nPosSeparator);
sTampon += GetStringLeft(sWorkingString,(nPosSeparator+1));
sWorkingString = GetSubString(sWorkingString, nPosSeparator+1, nLong);
nCount++;
}
}
}
//On arrive ici quand sWorkingString est vide, on est a nSeparator
//si ici nCount = nSeparator, alors c'est que l'insertion doit etre en fait un simple
//ajout de ligne !!!
if (nCount == (nSeparator))
{
return sDestination+sString;
}

//Pour la compil :
return "";
}

//******************************************************************************

string ReplaceStringBySeparator(string sDestination, string sString, string sSeparator, int nSeparator)
{
string sWorkingString = sDestination;
string sTampon = "";
int nPosSeparator, nLong;

int nCount = 1;
while(sWorkingString != "")
{ //trouve le 1er separateur a partir de la gauche.
nPosSeparator = FindSubString(sWorkingString, sSeparator);
if (nPosSeparator == -1)
{
return ""; //erreur, on renvoi une chaine vide.
}
else
{
if (nCount == nSeparator)//on est sur le bon separateur
{ //on renvoit le resultat
nLong = (GetStringLength(sWorkingString)-nPosSeparator);
sWorkingString = GetSubString(sWorkingString, nPosSeparator+1, nLong);

return sTampon+sString+sWorkingString;
}
else
{
nLong = (GetStringLength(sWorkingString)-nPosSeparator);
sTampon += GetStringLeft(sWorkingString,(nPosSeparator+1));
sWorkingString = GetSubString(sWorkingString, nPosSeparator+1, nLong);
nCount++;
}
}
}
return ""; //erreur, on renvoi une chaine vide.
}

//******************************************************************************

string CompleteString(string sStringToComplete, string sCaractereUseToComplete, int nMaxSize)
{
int nTaille = nMaxSize - GetStringLength(sStringToComplete);
int nI = 1;

while(nI <= nTaille)
{
sStringToComplete += sCaractereUseToComplete;
nI++;
}
return sStringToComplete;
}

//******************************************************************************

string ReplaceString(string sString, string sStringToReplace, int nPosition)
{
int nLongToReplace = GetStringLength(sStringToReplace);
int nLongTotale = GetStringLength(sString);

//si sStringToReplace plus grand que sString ---> erreur
if (nLongToReplace > nLongTotale)
{
return "";
}

//Combien de positions dans sString ?
int nNbPosition = nLongTotale / nLongToReplace;

//si on veut inserer a une position > nb de positions totale, erreur
if (nPosition > nNbPosition)
{
return "";
}

int nLongDebut, nPosFin, nLongFin;
nLongDebut = (nLongToReplace * (nPosition - 1)) ;
nPosFin = nNbPosition - nPosition;
nLongFin = nPosFin * nLongToReplace;

string sDebut = GetStringLeft(sString, nLongDebut);
string sFin = GetStringRight(sString, nLongFin);

return sDebut + sStringToReplace + sFin;

}

//******************************************************************************

string SupprimeUnString(string sString, string sStringToDelete)
{
if(GetStringLength(sStringToDelete) > 1)
{ //un seul caractere autorise pour sStringToDelete
return "";
}

int nI = 0;
int nLong = GetStringLength(sString);
string sNewString = "";
string sTest = "";

while(nI < nLong)
{
sTest = GetSubString(sString, nI, 1);
if(sTest != sStringToDelete)
{
sNewString += sTest;
}
sTest = "";
nI++;
}

return sNewString;
}

//******************************************************************************

string ReplaceStringByString(string sOldStr, string sNewStr, string sStr)
{
if (sOldStr == "")
return "";

int nTemp;
int nL = GetStringLength(sStr);
int nLength = GetStringLength(sOldStr);
string sTemp;
string sR = "";

while ((nTemp = FindSubString(sStr, sOldStr)) >= 0)
{
sTemp = GetStringLeft(sStr, nTemp);
sStr = GetStringRight(sStr, nL - nLength - nTemp);
sR = sR + sTemp + sNewStr;
nL = GetStringLength(sStr);
}
sR+=sStr;

return sR;
}

//******************************************************************************

//void main() {}

//://////////////////////////////////////////////
//:: Name
//:: FileName inc_tableaux
//:: Copyright (c) 2006 MOW Corp.
//://///////////////////////////////////////////
/*
Bibliotheque de fonctions de gestion des tableaux

Ce script est une bibliotheque.
Il contient toutes les fonctions utilisees pour
emuler des tableaux a 2 dimensions avec le nwnScript.

Limitations :
- 1 a n colonnes dans le tableau. (plus on en mets, moins faut mettre de lignes normal )
- nb de lignes 60 lignes pour un tableau 4 colonnes de 32 caracteres par cellules.
On peut ptet pousser au dela mais a 75-80 ---> TOO MANY INSTRUCTIONS, nwn jette l'eponge.
- Oblige de passer par des strings. Donc si une colonne
ne contient que des int ou des floats il ne faudra pas
oublier de faire les conversions.
- Les Tris : Necessite des tableaux 2 a 3 fois moins gros que ce qui est dit
juste au dessus sinon TOO MANY INSTRUCTIONS
*/
//://///////////////////////////////////////////
//:: Created By: Marco
//:: Created On: 09/09/2006
//://///////////////////////////////////////////

#include "inc_string"

///////////////////////////////
//DECLARATION DES STRUCTURES//
/////////////////////////////
//La ligne d'indice 1 d'un tableau est la premiere ligne.
struct Tableau {
string sData; //La chaine contenant les donnees
int nCol; //Le nb de colonnes (aucune utilite pour le moment. Mis a la creation, pas touche depuis)
int nLignes; //Le nb de lignes (seule utilite, connaitre le nb de ligne tres vite)
int nTailleMaxCellule; //Taille maxi de chaque cellule.
string sCaractereToComplete; //Caractere utilise pour completer les donnees des cellules.
};

///////////////////////////////
//DECLARATION DES CONSTANTES//
/////////////////////////////



/////////////////////////////////////////////////
//REGLE DE CONSTRUCTION DES DONNEES DU TABLEAU//
///////////////////////////////////////////////
/*

La taille des cellules est limitee a la creation du tableau.(cf la structure)
Ainsi, a chaque fois qu'une donnee est ajoutee dans une cellule, elle est
complete avec un caractere pre-defini (cf la structure) pour aller jusqu'a
la taille max de la cellule.

Cette methode permet d'eviter toutes les boucles de la version precedente
de inc_tableaux ou l'on construisait les cellules puis les lignes avec des
separateurs.

Je trouve pas de systeme pour donner aux cellules une taille dynamique tout en
evitant au maximum les boucles. Si quelqu'un a idee je suis preneur, ca reduirait
encore + les ressources necessaire...

*/


////////////////////////////////////////////////
//DECLARATIONS DES FONCTIONS & DES PROCEDURES//
//////////////////////////////////////////////

//Cree un tableau. Le tableau est en fait une structure composee de :
//string sData :...................une chaine qui contient toutes les donnees
//int nNbCol :...................le nombre de colonnes du tableau
//int nNbLignes :...................le nombre de lignes
//int nTailleMaxCellule :...........taille maxi de chaque cellule du tableau
//string sCaractereToComplete :.....le caractere qui sert a completer les cellules
//Retourne le tableau cree.
struct Tableau Tab_CreateTableau(string sData, int nNbCol, int nNbLignes, int nTailleMaxCellule, string sCaractereToComplete);

//Retourne la cellule (AVEC les caracteres qui completent) place dans le tableau :
//a l'indice nIndiceCol pour les X
//a l'indice nIndiceLigne pour les Y
string Tab_GetTabCelluleComplete(struct Tableau MonTableau, int nIndiceCol, int nIndiceLigne);

//Retourne la ligne (AVEC les caracteres qui completent) placee dans le tableau :
//a l'indice nIndiceLigne pour les Y
string Tab_GetTabLigneComplete(struct Tableau MonTableau, int nIndiceLigne);

//Retourne la cellule (SANS les caracteres qui completent) place dans le tableau :
//a l'indice nIndiceCol pour les X
//a l'indice nIndiceLigne pour les Y
string Tab_GetTabCellule(struct Tableau MonTableau, int nIndiceCol, int nIndiceLigne);

//Retourne la ligne (SANS les caracteres qui completent) placee dans le tableau :
//a l'indice nIndiceLigne pour les Y
string Tab_GetTableLigne(struct Tableau MonTableau, int nIndiceLigne);

//Remplace une ligne du tableau a l'indice nIndiceToReplace avec la ligne sLigneToReplace
//Retourne le nouveau tableau
struct Tableau Tab_ReplaceLigne(struct Tableau MonTableau, string sLigneToReplace, int nIndiceToReplace);

//Utilisee pour construire une ligne. Ajoute une cellule a la ligne que l'ont veut construire.
//Les caracteres manquants sont completes pour arriver a MonTableau.nTailleMaxCellule
//sNewLigne = Chaine vide pour la 1ere cellule de la ligne.
//Retourne sNewLigne construite.
string Tab_SetNewCellule(string sNewLigne, string sNewCellule, string sCaractereUseToComplete ,int nMaxSize);

//Ecrit une nouvelle ligne dans le tableau a la fin du tableau
//La ligne doit etre formatee correctement. Pour construire une ligne, utiliser la fonction
//Tab_SetNewCellule et boucler dessus jusqu'a avoir le nb de cellule composant la ligne.
//Retourne le nouveau tableau.
struct Tableau Tab_SetNewLigne(struct Tableau MonTableau, string sNewLigne);

//Insere une ligne sNewLigne a la position nIndiceInsertion
//Retourne le nouveau tableau.
struct Tableau Tab_InsertNewLigne(struct Tableau MonTableau, string sNewLigne, int nIndiceInsertion);

//Supprime la ligne d'indice nIndiceToDelete du tableau MonTableau
//Retourne le nouveau tableau.
//ATTENTION : Supprimer une ligne decale tous les indices > nIndiceToDelete de -1
struct Tableau Tab_DeleteLigne(struct Tableau MonTableau, int nIndiceToDelete);


/////////////////////////////////////////
//*** FONCTIONS DE TRI DES TABLEAUX
///////////////////////////////////////

//Fonction interne du tri Tab_TrieTableauParInsertion
struct Tableau DecaleTabTriParInsertion(struct Tableau MonTableau, int nPosition, int nIndiceCol);

//Trie le tableau
//Algorithme utilise : Tri par insertion (pas Dychotomique car certaines structures de controle indisponibles en nwnScript(ex : Do... While)
//struct Tableau MonTableau : Le tableau a trier
//int nNumCol : defini sur quel numero de colonne on trie le tableau
//******************************************************************
//NOTE_1 : On ne peut trier que sur des int (ptet des floats mais pas essaye) donc
//il faut faire attention sur la colonne a trier sinon ca renvoie vide ("").
//NOTE_2 : A preferer au tri par selection si tableau partiellement trié
//Retourne le nouveau tableau trié.
struct Tableau Tab_TrieTableauParInsertion(struct Tableau MonTableau, int nNumCol);

//Fonction interne de Tab_TrieTableauParSelection
struct Tableau EchangeTabTriParSelection(struct Tableau MonTableau, int nI, int nJ, int nIndiceCol);

//Fonction interne de Tab_TrieTableauParSelection
struct Tableau PlusPetitTabTriParSelection(struct Tableau MonTableau, int nPd, int nN, int nIndiceCol);

//Trie le tableau
//Algorithme utilise : Tri par selection (pas Dychotomique car certaines structures de controle indisponibles en nwnScript(ex : Do... While)
//struct Tableau MonTableau : Le tableau a trier
//int nNumCol : defini sur quel numero de colonne on trie le tableau
//******************************************************************
//NOTE_1 : On ne peut trier que sur des int (ptet des floats mais pas essaye) donc
//il faut faire attention sur la colonne a trier sinon ca renvoie vide ("").
//NOTE_2 : A preferer au tri par insertion si tableau totalement desordonne
//Retourne le nouveau tableau trié.
struct Tableau Tab_TrieTableauParSelection(struct Tableau MonTableau, int nNumCol);


/////////////////////////////////////////////////////
//*** GESTION EN VARIABLES LOCALES DES TABLEAUX
///////////////////////////////////////////////////

//Enregistre le Tableau MonTableau de nom sVarName sur l'objet oObject.
void SetLocalTableau(object oObject, string sVarName, struct Tableau MonTableau);

//Renvoi une structure Tableau nommee sVarName.
//Retourne une structure vide en cas d'erreur.
struct Tableau GetLocalTableau(object oObject, string sVarName);

//Supprime le tableau de nom sVarName stocke sur oObject.
void DeleteLocalTableau(object oObject, string sVarName);


////////////////////////////////////////////////////
//IMPLEMENTATION DES FONCTIONS & DES PROCEDURES /
//////////////////////////////////////////////////

struct Tableau Tab_CreateTableau(string sData, int nNbCol, int nNbLignes, int nTailleMaxCellule, string sCaractereToComplete)
{
struct Tableau MonTableau; //Declaration de la structure

MonTableau.sData = sData; //La chaine contenant les donnees
MonTableau.nCol = nNbCol; //Le nb de colonnes
MonTableau.nLignes = nNbLignes; //Le nb de lignes
MonTableau.nTailleMaxCellule = nTailleMaxCellule; //Taille max des cellules
MonTableau.sCaractereToComplete = sCaractereToComplete; //Caract. pour completer les cells.

return MonTableau; //On a cree le tableau, et on le retourne
}

//******************************************************************************

string Tab_GetTabCelluleComplete(struct Tableau MonTableau, int nIndiceCol, int nIndiceLigne)
{
string sCellule, sLigne;
int nStart, nCount;
int nLongLigne = MonTableau.nTailleMaxCellule * MonTableau.nCol;

nCount = MonTableau.nTailleMaxCellule;
nStart = (nIndiceCol-1) * nCount;

sLigne = Tab_GetTabLigneComplete(MonTableau, nIndiceLigne);

sCellule = GetSubString(sLigne, nStart, nCount);

return sCellule;
}

//******************************************************************************

string Tab_GetTabLigneComplete(struct Tableau MonTableau, int nIndiceLigne)
{
int nStart, nCount;
int nLongLigne = MonTableau.nTailleMaxCellule * MonTableau.nCol;

nStart = (nIndiceLigne-1) * nLongLigne;

string sLigne = GetSubString(MonTableau.sData, nStart, nLongLigne);

return sLigne;
}

//******************************************************************************

string Tab_GetTabCellule(struct Tableau MonTableau, int nIndiceCol, int nIndiceLigne)
{
string sCellule, sLigne;
int nStart, nCount;
int nLongLigne = MonTableau.nTailleMaxCellule * MonTableau.nCol;

nCount = MonTableau.nTailleMaxCellule;
nStart = (nIndiceCol-1) * nCount;

sLigne = Tab_GetTabLigneComplete(MonTableau, nIndiceLigne);

sCellule = SupprimeUnString(GetSubString(sLigne, nStart, nCount), MonTableau.sCaractereToComplete);

return sCellule;
}

//******************************************************************************

string Tab_GetTableLigne(struct Tableau MonTableau, int nIndiceLigne)
{
int nStart, nCount;
int nLongLigne = MonTableau.nTailleMaxCellule * MonTableau.nCol;

nStart = (nIndiceLigne-1) * nLongLigne;

string sLigne = SupprimeUnString(GetSubString(MonTableau.sData, nStart, nLongLigne), MonTableau.sCaractereToComplete);

return sLigne;
}

//******************************************************************************

struct Tableau Tab_ReplaceLigne(struct Tableau MonTableau, string sLigneToReplace, int nIndiceToReplace)
{
string sDataTab = ReplaceString(MonTableau.sData, sLigneToReplace, nIndiceToReplace);
MonTableau.sData = sDataTab;

return MonTableau;
}

//******************************************************************************

string Tab_SetNewCellule(string sNewLigne, string sNewCellule,
string sCaractereUseToComplete ,int nMaxSize)
{
sNewLigne += CompleteString(sNewCellule, sCaractereUseToComplete, nMaxSize);
return sNewLigne;
}

//******************************************************************************

struct Tableau Tab_SetNewLigne(struct Tableau MonTableau, string sNewLigne)
{
int nNbLignes = MonTableau.nLignes;
nNbLignes++;
MonTableau.nLignes = nNbLignes;

string sDataTab = MonTableau.sData;
sDataTab += sNewLigne;
MonTableau.sData = sDataTab;

return MonTableau;
}

//******************************************************************************

struct Tableau Tab_InsertNewLigne(struct Tableau MonTableau, string sNewLigne, int nIndiceInsertion)
{
int nNbLignes = MonTableau.nLignes;
nNbLignes++;
MonTableau.nLignes = nNbLignes;

int nPosition;
int nLongLigne = MonTableau.nTailleMaxCellule * MonTableau.nCol;

nPosition = (nIndiceInsertion-1) * nLongLigne;

MonTableau.sData = InsertString(MonTableau.sData, sNewLigne, nPosition);

return MonTableau;
}

//******************************************************************************

struct Tableau Tab_DeleteLigne(struct Tableau MonTableau, int nIndiceToDelete)
{
int nLongLigne = MonTableau.nTailleMaxCellule * MonTableau.nCol;
string sDataGauche = "";
string sDataDroite = "";
int nTailleData = GetStringLength(MonTableau.sData);
int nNbPositions = nTailleData / nLongLigne;
int nCountGauche = ((nIndiceToDelete - 1) * nLongLigne);
int nCountDroite = ((nNbPositions - nIndiceToDelete) * nLongLigne);
if (nCountGauche < 0)
{
nCountGauche = 0;
}
if (nCountDroite < 0)
{
nCountDroite = 0;
}

sDataGauche = GetStringLeft(MonTableau.sData, nCountGauche);

sDataDroite = GetStringRight(MonTableau.sData, nCountDroite);

MonTableau.sData = sDataGauche + sDataDroite;

return MonTableau;
}

//******************************************************************************

struct Tableau DecaleTabTriParInsertion(struct Tableau MonTableau, int nPosition, int nIndiceCol)
{
int nDpg = nPosition-1;
struct Tableau WorkingTableau = MonTableau;

string sTamponCellule = Tab_GetTabCelluleComplete(WorkingTableau, nIndiceCol, nPosition);
string sTamponLigne = Tab_GetTabLigneComplete(WorkingTableau, nPosition);

while ( ( StringToInt((Tab_GetTabCelluleComplete(WorkingTableau, nIndiceCol, nDpg))) > StringToInt(sTamponCellule) ) && (nDpg >= 0) )
{
WorkingTableau = Tab_ReplaceLigne(WorkingTableau, (Tab_GetTabLigneComplete(WorkingTableau, nDpg)),(nDpg+1));
nDpg--;
}
WorkingTableau = Tab_ReplaceLigne(WorkingTableau, sTamponLigne, (nDpg+1));
return WorkingTableau;
}

//******************************************************************************

struct Tableau Tab_TrieTableauParInsertion(struct Tableau MonTableau, int nNumCol)
{
struct Tableau WorkingTableau = MonTableau;
int nPosition;
for(nPosition = 1; nPosition < WorkingTableau.nLignes+1; nPosition++)
{
WorkingTableau = DecaleTabTriParInsertion(WorkingTableau, nPosition, nNumCol);
}
return WorkingTableau;
}

//******************************************************************************

struct Tableau EchangeTabTriParSelection(struct Tableau MonTableau, int nI, int nJ, int nIndiceCol)
{
struct Tableau WorkingTableau = MonTableau;
string sTamponCellule = Tab_GetTabCelluleComplete(WorkingTableau, nIndiceCol, nI);
string sTamponLigne = Tab_GetTabLigneComplete(WorkingTableau, nI);

WorkingTableau = Tab_ReplaceLigne(WorkingTableau, (Tab_GetTabLigneComplete(WorkingTableau, nJ)),(nI));
WorkingTableau = Tab_ReplaceLigne(WorkingTableau, sTamponLigne, nJ);

return WorkingTableau;
}
//******************************************************************************

struct Tableau PlusPetitTabTriParSelection(struct Tableau MonTableau, int nPd, int nN, int nIndiceCol)
{
struct Tableau WorkingTableau = MonTableau;

int nI;
int nPp = nPd;

for(nI = nPd+1; nI < nN; nI++)
{
if ( StringToInt(Tab_GetTabCelluleComplete(WorkingTableau, nIndiceCol, nI)) < StringToInt(Tab_GetTabCelluleComplete(WorkingTableau, nIndiceCol, nPp)) )
{
nPp = nI;
}
}

WorkingTableau = EchangeTabTriParSelection(WorkingTableau, nPp, nPd, nIndiceCol);

return WorkingTableau;
}
//******************************************************************************

struct Tableau Tab_TrieTableauParSelection(struct Tableau MonTableau, int nNumCol)
{
struct Tableau WorkingTableau = MonTableau;

int nPd;
int nN = WorkingTableau.nLignes+1;

for(nPd = 1; nPd < (nN-1); nPd++)
{
WorkingTableau = PlusPetitTabTriParSelection(WorkingTableau, nPd, nN, nNumCol);
}

return WorkingTableau;
}

//******************************************************************************

void SetLocalTableau(object oObject, string sVarName, struct Tableau MonTableau)
{
string sDataVarName = sVarName + "String"; //Pour sData
string sLignesVarName = sVarName + "Lignes"; //Pour sLignes
string sColVarName = sVarName + "Col"; //Pour sCol
string sTailleMaxCelluleVarName = sVarName + "TailleMaxCellule"; //Taille maxi de chaque cellule
string sCaractereToCompleteVarName = sVarName + "CaractCompletion";//Caractere de completion

SetLocalString(oObject, sDataVarName, MonTableau.sData);
SetLocalInt(oObject, sLignesVarName, MonTableau.nLignes);
SetLocalInt(oObject, sColVarName, MonTableau.nCol);
SetLocalInt(oObject, sTailleMaxCelluleVarName, MonTableau.nTailleMaxCellule);
SetLocalString(oObject, sCaractereToCompleteVarName, MonTableau.sCaractereToComplete);

}

//******************************************************************************

struct Tableau GetLocalTableau(object oObject, string sVarName)
{
struct Tableau MonTableau;
string sDataVarName = sVarName + "String"; //Pour sData
string sLignesVarName = sVarName + "Lignes"; //Pour sLignes
string sColVarName = sVarName + "Col"; //Pour sCol
string sTailleMaxCelluleVarName = sVarName + "TailleMaxCellule"; //Taille maxi de chaque cellule
string sCaractereToCompleteVarName = sVarName + "CaractCompletion";//Caractere de completion

MonTableau = Tab_CreateTableau(GetLocalString(oObject, sDataVarName),
GetLocalInt(oObject, sColVarName),
GetLocalInt(oObject, sLignesVarName),
GetLocalInt(oObject, sTailleMaxCelluleVarName),
GetLocalString(oObject, sCaractereToCompleteVarName));

return MonTableau;
}

//******************************************************************************

void DeleteLocalTableau(object oObject, string sVarName)
{
string sDataVarName = sVarName + "String"; //Pour sData
string sLignesVarName = sVarName + "Lignes"; //Pour sLignes
string sColVarName = sVarName + "Col"; //Pour sCol
string sTailleMaxCelluleVarName = sVarName + "TailleMaxCellule"; //Taille maxi de chaque cellule
string sCaractereToCompleteVarName = sVarName + "CaractCompletion";//Caractere de completion

DeleteLocalString(oObject, sDataVarName);
DeleteLocalInt(oObject, sLignesVarName);
DeleteLocalInt(oObject, sColVarName);
DeleteLocalInt(oObject, sTailleMaxCelluleVarName);
DeleteLocalString(oObject, sCaractereToCompleteVarName);
}

//******************************************************************************

//void main(){}