diff --git a/boutons.c b/boutons.c
index 892f51e7..f39951f5 100644
--- a/boutons.c
+++ b/boutons.c
@@ -415,7 +415,6 @@ void Bouton_Cacher_menu(void)
 byte Bouton_Quitter_Routine_locale(void)
 {
   short Bouton_clicke;
-  //byte  Enregistrer;
   static char  Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
   byte  Ancienne_forme_curseur;
 
@@ -1254,11 +1253,11 @@ void Bouton_Kill(void)
 
 //------------------------- Dimensions Image/Ecran ---------------------------
 
-void Cocher_bouton_mode(short Pos_X, short Pos_Y, byte Etat)
+void Cocher_bouton_mode(short Pos_X, short Pos_Y, byte state)
 {
   byte Couleur;
 
-  switch (Etat & 0x7F)
+  switch (state & 0x7F)
   {
     case 0 : Couleur=CM_Blanc; break;
     case 1 : Couleur=CM_Clair; break;
@@ -2291,22 +2290,22 @@ void Print_Nom_fichier_dans_selecteur(void)
 int   Type_selectionne; // Utilisé pour mémoriser le type d'entrée choisi
                         // dans le selecteur de fichier.
 
-void Preparer_et_afficher_liste_fichiers(short Position, short Decalage,
-                                         T_Bouton_scroller * Enreg)
+void Preparer_et_afficher_liste_fichiers(short Position, short offset,
+                                         T_Bouton_scroller * button)
 {
-  Enreg->Nb_elements=Liste_Nb_elements;
-  Enreg->Position=Position;
-  Calculer_hauteur_curseur_jauge(Enreg);
-  Fenetre_Dessiner_jauge(Enreg);
+  button->Nb_elements=Liste_Nb_elements;
+  button->Position=Position;
+  Calculer_hauteur_curseur_jauge(button);
+  Fenetre_Dessiner_jauge(button);
   // On efface les anciens noms de fichier:
   Block(Fenetre_Pos_X+(Menu_Facteur_X<<3),Fenetre_Pos_Y+(Menu_Facteur_Y*(89+FILENAMESPACE)),Menu_Facteur_X*98,Menu_Facteur_Y*82,CM_Noir);
   // On affiche les nouveaux:
-  Afficher_la_liste_des_fichiers(Position,Decalage);
+  Afficher_la_liste_des_fichiers(Position,offset);
 
   UpdateRect(Fenetre_Pos_X+(Menu_Facteur_X<<3),Fenetre_Pos_Y+(Menu_Facteur_Y*(89+FILENAMESPACE)),Menu_Facteur_X*98,Menu_Facteur_Y*82);
 
   // On récupère le nom du schmilblick à "accéder"
-  Determiner_element_de_la_liste(Position,Decalage,Principal_Nom_fichier,&Type_selectionne);
+  Determiner_element_de_la_liste(Position,offset,Principal_Nom_fichier,&Type_selectionne);
   // On affiche le nouveau nom de fichier
   Print_Nom_fichier_dans_selecteur();
   // On affiche le nom du répertoire courant
@@ -2314,12 +2313,12 @@ void Preparer_et_afficher_liste_fichiers(short Position, short Decalage,
 }
 
 
-void Relire_liste_fichiers(byte Filtre, short Position, short Decalage,
-                           T_Bouton_scroller * Enreg)
+void Relire_liste_fichiers(byte Filtre, short Position, short offset,
+                           T_Bouton_scroller * button)
 {
   Lire_liste_des_fichiers(Filtre);
   Trier_la_liste_des_fichiers();
-  Preparer_et_afficher_liste_fichiers(Position,Decalage,Enreg);
+  Preparer_et_afficher_liste_fichiers(Position,offset,button);
 }
 
 void On_vient_de_scroller_dans_le_fileselect(T_Bouton_scroller * Scroller_de_fichiers)
@@ -5603,13 +5602,13 @@ void Afficher_sprite_effet(short Numero_sprite, short Debut_X, short Debut_Y)
 }
 
 
-void Afficher_etat_effet(short X, short Y, char * Libelle, byte Etat)
+void Afficher_etat_effet(short X, short Y, char * Libelle, byte state)
 {
   Block(Fenetre_Pos_X+(X*Menu_Facteur_X),Fenetre_Pos_Y+(Y*Menu_Facteur_Y),
         12*Menu_Facteur_X,Menu_Facteur_Y<<3,CM_Clair);
 
-  Print_dans_fenetre(X,Y,Libelle,(Etat)?CM_Blanc:CM_Noir,CM_Clair);
-  if (Etat)
+  Print_dans_fenetre(X,Y,Libelle,(state)?CM_Blanc:CM_Noir,CM_Clair);
+  if (state)
     Print_dans_fenetre(X+56,Y,":ON ",CM_Blanc,CM_Clair);
   else
     Print_dans_fenetre(X+56,Y,":OFF",CM_Noir,CM_Clair);
diff --git a/brush.c b/brush.c
index c6715758..8cbb66c5 100644
--- a/brush.c
+++ b/brush.c
@@ -608,7 +608,7 @@ void Effacer_pinceau(short X,short Y)
 
 
 
-void Capturer_brosse(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y,short Effacement)
+void Capturer_brosse(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y,short clear)
 {
   short Temporaire;
   short Pos_X;
@@ -691,7 +691,7 @@ void Capturer_brosse(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y,short E
     Copier_image_dans_brosse(Debut_X,Debut_Y,Brosse_Largeur,Brosse_Hauteur,Principal_Largeur_image);
 
     // On regarde s'il faut effacer quelque chose:
-    if (Effacement)
+    if (clear)
     {
       for (Pos_Y=Debut_Y;Pos_Y<Debut_Y+Brosse_Hauteur;Pos_Y++)
         for (Pos_X=Debut_X;Pos_X<Debut_X+Brosse_Largeur;Pos_X++)
@@ -791,7 +791,7 @@ void Remap_brosse(void)
 void Outline_brush(void)
 {
   long /*Pos,*/Pos_X,Pos_Y;
-  byte Etat;
+  byte state;
   byte * Nouvelle_brosse;
   byte * Temporaire;
   word Largeur;
@@ -831,56 +831,56 @@ void Outline_brush(void)
       // 1er balayage (horizontal)
       for (Pos_Y=1; Pos_Y<Brosse_Hauteur-1; Pos_Y++)
       {
-        Etat=0;
+        state=0;
         for (Pos_X=1; Pos_X<Brosse_Largeur-1; Pos_X++)
         {
           if (Temporaire[((Pos_Y-1)*Largeur)+Pos_X-1]==Back_color)
           {
-            if (Etat)
+            if (state)
             {
               Pixel_dans_brosse(Pos_X,Pos_Y,Fore_color);
-              Etat=0;
+              state=0;
             }
           }
           else
           {
-            if (!Etat)
+            if (!state)
             {
               Pixel_dans_brosse(Pos_X-1,Pos_Y,Fore_color);
-              Etat=1;
+              state=1;
             }
           }
         }
         // Cas du dernier pixel à droite de la ligne
-        if (Etat)
+        if (state)
           Pixel_dans_brosse(Pos_X,Pos_Y,Fore_color);
       }
 
       // 2ème balayage (vertical)
       for (Pos_X=1; Pos_X<Brosse_Largeur-1; Pos_X++)
       {
-        Etat=0;
+        state=0;
         for (Pos_Y=1; Pos_Y<Brosse_Hauteur-1; Pos_Y++)
         {
           if (Temporaire[((Pos_Y-1)*Largeur)+Pos_X-1]==Back_color)
           {
-            if (Etat)
+            if (state)
             {
               Pixel_dans_brosse(Pos_X,Pos_Y,Fore_color);
-              Etat=0;
+              state=0;
             }
           }
           else
           {
-            if (!Etat)
+            if (!state)
             {
               Pixel_dans_brosse(Pos_X,Pos_Y-1,Fore_color);
-              Etat=1;
+              state=1;
             }
           }
         }
         // Cas du dernier pixel en bas de la colonne
-        if (Etat)
+        if (state)
           Pixel_dans_brosse(Pos_X,Pos_Y,Fore_color);
       }
     }
@@ -905,7 +905,7 @@ void Outline_brush(void)
 void Nibble_brush(void)
 {
   long /*Pos,*/Pos_X,Pos_Y;
-  byte Etat;
+  byte state;
   byte * Nouvelle_brosse;
   byte * Temporaire;
   word Largeur;
@@ -942,24 +942,24 @@ void Nibble_brush(void)
       // 1er balayage (horizontal)
       for (Pos_Y=0; Pos_Y<Brosse_Hauteur; Pos_Y++)
       {
-        Etat=(Temporaire[(Pos_Y+1)*Largeur]!=Back_color);
+        state=(Temporaire[(Pos_Y+1)*Largeur]!=Back_color);
         for (Pos_X=0; Pos_X<Brosse_Largeur; Pos_X++)
         {
           if (Temporaire[((Pos_Y+1)*Largeur)+Pos_X+1]==Back_color)
           {
-            if (Etat)
+            if (state)
             {
               if (Pos_X>0)
                 Pixel_dans_brosse(Pos_X-1,Pos_Y,Back_color);
-              Etat=0;
+              state=0;
             }
           }
           else
           {
-            if (!Etat)
+            if (!state)
             {
               Pixel_dans_brosse(Pos_X,Pos_Y,Back_color);
-              Etat=1;
+              state=1;
             }
           }
         }
@@ -971,24 +971,24 @@ void Nibble_brush(void)
       // 2ème balayage (vertical)
       for (Pos_X=0; Pos_X<Brosse_Largeur; Pos_X++)
       {
-        Etat=(Temporaire[Largeur+Pos_X+1]!=Back_color);;
+        state=(Temporaire[Largeur+Pos_X+1]!=Back_color);;
         for (Pos_Y=0; Pos_Y<Brosse_Hauteur; Pos_Y++)
         {
           if (Temporaire[((Pos_Y+1)*Largeur)+Pos_X+1]==Back_color)
           {
-            if (Etat)
+            if (state)
             {
               if (Pos_Y>0)
                 Pixel_dans_brosse(Pos_X,Pos_Y-1,Back_color);
-              Etat=0;
+              state=0;
             }
           }
           else
           {
-            if (!Etat)
+            if (!state)
             {
               Pixel_dans_brosse(Pos_X,Pos_Y,Back_color);
-              Etat=1;
+              state=1;
             }
           }
         }
@@ -1016,7 +1016,7 @@ void Nibble_brush(void)
 
 
 
-void Capturer_brosse_au_lasso(int Vertices, short * Points,short Effacement)
+void Capturer_brosse_au_lasso(int Vertices, short * Points,short clear)
 {
   short Debut_X=Limite_Droite+1;
   short Debut_Y=Limite_Bas+1;
@@ -1132,7 +1132,7 @@ void Capturer_brosse_au_lasso(int Vertices, short * Points,short Effacement)
         {
           Pixel_dans_brosse(Pos_X-Debut_X,Pos_Y-Debut_Y,Lit_pixel_dans_ecran_courant(Pos_X,Pos_Y));
           // On regarde s'il faut effacer quelque chose:
-          if (Effacement)
+          if (clear)
             Pixel_dans_ecran_courant(Pos_X,Pos_Y,Back_color);
         }
 
diff --git a/brush.h b/brush.h
index 6a74b0d2..0e1b57f8 100644
--- a/brush.h
+++ b/brush.h
@@ -30,7 +30,7 @@
     @param Fin_Y bottom edge coordinate in the picture
     @param effacement If 1, the area is also cleared from the picture.
 */
-void Capturer_brosse(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y,short Effacement);
+void Capturer_brosse(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y,short clear);
 
 /*!
   Rotates the brush to the right.
@@ -86,8 +86,8 @@ void Nibble_brush(void);
     Get brush from picture according to a freehand form.
     @param Vertices number of points in the freehand form
     @param Points array of points coordinates
-    @param Effacement If set to 1, the captured area is also cleared from the picture.
+    @param clear If set to 1, the captured area is also cleared from the picture.
 */
-void Capturer_brosse_au_lasso(int Vertices, short * Points,short Effacement);
+void Capturer_brosse_au_lasso(int Vertices, short * Points,short clear);
 
 #endif
diff --git a/divers.c b/divers.c
index c1d4cd74..6fb195da 100644
--- a/divers.c
+++ b/divers.c
@@ -221,13 +221,13 @@ byte Pixel_dans_cercle(void)
         return 0;
 }
 
-void Copier_une_partie_d_image_dans_une_autre(byte * Source,word S_Pos_X,word S_Pos_Y,word Largeur,word Hauteur,word Largeur_source,byte * Destination,word D_Pos_X,word D_Pos_Y,word Largeur_destination)
+void Copier_une_partie_d_image_dans_une_autre(byte * Source,word S_Pos_X,word S_Pos_Y,word Largeur,word Hauteur,word Largeur_source,byte * dest,word D_Pos_X,word D_Pos_Y,word Largeur_destination)
 {
         // ESI = adresse de la source en (S_Pox_X,S_Pos_Y)
         byte* esi = Source + S_Pos_Y * Largeur_source + S_Pos_X;
 
         // EDI = adresse de la destination (D_Pos_X,D_Pos_Y)
-        byte* edi = Destination + D_Pos_Y * Largeur_destination + D_Pos_X;
+        byte* edi = dest + D_Pos_Y * Largeur_destination + D_Pos_X;
 
         int Ligne;
 
@@ -249,7 +249,7 @@ byte Lit_pixel_dans_ecran_brouillon(word X,word Y)
   return *(Brouillon_Ecran+Y*Brouillon_Largeur_image+X);
 }
 
-void Rotate_90_deg_LOWLEVEL(byte * Source,byte * Destination)
+void Rotate_90_deg_LOWLEVEL(byte * Source,byte * dest)
 {
   byte* esi;
   byte* edi;
@@ -257,7 +257,7 @@ void Rotate_90_deg_LOWLEVEL(byte * Source,byte * Destination)
 
   //ESI = Point haut droit de la source
   byte* Debut_de_colonne = Source + Brosse_Largeur - 1;
-  edi = Destination;
+  edi = dest;
 
   // Largeur de la source = Hauteur de la destination
   dx = bx = Brosse_Largeur;
@@ -554,39 +554,39 @@ void Rotate_180_deg_LOWLEVEL(void)
 void Tempo_jauge(byte Vitesse)
 //Boucle d'attente pour faire bouger les scrollbars à une vitesse correcte
 {
-  Uint32 Fin;
+  Uint32 end;
   byte MouseK_Original = Mouse_K;
-  Fin = SDL_GetTicks() + Vitesse*10;
+  end = SDL_GetTicks() + Vitesse*10;
   do
   {
     if (!Get_input()) Wait_VBL();
-  } while (Mouse_K == MouseK_Original && SDL_GetTicks()<Fin);
+  } while (Mouse_K == MouseK_Original && SDL_GetTicks()<end);
 }
 
-void Scroll_picture(short Decalage_X,short Decalage_Y)
+void Scroll_picture(short x_offset,short y_offset)
 {
   byte* esi = Ecran_backup; //Source de la copie
-  byte* edi = Principal_Ecran + Decalage_Y * Principal_Largeur_image + Decalage_X;
-  const word ax = Principal_Largeur_image - Decalage_X; // Nombre de pixels à copier à droite
+  byte* edi = Principal_Ecran + y_offset * Principal_Largeur_image + x_offset;
+  const word ax = Principal_Largeur_image - x_offset; // Nombre de pixels à copier à droite
   word dx;
-  for(dx = Principal_Hauteur_image - Decalage_Y;dx>0;dx--)
+  for(dx = Principal_Hauteur_image - y_offset;dx>0;dx--)
   {
   // Pour chaque ligne
     memcpy(edi,esi,ax);
-    memcpy(edi - Decalage_X,esi+ax,Decalage_X);
+    memcpy(edi - x_offset,esi+ax,x_offset);
 
     // On passe à la ligne suivante
     edi += Principal_Largeur_image;
     esi += Principal_Largeur_image;
   }
 
-  // On vient de faire le traitement pour otutes les lignes au-dessous de Decalage_Y
+  // On vient de faire le traitement pour otutes les lignes au-dessous de y_offset
   // Maintenant on traite celles au dessus
-  edi = Decalage_X + Principal_Ecran;
-  for(dx = Decalage_Y;dx>0;dx--)
+  edi = x_offset + Principal_Ecran;
+  for(dx = y_offset;dx>0;dx--)
   {
     memcpy(edi,esi,ax);
-    memcpy(edi - Decalage_X,esi+ax,Decalage_X);
+    memcpy(edi - x_offset,esi+ax,x_offset);
 
     edi += Principal_Largeur_image;
     esi += Principal_Largeur_image;
@@ -596,7 +596,7 @@ void Scroll_picture(short Decalage_X,short Decalage_Y)
 }
 
 void Zoomer_une_ligne(byte* Ligne_originale, byte* Ligne_zoomee,
-        word Facteur, word Largeur
+        word factor, word Largeur
 )
 {
         byte color;
@@ -606,8 +606,8 @@ void Zoomer_une_ligne(byte* Ligne_originale, byte* Ligne_zoomee,
         for(X=0;X<Largeur;X++){
                 color = *Ligne_originale;
 
-                memset(Ligne_zoomee,color,Facteur);
-                Ligne_zoomee+=Facteur;
+                memset(Ligne_zoomee,color,factor);
+                Ligne_zoomee+=factor;
 
                 Ligne_originale++;
         }
diff --git a/divers.h b/divers.h
index 1d2e4697..19f7ecca 100644
--- a/divers.h
+++ b/divers.h
@@ -23,7 +23,7 @@ void Copier_ecran_sur_brouillon(void);
 void Copier_image_dans_brosse(short Debut_X,short Debut_Y,short Brosse_Largeur,short Brosse_Hauteur,word Largeur_image);
 void Permuter_dans_l_image_les_couleurs(byte Couleur_1,byte Couleur_2);
 void Remap_general_LOWLEVEL(byte * Table_conv,byte * Buffer,short Largeur,short Hauteur,short Largeur_buffer);
-void Scroll_picture(short Decalage_X,short Decalage_Y);
+void Scroll_picture(short x_offset,short y_offset);
 void Set_mouse_video_mode_number(void);
 void Set_mouse_position(void);
 void Attendre_fin_de_click(void);
@@ -84,10 +84,10 @@ byte Effet_Trame(word X,word Y);
 
 void Flip_Y_LOWLEVEL(void);
 void Flip_X_LOWLEVEL(void);
-void Rotate_90_deg_LOWLEVEL(byte * Source,byte * Destination);
+void Rotate_90_deg_LOWLEVEL(byte * Source,byte * dest);
 void Rotate_180_deg_LOWLEVEL(void);
-void Zoomer_une_ligne(byte * Ligne_originale,byte * Ligne_zoomee,word Facteur,word Largeur);
-void Copier_une_partie_d_image_dans_une_autre(byte * Source,word S_Pos_X,word S_Pos_Y,word Largeur,word Hauteur,word Largeur_source,byte * Destination,word D_Pos_X,word D_Pos_Y,word Largeur_destination);
+void Zoomer_une_ligne(byte * Ligne_originale,byte * Ligne_zoomee,word factor,word Largeur);
+void Copier_une_partie_d_image_dans_une_autre(byte * Source,word S_Pos_X,word S_Pos_Y,word Largeur,word Hauteur,word Largeur_source,byte * dest,word D_Pos_X,word D_Pos_Y,word Largeur_destination);
 
 // -- Gestion du chrono --
 byte Etat_chrono; // Etat du chrono: 0=Attente d'un Xème de seconde
diff --git a/files.c b/files.c
index 360ddbe8..31cff982 100644
--- a/files.c
+++ b/files.c
@@ -32,14 +32,14 @@
 #if defined(__amigaos4__) || defined(__AROS__) || defined(__MORPHOS__)
     #include <proto/dos.h>
     #include <dirent.h>
-    #define isHidden(Enreg) (0)
+    #define isHidden(x) (0)
 #elif defined(__WIN32__)
     #include <dirent.h>
     #include <windows.h>
-    #define isHidden(Enreg) (GetFileAttributesA((Enreg)->d_name)&FILE_ATTRIBUTE_HIDDEN)
+    #define isHidden(x) (GetFileAttributesA((x)->d_name)&FILE_ATTRIBUTE_HIDDEN)
 #else
     #include <dirent.h>
-    #define isHidden(Enreg) ((Enreg)->d_name[0]=='.')
+    #define isHidden(x) ((x)->d_name[0]=='.')
 #endif
 
 #include "const.h"
@@ -209,7 +209,7 @@ void Lire_liste_des_fichiers(byte Format_demande)
 // correspond au format demandé.
 {
   DIR*  Repertoire_Courant; //Répertoire courant
-  struct dirent* Enreg; // Structure de lecture des éléments
+  struct dirent* entry; // Structure de lecture des éléments
   char * Filtre = "*"; // Extension demandée
   struct stat Infos_enreg;
   char * Chemin_courant;
@@ -227,34 +227,34 @@ void Lire_liste_des_fichiers(byte Format_demande)
   // On lit tous les répertoires:
   Chemin_courant=getcwd(NULL,0);
   Repertoire_Courant=opendir(Chemin_courant);
-  while ((Enreg=readdir(Repertoire_Courant)))
+  while ((entry=readdir(Repertoire_Courant)))
   {
     // On ignore le répertoire courant
-    if ( !strcmp(Enreg->d_name, "."))
+    if ( !strcmp(entry->d_name, "."))
     {
       continue;
     }
-    stat(Enreg->d_name,&Infos_enreg);
+    stat(entry->d_name,&Infos_enreg);
     // et que l'élément trouvé est un répertoire
     if( S_ISDIR(Infos_enreg.st_mode) &&
       // et que c'est ".."
-      (!strcmp(Enreg->d_name, PARENT_DIR) ||
+      (!strcmp(entry->d_name, PARENT_DIR) ||
       // ou qu'il n'est pas caché
        Config.Lire_les_repertoires_caches ||
-     !isHidden(Enreg)))
+     !isHidden(entry)))
     {
       // On rajoute le répertoire à la liste
-      Ajouter_element_a_la_liste(Enreg->d_name, 1);
+      Ajouter_element_a_la_liste(entry->d_name, 1);
       Liste_Nb_repertoires++;
     }
     else if (S_ISREG(Infos_enreg.st_mode) && //Il s'agit d'un fichier
       (Config.Lire_les_fichiers_caches || //Il n'est pas caché
-      !isHidden(Enreg)))
+      !isHidden(entry)))
     {
-      if (VerifieExtension(Enreg->d_name, Filtre))
+      if (VerifieExtension(entry->d_name, Filtre))
       {
         // On rajoute le fichier à la liste
-        Ajouter_element_a_la_liste(Enreg->d_name, 0);
+        Ajouter_element_a_la_liste(entry->d_name, 0);
         Liste_Nb_fichiers++;
       }
     }
@@ -746,7 +746,7 @@ void for_each_file(const char * Nom_repertoire, void Callback(const char *))
 {
   // Pour scan de répertoire
   DIR*  Repertoire_Courant; //Répertoire courant
-  struct dirent* Enreg; // Structure de lecture des éléments
+  struct dirent* entry; // Structure de lecture des éléments
   char Nom_fichier_complet[TAILLE_CHEMIN_FICHIER];
   int Position_nom_fichier;
   strcpy(Nom_fichier_complet, Nom_repertoire);
@@ -754,10 +754,10 @@ void for_each_file(const char * Nom_repertoire, void Callback(const char *))
   if(Repertoire_Courant == NULL) return;        // Répertoire invalide ...
   strcat(Nom_fichier_complet, SEPARATEUR_CHEMIN);
   Position_nom_fichier = strlen(Nom_fichier_complet);
-  while ((Enreg=readdir(Repertoire_Courant)))
+  while ((entry=readdir(Repertoire_Courant)))
   {
     struct stat Infos_enreg;
-    strcpy(&Nom_fichier_complet[Position_nom_fichier], Enreg->d_name);
+    strcpy(&Nom_fichier_complet[Position_nom_fichier], entry->d_name);
     stat(Nom_fichier_complet,&Infos_enreg);
     if (S_ISREG(Infos_enreg.st_mode))
     {
diff --git a/graph.c b/graph.c
index 7d1fa61e..decd7ebd 100644
--- a/graph.c
+++ b/graph.c
@@ -185,7 +185,7 @@ int Initialiser_mode_video(int Largeur, int Hauteur, int Fullscreen)
   int Sensibilite_X;
   int Sensibilite_Y;
   int Indice;
-  int Facteur;
+  int factor;
 
   // Pour la première entrée dans cette fonction
   if (Pixel_width<1)
@@ -322,20 +322,20 @@ int Initialiser_mode_video(int Largeur, int Hauteur, int Fullscreen)
 
     // Taille des menus
     if (Largeur_ecran/320 > Hauteur_ecran/200)
-      Facteur=Hauteur_ecran/200;
+      factor=Hauteur_ecran/200;
     else
-      Facteur=Largeur_ecran/320;
+      factor=Largeur_ecran/320;
 
     switch (Config.Ratio)
     {
       case 1: // adapter tout
-        Menu_Facteur_X=Facteur;
-        Menu_Facteur_Y=Facteur;
+        Menu_Facteur_X=factor;
+        Menu_Facteur_Y=factor;
         break;
       case 2: // adapter légèrement
-        Menu_Facteur_X=Facteur-1;
+        Menu_Facteur_X=factor-1;
         if (Menu_Facteur_X<1) Menu_Facteur_X=1;
-        Menu_Facteur_Y=Facteur-1;
+        Menu_Facteur_Y=factor-1;
         if (Menu_Facteur_Y<1) Menu_Facteur_Y=1;
         break;
       default: // ne pas adapter
@@ -723,7 +723,7 @@ void Fill(short * Limite_atteinte_Haut  , short * Limite_atteinte_Bas,
   *Limite_atteinte_Haut=Limite_courante_Haut;
   *Limite_atteinte_Bas =Limite_courante_Bas;
   (*Limite_atteinte_Droite)--;
-} // Fin de la routine de remplissage "Fill"
+} // end de la routine de remplissage "Fill"
 
 
 void Remplir(byte Couleur_de_remplissage)
@@ -1467,7 +1467,7 @@ void Tracer_courbe_General(short X1, short Y1,
                            short X4, short Y4,
                            byte Couleur)
 {
-  float Delta,t,t2,t3;
+  float delta,t,t2,t3;
   short X,Y,Old_X,Old_Y;
   word  i;
   int   CX[4];
@@ -1487,11 +1487,11 @@ void Tracer_courbe_General(short X1, short Y1,
   Old_X=X1;
   Old_Y=Y1;
   Pixel_figure(Old_X,Old_Y,Couleur);
-  Delta=0.05; // 1.0/20
+  delta=0.05; // 1.0/20
   t=0;
   for (i=1; i<=20; i++)
   {
-    t=t+Delta; t2=t*t; t3=t2*t;
+    t=t+delta; t2=t*t; t3=t2*t;
     X=Round(t3*CX[0] + t2*CX[1] + t*CX[2] + CX[3]);
     Y=Round(t3*CY[0] + t2*CY[1] + t*CY[2] + CY[3]);
     Tracer_ligne_General(Old_X,Old_Y,X,Y,Couleur);
@@ -2279,7 +2279,7 @@ void Liste2tables(word * Liste,short Pas,byte Mode,byte * Table_inc,byte * Table
 {
   int Indice;
   int Premier;
-  int Dernier;
+  int last;
   int Couleur;
   int Temp;
 
@@ -2302,7 +2302,7 @@ void Liste2tables(word * Liste,short Pas,byte Mode,byte * Table_inc,byte * Table
     Premier=Indice;
 
     // On recherche la position de la dernière case de la séquence
-    for (Dernier=Premier;Liste[Dernier+1]<256;Dernier++);
+    for (last=Premier;Liste[last+1]<256;last++);
 
     // Pour toutes les cases non vides (et non inhibées) qui suivent
     switch (Mode)
@@ -2311,12 +2311,12 @@ void Liste2tables(word * Liste,short Pas,byte Mode,byte * Table_inc,byte * Table
         for (;(Indice<512) && (Liste[Indice]<256);Indice++)
         { // On met à jour les tables de conversion
           Couleur=Liste[Indice];
-          Table_inc[Couleur]=Liste[(Indice+Pas<=Dernier)?Indice+Pas:Dernier];
+          Table_inc[Couleur]=Liste[(Indice+Pas<=last)?Indice+Pas:last];
           Table_dec[Couleur]=Liste[(Indice-Pas>=Premier)?Indice-Pas:Premier];
         }
         break;
       case MODE_SHADE_BOUCLE :
-        Temp=1+Dernier-Premier;
+        Temp=1+last-Premier;
         for (;(Indice<512) && (Liste[Indice]<256);Indice++)
         { // On met à jour les tables de conversion
           Couleur=Liste[Indice];
@@ -2328,7 +2328,7 @@ void Liste2tables(word * Liste,short Pas,byte Mode,byte * Table_inc,byte * Table
         for (;(Indice<512) && (Liste[Indice]<256);Indice++)
         { // On met à jour les tables de conversion
           Couleur=Liste[Indice];
-          if (Indice+Pas<=Dernier)
+          if (Indice+Pas<=last)
             Table_inc[Couleur]=Liste[Indice+Pas];
           if (Indice-Pas>=Premier)
             Table_dec[Couleur]=Liste[Indice-Pas];
@@ -2383,41 +2383,41 @@ byte Effet_Quick_shade(word X,word Y,byte Couleur)
 {
   int color=Couleur=Lit_pixel_dans_ecran_feedback(X,Y);
   int Sens=(Fore_color<=Back_color);
-  byte Debut,Fin;
+  byte start,end;
   int Largeur;
 
   if (Sens)
   {
-    Debut=Fore_color;
-    Fin  =Back_color;
+    start=Fore_color;
+    end  =Back_color;
   }
   else
   {
-    Debut=Back_color;
-    Fin  =Fore_color;
+    start=Back_color;
+    end  =Fore_color;
   }
 
-  if ((color>=Debut) && (color<=Fin) && (Debut!=Fin))
+  if ((color>=start) && (color<=end) && (start!=end))
   {
-    Largeur=1+Fin-Debut;
+    Largeur=1+end-start;
 
     if ( ((Shade_Table==Shade_Table_gauche) && Sens) || ((Shade_Table==Shade_Table_droite) && (!Sens)) )
       color-=Quick_shade_Step%Largeur;
     else
       color+=Quick_shade_Step%Largeur;
 
-    if (color<Debut)
+    if (color<start)
       switch (Quick_shade_Loop)
       {
-        case MODE_SHADE_NORMAL : return Debut;
+        case MODE_SHADE_NORMAL : return start;
         case MODE_SHADE_BOUCLE : return (Largeur+color);
         default : return Couleur;
       }
 
-    if (color>Fin)
+    if (color>end)
       switch (Quick_shade_Loop)
       {
-        case MODE_SHADE_NORMAL : return Fin;
+        case MODE_SHADE_NORMAL : return end;
         case MODE_SHADE_BOUCLE : return (color-Largeur);
         default : return Couleur;
       }
diff --git a/init.c b/init.c
index 7f527a4f..0579fe83 100644
--- a/init.c
+++ b/init.c
@@ -746,15 +746,15 @@ void Rien_du_tout(void)
   // Initialiseur d'un bouton:
 
 void Initialiser_bouton(byte   Numero,
-                        word   Decalage_X      , word   Decalage_Y,
+                        word   x_offset      , word   y_offset,
                         word   Largeur         , word   Hauteur,
                         byte   Forme,
                         fonction_action Gauche , fonction_action Droite,
                         fonction_action Desenclencher,
                         byte   Famille)
 {
-  Bouton[Numero].Decalage_X      =Decalage_X;
-  Bouton[Numero].Decalage_Y      =Decalage_Y;
+  Bouton[Numero].Decalage_X      =x_offset;
+  Bouton[Numero].Decalage_Y      =y_offset;
   Bouton[Numero].Largeur         =Largeur-1;
   Bouton[Numero].Hauteur         =Hauteur-1;
   Bouton[Numero].Enfonce         =0;
diff --git a/io.c b/io.c
index 9edb6838..5f6147b9 100644
--- a/io.c
+++ b/io.c
@@ -182,26 +182,26 @@ char * Position_dernier_slash(const char * Chaine)
   return (char *)Position;
 }
 // Récupère la partie "nom de fichier seul" d'un chemin
-void Extraire_nom_fichier(char *Destination, const char *Source)
+void Extraire_nom_fichier(char *dest, const char *Source)
 {
   const char * Position = Position_dernier_slash(Source);
 
   if (Position)
-    strcpy(Destination,Position+1);
+    strcpy(dest,Position+1);
   else
-    strcpy(Destination,Source);
+    strcpy(dest,Source);
 }
 // Récupère la partie "répertoire+/" d'un chemin.
-void Extraire_chemin(char *Destination, const char *Source)
+void Extraire_chemin(char *dest, const char *Source)
 {
   char * Position;
 
-  strcpy(Destination,Source);
-  Position = Position_dernier_slash(Destination);
+  strcpy(dest,Source);
+  Position = Position_dernier_slash(dest);
   if (Position)
     *(Position+1) = '\0';
   else
-    strcat(Destination, SEPARATEUR_CHEMIN);
+    strcat(dest, SEPARATEUR_CHEMIN);
 }
 
 int Fichier_existe(char * Fichier)
@@ -222,7 +222,7 @@ int Repertoire_existe(char * Repertoire)
 //   Détermine si un répertoire passé en paramètre existe ou non dans le
 // répertoire courant.
 {
-  DIR* Enreg;    // Structure de lecture des éléments
+  DIR* entry;    // Structure de lecture des éléments
 
   if (strcmp(Repertoire,PARENT_DIR)==0)
     return 1;
@@ -231,12 +231,12 @@ int Repertoire_existe(char * Repertoire)
     //  On va chercher si le répertoire existe à l'aide d'un Opendir. S'il
     //  renvoie NULL c'est que le répertoire n'est pas accessible...
 
-    Enreg=opendir(Repertoire);
-    if (Enreg==NULL)
+    entry=opendir(Repertoire);
+    if (entry==NULL)
         return 0;
     else
     {
-        closedir(Enreg);
+        closedir(entry);
         return 1;
     }
   }
diff --git a/io.h b/io.h
index 3ad475da..ea72b5d5 100644
--- a/io.h
+++ b/io.h
@@ -38,8 +38,8 @@ int write_word_be(FILE *Fichier, word w);
 int read_dword_be(FILE *Fichier, dword *Dest);
 int write_dword_be(FILE *Fichier, dword dw);
 
-void Extraire_nom_fichier(char *Destination, const char *Source);
-void Extraire_chemin(char *Destination, const char *Source);
+void Extraire_nom_fichier(char *dest, const char *Source);
+void Extraire_chemin(char *dest, const char *Source);
 
 char * Position_dernier_slash(const char * Chaine);
 
diff --git a/loadsave.c b/loadsave.c
index 4416e4e3..255aa69d 100644
--- a/loadsave.c
+++ b/loadsave.c
@@ -3597,17 +3597,17 @@ void Test_PCX(void)
 // -- Lire un fichier au format PCX -----------------------------------------
 
   // -- Afficher une ligne PCX codée sur 1 seul plan avec moins de 256 c. --
-  void Draw_PCX_line(short Pos_Y, byte Depth)
+  void Draw_PCX_line(short Pos_Y, byte depth)
   {
     short Pos_X;
     byte  Couleur;
-    byte  Reduction=8/Depth;
-    byte  Masque=(1<<Depth)-1;
+    byte  Reduction=8/depth;
+    byte  Masque=(1<<depth)-1;
     byte  Reduction_moins_1=Reduction-1;
 
     for (Pos_X=0; Pos_X<Principal_Largeur_image; Pos_X++)
     {
-      Couleur=(LBM_Buffer[Pos_X/Reduction]>>((Reduction_moins_1-(Pos_X%Reduction))*Depth)) & Masque;
+      Couleur=(LBM_Buffer[Pos_X/Reduction]>>((Reduction_moins_1-(Pos_X%Reduction))*depth)) & Masque;
       Pixel_de_chargement(Pos_X,Pos_Y,Couleur);
     }
   }
diff --git a/moteur.c b/moteur.c
index cb11698c..25c5284e 100644
--- a/moteur.c
+++ b/moteur.c
@@ -213,7 +213,7 @@ int Numero_bouton_sous_souris(void)
 }
 
 
-void Tracer_cadre_de_bouton_du_menu(byte Numero,byte Enfonce)
+void Tracer_cadre_de_bouton_du_menu(byte Numero,byte pressed)
 {
   byte Couleur_Haut_gauche;
   byte Couleur_Bas_droite;
@@ -230,7 +230,7 @@ void Tracer_cadre_de_bouton_du_menu(byte Numero,byte Enfonce)
   Fin_X  =Debut_X+Bouton[Numero].Largeur;
   Fin_Y  =Debut_Y+Bouton[Numero].Hauteur;
 
-  if (!Enfonce)
+  if (!pressed)
   {
     Couleur_Haut_gauche=CM_Blanc;
     Couleur_Bas_droite=CM_Fonce;
@@ -442,7 +442,7 @@ void Deplacer_Split(void)
 {
   short Ancien_Split=Principal_Split;
   short Ancien_X_Zoom=Principal_X_Zoom;
-  short Decalage=Principal_X_Zoom-Mouse_X;
+  short offset=Principal_X_Zoom-Mouse_X;
   byte  Ancienne_forme_curseur=Forme_curseur;
   short Ancien_Mouse_X=-1;
 
@@ -460,7 +460,7 @@ void Deplacer_Split(void)
     if (Mouse_X!=Ancien_Mouse_X)
     {
       Ancien_Mouse_X=Mouse_X;
-      Principal_Proportion_split=(float)(Mouse_X+Decalage)/Largeur_ecran;
+      Principal_Proportion_split=(float)(Mouse_X+offset)/Largeur_ecran;
       Calculer_split();
   
       if (Principal_X_Zoom!=Ancien_X_Zoom)
@@ -1310,7 +1310,7 @@ void Fenetre_Effacer_tags(void)
 
 
 // ---- Tracer les TAGs sur les palettes du menu Palette ou du menu Shade ----
-void Tagger_intervalle_palette(byte Debut,byte Fin)
+void Tagger_intervalle_palette(byte start,byte end)
 {
   word Origine_X;
   word Origine_Y;
@@ -1321,33 +1321,33 @@ void Tagger_intervalle_palette(byte Debut,byte Fin)
   word Indice;
 
   // On efface les anciens TAGs
-  for (Indice=0;Indice<=Debut;Indice++)
+  for (Indice=0;Indice<=start;Indice++)
     Block(Fenetre_Pos_X+(Fenetre_Liste_boutons_palette->Pos_X+3+((Indice>>4)*10))*Menu_Facteur_X,
           Fenetre_Pos_Y+(Fenetre_Liste_boutons_palette->Pos_Y+3+((Indice&15)* 5))*Menu_Facteur_Y,
           Menu_Facteur_X*3,Menu_Facteur_Y*5,CM_Clair);
 
-  for (Indice=Fin;Indice<256;Indice++)
+  for (Indice=end;Indice<256;Indice++)
     Block(Fenetre_Pos_X+(Fenetre_Liste_boutons_palette->Pos_X+3+((Indice>>4)*10))*Menu_Facteur_X,
           Fenetre_Pos_Y+(Fenetre_Liste_boutons_palette->Pos_Y+3+((Indice&15)* 5))*Menu_Facteur_Y,
           Menu_Facteur_X*3,Menu_Facteur_Y*5,CM_Clair);
 
   // On affiche le 1er TAG
-  Origine_X=(Fenetre_Liste_boutons_palette->Pos_X+3)+(Debut>>4)*10;
-  Origine_Y=(Fenetre_Liste_boutons_palette->Pos_Y+3)+(Debut&15)* 5;
+  Origine_X=(Fenetre_Liste_boutons_palette->Pos_X+3)+(start>>4)*10;
+  Origine_Y=(Fenetre_Liste_boutons_palette->Pos_Y+3)+(start&15)* 5;
   for (Pos_Y=0,Pos_fenetre_Y=Origine_Y  ;Pos_Y<5;Pos_Y++,Pos_fenetre_Y++)
     Pixel_dans_fenetre(Origine_X  ,Pos_fenetre_Y,CM_Noir);
   for (Pos_Y=0,Pos_fenetre_Y=Origine_Y+1;Pos_Y<3;Pos_Y++,Pos_fenetre_Y++)
     Pixel_dans_fenetre(Origine_X+1,Pos_fenetre_Y,CM_Noir);
   Pixel_dans_fenetre(Origine_X+2,Origine_Y+2,CM_Noir);
 
-  if (Debut!=Fin)
+  if (start!=end)
   {
     // On complète le 1er TAG
     Pixel_dans_fenetre(Origine_X+1,Origine_Y+4,CM_Noir);
 
     // On affiche le 2ème TAG
-    Origine_X=(Fenetre_Liste_boutons_palette->Pos_X+3)+(Fin>>4)*10;
-    Origine_Y=(Fenetre_Liste_boutons_palette->Pos_Y+3)+(Fin&15)* 5;
+    Origine_X=(Fenetre_Liste_boutons_palette->Pos_X+3)+(end>>4)*10;
+    Origine_Y=(Fenetre_Liste_boutons_palette->Pos_Y+3)+(end&15)* 5;
     for (Pos_Y=0,Pos_fenetre_Y=Origine_Y; Pos_Y<5; Pos_Y++,Pos_fenetre_Y++)
       Pixel_dans_fenetre(Origine_X  ,Pos_fenetre_Y,CM_Noir);
     for (Pos_Y=0,Pos_fenetre_Y=Origine_Y; Pos_Y<4; Pos_Y++,Pos_fenetre_Y++)
@@ -1355,7 +1355,7 @@ void Tagger_intervalle_palette(byte Debut,byte Fin)
     Pixel_dans_fenetre(Origine_X+2,Origine_Y+2,CM_Noir);
 
     // On TAG toutes les couleurs intermédiaires
-    for (Indice=Debut+1;Indice<Fin;Indice++)
+    for (Indice=start+1;Indice<end;Indice++)
     {
       Block(Fenetre_Pos_X+(Fenetre_Liste_boutons_palette->Pos_X+3+((Indice>>4)*10))*Menu_Facteur_X,
             Fenetre_Pos_Y+(Fenetre_Liste_boutons_palette->Pos_Y+3+((Indice&15)* 5))*Menu_Facteur_Y,
@@ -1376,51 +1376,51 @@ void Tagger_intervalle_palette(byte Debut,byte Fin)
 
 //------------------ Dessiner un scroller dans une fenêtre -------------------
 
-void Calculer_hauteur_curseur_jauge(T_Bouton_scroller * Enreg)
+void Calculer_hauteur_curseur_jauge(T_Bouton_scroller * button)
 {
-  if (Enreg->Nb_elements>Enreg->Nb_visibles)
+  if (button->Nb_elements>button->Nb_visibles)
   {
-    Enreg->Hauteur_curseur=(Enreg->Nb_visibles*(Enreg->Hauteur-24))/Enreg->Nb_elements;
-    if (!(Enreg->Hauteur_curseur))
-      Enreg->Hauteur_curseur=1;
+    button->Hauteur_curseur=(button->Nb_visibles*(button->Hauteur-24))/button->Nb_elements;
+    if (!(button->Hauteur_curseur))
+      button->Hauteur_curseur=1;
   }
   else
   {
-    Enreg->Hauteur_curseur=Enreg->Hauteur-24;
+    button->Hauteur_curseur=button->Hauteur-24;
   }
 }
 
-void Fenetre_Dessiner_jauge(T_Bouton_scroller * Enreg)
+void Fenetre_Dessiner_jauge(T_Bouton_scroller * button)
 {
   word Position_curseur_jauge;
 
-  Position_curseur_jauge=Enreg->Pos_Y+12;
+  Position_curseur_jauge=button->Pos_Y+12;
 
-  Block(Fenetre_Pos_X+(Enreg->Pos_X*Menu_Facteur_X),
+  Block(Fenetre_Pos_X+(button->Pos_X*Menu_Facteur_X),
         Fenetre_Pos_Y+(Position_curseur_jauge*Menu_Facteur_Y),
-        11*Menu_Facteur_X,(Enreg->Hauteur-24)*Menu_Facteur_Y,CM_Noir/*CM_Fonce*/);
+        11*Menu_Facteur_X,(button->Hauteur-24)*Menu_Facteur_Y,CM_Noir/*CM_Fonce*/);
 
-  if (Enreg->Nb_elements>Enreg->Nb_visibles)
-    Position_curseur_jauge+=Round_div(Enreg->Position*(Enreg->Hauteur-24-Enreg->Hauteur_curseur),Enreg->Nb_elements-Enreg->Nb_visibles);
+  if (button->Nb_elements>button->Nb_visibles)
+    Position_curseur_jauge+=Round_div(button->Position*(button->Hauteur-24-button->Hauteur_curseur),button->Nb_elements-button->Nb_visibles);
 
-  Block(Fenetre_Pos_X+(Enreg->Pos_X*Menu_Facteur_X),
+  Block(Fenetre_Pos_X+(button->Pos_X*Menu_Facteur_X),
         Fenetre_Pos_Y+(Position_curseur_jauge*Menu_Facteur_Y),
-        11*Menu_Facteur_X,Enreg->Hauteur_curseur*Menu_Facteur_Y,CM_Clair/*CM_Blanc*/);
+        11*Menu_Facteur_X,button->Hauteur_curseur*Menu_Facteur_Y,CM_Clair/*CM_Blanc*/);
 
-  UpdateRect(Fenetre_Pos_X+(Enreg->Pos_X*Menu_Facteur_X),
-        Fenetre_Pos_Y+Enreg->Pos_Y*Menu_Facteur_Y,
-        11*Menu_Facteur_X,(Enreg->Hauteur)*Menu_Facteur_Y);
+  UpdateRect(Fenetre_Pos_X+(button->Pos_X*Menu_Facteur_X),
+        Fenetre_Pos_Y+button->Pos_Y*Menu_Facteur_Y,
+        11*Menu_Facteur_X,(button->Hauteur)*Menu_Facteur_Y);
 }
 
-void Fenetre_Dessiner_bouton_scroller(T_Bouton_scroller * Enreg)
+void Fenetre_Dessiner_bouton_scroller(T_Bouton_scroller * button)
 {
-  Fenetre_Afficher_cadre_general(Enreg->Pos_X-1,Enreg->Pos_Y-1,13,Enreg->Hauteur+2,CM_Noir,CM_Noir,CM_Fonce,CM_Fonce,CM_Fonce);
-  Fenetre_Afficher_cadre_mono(Enreg->Pos_X-1,Enreg->Pos_Y+11,13,Enreg->Hauteur-22,CM_Noir);
-  Fenetre_Afficher_cadre_bombe(Enreg->Pos_X,Enreg->Pos_Y,11,11);
-  Fenetre_Afficher_cadre_bombe(Enreg->Pos_X,Enreg->Pos_Y+Enreg->Hauteur-11,11,11);
-  Print_dans_fenetre(Enreg->Pos_X+2,Enreg->Pos_Y+2,"\030",CM_Noir,CM_Clair);
-  Print_dans_fenetre(Enreg->Pos_X+2,Enreg->Pos_Y+Enreg->Hauteur-9,"\031",CM_Noir,CM_Clair);
-  Fenetre_Dessiner_jauge(Enreg);
+  Fenetre_Afficher_cadre_general(button->Pos_X-1,button->Pos_Y-1,13,button->Hauteur+2,CM_Noir,CM_Noir,CM_Fonce,CM_Fonce,CM_Fonce);
+  Fenetre_Afficher_cadre_mono(button->Pos_X-1,button->Pos_Y+11,13,button->Hauteur-22,CM_Noir);
+  Fenetre_Afficher_cadre_bombe(button->Pos_X,button->Pos_Y,11,11);
+  Fenetre_Afficher_cadre_bombe(button->Pos_X,button->Pos_Y+button->Hauteur-11,11,11);
+  Print_dans_fenetre(button->Pos_X+2,button->Pos_Y+2,"\030",CM_Noir,CM_Clair);
+  Print_dans_fenetre(button->Pos_X+2,button->Pos_Y+button->Hauteur-9,"\031",CM_Noir,CM_Clair);
+  Fenetre_Dessiner_jauge(button);
 }
 
 
@@ -1434,17 +1434,17 @@ void Fenetre_Dessiner_bouton_saisie(word Pos_X,word Pos_Y,word Largeur_en_caract
 
 //------------ Modifier le contenu (caption) d'une zone de saisie ------------
 
-void Fenetre_Contenu_bouton_saisie(T_Bouton_special * Enreg, char * content)
+void Fenetre_Contenu_bouton_saisie(T_Bouton_special * button, char * content)
 {
-  Print_dans_fenetre_limite(Enreg->Pos_X+2,Enreg->Pos_Y+2,content,Enreg->Largeur/8,CM_Noir,CM_Clair);
+  Print_dans_fenetre_limite(button->Pos_X+2,button->Pos_Y+2,content,button->Largeur/8,CM_Noir,CM_Clair);
 }
 
 //------------ Effacer le contenu (caption) d'une zone de saisie ------------
 
-void Fenetre_Effacer_bouton_saisie(T_Bouton_special * Enreg)
+void Fenetre_Effacer_bouton_saisie(T_Bouton_special * button)
 {
-  Block((Enreg->Pos_X+2)*Menu_Facteur_X+Fenetre_Pos_X,(Enreg->Pos_Y+2)*Menu_Facteur_Y+Fenetre_Pos_Y,(Enreg->Largeur/8)*8*Menu_Facteur_X,8*Menu_Facteur_Y,CM_Clair);
-  UpdateRect((Enreg->Pos_X+2)*Menu_Facteur_X+Fenetre_Pos_X,(Enreg->Pos_Y+2)*Menu_Facteur_Y+Fenetre_Pos_Y,Enreg->Largeur/8*8*Menu_Facteur_X,8*Menu_Facteur_Y);
+  Block((button->Pos_X+2)*Menu_Facteur_X+Fenetre_Pos_X,(button->Pos_Y+2)*Menu_Facteur_Y+Fenetre_Pos_Y,(button->Largeur/8)*8*Menu_Facteur_X,8*Menu_Facteur_Y,CM_Clair);
+  UpdateRect((button->Pos_X+2)*Menu_Facteur_X+Fenetre_Pos_X,(button->Pos_Y+2)*Menu_Facteur_Y+Fenetre_Pos_Y,button->Largeur/8*8*Menu_Facteur_X,8*Menu_Facteur_Y);
 }
 
 
@@ -1606,39 +1606,39 @@ T_Bouton_dropdown * Fenetre_Definir_bouton_dropdown(word Pos_X,word Pos_Y,word L
 // Ajoute un choix à une dropdown. Le libellé est seulement référencé,
 // il doit pointer sur une zone qui doit être encore valide à la fermeture 
 // de la fenêtre (comprise).
-void Fenetre_Dropdown_choix(T_Bouton_dropdown * Dropdown, word Numero, const char *Libelle)
+void Fenetre_Dropdown_choix(T_Bouton_dropdown * dropdown, word Numero, const char *Libelle)
 {
   T_Dropdown_choix *Temp;
-  T_Dropdown_choix *Dernier;
+  T_Dropdown_choix *last;
   
   Temp=(T_Dropdown_choix *)malloc(sizeof(T_Dropdown_choix));
   Temp->Numero =Numero;
   Temp->Libelle=Libelle;
   Temp->Next=NULL;
 
-  Dernier=Dropdown->Premier_choix;
-  if (Dernier)
+  last=dropdown->Premier_choix;
+  if (last)
   {
     // On cherche le dernier élément
-    for (;Dernier->Next;Dernier=Dernier->Next)
+    for (;last->Next;last=last->Next)
       ;
-    Dernier->Next=Temp;
+    last->Next=Temp;
   }
   else
   {
-    Dropdown->Premier_choix=Temp;
+    dropdown->Premier_choix=Temp;
   }
 }
 
 // ------------- Suppression de tous les choix d'une dropdown ---------
-void Fenetre_Dropdown_vider_choix(T_Bouton_dropdown * Dropdown)
+void Fenetre_Dropdown_vider_choix(T_Bouton_dropdown * dropdown)
 {
   T_Dropdown_choix * Choix_suivant;
-    while (Dropdown->Premier_choix)
+    while (dropdown->Premier_choix)
     {
-      Choix_suivant=Dropdown->Premier_choix->Next;
-      free(Dropdown->Premier_choix);
-      Dropdown->Premier_choix=Choix_suivant;
+      Choix_suivant=dropdown->Premier_choix->Next;
+      free(dropdown->Premier_choix);
+      dropdown->Premier_choix=Choix_suivant;
     }
 }
 
@@ -1798,12 +1798,12 @@ byte Fenetre_click_dans_zone(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y
 
 // --- Attend que l'on clique dans la palette pour renvoyer la couleur choisie
 // ou bien renvoie -1 si on a annulé l'action pas click-droit ou Escape ------
-short Attendre_click_dans_palette(T_Bouton_palette * Enreg)
+short Attendre_click_dans_palette(T_Bouton_palette * button)
 {
-  short Debut_X=Enreg->Pos_X+5;
-  short Debut_Y=Enreg->Pos_Y+3;
-  short Fin_X  =Enreg->Pos_X+160;
-  short Fin_Y  =Enreg->Pos_Y+82;
+  short Debut_X=button->Pos_X+5;
+  short Debut_Y=button->Pos_Y+3;
+  short Fin_X  =button->Pos_X+160;
+  short Fin_Y  =button->Pos_Y+82;
   byte  Couleur_choisie;
   byte  Ancien_Cacher_curseur;
   byte  Ancien_Loupe_Mode;
@@ -1825,8 +1825,8 @@ short Attendre_click_dans_palette(T_Bouton_palette * Enreg)
       if (Fenetre_click_dans_zone(Debut_X,Debut_Y,Fin_X,Fin_Y))
       {
         Effacer_curseur();
-        Couleur_choisie=(((Mouse_X-Fenetre_Pos_X)/Menu_Facteur_X)-(Enreg->Pos_X+2)) / 10 * 16 +
-        (((Mouse_Y-Fenetre_Pos_Y)/Menu_Facteur_Y)-(Enreg->Pos_Y+3)) / 5;
+        Couleur_choisie=(((Mouse_X-Fenetre_Pos_X)/Menu_Facteur_X)-(button->Pos_X+2)) / 10 * 16 +
+        (((Mouse_Y-Fenetre_Pos_Y)/Menu_Facteur_Y)-(button->Pos_Y+3)) / 5;
         Forme_curseur=FORME_CURSEUR_FLECHE;
         Cacher_curseur=Ancien_Cacher_curseur;
         Loupe_Mode=Ancien_Loupe_Mode;
diff --git a/moteur.h b/moteur.h
index fd455d6f..f7a374c3 100644
--- a/moteur.h
+++ b/moteur.h
@@ -37,12 +37,12 @@ void Fenetre_Enfoncer_bouton_normal(word Pos_X,word Pos_Y,word Largeur,word Haut
 void Fenetre_Desenfoncer_bouton_normal(word Pos_X,word Pos_Y,word Largeur,word Hauteur);
 void Fenetre_Dessiner_bouton_palette(word Pos_X,word Pos_Y);
 
-void Calculer_hauteur_curseur_jauge(T_Bouton_scroller * Enreg);
-void Fenetre_Dessiner_jauge(T_Bouton_scroller * Enreg);
-void Fenetre_Dessiner_bouton_scroller(T_Bouton_scroller * Enreg);
+void Calculer_hauteur_curseur_jauge(T_Bouton_scroller * button);
+void Fenetre_Dessiner_jauge(T_Bouton_scroller * button);
+void Fenetre_Dessiner_bouton_scroller(T_Bouton_scroller * button);
 
-void Fenetre_Contenu_bouton_saisie(T_Bouton_special * Enreg, char * content);
-void Fenetre_Effacer_bouton_saisie(T_Bouton_special * Enreg);
+void Fenetre_Contenu_bouton_saisie(T_Bouton_special * button, char * content);
+void Fenetre_Effacer_bouton_saisie(T_Bouton_special * button);
 void Fenetre_Dessiner_bouton_saisie(word Pos_X,word Pos_Y,word Largeur_en_caracteres);
 
 T_Bouton_normal * Fenetre_Definir_bouton_normal(word Pos_X, word Pos_Y,
@@ -56,7 +56,7 @@ T_Bouton_normal * Fenetre_Definir_bouton_repetable(word Pos_X, word Pos_Y,
 
 T_Bouton_palette * Fenetre_Definir_bouton_palette(word Pos_X, word Pos_Y);
 void Fenetre_Effacer_tags(void);
-void Tagger_intervalle_palette(byte Debut,byte Fin);
+void Tagger_intervalle_palette(byte start,byte end);
 
 T_Bouton_scroller * Fenetre_Definir_bouton_scroller(word Pos_X, word Pos_Y,
                                      word Hauteur,
@@ -66,10 +66,10 @@ T_Bouton_scroller * Fenetre_Definir_bouton_scroller(word Pos_X, word Pos_Y,
 T_Bouton_special * Fenetre_Definir_bouton_special(word Pos_X,word Pos_Y,word Largeur,word Hauteur);
 T_Bouton_special * Fenetre_Definir_bouton_saisie(word Pos_X,word Pos_Y,word Largeur_en_caracteres);
 T_Bouton_dropdown * Fenetre_Definir_bouton_dropdown(word Pos_X,word Pos_Y,word Largeur,word Hauteur,word Largeur_choix,char *Libelle,byte display_choice,byte display_centered,byte display_arrow,byte active_button);
-void Fenetre_Dropdown_choix(T_Bouton_dropdown * Dropdown, word Numero, const char *Libelle);
-void Fenetre_Dropdown_vider_choix(T_Bouton_dropdown * Dropdown);
+void Fenetre_Dropdown_choix(T_Bouton_dropdown * dropdown, word Numero, const char *Libelle);
+void Fenetre_Dropdown_vider_choix(T_Bouton_dropdown * dropdown);
 byte Fenetre_click_dans_zone(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y);
-short Attendre_click_dans_palette(T_Bouton_palette * Enreg);
+short Attendre_click_dans_palette(T_Bouton_palette * button);
 void Recuperer_couleur_derriere_fenetre(byte * Couleur, byte * click);
 
 short Fenetre_Bouton_clicke(void);
diff --git a/op_c.c b/op_c.c
index 8c094399..69744d09 100644
--- a/op_c.c
+++ b/op_c.c
@@ -959,7 +959,7 @@ void DS_Generer(DegradeSet * ds,ClusterSet * cs)
     int ic,id; // Les indexs de parcours des ensembles
     int mdegr; // Meilleur d‚grad‚
     int mdiff; // Meilleure diff‚rence de chrominance
-    int diff;  // Diff‚rence de chrominance courante
+    int diff;  // Difference de chrominance courante
 
     // Pour chacun des clusters … traiter
     for (ic=1;ic<cs->nb;ic++)
diff --git a/operatio.c b/operatio.c
index 130b0b45..3217ce2a 100644
--- a/operatio.c
+++ b/operatio.c
@@ -626,14 +626,14 @@ void K_Ligne_0_6(void)
   short Fin_X;
   short Fin_Y;
   short Couleur;
-  short Direction;
+  short direction;
 
   Operation_POP(&Fin_Y);
   Operation_POP(&Fin_X);
   Operation_POP(&Debut_Y);
   Operation_POP(&Debut_X);
   Operation_POP(&Couleur);
-  Operation_POP(&Direction);
+  Operation_POP(&direction);
 
   if ((Config.Coords_rel) && (Menu_visible))
     Print_dans_menu("X:±   0   Y:±   0",0);
@@ -645,16 +645,16 @@ void K_Ligne_0_6(void)
   Tracer_ligne_Preview_xor (Debut_X,Debut_Y,Fin_X,Fin_Y,0);
   */
   Pinceau_Forme=Pinceau_Forme_avant_operation;
-  if (Direction & 0x80)
+  if (direction & 0x80)
   {
     Afficher_pinceau(Debut_X,Debut_Y,Couleur,0);
-    Direction=(Direction & 0x7F);
+    direction=(direction & 0x7F);
   }
   Tracer_ligne_Definitif(Debut_X,Debut_Y,Pinceau_X,Pinceau_Y,Couleur);
   Pinceau_Forme=FORME_PINCEAU_POINT;
 
-  Operation_PUSH(Direction);
-  Operation_PUSH(Direction); // Valeur bidon servant de nouvel état de pile
+  Operation_PUSH(direction);
+  Operation_PUSH(direction); // Valeur bidon servant de nouvel état de pile
   Operation_PUSH(Couleur);
   Operation_PUSH(Pinceau_X);
   Operation_PUSH(Pinceau_Y);
@@ -676,19 +676,19 @@ void K_Ligne_12_7(void)
   short Fin_X;
   short Fin_Y;
   short Couleur;
-  short Direction;
+  short direction;
 
   Operation_POP(&Fin_Y);
   Operation_POP(&Fin_X);
   Operation_POP(&Debut_Y);
   Operation_POP(&Debut_X);
   Operation_POP(&Couleur);
-  Operation_POP(&Direction);
-  Operation_POP(&Direction);
+  Operation_POP(&direction);
+  Operation_POP(&direction);
 
-  if (Direction==Mouse_K)
+  if (direction==Mouse_K)
   {
-    Operation_PUSH(Direction);
+    Operation_PUSH(direction);
     Operation_PUSH(Couleur);
     Operation_PUSH(Debut_X);
     Operation_PUSH(Debut_Y);
@@ -2165,19 +2165,19 @@ void Polygone_12_9(void)
   short Fin_X;
   short Fin_Y;
   short Couleur;
-  short Direction;
+  short direction;
 
   Operation_POP(&Fin_Y);
   Operation_POP(&Fin_X);
   Operation_POP(&Debut_Y);
   Operation_POP(&Debut_X);
   Operation_POP(&Couleur);
-  Operation_POP(&Direction);
-  Operation_POP(&Direction);
+  Operation_POP(&direction);
+  Operation_POP(&direction);
 
-  if (Direction==Mouse_K)
+  if (direction==Mouse_K)
   {
-    Operation_PUSH(Direction);
+    Operation_PUSH(direction);
     Operation_PUSH(Couleur);
     Operation_PUSH(Debut_X);
     Operation_PUSH(Debut_Y);
@@ -2271,25 +2271,25 @@ void Polyfill_0_8(void)
   short Fin_X;
   short Fin_Y;
   short Couleur;
-  short Direction;
+  short direction;
 
   Operation_POP(&Fin_Y);
   Operation_POP(&Fin_X);
   Operation_POP(&Debut_Y);
   Operation_POP(&Debut_X);
   Operation_POP(&Couleur);
-  Operation_POP(&Direction);
+  Operation_POP(&direction);
 
   if ((Config.Coords_rel) && (Menu_visible))
     Print_dans_menu("X:±   0   Y:±   0",0);
 
   Tracer_ligne_Preview_xor(Debut_X,Debut_Y,Fin_X,Fin_Y,0);
 
-  if (Direction & 0x80)
-    Direction=(Direction & 0x7F);
+  if (direction & 0x80)
+    direction=(direction & 0x7F);
 
-  Operation_PUSH(Direction); // Valeur bidon servant de nouvel état de pile
-  Operation_PUSH(Direction);
+  Operation_PUSH(direction); // Valeur bidon servant de nouvel état de pile
+  Operation_PUSH(direction);
   Operation_PUSH(Couleur);
 
   Tracer_ligne_Preview_xor(Debut_X,Debut_Y,Pinceau_X,Pinceau_Y,0);
@@ -2364,19 +2364,19 @@ void Polyfill_12_9(void)
   short Fin_X;
   short Fin_Y;
   short Couleur;
-  short Direction;
+  short direction;
 
   Operation_POP(&Fin_Y);
   Operation_POP(&Fin_X);
   Operation_POP(&Debut_Y);
   Operation_POP(&Debut_X);
   Operation_POP(&Couleur);
-  Operation_POP(&Direction);
-  Operation_POP(&Direction);
+  Operation_POP(&direction);
+  Operation_POP(&direction);
 
-  if (Direction==Mouse_K)
+  if (direction==Mouse_K)
   {
-    Operation_PUSH(Direction);
+    Operation_PUSH(direction);
     Operation_PUSH(Couleur);
     Operation_PUSH(Debut_X);
     Operation_PUSH(Debut_Y);
@@ -2909,7 +2909,7 @@ void Brosse_0_5(void)
   short Debut_Y;
   short Ancien_Pinceau_X;
   short Ancien_Pinceau_Y;
-  short Effacement;
+  short clear;
 
   // Comme on a demandé l'effacement du curseur, il n'y a plus de croix en
   // (Pinceau_X,Pinceau_Y). C'est une bonne chose.
@@ -2917,7 +2917,7 @@ void Brosse_0_5(void)
   Operation_Taille_pile-=2;
   Operation_POP(&Debut_Y);
   Operation_POP(&Debut_X);
-  Operation_POP(&Effacement);
+  Operation_POP(&clear);
 
   // On efface l'ancienne croix:
   Ancien_Pinceau_X=Pinceau_X;
@@ -2947,7 +2947,7 @@ void Brosse_0_5(void)
     if (Ancien_Pinceau_Y!=Debut_Y)
       Ancien_Pinceau_Y--;
   }
-  Capturer_brosse(Debut_X,Debut_Y,Ancien_Pinceau_X,Ancien_Pinceau_Y,Effacement);
+  Capturer_brosse(Debut_X,Debut_Y,Ancien_Pinceau_X,Ancien_Pinceau_Y,clear);
   if ((Snap_Mode) && (Config.Adjust_brush_pick))
   {
     Brosse_Decalage_X=(Brosse_Decalage_X/Snap_Largeur)*Snap_Largeur;
@@ -3717,8 +3717,8 @@ void Scroll_12_4(void)
   short Centre_Y;
   short Pos_X;
   short Pos_Y;
-  short Decalage_X;
-  short Decalage_Y;
+  short x_offset;
+  short y_offset;
   //char  Chaine[5];
 
   Operation_POP(&Pos_Y);
@@ -3731,18 +3731,18 @@ void Scroll_12_4(void)
     // L'utilisateur a bougé, il faut scroller l'image
 
     if (Pinceau_X>=Centre_X)
-      Decalage_X=(Pinceau_X-Centre_X)%Principal_Largeur_image;
+      x_offset=(Pinceau_X-Centre_X)%Principal_Largeur_image;
     else
-      Decalage_X=Principal_Largeur_image-((Centre_X-Pinceau_X)%Principal_Largeur_image);
+      x_offset=Principal_Largeur_image-((Centre_X-Pinceau_X)%Principal_Largeur_image);
 
     if (Pinceau_Y>=Centre_Y)
-      Decalage_Y=(Pinceau_Y-Centre_Y)%Principal_Hauteur_image;
+      y_offset=(Pinceau_Y-Centre_Y)%Principal_Hauteur_image;
     else
-      Decalage_Y=Principal_Hauteur_image-((Centre_Y-Pinceau_Y)%Principal_Hauteur_image);
+      y_offset=Principal_Hauteur_image-((Centre_Y-Pinceau_Y)%Principal_Hauteur_image);
 
     Aff_coords_rel_ou_abs(Centre_X,Centre_Y);
 
-    Scroll_picture(Decalage_X,Decalage_Y);
+    Scroll_picture(x_offset,y_offset);
 
     Afficher_ecran();
   }
diff --git a/pages.c b/pages.c
index 6e4df68a..c56c6964 100644
--- a/pages.c
+++ b/pages.c
@@ -266,9 +266,9 @@ void Liberer_une_page(S_Page * Page)
   // On ne se préoccupe pas de ce que deviens le reste des infos de l'image.
 }
 
-void Copier_S_page(S_Page * Destination,S_Page * Source)
+void Copier_S_page(S_Page * dest,S_Page * Source)
 {
-  *Destination=*Source;
+  *dest=*Source;
 }
 
 int Taille_d_une_page(S_Page * Page)
diff --git a/pages.h b/pages.h
index 7aa42c9e..7db56339 100644
--- a/pages.h
+++ b/pages.h
@@ -39,7 +39,7 @@ void Upload_infos_page_brouillon(S_Page * Page);
 void Download_infos_backup(S_Liste_de_pages * Liste);
 int Allouer_une_page(S_Page * Page,int Largeur,int Hauteur);
 void Liberer_une_page(S_Page * Page);
-void Copier_S_page(S_Page * Destination,S_Page * Source);
+void Copier_S_page(S_Page * dest,S_Page * Source);
 int Taille_d_une_page(S_Page * Page);
 
 
diff --git a/palette.c b/palette.c
index 790243cd..a711b946 100644
--- a/palette.c
+++ b/palette.c
@@ -147,7 +147,7 @@ void Formate_composante(byte Valeur, char *Chaine)
   Chaine[4]='\0';
 }
 
-void Degrader_palette(short Debut,short Fin,T_Palette Palette)
+void Degrader_palette(short start,short end,T_Palette Palette)
 // Modifie la palette pour obtenir un dégradé de couleur entre les deux bornes
 // passées en paramètre
 {
@@ -161,21 +161,21 @@ void Degrader_palette(short Debut,short Fin,T_Palette Palette)
 
   // On vérifie qu'il y ait assez de couleurs entre le début et la fin pour
   // pouvoir faire un dégradé:
-  if ( (Debut!=Fin) && (Debut+1!=Fin) )
+  if ( (start!=end) && (start+1!=end) )
   {
-    Debut_Rouge=Palette[Debut].R;
-    Debut_Vert =Palette[Debut].V;
-    Debut_Bleu =Palette[Debut].B;
+    Debut_Rouge=Palette[start].R;
+    Debut_Vert =Palette[start].V;
+    Debut_Bleu =Palette[start].B;
 
-    Fin_Rouge  =Palette[Fin  ].R;
-    Fin_Vert   =Palette[Fin  ].V;
-    Fin_Bleu   =Palette[Fin  ].B;
+    Fin_Rouge  =Palette[end  ].R;
+    Fin_Vert   =Palette[end  ].V;
+    Fin_Bleu   =Palette[end  ].B;
 
-    for (Indice=Debut+1;Indice<Fin;Indice++)
+    for (Indice=start+1;Indice<end;Indice++)
     {
-      Modifier_Rouge(Indice, ((Fin_Rouge-Debut_Rouge) * (Indice-Debut))/(Fin-Debut) + Debut_Rouge,Palette);
-      Modifier_Vert (Indice, ((Fin_Vert -Debut_Vert ) * (Indice-Debut))/(Fin-Debut) + Debut_Vert ,Palette);
-      Modifier_Bleu (Indice, ((Fin_Bleu -Debut_Bleu ) * (Indice-Debut))/(Fin-Debut) + Debut_Bleu ,Palette);
+      Modifier_Rouge(Indice, ((Fin_Rouge-Debut_Rouge) * (Indice-start))/(end-start) + Debut_Rouge,Palette);
+      Modifier_Vert (Indice, ((Fin_Vert -Debut_Vert ) * (Indice-start))/(end-start) + Debut_Vert ,Palette);
+      Modifier_Bleu (Indice, ((Fin_Bleu -Debut_Bleu ) * (Indice-start))/(end-start) + Debut_Bleu ,Palette);
     }
   }
 }
@@ -691,13 +691,13 @@ void Afficher_les_jauges(T_Bouton_scroller * Jauge_rouge,
 void Palette_Reafficher_jauges(T_Bouton_scroller * Jauge_rouge,
                                T_Bouton_scroller * Jauge_verte,
                                T_Bouton_scroller * Jauge_bleue,
-                               T_Palette Palette,byte Debut,byte Fin)
+                               T_Palette Palette,byte start,byte end)
 {
   char Chaine[5];
 
   Effacer_curseur();
   // Réaffichage des jauges:
-  if (Debut!=Fin)
+  if (start!=end)
   {
     // Dans le cas d'un bloc, tout à 0.
     Jauge_rouge->Position   =Color_Max;
@@ -716,9 +716,9 @@ void Palette_Reafficher_jauges(T_Bouton_scroller * Jauge_rouge,
   {
     // Dans le cas d'une seule couleur, composantes.
     byte j1, j2, j3;
-    j1= Palette[Debut].R;
-    j2= Palette[Debut].V;
-    j3= Palette[Debut].B;
+    j1= Palette[start].R;
+    j2= Palette[start].V;
+    j3= Palette[start].B;
     if (!Palette_mode_RGB)
     {
       RGBtoHSL(j1,j2,j3,&j1,&j2,&j3);
diff --git a/pxdouble.c b/pxdouble.c
index 6689e9ca..cde56b0a 100644
--- a/pxdouble.c
+++ b/pxdouble.c
@@ -145,12 +145,12 @@ void Ligne_verticale_XOR_Double(word Pos_X,word Pos_Y,word Hauteur)
   }
 }
 
-void Display_brush_Color_Double(word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
+void Display_brush_Color_Double(word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
 {
   // Dest = Position à l'écran
   byte* Dest = Ecran + Pos_Y * 4 * Largeur_ecran + Pos_X * 2;
   // Src = Position dans la brosse
-  byte* Src = Brosse + Decalage_Y * Largeur_brosse + Decalage_X;
+  byte* Src = Brosse + y_offset * Largeur_brosse + x_offset;
 
   word x,y;
 
@@ -179,13 +179,13 @@ void Display_brush_Color_Double(word Pos_X,word Pos_Y,word Decalage_X,word Decal
 }
 
 void Display_brush_Mono_Double(word Pos_X, word Pos_Y,
-        word Decalage_X, word Decalage_Y, word Largeur, word Hauteur,
+        word x_offset, word y_offset, word Largeur, word Hauteur,
         byte Couleur_de_transparence, byte Couleur, word Largeur_brosse)
 /* On affiche la brosse en monochrome */
 {
   byte* Dest=Pos_Y*4*Largeur_ecran+Pos_X*2+Ecran; // Dest = adr destination à 
       // l'écran
-  byte* Src=Largeur_brosse*Decalage_Y+Decalage_X+Brosse; // Src = adr ds 
+  byte* Src=Largeur_brosse*y_offset+x_offset+Brosse; // Src = adr ds 
       // la brosse
   int x,y;
 
@@ -210,7 +210,7 @@ void Display_brush_Mono_Double(word Pos_X, word Pos_Y,
   UpdateRect(Pos_X,Pos_Y,Largeur,Hauteur);
 }
 
-void Clear_brush_Double(word Pos_X,word Pos_Y,__attribute__((unused)) word Decalage_X,__attribute__((unused)) word Decalage_Y,word Largeur,word Hauteur,__attribute__((unused))byte Couleur_de_transparence,word Largeur_image)
+void Clear_brush_Double(word Pos_X,word Pos_Y,__attribute__((unused)) word x_offset,__attribute__((unused)) word y_offset,word Largeur,word Hauteur,__attribute__((unused))byte Couleur_de_transparence,word Largeur_image)
 {
   byte* Dest=Ecran+Pos_X*2+Pos_Y*4*Largeur_ecran; //On va se mettre en 0,0 dans l'écran (Dest)
   byte* Src = ( Pos_Y + Principal_Decalage_Y ) * Largeur_image + Pos_X + Principal_Decalage_X + Principal_Ecran; //Coords de départ ds la source (Src)
@@ -238,12 +238,12 @@ void Clear_brush_Double(word Pos_X,word Pos_Y,__attribute__((unused)) word Decal
 }
 
 // Affiche une brosse (arbitraire) à l'écran
-void Affiche_brosse_Double(byte * brush, word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
+void Affiche_brosse_Double(byte * brush, word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
 {
   // Dest = Position à l'écran
   byte* Dest = Ecran + Pos_Y * 4 * Largeur_ecran + Pos_X * 2;
   // Src = Position dans la brosse
-  byte* Src = brush + Decalage_Y * Largeur_brosse + Decalage_X;
+  byte* Src = brush + y_offset * Largeur_brosse + x_offset;
   
   word x,y;
   
@@ -345,7 +345,7 @@ void Afficher_partie_de_l_ecran_zoomee_Double(
 {
   byte* Src = Principal_Ecran + Loupe_Decalage_Y * Largeur_image 
                       + Loupe_Decalage_X;
-  int EDX = 0; // Ligne en cours de traitement
+  int y = 0; // Ligne en cours de traitement
 
   // Pour chaque ligne à zoomer
   while(1)
@@ -360,12 +360,12 @@ void Afficher_partie_de_l_ecran_zoomee_Double(
     do{
       // On affiche la ligne zoomée
       Afficher_une_ligne_ecran_fast_Double(
-        Principal_X_Zoom, EDX, Largeur*Loupe_Facteur,
+        Principal_X_Zoom, y, Largeur*Loupe_Facteur,
         Buffer
       );
       // On passe à la suivante
-      EDX++;
-      if(EDX==Hauteur/**ZOOMY*/)
+      y++;
+      if(y==Hauteur/**ZOOMY*/)
       {
         UpdateRect(Principal_X_Zoom,0,
           Largeur*Loupe_Facteur,Hauteur);
@@ -380,13 +380,13 @@ void Afficher_partie_de_l_ecran_zoomee_Double(
 
 // Affiche une partie de la brosse couleur zoomée
 void Display_brush_Color_zoom_Double(word Pos_X,word Pos_Y,
-        word Decalage_X,word Decalage_Y,
+        word x_offset,word y_offset,
         word Largeur, // Largeur non zoomée
         word Pos_Y_Fin,byte Couleur_de_transparence,
         word Largeur_brosse, // Largeur réelle de la brosse
         byte * Buffer)
 {
-  byte* Src = Brosse+Decalage_Y*Largeur_brosse + Decalage_X;
+  byte* Src = Brosse+y_offset*Largeur_brosse + x_offset;
   word y = Pos_Y;
   byte bx;
 
@@ -412,7 +412,7 @@ void Display_brush_Color_zoom_Double(word Pos_X,word Pos_Y,
 }
 
 void Display_brush_Mono_zoom_Double(word Pos_X, word Pos_Y,
-        word Decalage_X, word Decalage_Y, 
+        word x_offset, word y_offset, 
         word Largeur, // Largeur non zoomée 
         word Pos_Y_Fin,
         byte Couleur_de_transparence, byte Couleur, 
@@ -421,7 +421,7 @@ void Display_brush_Mono_zoom_Double(word Pos_X, word Pos_Y,
 )
 
 {
-  byte* Src = Brosse + Decalage_Y * Largeur_brosse + Decalage_X;
+  byte* Src = Brosse + y_offset * Largeur_brosse + x_offset;
   int y=Pos_Y*ZOOMY;
 
   //Pour chaque ligne à zoomer :
@@ -462,11 +462,11 @@ void Display_brush_Mono_zoom_Double(word Pos_X, word Pos_Y,
   }
 }
 
-void Clear_brush_zoom_Double(word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,__attribute__((unused)) byte Couleur_de_transparence,word Largeur_image,byte * Buffer)
+void Clear_brush_zoom_Double(word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,__attribute__((unused)) byte Couleur_de_transparence,word Largeur_image,byte * Buffer)
 {
 
   // En fait on va recopier l'image non zoomée dans la partie zoomée !
-  byte* Src = Principal_Ecran + Decalage_Y * Largeur_image + Decalage_X;
+  byte* Src = Principal_Ecran + y_offset * Largeur_image + x_offset;
   int y = Pos_Y;
   int bx;
 
diff --git a/pxdouble.h b/pxdouble.h
index be58fea3..09472444 100644
--- a/pxdouble.h
+++ b/pxdouble.h
@@ -28,17 +28,17 @@
   void Pixel_Preview_Loupe_Double        (word X,word Y,byte Couleur);
   void Ligne_horizontale_XOR_Double      (word Pos_X,word Pos_Y,word Largeur);
   void Ligne_verticale_XOR_Double        (word Pos_X,word Pos_Y,word Hauteur);
-  void Display_brush_Color_Double        (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
-  void Display_brush_Mono_Double         (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse);
-  void Clear_brush_Double                (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_image);
+  void Display_brush_Color_Double        (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
+  void Display_brush_Mono_Double         (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse);
+  void Clear_brush_Double                (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_image);
   void Remap_screen_Double               (word Pos_X,word Pos_Y,word Largeur,word Hauteur,byte * Table_de_conversion);
   void Afficher_partie_de_l_ecran_Double (word Largeur,word Hauteur,word Largeur_image);
   void Afficher_une_ligne_ecran_Double   (word Pos_X,word Pos_Y,word Largeur,byte * Ligne);
   void Lire_une_ligne_ecran_Double       (word Pos_X,word Pos_Y,word Largeur,byte * Ligne);
   void Afficher_partie_de_l_ecran_zoomee_Double(word Largeur,word Hauteur,word Largeur_image,byte * Buffer);
-  void Display_brush_Color_zoom_Double   (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_brosse,byte * Buffer);
-  void Display_brush_Mono_zoom_Double    (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse,byte * Buffer);
-  void Clear_brush_zoom_Double           (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer);
-  void Affiche_brosse_Double             (byte * brush, word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
+  void Display_brush_Color_zoom_Double   (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_brosse,byte * Buffer);
+  void Display_brush_Mono_zoom_Double    (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse,byte * Buffer);
+  void Clear_brush_zoom_Double           (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer);
+  void Affiche_brosse_Double             (byte * brush, word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
 
   void Afficher_une_ligne_ecran_fast_Double   (word Pos_X,word Pos_Y,word Largeur,byte * Ligne);
diff --git a/pxsimple.c b/pxsimple.c
index 279f2632..eaa32f1d 100644
--- a/pxsimple.c
+++ b/pxsimple.c
@@ -130,12 +130,12 @@ void Ligne_verticale_XOR_Simple(word Pos_X,word Pos_Y,word Hauteur)
   }
 }
 
-void Display_brush_Color_Simple(word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
+void Display_brush_Color_Simple(word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
 {
   // Dest = Position à l'écran
   byte* Dest = Ecran + Pos_Y * Largeur_ecran + Pos_X;
   // Src = Position dans la brosse
-  byte* Src = Brosse + Decalage_Y * Largeur_brosse + Decalage_X;
+  byte* Src = Brosse + y_offset * Largeur_brosse + x_offset;
 
   word x,y;
 
@@ -163,13 +163,13 @@ void Display_brush_Color_Simple(word Pos_X,word Pos_Y,word Decalage_X,word Decal
 }
 
 void Display_brush_Mono_Simple(word Pos_X, word Pos_Y,
-        word Decalage_X, word Decalage_Y, word Largeur, word Hauteur,
+        word x_offset, word y_offset, word Largeur, word Hauteur,
         byte Couleur_de_transparence, byte Couleur, word Largeur_brosse)
 /* On affiche la brosse en monochrome */
 {
   byte* Dest=Pos_Y*Largeur_ecran+Pos_X+Ecran; // Dest = adr Destination à 
       // l'écran
-  byte* Src=Largeur_brosse*Decalage_Y+Decalage_X+Brosse; // Src = adr ds 
+  byte* Src=Largeur_brosse*y_offset+x_offset+Brosse; // Src = adr ds 
       // la brosse
   int x,y;
 
@@ -194,7 +194,7 @@ void Display_brush_Mono_Simple(word Pos_X, word Pos_Y,
   UpdateRect(Pos_X,Pos_Y,Largeur,Hauteur);
 }
 
-void Clear_brush_Simple(word Pos_X,word Pos_Y,__attribute__((unused)) word Decalage_X,__attribute__((unused)) word Decalage_Y,word Largeur,word Hauteur,__attribute__((unused))byte Couleur_de_transparence,word Largeur_image)
+void Clear_brush_Simple(word Pos_X,word Pos_Y,__attribute__((unused)) word x_offset,__attribute__((unused)) word y_offset,word Largeur,word Hauteur,__attribute__((unused))byte Couleur_de_transparence,word Largeur_image)
 {
   byte* Dest=Ecran+Pos_X+Pos_Y*Largeur_ecran; //On va se mettre en 0,0 dans l'écran (Dest)
   byte* Src = ( Pos_Y + Principal_Decalage_Y ) * Largeur_image + Pos_X + Principal_Decalage_X + Principal_Ecran; //Coords de départ ds la source (Src)
@@ -214,12 +214,12 @@ void Clear_brush_Simple(word Pos_X,word Pos_Y,__attribute__((unused)) word Decal
 }
 
 // Affiche une brosse (arbitraire) à l'écran
-void Affiche_brosse_Simple(byte * brush, word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
+void Affiche_brosse_Simple(byte * brush, word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
 {
   // Dest = Position à l'écran
   byte* Dest = Ecran + Pos_Y * Largeur_ecran + Pos_X;
   // Src = Position dans la brosse
-  byte* Src = brush + Decalage_Y * Largeur_brosse + Decalage_X;
+  byte* Src = brush + y_offset * Largeur_brosse + x_offset;
   
   word x,y;
   
@@ -303,7 +303,7 @@ void Afficher_partie_de_l_ecran_zoomee_Simple(
 {
   byte* Src = Principal_Ecran + Loupe_Decalage_Y * Largeur_image 
                       + Loupe_Decalage_X;
-  int EDX = 0; // Ligne en cours de traitement
+  int y = 0; // Ligne en cours de traitement
 
   // Pour chaque ligne à zoomer
   while(1)
@@ -318,12 +318,12 @@ void Afficher_partie_de_l_ecran_zoomee_Simple(
     do{
       // On affiche la ligne zoomée
       Afficher_une_ligne_ecran_Simple(
-        Principal_X_Zoom, EDX, Largeur*Loupe_Facteur,
+        Principal_X_Zoom, y, Largeur*Loupe_Facteur,
         Buffer
       );
       // On passe à la suivante
-      EDX++;
-      if(EDX==Hauteur)
+      y++;
+      if(y==Hauteur)
       {
         UpdateRect(Principal_X_Zoom,0,
           Largeur*Loupe_Facteur,Hauteur);
@@ -355,13 +355,13 @@ void Afficher_une_ligne_transparente_a_l_ecran_Simple(word Pos_X,word Pos_Y,word
 
 // Affiche une partie de la brosse couleur zoomée
 void Display_brush_Color_zoom_Simple(word Pos_X,word Pos_Y,
-        word Decalage_X,word Decalage_Y,
+        word x_offset,word y_offset,
         word Largeur, // Largeur non zoomée
         word Pos_Y_Fin,byte Couleur_de_transparence,
         word Largeur_brosse, // Largeur réelle de la brosse
         byte * Buffer)
 {
-  byte* Src = Brosse+Decalage_Y*Largeur_brosse + Decalage_X;
+  byte* Src = Brosse+y_offset*Largeur_brosse + x_offset;
   word y = Pos_Y;
   byte bx;
 
@@ -385,7 +385,7 @@ void Display_brush_Color_zoom_Simple(word Pos_X,word Pos_Y,
 }
 
 void Display_brush_Mono_zoom_Simple(word Pos_X, word Pos_Y,
-        word Decalage_X, word Decalage_Y, 
+        word x_offset, word y_offset, 
         word Largeur, // Largeur non zoomée 
         word Pos_Y_Fin,
         byte Couleur_de_transparence, byte Couleur, 
@@ -394,7 +394,7 @@ void Display_brush_Mono_zoom_Simple(word Pos_X, word Pos_Y,
 )
 
 {
-  byte* Src = Brosse + Decalage_Y * Largeur_brosse + Decalage_X;
+  byte* Src = Brosse + y_offset * Largeur_brosse + x_offset;
   int y=Pos_Y;
 
   //Pour chaque ligne à zoomer :
@@ -435,10 +435,10 @@ void Display_brush_Mono_zoom_Simple(word Pos_X, word Pos_Y,
   }
 }
 
-void Clear_brush_zoom_Simple(word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,__attribute__((unused)) byte Couleur_de_transparence,word Largeur_image,byte * Buffer)
+void Clear_brush_zoom_Simple(word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,__attribute__((unused)) byte Couleur_de_transparence,word Largeur_image,byte * Buffer)
 {
   // En fait on va recopier l'image non zoomée dans la partie zoomée !
-  byte* Src = Principal_Ecran + Decalage_Y * Largeur_image + Decalage_X;
+  byte* Src = Principal_Ecran + y_offset * Largeur_image + x_offset;
   int y = Pos_Y;
   int bx;
 
diff --git a/pxsimple.h b/pxsimple.h
index 7a6195f3..553767da 100644
--- a/pxsimple.h
+++ b/pxsimple.h
@@ -28,18 +28,18 @@
   void Pixel_Preview_Loupe_Simple        (word X,word Y,byte Couleur);
   void Ligne_horizontale_XOR_Simple      (word Pos_X,word Pos_Y,word Largeur);
   void Ligne_verticale_XOR_Simple        (word Pos_X,word Pos_Y,word Hauteur);
-  void Display_brush_Color_Simple        (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
-  void Display_brush_Mono_Simple         (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse);
-  void Clear_brush_Simple                (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_image);
+  void Display_brush_Color_Simple        (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
+  void Display_brush_Mono_Simple         (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse);
+  void Clear_brush_Simple                (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_image);
   void Remap_screen_Simple               (word Pos_X,word Pos_Y,word Largeur,word Hauteur,byte * Table_de_conversion);
   void Afficher_partie_de_l_ecran_Simple (word Largeur,word Hauteur,word Largeur_image);
   void Afficher_une_ligne_ecran_Simple   (word Pos_X,word Pos_Y,word Largeur,byte * Ligne);
   void Lire_une_ligne_ecran_Simple       (word Pos_X,word Pos_Y,word Largeur,byte * Ligne);
   void Afficher_partie_de_l_ecran_zoomee_Simple(word Largeur,word Hauteur,word Largeur_image,byte * Buffer);
-  void Display_brush_Color_zoom_Simple   (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_brosse,byte * Buffer);
-  void Display_brush_Mono_zoom_Simple    (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse,byte * Buffer);
-  void Clear_brush_zoom_Simple           (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer);
-  void Affiche_brosse_Simple             (byte * brush, word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
+  void Display_brush_Color_zoom_Simple   (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_brosse,byte * Buffer);
+  void Display_brush_Mono_zoom_Simple    (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse,byte * Buffer);
+  void Clear_brush_zoom_Simple           (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer);
+  void Affiche_brosse_Simple             (byte * brush, word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
 
 void Afficher_une_ligne_transparente_mono_a_l_ecran_Simple(
         word Pos_X, word Pos_Y, word Largeur, byte* Ligne, 
diff --git a/pxtall.c b/pxtall.c
index eeb02659..b8c477bb 100644
--- a/pxtall.c
+++ b/pxtall.c
@@ -138,12 +138,12 @@ void Ligne_verticale_XOR_Tall(word Pos_X,word Pos_Y,word Hauteur)
   }
 }
 
-void Display_brush_Color_Tall(word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
+void Display_brush_Color_Tall(word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
 {
   // Dest = Position à l'écran
   byte* Dest = Ecran + Pos_Y * 2 * Largeur_ecran + Pos_X;
   // Src = Position dans la brosse
-  byte* Src = Brosse + Decalage_Y * Largeur_brosse + Decalage_X;
+  byte* Src = Brosse + y_offset * Largeur_brosse + x_offset;
 
   word x,y;
 
@@ -172,13 +172,13 @@ void Display_brush_Color_Tall(word Pos_X,word Pos_Y,word Decalage_X,word Decalag
 }
 
 void Display_brush_Mono_Tall(word Pos_X, word Pos_Y,
-        word Decalage_X, word Decalage_Y, word Largeur, word Hauteur,
+        word x_offset, word y_offset, word Largeur, word Hauteur,
         byte Couleur_de_transparence, byte Couleur, word Largeur_brosse)
 /* On affiche la brosse en monochrome */
 {
   byte* Dest=Pos_Y*2*Largeur_ecran+Pos_X+Ecran; // Dest = adr Destination à 
       // l'écran
-  byte* Src=Largeur_brosse*Decalage_Y+Decalage_X+Brosse; // Src = adr ds 
+  byte* Src=Largeur_brosse*y_offset+x_offset+Brosse; // Src = adr ds 
       // la brosse
   int x,y;
 
@@ -206,7 +206,7 @@ void Display_brush_Mono_Tall(word Pos_X, word Pos_Y,
   UpdateRect(Pos_X,Pos_Y,Largeur,Hauteur);
 }
 
-void Clear_brush_Tall(word Pos_X,word Pos_Y,__attribute__((unused)) word Decalage_X,__attribute__((unused)) word Decalage_Y,word Largeur,word Hauteur,__attribute__((unused))byte Couleur_de_transparence,word Largeur_image)
+void Clear_brush_Tall(word Pos_X,word Pos_Y,__attribute__((unused)) word x_offset,__attribute__((unused)) word y_offset,word Largeur,word Hauteur,__attribute__((unused))byte Couleur_de_transparence,word Largeur_image)
 {
   byte* Dest=Ecran+Pos_X+Pos_Y*2*Largeur_ecran; //On va se mettre en 0,0 dans l'écran (Dest)
   byte* Src = ( Pos_Y + Principal_Decalage_Y ) * Largeur_image + Pos_X + Principal_Decalage_X + Principal_Ecran; //Coords de départ ds la source (Src)
@@ -228,12 +228,12 @@ void Clear_brush_Tall(word Pos_X,word Pos_Y,__attribute__((unused)) word Decalag
 }
 
 // Affiche une brosse (arbitraire) à l'écran
-void Affiche_brosse_Tall(byte * brush, word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
+void Affiche_brosse_Tall(byte * brush, word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
 {
   // Dest = Position à l'écran
   byte* Dest = Ecran + Pos_Y * 2 * Largeur_ecran + Pos_X;
   // Src = Position dans la brosse
-  byte* Src = brush + Decalage_Y * Largeur_brosse + Decalage_X;
+  byte* Src = brush + y_offset * Largeur_brosse + x_offset;
   
   word x,y;
   
@@ -301,7 +301,7 @@ void Afficher_partie_de_l_ecran_zoomee_Tall(
 {
   byte* Src = Principal_Ecran + Loupe_Decalage_Y * Largeur_image 
                       + Loupe_Decalage_X;
-  int EDX = 0; // Ligne en cours de traitement
+  int y = 0; // Ligne en cours de traitement
 
   // Pour chaque ligne à zoomer
   while(1)
@@ -316,12 +316,12 @@ void Afficher_partie_de_l_ecran_zoomee_Tall(
     do{
       // On affiche la ligne zoomée
       Afficher_une_ligne_ecran_Simple(
-        Principal_X_Zoom, EDX, Largeur*Loupe_Facteur,
+        Principal_X_Zoom, y, Largeur*Loupe_Facteur,
         Buffer
       );
       // On passe à la suivante
-      EDX++;
-      if(EDX==Hauteur*2)
+      y++;
+      if(y==Hauteur*2)
       {
         UpdateRect(Principal_X_Zoom,0,
           Largeur*Loupe_Facteur,Hauteur);
@@ -336,13 +336,13 @@ void Afficher_partie_de_l_ecran_zoomee_Tall(
 
 // Affiche une partie de la brosse couleur zoomée
 void Display_brush_Color_zoom_Tall(word Pos_X,word Pos_Y,
-        word Decalage_X,word Decalage_Y,
+        word x_offset,word y_offset,
         word Largeur, // Largeur non zoomée
         word Pos_Y_Fin,byte Couleur_de_transparence,
         word Largeur_brosse, // Largeur réelle de la brosse
         byte * Buffer)
 {
-  byte* Src = Brosse+Decalage_Y*Largeur_brosse + Decalage_X;
+  byte* Src = Brosse+y_offset*Largeur_brosse + x_offset;
   word y = Pos_Y;
   byte bx;
 
@@ -367,7 +367,7 @@ void Display_brush_Color_zoom_Tall(word Pos_X,word Pos_Y,
 }
 
 void Display_brush_Mono_zoom_Tall(word Pos_X, word Pos_Y,
-        word Decalage_X, word Decalage_Y, 
+        word x_offset, word y_offset, 
         word Largeur, // Largeur non zoomée 
         word Pos_Y_Fin,
         byte Couleur_de_transparence, byte Couleur, 
@@ -376,7 +376,7 @@ void Display_brush_Mono_zoom_Tall(word Pos_X, word Pos_Y,
 )
 
 {
-  byte* Src = Brosse + Decalage_Y * Largeur_brosse + Decalage_X;
+  byte* Src = Brosse + y_offset * Largeur_brosse + x_offset;
   int y=Pos_Y*2;
 
   //Pour chaque ligne à zoomer :
@@ -417,10 +417,10 @@ void Display_brush_Mono_zoom_Tall(word Pos_X, word Pos_Y,
   }
 }
 
-void Clear_brush_zoom_Tall(word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,__attribute__((unused)) byte Couleur_de_transparence,word Largeur_image,byte * Buffer)
+void Clear_brush_zoom_Tall(word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,__attribute__((unused)) byte Couleur_de_transparence,word Largeur_image,byte * Buffer)
 {
   // En fait on va recopier l'image non zoomée dans la partie zoomée !
-  byte* Src = Principal_Ecran + Decalage_Y * Largeur_image + Decalage_X;
+  byte* Src = Principal_Ecran + y_offset * Largeur_image + x_offset;
   int y = Pos_Y;
   int bx;
 
diff --git a/pxtall.h b/pxtall.h
index d9d64e1c..4b0165b1 100644
--- a/pxtall.h
+++ b/pxtall.h
@@ -28,15 +28,15 @@
   void Pixel_Preview_Loupe_Tall          (word X,word Y,byte Couleur);
   void Ligne_horizontale_XOR_Tall        (word Pos_X,word Pos_Y,word Largeur);
   void Ligne_verticale_XOR_Tall          (word Pos_X,word Pos_Y,word Hauteur);
-  void Display_brush_Color_Tall          (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
-  void Display_brush_Mono_Tall           (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse);
-  void Clear_brush_Tall                  (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_image);
+  void Display_brush_Color_Tall          (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
+  void Display_brush_Mono_Tall           (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse);
+  void Clear_brush_Tall                  (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_image);
   void Remap_screen_Tall                 (word Pos_X,word Pos_Y,word Largeur,word Hauteur,byte * Table_de_conversion);
   void Afficher_partie_de_l_ecran_Tall   (word Largeur,word Hauteur,word Largeur_image);
   void Afficher_une_ligne_ecran_Tall     (word Pos_X,word Pos_Y,word Largeur,byte * Ligne);
   void Lire_une_ligne_ecran_Tall         (word Pos_X,word Pos_Y,word Largeur,byte * Ligne);
   void Afficher_partie_de_l_ecran_zoomee_Tall(word Largeur,word Hauteur,word Largeur_image,byte * Buffer);
-  void Display_brush_Color_zoom_Tall     (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_brosse,byte * Buffer);
-  void Display_brush_Mono_zoom_Tall      (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse,byte * Buffer);
-  void Clear_brush_zoom_Tall             (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer);
-  void Affiche_brosse_Tall               (byte * brush, word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
+  void Display_brush_Color_zoom_Tall     (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_brosse,byte * Buffer);
+  void Display_brush_Mono_zoom_Tall      (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse,byte * Buffer);
+  void Clear_brush_zoom_Tall             (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer);
+  void Affiche_brosse_Tall               (byte * brush, word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
diff --git a/pxwide.c b/pxwide.c
index 3a51f182..77324e3a 100644
--- a/pxwide.c
+++ b/pxwide.c
@@ -140,12 +140,12 @@ void Ligne_verticale_XOR_Wide(word Pos_X,word Pos_Y,word Hauteur)
   }
 }
 
-void Display_brush_Color_Wide(word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
+void Display_brush_Color_Wide(word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
 {
   // Dest = Position à l'écran
   byte* Dest = Ecran + Pos_Y * 2 * Largeur_ecran + Pos_X * 2;
   // Src = Position dans la brosse
-  byte* Src = Brosse + Decalage_Y * Largeur_brosse + Decalage_X;
+  byte* Src = Brosse + y_offset * Largeur_brosse + x_offset;
 
   word x,y;
 
@@ -174,13 +174,13 @@ void Display_brush_Color_Wide(word Pos_X,word Pos_Y,word Decalage_X,word Decalag
 }
 
 void Display_brush_Mono_Wide(word Pos_X, word Pos_Y,
-        word Decalage_X, word Decalage_Y, word Largeur, word Hauteur,
+        word x_offset, word y_offset, word Largeur, word Hauteur,
         byte Couleur_de_transparence, byte Couleur, word Largeur_brosse)
 /* On affiche la brosse en monochrome */
 {
   byte* Dest=Pos_Y*2*Largeur_ecran+Pos_X*2+Ecran; // Dest = adr Destination à 
       // l'écran
-  byte* Src=Largeur_brosse*Decalage_Y+Decalage_X+Brosse; // Src = adr ds 
+  byte* Src=Largeur_brosse*y_offset+x_offset+Brosse; // Src = adr ds 
       // la brosse
   int x,y;
 
@@ -205,7 +205,7 @@ void Display_brush_Mono_Wide(word Pos_X, word Pos_Y,
   UpdateRect(Pos_X,Pos_Y,Largeur,Hauteur);
 }
 
-void Clear_brush_Wide(word Pos_X,word Pos_Y,__attribute__((unused)) word Decalage_X,__attribute__((unused)) word Decalage_Y,word Largeur,word Hauteur,__attribute__((unused))byte Couleur_de_transparence,word Largeur_image)
+void Clear_brush_Wide(word Pos_X,word Pos_Y,__attribute__((unused)) word x_offset,__attribute__((unused)) word y_offset,word Largeur,word Hauteur,__attribute__((unused))byte Couleur_de_transparence,word Largeur_image)
 {
   byte* Dest=Ecran+Pos_X*2+Pos_Y*2*Largeur_ecran; //On va se mettre en 0,0 dans l'écran (Dest)
   byte* Src = ( Pos_Y + Principal_Decalage_Y ) * Largeur_image + Pos_X + Principal_Decalage_X + Principal_Ecran; //Coords de départ ds la source (Src)
@@ -233,12 +233,12 @@ void Clear_brush_Wide(word Pos_X,word Pos_Y,__attribute__((unused)) word Decalag
 }
 
 // Affiche une brosse (arbitraire) à l'écran
-void Affiche_brosse_Wide(byte * brush, word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
+void Affiche_brosse_Wide(byte * brush, word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
 {
   // Dest = Position à l'écran
   byte* Dest = Ecran + Pos_Y * 2 * Largeur_ecran + Pos_X * 2;
   // Src = Position dans la brosse
-  byte* Src = brush + Decalage_Y * Largeur_brosse + Decalage_X;
+  byte* Src = brush + y_offset * Largeur_brosse + x_offset;
   
   word x,y;
   
@@ -341,7 +341,7 @@ void Afficher_partie_de_l_ecran_zoomee_Wide(
 {
   byte* Src = Principal_Ecran + Loupe_Decalage_Y * Largeur_image 
                       + Loupe_Decalage_X;
-  int EDX = 0; // Ligne en cours de traitement
+  int y = 0; // Ligne en cours de traitement
 
   // Pour chaque ligne à zoomer
   while(1)
@@ -356,12 +356,12 @@ void Afficher_partie_de_l_ecran_zoomee_Wide(
     do{
       // On affiche la ligne zoomée
       Afficher_une_ligne_ecran_fast_Wide(
-        Principal_X_Zoom, EDX, Largeur*Loupe_Facteur,
+        Principal_X_Zoom, y, Largeur*Loupe_Facteur,
         Buffer
       );
       // On passe à la suivante
-      EDX++;
-      if(EDX==Hauteur)
+      y++;
+      if(y==Hauteur)
       {
         UpdateRect(Principal_X_Zoom,0,
           Largeur*Loupe_Facteur,Hauteur);
@@ -396,13 +396,13 @@ void Afficher_une_ligne_transparente_a_l_ecran_Wide(word Pos_X,word Pos_Y,word L
 
 // Affiche une partie de la brosse couleur zoomée
 void Display_brush_Color_zoom_Wide(word Pos_X,word Pos_Y,
-        word Decalage_X,word Decalage_Y,
+        word x_offset,word y_offset,
         word Largeur, // Largeur non zoomée
         word Pos_Y_Fin,byte Couleur_de_transparence,
         word Largeur_brosse, // Largeur réelle de la brosse
         byte * Buffer)
 {
-  byte* Src = Brosse+Decalage_Y*Largeur_brosse + Decalage_X;
+  byte* Src = Brosse+y_offset*Largeur_brosse + x_offset;
   word y = Pos_Y;
   byte bx;
 
@@ -426,7 +426,7 @@ void Display_brush_Color_zoom_Wide(word Pos_X,word Pos_Y,
 }
 
 void Display_brush_Mono_zoom_Wide(word Pos_X, word Pos_Y,
-        word Decalage_X, word Decalage_Y, 
+        word x_offset, word y_offset, 
         word Largeur, // Largeur non zoomée 
         word Pos_Y_Fin,
         byte Couleur_de_transparence, byte Couleur, 
@@ -435,7 +435,7 @@ void Display_brush_Mono_zoom_Wide(word Pos_X, word Pos_Y,
 )
 
 {
-  byte* Src = Brosse + Decalage_Y * Largeur_brosse + Decalage_X;
+  byte* Src = Brosse + y_offset * Largeur_brosse + x_offset;
   int y=Pos_Y;
 
   //Pour chaque ligne à zoomer :
@@ -476,10 +476,10 @@ void Display_brush_Mono_zoom_Wide(word Pos_X, word Pos_Y,
   }
 }
 
-void Clear_brush_zoom_Wide(word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,__attribute__((unused)) byte Couleur_de_transparence,word Largeur_image,byte * Buffer)
+void Clear_brush_zoom_Wide(word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,__attribute__((unused)) byte Couleur_de_transparence,word Largeur_image,byte * Buffer)
 {
   // En fait on va recopier l'image non zoomée dans la partie zoomée !
-  byte* Src = Principal_Ecran + Decalage_Y * Largeur_image + Decalage_X;
+  byte* Src = Principal_Ecran + y_offset * Largeur_image + x_offset;
   int y = Pos_Y;
   int bx;
 
diff --git a/pxwide.h b/pxwide.h
index c1981559..a9283b8a 100644
--- a/pxwide.h
+++ b/pxwide.h
@@ -28,18 +28,18 @@
   void Pixel_Preview_Loupe_Wide        (word X,word Y,byte Couleur);
   void Ligne_horizontale_XOR_Wide      (word Pos_X,word Pos_Y,word Largeur);
   void Ligne_verticale_XOR_Wide        (word Pos_X,word Pos_Y,word Hauteur);
-  void Display_brush_Color_Wide        (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
-  void Display_brush_Mono_Wide         (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse);
-  void Clear_brush_Wide                (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_image);
+  void Display_brush_Color_Wide        (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
+  void Display_brush_Mono_Wide         (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse);
+  void Clear_brush_Wide                (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_image);
   void Remap_screen_Wide               (word Pos_X,word Pos_Y,word Largeur,word Hauteur,byte * Table_de_conversion);
   void Afficher_partie_de_l_ecran_Wide (word Largeur,word Hauteur,word Largeur_image);
   void Afficher_une_ligne_ecran_Wide   (word Pos_X,word Pos_Y,word Largeur,byte * Ligne);
   void Lire_une_ligne_ecran_Wide       (word Pos_X,word Pos_Y,word Largeur,byte * Ligne);
   void Afficher_partie_de_l_ecran_zoomee_Wide(word Largeur,word Hauteur,word Largeur_image,byte * Buffer);
-  void Display_brush_Color_zoom_Wide   (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_brosse,byte * Buffer);
-  void Display_brush_Mono_zoom_Wide    (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse,byte * Buffer);
-  void Clear_brush_zoom_Wide           (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer);
-  void Affiche_brosse_Wide             (byte * brush, word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
+  void Display_brush_Color_zoom_Wide   (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_brosse,byte * Buffer);
+  void Display_brush_Mono_zoom_Wide    (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse,byte * Buffer);
+  void Clear_brush_zoom_Wide           (word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer);
+  void Affiche_brosse_Wide             (byte * brush, word Pos_X,word Pos_Y,word x_offset,word y_offset,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse);
 
   void Afficher_une_ligne_ecran_fast_Wide   (word Pos_X,word Pos_Y,word Largeur,byte * Ligne);
   void Afficher_une_ligne_transparente_a_l_ecran_Wide(word Pos_X,word Pos_Y,word Largeur,byte* Ligne,byte Couleur_transparence);
diff --git a/saveini.c b/saveini.c
index 39abb535..c65456a1 100644
--- a/saveini.c
+++ b/saveini.c
@@ -102,7 +102,7 @@ int Sauver_INI_char_in_value_alphabet(char Char)
 
 
 
-void Sauver_INI_Set_value(char * Destination,char * Source,int Nb_values_to_set,int * Values,int Litteral)
+void Sauver_INI_Set_value(char * dest,char * Source,int Nb_values_to_set,int * Values,int Litteral)
 {
   int Indice_destination;
   int Indice_source;
@@ -110,15 +110,15 @@ void Sauver_INI_Set_value(char * Destination,char * Source,int Nb_values_to_set,
 
   // On commence par recopier tout jusqu'au symbole '=':
   for (Indice_source=0;Source[Indice_source]!='=';Indice_source++)
-    Destination[Indice_source]=Source[Indice_source];
+    dest[Indice_source]=Source[Indice_source];
 
   // Puis on recopie le symbole '=':
-  Destination[Indice_source]=Source[Indice_source];
+  dest[Indice_source]=Source[Indice_source];
   Indice_source++;
 
   // Puis on recopie tous les espaces qui suivent:
   for (;Source[Indice_source]==' ';Indice_source++)
-    Destination[Indice_source]=Source[Indice_source];
+    dest[Indice_source]=Source[Indice_source];
 
   // Pour l'instant, la source et la destination en sont au même point:
   Indice_destination=Indice_source;
@@ -135,14 +135,14 @@ void Sauver_INI_Set_value(char * Destination,char * Source,int Nb_values_to_set,
       {
         // La valeur <=> Yes  
 
-        memcpy(Destination+Indice_destination,"yes",3);
+        memcpy(dest+Indice_destination,"yes",3);
         Indice_destination+=3;
       }
       else
       {
         // La valeur <=> No
 
-        memcpy(Destination+Indice_destination,"no",2);
+        memcpy(dest+Indice_destination,"no",2);
         Indice_destination+=2;
       }
     }
@@ -155,18 +155,18 @@ void Sauver_INI_Set_value(char * Destination,char * Source,int Nb_values_to_set,
         // On va écrire la valeur sous forme hexadécimale:
 
         // On commence par inscrire le symbole '$':
-        Destination[Indice_destination]='$';
+        dest[Indice_destination]='$';
 
         // Puis on y concatène la valeur:
-        sprintf(Destination+Indice_destination+1,"%x",Values[Indice_valeur]);
-        Indice_destination+=strlen(Destination+Indice_destination);
+        sprintf(dest+Indice_destination+1,"%x",Values[Indice_valeur]);
+        Indice_destination+=strlen(dest+Indice_destination);
       }
       else
       {
         // On va écrire la valeur sous forme décimale:
 
-        sprintf(Destination+Indice_destination,"%d",Values[Indice_valeur]);
-        Indice_destination+=strlen(Destination+Indice_destination);
+        sprintf(dest+Indice_destination,"%d",Values[Indice_valeur]);
+        Indice_destination+=strlen(dest+Indice_destination);
       }
     }
 
@@ -180,7 +180,7 @@ void Sauver_INI_Set_value(char * Destination,char * Source,int Nb_values_to_set,
       // On recopie tous les caractères de la source jusqu'au suivant qui
       // désigne une valeur:
       for (;(!Sauver_INI_char_in_value_alphabet(Source[Indice_source])) && (Source[Indice_source]!='\0');Indice_source++,Indice_destination++)
-        Destination[Indice_destination]=Source[Indice_source];
+        dest[Indice_destination]=Source[Indice_source];
     }
     else
     {
@@ -188,36 +188,36 @@ void Sauver_INI_Set_value(char * Destination,char * Source,int Nb_values_to_set,
 
       // On recopie toute la fin de la ligne:
       for (;Source[Indice_source]!='\0';Indice_source++,Indice_destination++)
-        Destination[Indice_destination]=Source[Indice_source];
+        dest[Indice_destination]=Source[Indice_source];
 
       // Et on n'oublie pas d'y mettre l''\0':
-      Destination[Indice_destination]='\0';
+      dest[Indice_destination]='\0';
     }
   }
 }
 
-void Sauver_INI_Set_string(char * Destination,char * Source,char * Value)
+void Sauver_INI_Set_string(char * dest,char * Source,char * Value)
 {
   int Indice_destination;
   int Indice_source;
      
   // On commence par recopier tout jusqu'au symbole '=':
   for (Indice_source=0;Source[Indice_source]!='=';Indice_source++)
-    Destination[Indice_source]=Source[Indice_source];
+    dest[Indice_source]=Source[Indice_source];
 
   // Puis on recopie le symbole '=':
-  Destination[Indice_source]=Source[Indice_source];
+  dest[Indice_source]=Source[Indice_source];
   Indice_source++;
 
   // Puis on recopie tous les espaces qui suivent:
   for (;Source[Indice_source]==' ';Indice_source++)
-    Destination[Indice_source]=Source[Indice_source];
+    dest[Indice_source]=Source[Indice_source];
 
   // Pour l'instant, la source et la destination en sont au même point:
   Indice_destination=Indice_source;
 
   // Dans la destination, on écrit la valeur:
-  strcpy(Destination+Indice_destination,Value);
+  strcpy(dest+Indice_destination,Value);
   Indice_destination+=strlen(Value);
 
   // Dans la source, on saute la valeur:
@@ -225,10 +225,10 @@ void Sauver_INI_Set_string(char * Destination,char * Source,char * Value)
 
   // On recopie toute la fin de la ligne:
   for (;Source[Indice_source]!='\0';Indice_source++,Indice_destination++)
-    Destination[Indice_destination]=Source[Indice_source];
+    dest[Indice_destination]=Source[Indice_source];
 
   // Et on n'oublie pas d'y mettre l''\0':
-  Destination[Indice_destination]='\0';
+  dest[Indice_destination]='\0';
 }
 
 int Sauver_INI_Set_strings(FILE * Old_file,FILE * New_file,char * Buffer,char * Option,char * Value)
diff --git a/sdlscreen.c b/sdlscreen.c
index 954a7bba..1fd512dc 100644
--- a/sdlscreen.c
+++ b/sdlscreen.c
@@ -140,7 +140,7 @@ void UpdateRect(short X, short Y, unsigned short Largeur, unsigned short Hauteur
 // Convertit une SDL_Surface (couleurs indexées ou RGB) en tableau de bytes (couleurs indexées)
 // Si on passe NULL comme destination, elle est allouée par malloc(). Sinon,
 // attention aux dimensions!
-byte * Surface_en_bytefield(SDL_Surface *Source, byte * Destination)
+byte * Surface_en_bytefield(SDL_Surface *Source, byte * dest)
 {
   byte *Src;
   byte *Dst;
@@ -156,10 +156,10 @@ byte * Surface_en_bytefield(SDL_Surface *Source, byte * Destination)
   else
     Reste=0;
 
-  if (Destination==NULL)
-    Destination=(byte *)malloc(Source->w*Source->h);
+  if (dest==NULL)
+    dest=(byte *)malloc(Source->w*Source->h);
 
-  Dst=Destination;
+  Dst=dest;
   Src=(byte *)(Source->pixels);
   for(Y=0; Y < Source->h; Y++)
   {
@@ -167,7 +167,7 @@ byte * Surface_en_bytefield(SDL_Surface *Source, byte * Destination)
     Dst += Source->w;
     Src += Source->w + Reste;
   }
-  return Destination;
+  return dest;
 
 }
 
diff --git a/sdlscreen.h b/sdlscreen.h
index 0ed1081f..376f3ec5 100644
--- a/sdlscreen.h
+++ b/sdlscreen.h
@@ -32,7 +32,7 @@
 
   void UpdateRect(short X, short Y, unsigned short Largeur, unsigned short Hauteur);
   void Flush_update(void);
-  byte * Surface_en_bytefield(SDL_Surface *Source, byte * Destination);
+  byte * Surface_en_bytefield(SDL_Surface *Source, byte * dest);
   SDL_Color Conversion_couleur_SDL(byte);
   byte Sdl_Get_pixel_8(SDL_Surface *Bmp, int X, int Y);
   
diff --git a/translat/translations.xls b/translat/translations.xls
index 50ba58cb..c6307c60 100644
Binary files a/translat/translations.xls and b/translat/translations.xls differ
diff --git a/windows.c b/windows.c
index 1f021965..d8a19870 100644
--- a/windows.c
+++ b/windows.c
@@ -1082,14 +1082,14 @@ void Afficher_palette_du_menu_en_evitant_la_fenetre(byte * Table)
         // Cela permet au bloc de couleur d'apparaitre si on déplace la fenetre.
         short Pos_X;
         short Pos_Y;
-        short Deb_X; // besoin d'une variable signée
-        short Deb_Y; // besoin d'une variable signée
+        short relative_x; // besoin d'une variable signée
+        short relative_y; // besoin d'une variable signée
         // Attention aux unités
-        Deb_X = ((short)Debut_X - (short)Fenetre_Pos_X);
-        Deb_Y = ((short)Debut_Y - (short)Fenetre_Pos_Y);
+        relative_x = ((short)Debut_X - (short)Fenetre_Pos_X);
+        relative_y = ((short)Debut_Y - (short)Fenetre_Pos_Y);
 
-        for (Pos_Y=Deb_Y;Pos_Y<(Deb_Y+Hauteur)&&Pos_Y<Fenetre_Hauteur*Menu_Facteur_Y;Pos_Y++)
-          for (Pos_X=Deb_X;Pos_X<(Deb_X+Largeur)&&Pos_X<Fenetre_Largeur*Menu_Facteur_X;Pos_X++)
+        for (Pos_Y=relative_y;Pos_Y<(relative_y+Hauteur)&&Pos_Y<Fenetre_Hauteur*Menu_Facteur_Y;Pos_Y++)
+          for (Pos_X=relative_x;Pos_X<(relative_x+Largeur)&&Pos_X<Fenetre_Largeur*Menu_Facteur_X;Pos_X++)
             if (Pos_X>=0&&Pos_Y>=0)
               Pixel_fond(Pos_X,Pos_Y,Vraie_couleur);
       }
@@ -1185,9 +1185,9 @@ void Calculer_coordonnees_pinceau(void)
 // -- Affichage de la limite de l'image -------------------------------------
 void Afficher_limites_de_l_image(void)
 {
-  short Debut;
+  short start;
   short Pos;
-  short Fin;
+  short end;
   byte Droite_visible;
   byte Bas_visible;
   short Ancienne_Limite_Zoom;
@@ -1199,22 +1199,22 @@ void Afficher_limites_de_l_image(void)
   // On vérifie que la limite à droite est visible:
   if (Droite_visible)
   {
-    Debut=Limite_Haut;
-    Fin=(Limite_Bas<Principal_Hauteur_image)?
+    start=Limite_Haut;
+    end=(Limite_Bas<Principal_Hauteur_image)?
         Limite_Bas:Principal_Hauteur_image;
 
     if (Bas_visible)
-      Fin++;
+      end++;
 
     // Juste le temps d'afficher les limites, on étend les limites de la loupe
     // aux limites visibles, car sinon Pixel_Preview ne voudra pas afficher.
     Ancienne_Limite_Zoom=Limite_Droite_Zoom;
     Limite_Droite_Zoom=Limite_visible_Droite_Zoom;
 
-    for (Pos=Debut;Pos<=Fin;Pos++)
+    for (Pos=start;Pos<=end;Pos++)
       Pixel_Preview(Principal_Largeur_image,Pos,((Pos+Principal_Hauteur_image)&1)?CM_Blanc:CM_Noir);
 
-    UpdateRect(Principal_Largeur_image,Debut,1,Fin-Debut + 1);
+    UpdateRect(Principal_Largeur_image,start,1,end-start + 1);
     // On restaure la bonne valeur des limites
     Limite_Droite_Zoom=Ancienne_Limite_Zoom;
   }
@@ -1222,18 +1222,18 @@ void Afficher_limites_de_l_image(void)
   // On vérifie que la limite en bas est visible:
   if (Bas_visible)
   {
-    Debut=Limite_Gauche;
-    Fin=(Limite_Droite<Principal_Largeur_image)?
+    start=Limite_Gauche;
+    end=(Limite_Droite<Principal_Largeur_image)?
         Limite_Droite:Principal_Largeur_image;
 
     // On étend également les limites en bas (comme pour la limite droit)
     Ancienne_Limite_Zoom=Limite_Bas_Zoom;
     Limite_Bas_Zoom=Limite_visible_Bas_Zoom;
 
-    for (Pos=Debut;Pos<=Fin;Pos++)
+    for (Pos=start;Pos<=end;Pos++)
       Pixel_Preview(Pos,Principal_Hauteur_image,((Pos+Principal_Hauteur_image)&1)?CM_Blanc:CM_Noir);
 
-    UpdateRect(Debut,Principal_Hauteur_image,Fin-Debut + 1,1);
+    UpdateRect(start,Principal_Hauteur_image,end-start + 1,1);
 
     // On restaure la bonne valeur des limites
     Limite_Bas_Zoom=Ancienne_Limite_Zoom;