diff --git a/Makefile.dep b/Makefile.dep
index 825aa201..81925932 100644
--- a/Makefile.dep
+++ b/Makefile.dep
@@ -1,8 +1,8 @@
 main.o: main.c const.h struct.h global.h loadsave.h graph.h divers.h \
   init.h boutons.h moteur.h pages.h files.h sdlscreen.h erreurs.h \
   readini.h saveini.h linux.h
-init.o: init.c const.h struct.h global.h loadsave.h graph.h \
-  boutons.h palette.h aide.h operatio.h divers.h erreurs.h clavier.h
+init.o: init.c const.h struct.h global.h loadsave.h graph.h boutons.h \
+  palette.h aide.h operatio.h divers.h erreurs.h clavier.h io.h
 graph.o: graph.c sdlscreen.h struct.h const.h graph.h divers.h moteur.h \
   boutons.h pages.h global.h loadsave.h erreurs.h
 sdlscreen.o: sdlscreen.c global.h struct.h const.h loadsave.h sdlscreen.h \
diff --git a/const.h b/const.h
index c556e07a..952dc110 100644
--- a/const.h
+++ b/const.h
@@ -14,7 +14,6 @@
 #define BETA1                     97    // |  plusieurs parties => 2.0 ß95.5%
 #define BETA2                     0     // |
 #define ALPHA_BETA                "ß"   // Type de la version "Þ" ou "ß"
-#define TAILLE_FICHIER_CONFIG     10351 // Taille du fichier GFX2.CFG
 #define DAT_DEBUT_INI_PAR_DEFAUT  0xF385 // Dans gfx2.dat, début du fichier gfx2.ini standard
 #define NB_MODES_VIDEO            60    // Nombre de modes vidéo
 #define NB_BOUTONS                38    // Nombre de boutons à gérer
@@ -274,6 +273,7 @@ enum CHUNKS_CFG
   CHUNK_SMOOTH             = 6,
   CHUNK_EXCLUDE_COLORS     = 7,
   CHUNK_QUICK_SHADE        = 8,
+  CHUNK_GRILLE             = 9,
   CHUNK_MAX 
 };
 
diff --git a/gfx2.cfg b/gfx2.cfg
index 67f5eb9b..3099d78d 100644
Binary files a/gfx2.cfg and b/gfx2.cfg differ
diff --git a/gfx2.ini b/gfx2.ini
index a5473a0a..96fb7238 100644
--- a/gfx2.ini
+++ b/gfx2.ini
@@ -62,7 +62,7 @@
   ; 1: Solid                          | 1: Solide
   ; 2: Transparent                    | 2: Transparent
   ; 3: Thin (solid)                   | 3: Fin (solide)
-  Cursor_aspect = 1	; (default 1)
+  Cursor_aspect = 3	; (default 1)
 
 
 
@@ -286,4 +286,4 @@
   ; Number of the default video mode  | Numéro du mode vidéo par défaut au
   ; at startup (see the list by typing| démarrage (voir la liste en tapant
   ; "gfx2 /?" at the DOS prompt).     | "gfx2 /?" sur la ligne de commande).
-  Default_video_mode = 58	; (default 0)
+  Default_video_mode = 53	; (default 0)
diff --git a/global.h b/global.h
index 25eec4d3..11bacf80 100644
--- a/global.h
+++ b/global.h
@@ -474,7 +474,7 @@ GLOBAL fonction_degrade Traiter_degrade; // Fonction de traitement du d
 GLOBAL fonction_afficheur Traiter_pixel_de_degrade; // Redirection de l'affichage
 
 GLOBAL struct T_Degrade_Tableau Degrade_Tableau[16]; // Données de tous les dégradés
-GLOBAL int Degrade_Courant;             // Indice du tableau correspondant au dégradé courant
+GLOBAL byte Degrade_Courant;             // Indice du tableau correspondant au dégradé courant
 
 
 
diff --git a/init.c b/init.c
index 81f37c18..dbee176b 100644
--- a/init.c
+++ b/init.c
@@ -20,6 +20,7 @@
 #include "divers.h"
 #include "erreurs.h"
 #include "clavier.h"
+#include "io.h"
 
 #include "errno.h"
 
@@ -231,38 +232,33 @@ void Charger_DAT(void)
   	Erreur(ERREUR_DAT_ABSENT);
   }
 
-  if (fread(Palette_defaut,1,sizeof(T_Palette),Handle)!=sizeof(T_Palette))
+  if (!read_bytes(Handle, Palette_defaut,sizeof(T_Palette)))
     Erreur(ERREUR_DAT_CORROMPU);
 
-  if (fread(BLOCK_MENU,1,LARGEUR_MENU*HAUTEUR_MENU,Handle)!=LARGEUR_MENU*HAUTEUR_MENU)
+  if (!read_bytes(Handle, BLOCK_MENU,LARGEUR_MENU*HAUTEUR_MENU))
     Erreur(ERREUR_DAT_CORROMPU);
 
-  if (fread(SPRITE_EFFET,1,LARGEUR_SPRITE_MENU*HAUTEUR_SPRITE_MENU*NB_SPRITES_EFFETS,Handle)!=
-      LARGEUR_SPRITE_MENU*HAUTEUR_SPRITE_MENU*NB_SPRITES_EFFETS)
+  if (!read_bytes(Handle, SPRITE_EFFET,LARGEUR_SPRITE_MENU*HAUTEUR_SPRITE_MENU*NB_SPRITES_EFFETS))
     Erreur(ERREUR_DAT_CORROMPU);
 
-  if (fread(SPRITE_CURSEUR,1,LARGEUR_SPRITE_CURSEUR*HAUTEUR_SPRITE_CURSEUR*NB_SPRITES_CURSEUR,Handle)!=
-      LARGEUR_SPRITE_CURSEUR*HAUTEUR_SPRITE_CURSEUR*NB_SPRITES_CURSEUR)
+  if (!read_bytes(Handle, SPRITE_CURSEUR,LARGEUR_SPRITE_CURSEUR*HAUTEUR_SPRITE_CURSEUR*NB_SPRITES_CURSEUR))
     Erreur(ERREUR_DAT_CORROMPU);
 
-  if (fread(SPRITE_MENU,1,LARGEUR_SPRITE_MENU*HAUTEUR_SPRITE_MENU*NB_SPRITES_MENU,Handle)!=
-      LARGEUR_SPRITE_MENU*HAUTEUR_SPRITE_MENU*NB_SPRITES_MENU)
+  if (!read_bytes(Handle, SPRITE_MENU,LARGEUR_SPRITE_MENU*HAUTEUR_SPRITE_MENU*NB_SPRITES_MENU))
     Erreur(ERREUR_DAT_CORROMPU);
 
-  if (fread(SPRITE_PINCEAU,1,LARGEUR_PINCEAU*HAUTEUR_PINCEAU*NB_SPRITES_PINCEAU,Handle)!=
-      LARGEUR_PINCEAU*HAUTEUR_PINCEAU*NB_SPRITES_PINCEAU)
+  if (!read_bytes(Handle, SPRITE_PINCEAU,LARGEUR_PINCEAU*HAUTEUR_PINCEAU*NB_SPRITES_PINCEAU))
     Erreur(ERREUR_DAT_CORROMPU);
 
-  if (fread(SPRITE_DRIVE,1,LARGEUR_SPRITE_DRIVE*HAUTEUR_SPRITE_DRIVE*NB_SPRITES_DRIVES,Handle)!=
-      LARGEUR_SPRITE_DRIVE*HAUTEUR_SPRITE_DRIVE*NB_SPRITES_DRIVES)
+  if (!read_bytes(Handle, SPRITE_DRIVE,LARGEUR_SPRITE_DRIVE*HAUTEUR_SPRITE_DRIVE*NB_SPRITES_DRIVES))
     Erreur(ERREUR_DAT_CORROMPU);
 
   if (!(Logo_GrafX2=(byte *)malloc(231*56)))
     Erreur(ERREUR_MEMOIRE);
-  if (fread(Logo_GrafX2,1,231*56,Handle)!=(231*56))
+  if (!read_bytes(Handle, Logo_GrafX2,231*56))
     Erreur(ERREUR_DAT_CORROMPU);
 
-  if (fread(TRAME_PREDEFINIE,1,2*16*NB_TRAMES_PREDEFINIES,Handle)!=2*16*NB_TRAMES_PREDEFINIES)
+  if (!read_bytes(Handle, TRAME_PREDEFINIE,2*16*NB_TRAMES_PREDEFINIES))
     Erreur(ERREUR_DAT_CORROMPU);
 
   // Lecture des fontes 8x8:
@@ -270,7 +266,7 @@ void Charger_DAT(void)
     Erreur(ERREUR_MEMOIRE);
 
   // Lecture de la fonte système
-  if (fread(Fonte_temporaire,1,2048,Handle)!=2048)
+  if (!read_bytes(Handle, Fonte_temporaire,2048))
     Erreur(ERREUR_DAT_CORROMPU);
   for (Indice=0;Indice<256;Indice++)
     for (Pos_X=0;Pos_X<8;Pos_X++)
@@ -278,7 +274,7 @@ void Charger_DAT(void)
         Fonte_systeme[(Indice<<6)+(Pos_X<<3)+Pos_Y]=( ((*(Fonte_temporaire+(Indice*8)+Pos_Y))&(0x80>>Pos_X)) ? 1 : 0);
 
   // Lecture de la fonte alternative
-  if (fread(Fonte_temporaire,1,2048,Handle)!=2048)
+  if (!read_bytes(Handle, Fonte_temporaire,2048))
     Erreur(ERREUR_DAT_CORROMPU);
   for (Indice=0;Indice<256;Indice++)
     for (Pos_X=0;Pos_X<8;Pos_X++)
@@ -290,7 +286,7 @@ void Charger_DAT(void)
   Fonte=Fonte_systeme;
 
   // Lecture de la fonte 6x8: (spéciale aide)
-  if (fread(Fonte_help,1,315*6*8,Handle)!=(315*6*8))
+  if (!read_bytes(Handle, Fonte_help,315*6*8))
     Erreur(ERREUR_DAT_CORROMPU);
 
   // Le reste est actuellement une copie du fichier INI par défaut:
@@ -1719,8 +1715,12 @@ int Charger_CFG(int Tout_charger)
     return ERREUR_CFG_ABSENT;
 
   if ( (Taille_fichier<sizeof(CFG_Header))
-    || (fread(&CFG_Header,1,sizeof(CFG_Header),Handle)!=sizeof(CFG_Header))
-    || memcmp(CFG_Header.Signature,"CFG",3) )
+    || (!read_bytes(Handle, &CFG_Header.Signature, 3))
+    || memcmp(CFG_Header.Signature,"CFG",3)
+    || (!read_byte(Handle, &CFG_Header.Version1))
+    || (!read_byte(Handle, &CFG_Header.Version2))
+    || (!read_byte(Handle, &CFG_Header.Beta1))
+    || (!read_byte(Handle, &CFG_Header.Beta2)) )
       goto Erreur_lecture_config;
 
   // Version DOS de Robinson et X-Man
@@ -1738,43 +1738,32 @@ int Charger_CFG(int Tout_charger)
     || (CFG_Header.Beta2!=BETA2) )
     goto Erreur_config_ancienne;
 
-  if (Taille_fichier!=TAILLE_FICHIER_CONFIG)
-    goto Erreur_lecture_config;
-
   // - Lecture des infos contenues dans le fichier de config -
-  while (fread(&(Chunk.Numero),1,sizeof(byte),Handle)==sizeof(byte))
+  while (read_byte(Handle, &Chunk.Numero))
   {
-                fread(&(Chunk.Taille),1,sizeof(word),Handle);
-                #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-                        Chunk.Taille=bswap_16(Chunk.Taille);
-                #endif
+    read_word_le(Handle, &Chunk.Taille);
     switch (Chunk.Numero)
     {
       case CHUNK_TOUCHES: // Touches
         if (Tout_charger)
         {
-          if ((Chunk.Taille/sizeof(CFG_Infos_touche))!=NB_TOUCHES)
-            goto Erreur_lecture_config;
-          for (Indice=1; Indice<=NB_TOUCHES; Indice++)
+          for (Indice=0; Indice<(Chunk.Taille/sizeof(CFG_Infos_touche)); Indice++)
           {
-            if (fread(&CFG_Infos_touche,1,sizeof(CFG_Infos_touche),Handle)!=sizeof(CFG_Infos_touche))
+            if (!read_word_le(Handle, &CFG_Infos_touche.Numero) ||
+                !read_word_le(Handle, &CFG_Infos_touche.Touche) ||
+                !read_word_le(Handle, &CFG_Infos_touche.Touche2) )
               goto Erreur_lecture_config;
             else
             {
-                #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-                    CFG_Infos_touche.Touche=bswap_16(CFG_Infos_touche.Touche);
-                    CFG_Infos_touche.Touche2=bswap_16(CFG_Infos_touche.Touche2);
-                    CFG_Infos_touche.Numero=bswap_16(CFG_Infos_touche.Numero);
-                #endif
-                if (Conversion_touches)
-                {
-                  CFG_Infos_touche.Touche = Touche_pour_scancode(CFG_Infos_touche.Touche);
-                }
-                for (Indice2=0;
-                   ((Indice2<NB_TOUCHES) && (Numero_option[Indice2]!=CFG_Infos_touche.Numero));
-                   Indice2++);
-                if (Indice2<NB_TOUCHES)
-                {
+              if (Conversion_touches)
+              {
+                CFG_Infos_touche.Touche = Touche_pour_scancode(CFG_Infos_touche.Touche);
+              }
+              for (Indice2=0;
+                 ((Indice2<NB_TOUCHES) && (Numero_option[Indice2]!=CFG_Infos_touche.Numero));
+                 Indice2++);
+              if (Indice2<NB_TOUCHES)
+              {
                 switch(Ordonnancement[Indice2]>>8)
                 {
                   case 0 :
@@ -1804,38 +1793,44 @@ int Charger_CFG(int Tout_charger)
           goto Erreur_lecture_config;
         for (Indice=1; Indice<=NB_MODES_VIDEO; Indice++)
         {
-          fread(&(CFG_Mode_video.Etat),1,1,Handle);
-          fread(&(CFG_Mode_video.Largeur),1,2,Handle);
-          if (fread(&(CFG_Mode_video.Hauteur),1,2,Handle)!=2)
+          if (!read_byte(Handle, &CFG_Mode_video.Etat) ||
+              !read_word_le(Handle, &CFG_Mode_video.Largeur) ||
+              !read_word_le(Handle, &CFG_Mode_video.Hauteur) )
             goto Erreur_lecture_config;
-          else
+          
+          for (Indice2=0; Indice2<NB_MODES_VIDEO; Indice2++)
           {
-            for (Indice2=0;
-                 ( (Indice2<NB_MODES_VIDEO) &&
-                   ( (Mode_video[Indice2].Largeur!=CFG_Mode_video.Largeur) ||
-                     (Mode_video[Indice2].Hauteur!=CFG_Mode_video.Hauteur) ||
-                     (Mode_video[Indice2].Mode!=(CFG_Mode_video.Etat>>6)) ) );
-                 Indice2++);
-            if (Indice2<NB_MODES_VIDEO)
+            if (Mode_video[Indice2].Largeur==CFG_Mode_video.Largeur &&
+                Mode_video[Indice2].Hauteur==CFG_Mode_video.Hauteur &&
+                Mode_video[Indice2].Mode==(CFG_Mode_video.Etat>>6))
+            {
               Mode_video[Indice2].Etat=(Mode_video[Indice2].Etat&0xFC) | (CFG_Mode_video.Etat&3);
+              break;
+            }
           }
         }
         break;
       case CHUNK_SHADE: // Shade
         if (Tout_charger)
         {
-          if (fread(&Shade_Actuel,1,sizeof(Shade_Actuel),Handle)!=sizeof(Shade_Actuel))
+          if (! read_byte(Handle, &Shade_Actuel) )
             goto Erreur_lecture_config;
-          else
+
+          for (Indice=0; Indice<8; Indice++)
           {
-            if (fread(Shade_Liste,1,sizeof(Shade_Liste),Handle)!=sizeof(Shade_Liste))
-              goto Erreur_lecture_config;
-            else
-              Liste2tables(Shade_Liste[Shade_Actuel].Liste,
-                           Shade_Liste[Shade_Actuel].Pas,
-                           Shade_Liste[Shade_Actuel].Mode,
-                           Shade_Table_gauche,Shade_Table_droite);
+            for (Indice2=0; Indice2<512; Indice2++)
+            {
+              if (! read_word_le(Handle, &Shade_Liste[Indice].Liste[Indice2]))
+                goto Erreur_lecture_config;
+            }
+            if (! read_byte(Handle, &Shade_Liste[Indice].Pas) ||
+              ! read_byte(Handle, &Shade_Liste[Indice].Mode) )
+            goto Erreur_lecture_config;
           }
+          Liste2tables(Shade_Liste[Shade_Actuel].Liste,
+            Shade_Liste[Shade_Actuel].Pas,
+            Shade_Liste[Shade_Actuel].Mode,
+            Shade_Table_gauche,Shade_Table_droite);        
         }
         else
         {
@@ -1846,7 +1841,7 @@ int Charger_CFG(int Tout_charger)
       case CHUNK_MASQUE: // Masque
         if (Tout_charger)
         {
-          if (fread(Mask,1,sizeof(Mask),Handle)!=sizeof(Mask))
+          if (!read_bytes(Handle, Mask, 256))
             goto Erreur_lecture_config;
         }
         else
@@ -1858,7 +1853,7 @@ int Charger_CFG(int Tout_charger)
       case CHUNK_STENCIL: // Stencil
         if (Tout_charger)
         {
-          if (fread(Stencil,1,sizeof(Stencil),Handle)!=sizeof(Stencil))
+          if (!read_bytes(Handle, Stencil, 256))
             goto Erreur_lecture_config;
         }
         else
@@ -1871,16 +1866,16 @@ int Charger_CFG(int Tout_charger)
         if (Tout_charger)
         {
           // fixme endianness : Degrade_Courant est un int, enregistre en byte
-          if (fread(&Degrade_Courant,1,1,Handle)!=1)
+          if (! read_byte(Handle, &Degrade_Courant))
             goto Erreur_lecture_config;
           for(Indice=0;Indice<16;Indice++)
           {
-                fread(&(Degrade_Tableau[Indice].Debut),1,1,Handle);
-                fread(&(Degrade_Tableau[Indice].Fin),1,1,Handle);
-                fread(&(Degrade_Tableau[Indice].Inverse),1,4,Handle);
-                fread(&(Degrade_Tableau[Indice].Melange),1,4,Handle);
-                if (fread(&(Degrade_Tableau[Indice]).Technique,1,4,Handle)!=4)
-                goto Erreur_lecture_config;
+            if (!read_byte(Handle, &Degrade_Tableau[Indice].Debut) ||
+                !read_byte(Handle, &Degrade_Tableau[Indice].Fin) ||
+                !read_dword_le(Handle, &Degrade_Tableau[Indice].Inverse) ||
+                !read_dword_le(Handle, &Degrade_Tableau[Indice].Melange) ||
+                !read_dword_le(Handle, &Degrade_Tableau[Indice].Technique) )
+            goto Erreur_lecture_config;
           }
           Degrade_Charger_infos_du_tableau(Degrade_Courant);
         }
@@ -1893,8 +1888,10 @@ int Charger_CFG(int Tout_charger)
       case CHUNK_SMOOTH: // Matrice du smooth
         if (Tout_charger)
         {
-          if (fread(Smooth_Matrice,1,sizeof(Smooth_Matrice),Handle)!=sizeof(Smooth_Matrice))
-            goto Erreur_lecture_config;
+          for (Indice=0; Indice<3; Indice++)
+            for (Indice2=0; Indice2<3; Indice2++)
+              if (!read_byte(Handle, &(Smooth_Matrice[Indice][Indice2])))
+                goto Erreur_lecture_config;
         }
         else
         {
@@ -1905,7 +1902,7 @@ int Charger_CFG(int Tout_charger)
       case CHUNK_EXCLUDE_COLORS: // Exclude_color
         if (Tout_charger)
         {
-          if (fread(Exclude_color,1,sizeof(Exclude_color),Handle)!=sizeof(Exclude_color))
+          if (!read_bytes(Handle, Exclude_color, 256))
             goto Erreur_lecture_config;
         }
         else
@@ -1917,9 +1914,27 @@ int Charger_CFG(int Tout_charger)
       case CHUNK_QUICK_SHADE: // Quick-shade
         if (Tout_charger)
         {
-          if (fread(&Quick_shade_Step,1,sizeof(Quick_shade_Step),Handle)!=sizeof(Quick_shade_Step))
+          if (!read_byte(Handle, &Quick_shade_Step))
             goto Erreur_lecture_config;
-          if (fread(&Quick_shade_Loop,1,sizeof(Quick_shade_Loop),Handle)!=sizeof(Quick_shade_Loop))
+          if (!read_byte(Handle, &Quick_shade_Loop))
+            goto Erreur_lecture_config;
+        }
+        else
+        {
+          if (fseek(Handle,Chunk.Taille,SEEK_CUR)==-1)
+            goto Erreur_lecture_config;
+        }
+        break;
+        case CHUNK_GRILLE: // Grille
+        if (Tout_charger)
+        {
+          if (!read_word_le(Handle, &Snap_Largeur))
+            goto Erreur_lecture_config;
+          if (!read_word_le(Handle, &Snap_Hauteur))
+            goto Erreur_lecture_config;
+          if (!read_word_le(Handle, &Snap_Decalage_X))
+            goto Erreur_lecture_config;
+          if (!read_word_le(Handle, &Snap_Decalage_Y))
             goto Erreur_lecture_config;
         }
         else
@@ -1951,6 +1966,7 @@ int Sauver_CFG(void)
 {
   FILE*  Handle;
   int  Indice;
+  int  Indice2;
   //byte Octet;
   char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
   struct Config_Header       CFG_Header;
@@ -1971,17 +1987,19 @@ int Sauver_CFG(void)
   CFG_Header.Version2=VERSION2;
   CFG_Header.Beta1   =BETA1;
   CFG_Header.Beta2   =BETA2;
-  if (fwrite(&CFG_Header,1,sizeof(CFG_Header),Handle)!=sizeof(CFG_Header))
+  if (!write_bytes(Handle, &CFG_Header.Signature,3) ||
+      !write_byte(Handle, CFG_Header.Version1) ||
+      !write_byte(Handle, CFG_Header.Version2) ||
+      !write_byte(Handle, CFG_Header.Beta1) ||
+      !write_byte(Handle, CFG_Header.Beta2) )
     goto Erreur_sauvegarde_config;
 
   // Enregistrement des touches
   Chunk.Numero=CHUNK_TOUCHES;
   Chunk.Taille=NB_TOUCHES*sizeof(CFG_Infos_touche);
-  #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    //On remet les octets dans l'ordre "normal"
-    Chunk.Taille=bswap_16(Chunk.Taille);
-  #endif
-  if (fwrite(&(Chunk.Numero),1,sizeof(byte),Handle)!=sizeof(byte)||fwrite(&(Chunk.Taille),1,sizeof(word),Handle)!=sizeof(word))
+
+  if (!write_byte(Handle, Chunk.Numero) ||
+      !write_word_le(Handle, Chunk.Taille) )
     goto Erreur_sauvegarde_config;
   for (Indice=0; Indice<NB_TOUCHES; Indice++)
   {
@@ -1993,139 +2011,133 @@ int Sauver_CFG(void)
       case 2 : CFG_Infos_touche.Touche=Bouton[Ordonnancement[Indice]&0xFF].Raccourci_droite; break;
     }
     CFG_Infos_touche.Touche2=0x00FF;
-    #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-        CFG_Infos_touche.Touche=bswap_16(CFG_Infos_touche.Touche);
-        CFG_Infos_touche.Touche2=bswap_16(CFG_Infos_touche.Touche2);
-        CFG_Infos_touche.Numero=bswap_16(CFG_Infos_touche.Numero);
-    #endif
-    if (fwrite(&CFG_Infos_touche,1,sizeof(CFG_Infos_touche),Handle)!=sizeof(CFG_Infos_touche))
+    if (!write_word_le(Handle, CFG_Infos_touche.Numero) ||
+        !write_word_le(Handle, CFG_Infos_touche.Touche) ||
+        !write_word_le(Handle, CFG_Infos_touche.Touche2) )
       goto Erreur_sauvegarde_config;
   }
 
   // Sauvegarde de l'état de chaque mode vidéo
   Chunk.Numero=CHUNK_MODES_VIDEO;
   Chunk.Taille=NB_MODES_VIDEO * sizeof(CFG_Mode_video);
-  #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    //On remet les octets dans l'ordre "normal"
-    Chunk.Taille=bswap_16(Chunk.Taille);
-  #endif
-  if (fwrite(&(Chunk.Numero),1,sizeof(byte),Handle)!=sizeof(byte)||fwrite(&(Chunk.Taille),1,sizeof(word),Handle)!=sizeof(word))
+  if (!write_byte(Handle, Chunk.Numero) ||
+      !write_word_le(Handle, Chunk.Taille) )
     goto Erreur_sauvegarde_config;
   for (Indice=0; Indice<NB_MODES_VIDEO; Indice++)
   {
     CFG_Mode_video.Etat   =(Mode_video[Indice].Mode<<6) | (Mode_video[Indice].Etat&3);
     CFG_Mode_video.Largeur=Mode_video[Indice].Largeur;
     CFG_Mode_video.Hauteur=Mode_video[Indice].Hauteur;
-    if (fwrite(&(CFG_Mode_video.Etat),1,1,Handle)!=1 ||
-	fwrite(&(CFG_Mode_video.Largeur),1,2,Handle)!=2 ||
-	fwrite(&(CFG_Mode_video.Hauteur),1,2,Handle)!=2)
+    
+    if (!write_byte(Handle, CFG_Mode_video.Etat) ||
+      !write_word_le(Handle, CFG_Mode_video.Largeur) ||
+      !write_word_le(Handle, CFG_Mode_video.Hauteur) )
       goto Erreur_sauvegarde_config;
   }
 
   // Ecriture des données du Shade (précédées du shade en cours)
   Chunk.Numero=CHUNK_SHADE;
   Chunk.Taille=sizeof(Shade_Liste)+sizeof(Shade_Actuel);
-  #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    //On remet les octets dans l'ordre "normal"
-    Chunk.Taille=bswap_16(Chunk.Taille);
-  #endif
-  if (fwrite(&(Chunk.Numero),1,sizeof(byte),Handle)!=sizeof(byte)||
-	fwrite(&(Chunk.Taille),1,sizeof(word),Handle)!=sizeof(word))
+  if (!write_byte(Handle, Chunk.Numero) ||
+      !write_word_le(Handle, Chunk.Taille) )
     goto Erreur_sauvegarde_config;
-  if (fwrite(&Shade_Actuel,1,sizeof(Shade_Actuel),Handle)!=sizeof(Shade_Actuel))
+  if (!write_byte(Handle, Shade_Actuel))
     goto Erreur_sauvegarde_config;
-  if (fwrite(Shade_Liste,1,sizeof(Shade_Liste),Handle)!=sizeof(Shade_Liste))
+  for (Indice=0; Indice<8; Indice++)
+  {
+    for (Indice2=0; Indice2<512; Indice2++)
+    {
+      if (! write_word_le(Handle, Shade_Liste[Indice].Liste[Indice2]))
+        goto Erreur_sauvegarde_config;
+    }
+    if (! write_byte(Handle, Shade_Liste[Indice].Pas) ||
+      ! write_byte(Handle, Shade_Liste[Indice].Mode) )
     goto Erreur_sauvegarde_config;
+  }    
 
   // Sauvegarde des informations du Masque
   Chunk.Numero=CHUNK_MASQUE;
   Chunk.Taille=sizeof(Mask);
-  #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    //On remet les octets dans l'ordre "normal"
-    Chunk.Taille=bswap_16(Chunk.Taille);
-  #endif
-  if (fwrite(&(Chunk.Numero),1,sizeof(byte),Handle)!=sizeof(byte)||
-	fwrite(&(Chunk.Taille),1,sizeof(word),Handle)!=sizeof(word))
+  if (!write_byte(Handle, Chunk.Numero) ||
+      !write_word_le(Handle, Chunk.Taille) )
     goto Erreur_sauvegarde_config;
-  if (fwrite(Mask,1,sizeof(Mask),Handle)!=sizeof(Mask))
+  if (!write_bytes(Handle, Mask,256))
     goto Erreur_sauvegarde_config;
 
   // Sauvegarde des informations du Stencil
   Chunk.Numero=CHUNK_STENCIL;
   Chunk.Taille=sizeof(Stencil);
-  #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    //On remet les octets dans l'ordre "normal"
-    Chunk.Taille=bswap_16(Chunk.Taille);
-  #endif
-  if (fwrite(&(Chunk.Numero),1,sizeof(byte),Handle)!=sizeof(byte)||
-	fwrite(&(Chunk.Taille),1,sizeof(word),Handle)!=sizeof(word))
+  if (!write_byte(Handle, Chunk.Numero) ||
+      !write_word_le(Handle, Chunk.Taille) )
     goto Erreur_sauvegarde_config;
-  if (fwrite(Stencil,1,sizeof(Stencil),Handle)!=sizeof(Stencil))
+  if (!write_bytes(Handle, Stencil,256))
     goto Erreur_sauvegarde_config;
 
   // Sauvegarde des informations des dégradés
   Chunk.Numero=CHUNK_DEGRADES;
   Chunk.Taille=sizeof(Degrade_Tableau)+1;
-  #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    //On remet les octets dans l'ordre "normal"
-    Chunk.Taille=bswap_16(Chunk.Taille);
-  #endif
-  if (fwrite(&(Chunk.Numero),1,sizeof(byte),Handle)!=sizeof(byte)||
-	fwrite(&(Chunk.Taille),1,sizeof(word),Handle)!=sizeof(word))
+  if (!write_byte(Handle, Chunk.Numero) ||
+      !write_word_le(Handle, Chunk.Taille) )
     goto Erreur_sauvegarde_config;
-  if (fwrite(&Degrade_Courant,1,1,Handle)!=1)
+  if (!write_byte(Handle, Degrade_Courant))
     goto Erreur_sauvegarde_config;
   for(Indice=0;Indice<16;Indice++)
   {
-    if (fwrite(&(Degrade_Tableau[Indice].Debut),1,1,Handle)!=1 ||
-        fwrite(&(Degrade_Tableau[Indice].Fin),1,1,Handle)!=1 ||
-        fwrite(&(Degrade_Tableau[Indice].Inverse),1,4,Handle)!=4 ||
-        fwrite(&(Degrade_Tableau[Indice].Melange),1,4,Handle)!=4 ||
-        fwrite(&(Degrade_Tableau[Indice].Technique),1,4,Handle)!=4 )
+    if (!write_byte(Handle,Degrade_Tableau[Indice].Debut) ||
+        !write_byte(Handle,Degrade_Tableau[Indice].Fin) ||
+        !write_dword_le(Handle, Degrade_Tableau[Indice].Inverse) ||
+        !write_dword_le(Handle, Degrade_Tableau[Indice].Melange) ||
+        !write_dword_le(Handle, Degrade_Tableau[Indice].Technique) )
         goto Erreur_sauvegarde_config;
   }
 
   // Sauvegarde de la matrice du Smooth
   Chunk.Numero=CHUNK_SMOOTH;
   Chunk.Taille=sizeof(Smooth_Matrice);
-  #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    //On remet les octets dans l'ordre "normal"
-    Chunk.Taille=bswap_16(Chunk.Taille);
-  #endif
-  if (fwrite(&(Chunk.Numero),1,sizeof(byte),Handle)!=sizeof(byte)||
-	fwrite(&(Chunk.Taille),1,sizeof(word),Handle)!=sizeof(word))
-    goto Erreur_sauvegarde_config;
-  if (fwrite(Smooth_Matrice,1,sizeof(Smooth_Matrice),Handle)!=sizeof(Smooth_Matrice))
+  if (!write_byte(Handle, Chunk.Numero) ||
+      !write_word_le(Handle, Chunk.Taille) )
     goto Erreur_sauvegarde_config;
+  for (Indice=0; Indice<3; Indice++)
+    for (Indice2=0; Indice2<3; Indice2++)
+      if (!write_byte(Handle, Smooth_Matrice[Indice][Indice2]))
+        goto Erreur_sauvegarde_config;
 
   // Sauvegarde des couleurs à exclure
   Chunk.Numero=CHUNK_EXCLUDE_COLORS;
   Chunk.Taille=sizeof(Exclude_color);
-  #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    //On remet les octets dans l'ordre "normal"
-    Chunk.Taille=bswap_16(Chunk.Taille);
-  #endif
-  if (fwrite(&(Chunk.Numero),1,sizeof(byte),Handle)!=sizeof(byte)||
-	fwrite(&(Chunk.Taille),1,sizeof(word),Handle)!=sizeof(word))
+  if (!write_byte(Handle, Chunk.Numero) ||
+      !write_word_le(Handle, Chunk.Taille) )
     goto Erreur_sauvegarde_config;
-  if (fwrite(Exclude_color,1,sizeof(Exclude_color),Handle)!=sizeof(Exclude_color))
+ if (!write_bytes(Handle, Exclude_color, 256))
     goto Erreur_sauvegarde_config;
 
   // Sauvegarde des informations du Quick-shade
   Chunk.Numero=CHUNK_QUICK_SHADE;
   Chunk.Taille=sizeof(Quick_shade_Step)+sizeof(Quick_shade_Loop);
-  #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    //On remet les octets dans l'ordre "normal"
-    Chunk.Taille=bswap_16(Chunk.Taille);
-  #endif
-  if (fwrite(&(Chunk.Numero),1,sizeof(byte),Handle)!=sizeof(byte)||
-	fwrite(&(Chunk.Taille),1,sizeof(word),Handle)!=sizeof(word))
+  if (!write_byte(Handle, Chunk.Numero) ||
+      !write_word_le(Handle, Chunk.Taille) )
     goto Erreur_sauvegarde_config;
-  if (fwrite(&Quick_shade_Step,1,sizeof(Quick_shade_Step),Handle)!=sizeof(Quick_shade_Step))
+  if (!write_byte(Handle, Quick_shade_Step))
     goto Erreur_sauvegarde_config;
-  if (fwrite(&Quick_shade_Loop,1,sizeof(Quick_shade_Loop),Handle)!=sizeof(Quick_shade_Loop))
+  if (!write_byte(Handle, Quick_shade_Loop))
     goto Erreur_sauvegarde_config;
 
+  // Sauvegarde des informations de la grille
+  Chunk.Numero=CHUNK_GRILLE;
+  Chunk.Taille=8;
+  if (!write_byte(Handle, Chunk.Numero) ||
+      !write_word_le(Handle, Chunk.Taille) )
+    goto Erreur_sauvegarde_config;
+  if (!write_word_le(Handle, Snap_Largeur))
+    goto Erreur_sauvegarde_config;
+  if (!write_word_le(Handle, Snap_Hauteur))
+    goto Erreur_sauvegarde_config;
+  if (!write_word_le(Handle, Snap_Decalage_X))
+    goto Erreur_sauvegarde_config;
+  if (!write_word_le(Handle, Snap_Decalage_Y))
+    goto Erreur_sauvegarde_config;
+
+  
   if (fclose(Handle))
     return ERREUR_SAUVEGARDE_CFG;
 
diff --git a/io.c b/io.c
index 706ce9fa..24206e9f 100644
--- a/io.c
+++ b/io.c
@@ -22,6 +22,18 @@ word endian_magic32(word x)
   #endif
 }
 
+// Lit un octet
+// Renvoie -1 si OK, 0 en cas d'erreur
+int read_byte(FILE *Fichier, byte *Dest)
+{
+  return fread(Dest, 1, 1, Fichier) == 1;
+}
+// Ecrit un octet
+// Renvoie -1 si OK, 0 en cas d'erreur
+int write_byte(FILE *Fichier, byte Byte)
+{
+  return fwrite(&Byte, 1, 1, Fichier) == 1;
+}
 // Lit des octets
 // Renvoie -1 si OK, 0 en cas d'erreur
 int read_bytes(FILE *Fichier, void *Dest, size_t Taille)
diff --git a/io.h b/io.h
index e821c1f3..f2cb61d8 100644
--- a/io.h
+++ b/io.h
@@ -2,6 +2,9 @@
 word  endian_magic16(word x);
 dword endian_magic32(dword x);
 
+int read_byte(FILE *Fichier, byte *Dest);
+int write_byte(FILE *Fichier, byte Byte);
+
 int read_bytes(FILE *Fichier, void *Dest, size_t Taille);
 int write_bytes(FILE *Fichier, void *Dest, size_t Taille);
 
diff --git a/loadsave.c b/loadsave.c
index b61cc91b..455a9f18 100644
--- a/loadsave.c
+++ b/loadsave.c
@@ -369,7 +369,7 @@ void Nom_fichier_complet(char * Nom_du_fichier, byte Sauve_Colorix)
 void Lire_octet(FILE * Fichier, byte *Octet)
 {
   // FIXME : Remplacer les appelants par read_bytes(), et gérer les retours d'erreur.
-  if (!read_bytes(Fichier, Octet, 1))
+  if (!read_byte(Fichier, Octet))
   ;//  Erreur_fichier = 2;
 }
 
@@ -940,13 +940,13 @@ void Load_PKM(void)
         Indice=0;
         while ( (Indice<Head.Jump) && (!Erreur_fichier) )
         {
-          if (read_bytes(Fichier,&Octet,1))
+          if (read_byte(Fichier,&Octet))
           {
             Indice+=2; // On rajoute le "Field-id" et "le Field-size" pas encore lu
             switch (Octet)
             {
               case 0 : // Commentaire
-                if (read_bytes(Fichier,&Octet,1))
+                if (read_byte(Fichier,&Octet))
                 {
                   if (Octet>TAILLE_COMMENTAIRE)
                   {
@@ -973,7 +973,7 @@ void Load_PKM(void)
                 break;
 
               case 1 : // Dimensions de l'écran d'origine
-                if (read_bytes(Fichier,&Octet,1))
+                if (read_byte(Fichier,&Octet))
                 {
                   if (Octet==4)
                   {
@@ -990,12 +990,12 @@ void Load_PKM(void)
                 break;
 
               case 2 : // Couleur de transparence
-                if (read_bytes(Fichier,&Octet,1))
+                if (read_byte(Fichier,&Octet))
                 {
                   if (Octet==1)
                   {
                     Indice++;
-                    if (! read_bytes(Fichier,&Back_color,1))
+                    if (! read_byte(Fichier,&Back_color))
                       Erreur_fichier=2;
                   }
                   else
@@ -1006,7 +1006,7 @@ void Load_PKM(void)
                 break;
 
               default:
-                if (read_bytes(Fichier,&Octet,1))
+                if (read_byte(Fichier,&Octet))
                 {
                   Indice+=Octet;
                   if (fseek(Fichier,Octet,SEEK_CUR))
@@ -1595,13 +1595,13 @@ void Load_LBM(void)
       && (read_word_be(LBM_Fichier,&Header.Height))
       && (read_word_be(LBM_Fichier,&Header.Xorg))
       && (read_word_be(LBM_Fichier,&Header.Yorg))
-      && (read_bytes(LBM_Fichier,&Header.BitPlanes,1))
-      && (read_bytes(LBM_Fichier,&Header.Mask,1))
-      && (read_bytes(LBM_Fichier,&Header.Compression,1))
-      && (read_bytes(LBM_Fichier,&Header.Pad1,1))
+      && (read_byte(LBM_Fichier,&Header.BitPlanes))
+      && (read_byte(LBM_Fichier,&Header.Mask))
+      && (read_byte(LBM_Fichier,&Header.Compression))
+      && (read_byte(LBM_Fichier,&Header.Pad1))
       && (read_word_be(LBM_Fichier,&Header.Transp_col))
-      && (read_bytes(LBM_Fichier,&Header.Xaspect,1))
-      && (read_bytes(LBM_Fichier,&Header.Yaspect,1))
+      && (read_byte(LBM_Fichier,&Header.Xaspect))
+      && (read_byte(LBM_Fichier,&Header.Yaspect))
       && (read_word_be(LBM_Fichier,&Header.Xscreen))
       && (read_word_be(LBM_Fichier,&Header.Yscreen))
       && Header.Width && Header.Height)
@@ -1656,7 +1656,7 @@ void Load_LBM(void)
 
             // On lit l'octet de padding du CMAP si la taille est impaire
             if (Nb_couleurs&1)
-              if (read_bytes(LBM_Fichier,&Octet,1))
+              if (read_byte(LBM_Fichier,&Octet))
                 Erreur_fichier=2;
 
             if ( (Wait_for((byte *)"BODY")) && (!Erreur_fichier) )
@@ -2635,7 +2635,7 @@ void Load_GIF(void)
 
   word Nb_couleurs;       // Nombre de couleurs dans l'image
   word Indice_de_couleur; // Indice de traitement d'une couleur
-  word Taille_de_lecture; // Nombre de données à lire      (divers)
+  byte Taille_de_lecture; // Nombre de données à lire      (divers)
   //word Indice_de_lecture; // Indice de lecture des données (divers)
   byte Block_indicateur;  // Code indicateur du type de bloc en cours
   word Nb_bits_initial;   // Nb de bits au début du traitement LZW
@@ -2675,9 +2675,9 @@ void Load_GIF(void)
 
       if (read_word_le(GIF_Fichier,&(LSDB.Largeur))
       && read_word_le(GIF_Fichier,&(LSDB.Hauteur))
-      && read_bytes(GIF_Fichier,&(LSDB.Resol),1)
-      && read_bytes(GIF_Fichier,&(LSDB.Backcol),1)
-      && read_bytes(GIF_Fichier,&(LSDB.Aspect),1)
+      && read_byte(GIF_Fichier,&(LSDB.Resol))
+      && read_byte(GIF_Fichier,&(LSDB.Backcol))
+      && read_byte(GIF_Fichier,&(LSDB.Aspect))
         )
       {
         // Lecture du Logical Screen Descriptor Block réussie:
@@ -2715,19 +2715,19 @@ void Load_GIF(void)
             // Palette dans l'ordre:
             for(Indice_de_couleur=0;Indice_de_couleur<Nb_couleurs;Indice_de_couleur++)
             {
-              read_bytes(GIF_Fichier,&Principal_Palette[Indice_de_couleur].R,1);
-              read_bytes(GIF_Fichier,&Principal_Palette[Indice_de_couleur].V,1);
-              read_bytes(GIF_Fichier,&Principal_Palette[Indice_de_couleur].B,1);
+              read_byte(GIF_Fichier,&Principal_Palette[Indice_de_couleur].R);
+              read_byte(GIF_Fichier,&Principal_Palette[Indice_de_couleur].V);
+              read_byte(GIF_Fichier,&Principal_Palette[Indice_de_couleur].B);
             }
           else
           {
             // Palette triée par composantes:
             for (Indice_de_couleur=0;Indice_de_couleur<Nb_couleurs;Indice_de_couleur++)
-              read_bytes(GIF_Fichier,&Principal_Palette[Indice_de_couleur].R,1);
+              read_byte(GIF_Fichier,&Principal_Palette[Indice_de_couleur].R);
             for (Indice_de_couleur=0;Indice_de_couleur<Nb_couleurs;Indice_de_couleur++)
-              read_bytes(GIF_Fichier,&Principal_Palette[Indice_de_couleur].V,1);
+              read_byte(GIF_Fichier,&Principal_Palette[Indice_de_couleur].V);
             for (Indice_de_couleur=0;Indice_de_couleur<Nb_couleurs;Indice_de_couleur++)
-              read_bytes(GIF_Fichier,&Principal_Palette[Indice_de_couleur].B,1);
+              read_byte(GIF_Fichier,&Principal_Palette[Indice_de_couleur].B);
           }
 
           Palette_256_to_64(Principal_Palette);
@@ -2737,30 +2737,29 @@ void Load_GIF(void)
         // On s'apprête à sauter tous les blocks d'extension:
 
         // On lit un indicateur de block
-        read_bytes(GIF_Fichier,&Block_indicateur,1);
+        read_byte(GIF_Fichier,&Block_indicateur);
         // Si l'indicateur de block annonce un block d'extension:
         while (Block_indicateur==0x21)
         {
           // Lecture du code de fonction:
-          read_bytes(GIF_Fichier,&Block_indicateur,1);
+          read_byte(GIF_Fichier,&Block_indicateur);
 
           // On exploitera peut-être un jour ce code indicateur pour stocker
           // des remarques dans le fichier. En attendant d'en connaître plus
           // on se contente de sauter tous les blocs d'extension:
 
           // Lecture de la taille du bloc:
-          Taille_de_lecture=0;
-          read_bytes(GIF_Fichier,&Taille_de_lecture,1);
+          read_byte(GIF_Fichier,&Taille_de_lecture);
           while (Taille_de_lecture!=0)
           {
             // On saute le bloc:
             fseek(GIF_Fichier,Taille_de_lecture,SEEK_CUR);
             // Lecture de la taille du bloc suivant:
-            read_bytes(GIF_Fichier,&Taille_de_lecture,1);
+            read_byte(GIF_Fichier,&Taille_de_lecture);
           }
 
           // Lecture du code de fonction suivant:
-          read_bytes(GIF_Fichier,&Block_indicateur,1);
+          read_byte(GIF_Fichier,&Block_indicateur);
         }
 
         if (Block_indicateur==0x2C)
@@ -2772,8 +2771,8 @@ void Load_GIF(void)
             && read_word_le(GIF_Fichier,&(IDB.Pos_Y))
             && read_word_le(GIF_Fichier,&(IDB.Largeur_image))
             && read_word_le(GIF_Fichier,&(IDB.Hauteur_image))
-            && read_bytes(GIF_Fichier,&(IDB.Indicateur),1)
-            && read_bytes(GIF_Fichier,&(IDB.Nb_bits_pixel),1)
+            && read_byte(GIF_Fichier,&(IDB.Indicateur))
+            && read_byte(GIF_Fichier,&(IDB.Nb_bits_pixel))
             && IDB.Largeur_image && IDB.Hauteur_image)
           {
             Principal_Largeur_image=endian_magic16(IDB.Largeur_image);
@@ -2802,19 +2801,19 @@ void Load_GIF(void)
                 // Palette dans l'ordre:
                 for(Indice_de_couleur=0;Indice_de_couleur<Nb_couleurs;Indice_de_couleur++)
                 {   
-                  read_bytes(GIF_Fichier,&Principal_Palette[Indice_de_couleur].R,1);
-                  read_bytes(GIF_Fichier,&Principal_Palette[Indice_de_couleur].V,1);
-                  read_bytes(GIF_Fichier,&Principal_Palette[Indice_de_couleur].B,1);
+                  read_byte(GIF_Fichier,&Principal_Palette[Indice_de_couleur].R);
+                  read_byte(GIF_Fichier,&Principal_Palette[Indice_de_couleur].V);
+                  read_byte(GIF_Fichier,&Principal_Palette[Indice_de_couleur].B);
                 }
               else
               {
                 // Palette triée par composantes:
                 for (Indice_de_couleur=0;Indice_de_couleur<Nb_couleurs;Indice_de_couleur++)
-                  read_bytes(GIF_Fichier,&Principal_Palette[Indice_de_couleur].R,1);
+                  read_byte(GIF_Fichier,&Principal_Palette[Indice_de_couleur].R);
                 for (Indice_de_couleur=0;Indice_de_couleur<Nb_couleurs;Indice_de_couleur++)
-                  read_bytes(GIF_Fichier,&Principal_Palette[Indice_de_couleur].V,1);
+                  read_byte(GIF_Fichier,&Principal_Palette[Indice_de_couleur].V);
                 for (Indice_de_couleur=0;Indice_de_couleur<Nb_couleurs;Indice_de_couleur++)
-                  read_bytes(GIF_Fichier,&Principal_Palette[Indice_de_couleur].B,1);
+                  read_byte(GIF_Fichier,&Principal_Palette[Indice_de_couleur].B);
               }
 
               Palette_256_to_64(Principal_Palette);
@@ -3313,10 +3312,10 @@ void Test_PCX(void)
 
   if ((Fichier=fopen(Nom_du_fichier, "rb")))
   {
-    if (read_bytes(Fichier,&(PCX_Header.Manufacturer),1) &&
-        read_bytes(Fichier,&(PCX_Header.Version),1) &&
-        read_bytes(Fichier,&(PCX_Header.Compression),1) &&
-        read_bytes(Fichier,&(PCX_Header.Depth),1) &&
+    if (read_byte(Fichier,&(PCX_Header.Manufacturer)) &&
+        read_byte(Fichier,&(PCX_Header.Version)) &&
+        read_byte(Fichier,&(PCX_Header.Compression)) &&
+        read_byte(Fichier,&(PCX_Header.Depth)) &&
         read_word_le(Fichier,&(PCX_Header.X_min)) &&
         read_word_le(Fichier,&(PCX_Header.Y_min)) &&
         read_word_le(Fichier,&(PCX_Header.X_max)) &&
@@ -3324,8 +3323,8 @@ void Test_PCX(void)
         read_word_le(Fichier,&(PCX_Header.X_dpi)) &&
         read_word_le(Fichier,&(PCX_Header.Y_dpi)) &&
         read_bytes(Fichier,&(PCX_Header.Palette_16c),48) &&        
-        read_bytes(Fichier,&(PCX_Header.Reserved),1) &&
-        read_bytes(Fichier,&(PCX_Header.Plane),1) &&
+        read_byte(Fichier,&(PCX_Header.Reserved)) &&
+        read_byte(Fichier,&(PCX_Header.Plane)) &&
         read_word_le(Fichier,&(PCX_Header.Bytes_per_plane_line)) &&
         read_word_le(Fichier,&(PCX_Header.Palette_info)) &&
         read_word_le(Fichier,&(PCX_Header.Screen_X)) &&
@@ -3405,10 +3404,10 @@ void Load_PCX(void)
     if (read_bytes(Fichier,&PCX_Header,sizeof(T_PCX_Header)))
     {*/
     
-    if (read_bytes(Fichier,&(PCX_Header.Manufacturer),1) &&
-        read_bytes(Fichier,&(PCX_Header.Version),1) &&
-        read_bytes(Fichier,&(PCX_Header.Compression),1) &&
-        read_bytes(Fichier,&(PCX_Header.Depth),1) &&
+    if (read_byte(Fichier,&(PCX_Header.Manufacturer)) &&
+        read_byte(Fichier,&(PCX_Header.Version)) &&
+        read_byte(Fichier,&(PCX_Header.Compression)) &&
+        read_byte(Fichier,&(PCX_Header.Depth)) &&
         read_word_le(Fichier,&(PCX_Header.X_min)) &&
         read_word_le(Fichier,&(PCX_Header.Y_min)) &&
         read_word_le(Fichier,&(PCX_Header.X_max)) &&
@@ -3416,8 +3415,8 @@ void Load_PCX(void)
         read_word_le(Fichier,&(PCX_Header.X_dpi)) &&
         read_word_le(Fichier,&(PCX_Header.Y_dpi)) &&
         read_bytes(Fichier,&(PCX_Header.Palette_16c),48) &&        
-        read_bytes(Fichier,&(PCX_Header.Reserved),1) &&
-        read_bytes(Fichier,&(PCX_Header.Plane),1) &&
+        read_byte(Fichier,&(PCX_Header.Reserved)) &&
+        read_byte(Fichier,&(PCX_Header.Plane)) &&
         read_word_le(Fichier,&(PCX_Header.Bytes_per_plane_line)) &&
         read_word_le(Fichier,&(PCX_Header.Palette_info)) &&
         read_word_le(Fichier,&(PCX_Header.Screen_X)) &&
@@ -3475,15 +3474,15 @@ void Load_PCX(void)
           {
             fseek(Fichier,Taille_du_fichier-((256*3)+1),SEEK_SET);
             // On regarde s'il y a une palette après les données de l'image
-            if (read_bytes(Fichier,&Octet1,1))
+            if (read_byte(Fichier,&Octet1))
               if (Octet1==12) // Lire la palette si c'est une image en 256 couleurs
               {
                 int indice;
                 // On lit la palette 256c que ces crétins ont foutue à la fin du fichier
                 for(indice=0;indice<256;indice++)
-                  if ( ! read_bytes(Fichier,&Principal_Palette[indice].R,1)
-                   || ! read_bytes(Fichier,&Principal_Palette[indice].V,1)
-                   || ! read_bytes(Fichier,&Principal_Palette[indice].B,1) )
+                  if ( ! read_byte(Fichier,&Principal_Palette[indice].R)
+                   || ! read_byte(Fichier,&Principal_Palette[indice].V)
+                   || ! read_byte(Fichier,&Principal_Palette[indice].B) )
                   {
                     Erreur_fichier=2;
                     DEBUG("ERROR READING PCX PALETTE !",indice);
@@ -3862,10 +3861,14 @@ void Test_CEL(void)
     return;
   }
   Nom_fichier_complet(Nom_du_fichier,0);
-  if ((Fichier=fopen(Nom_du_fichier, "rb")))
+  if (! (Fichier=fopen(Nom_du_fichier, "rb")))
+  {
+    Erreur_fichier = 1;
+    return;
+  }
+  if (read_word_le(Fichier,&Header1.Width) &&
+      read_word_le(Fichier,&Header1.Height) )
   {
-    if (read_bytes(Fichier,&Header1,sizeof(T_CEL_Header1)))
-    {
       //   Vu que ce header n'a pas de signature, il va falloir tester la
       // cohérence de la dimension de l'image avec celle du fichier.
       
@@ -3874,28 +3877,32 @@ void Test_CEL(void)
       {
         // Tentative de reconnaissance de la signature des nouveaux fichiers
 
-        fseek(Fichier,0,SEEK_SET);
-        if (read_bytes(Fichier,&Header2,sizeof(T_CEL_Header2)))
+        fseek(Fichier,0,SEEK_SET);        
+        if (read_bytes(Fichier,&Header2.Signa,4) &&
+            !memcmp(Header2.Signa,"KiSS",4) &&
+            read_byte(Fichier,&Header2.Kind) &&
+            (Header2.Kind==0x20) &&
+            read_byte(Fichier,&Header2.Nbbits) &&
+            read_word_le(Fichier,&Header2.Filler1) &&
+            read_word_le(Fichier,&Header2.Largeur) &&
+            read_word_le(Fichier,&Header2.Hauteur) &&
+            read_word_le(Fichier,&Header2.Decalage_X) &&
+            read_word_le(Fichier,&Header2.Decalage_Y) &&
+            read_bytes(Fichier,&Header2.Filler2,16))
         {
-          if (memcmp(Header2.Signa,"KiSS",4)==0)
-          {
-            if (Header2.Kind!=0x20)
-              Erreur_fichier=1;
-          }
-          else
-            Erreur_fichier=1;
+          // ok
         }
         else
           Erreur_fichier=1;
       }
-    }
-    else
-      Erreur_fichier=1;
-
-    fclose(Fichier);
+      else
+        Erreur_fichier=1;
   }
   else
+  {
     Erreur_fichier=1;
+  }
+  fclose(Fichier);    
 }
 
 
@@ -5205,7 +5212,7 @@ void Load_RAW_24B(int Largeur,int Hauteur,Bitmap24B Source)
   FILE* Fichier;
 
   Fichier=fopen("TEST.RAW","rb");
-  if (read_bytes(Fichier,Source,Largeur*Hauteur*sizeof(struct Composantes))!=Largeur*Hauteur*sizeof(struct Composantes))
+  if (read_bytes(Fichier,Source,Largeur*Hauteur*sizeof(struct Composantes)))
     exit(3);
   fclose(Fichier);
 }