m/grafX2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Support for long file names in file selector, up to 27char.

Browse Source 
Cleanup in the Load/Save function for all formats, preparing for big endianness fix.

git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@146 416bcca6-2ee7-4201-b75f-2eb2f807beb1
This commit is contained in:
Yves Rizoud 2008-09-14 18:07:17 +00:00
parent beea105ef7
commit 2f5c16a8a0
7 changed files with 362 additions and 507 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
boutons.c
View File

@ -30,6 +30,8 @@
#define rmdir(x) DeleteFile(x) #define rmdir(x) DeleteFile(x)
#endif #endif
#define FILENAMESPACE 16
//-- MODELE DE BOUTON DE MENU ------------------------------------------------ //-- MODELE DE BOUTON DE MENU ------------------------------------------------
/* /*
void Bouton_***(void) void Bouton_***(void)
@ -2130,8 +2132,8 @@ void Print_Nom_fichier_dans_selecteur(void)
// Affiche Principal_Nom_fichier dans le Fileselect // Affiche Principal_Nom_fichier dans le Fileselect
// //
{ {
Block(Fenetre_Pos_X+(Menu_Facteur_X*202),Fenetre_Pos_Y+(Menu_Facteur_Y*73),Menu_Facteur_X*96,Menu_Facteur_Y<<3,CM_Clair); Block(Fenetre_Pos_X+(Menu_Facteur_X*(13+9*8)),Fenetre_Pos_Y+(Menu_Facteur_Y*90),Menu_Facteur_X*(27*8),Menu_Facteur_Y<<3,CM_Clair);
Print_dans_fenetre(202,73,Principal_Nom_fichier,CM_Noir,CM_Clair); Print_dans_fenetre(13+9*8,90,Principal_Nom_fichier,CM_Noir,CM_Clair);
} }
@ -2156,7 +2158,7 @@ void Preparer_et_afficher_liste_fichiers(short Position, short Decalage,
Calculer_hauteur_curseur_jauge(Enreg); Calculer_hauteur_curseur_jauge(Enreg);
Fenetre_Dessiner_jauge(Enreg); Fenetre_Dessiner_jauge(Enreg);
// On efface les anciens noms de fichier: // On efface les anciens noms de fichier:
Block(Fenetre_Pos_X+(Menu_Facteur_X<<3),Fenetre_Pos_Y+(Menu_Facteur_Y*89),Menu_Facteur_X*98,Menu_Facteur_Y*82,CM_Noir); 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: // On affiche les nouveaux:
Afficher_la_liste_des_fichiers(Position,Decalage); Afficher_la_liste_des_fichiers(Position,Decalage);
@ -2179,7 +2181,7 @@ void Relire_liste_fichiers(byte Filtre, short Position, short Decalage,
void On_vient_de_scroller_dans_le_fileselect(struct Fenetre_Bouton_scroller * Scroller_de_fichiers) void On_vient_de_scroller_dans_le_fileselect(struct Fenetre_Bouton_scroller * Scroller_de_fichiers)
{ {
char Ancien_nom_de_fichier[13]; char Ancien_nom_de_fichier[TAILLE_CHEMIN_FICHIER];
strcpy(Ancien_nom_de_fichier,Principal_Nom_fichier); strcpy(Ancien_nom_de_fichier,Principal_Nom_fichier);
@ -2207,7 +2209,7 @@ short Position_fichier_dans_liste(char * Nom)
short Indice; short Indice;
for (Indice=0, Element_courant=Liste_du_fileselect; for (Indice=0, Element_courant=Liste_du_fileselect;
((Element_courant!=NULL) && (strcmp(Element_courant->Nom,Nom))); ((Element_courant!=NULL) && (strcmp(Element_courant->NomComplet,Nom)));
Indice++,Element_courant=Element_courant->Suivant); Indice++,Element_courant=Element_courant->Suivant);
return (Element_courant!=NULL)?Indice:0; return (Element_courant!=NULL)?Indice:0;
@ -2241,10 +2243,10 @@ void Placer_barre_de_selection_sur(char * Nom)
} }
char FFF_Meilleur_nom[13]; char FFF_Meilleur_nom[TAILLE_CHEMIN_FICHIER];
char * Nom_correspondant_le_mieux_a(char * Nom) char * Nom_correspondant_le_mieux_a(char * Nom)
{ {
char Nom_courant[13]; char Nom_courant[TAILLE_CHEMIN_FICHIER];
char * Pointeur1; char * Pointeur1;
char * Pointeur2; char * Pointeur2;
char * Pointeur_Meilleur_nom; char * Pointeur_Meilleur_nom;
@ -2262,7 +2264,7 @@ char * Nom_correspondant_le_mieux_a(char * Nom)
{ {
// On copie le nom de la liste en cours de traitement dans Nom_courant // On copie le nom de la liste en cours de traitement dans Nom_courant
// tout en le remettant sous forme normale. // tout en le remettant sous forme normale.
for (Pointeur1=Element_courant->Nom,Pointeur2=Nom_courant;*Pointeur1;Pointeur1++) for (Pointeur1=Element_courant->NomComplet,Pointeur2=Nom_courant;*Pointeur1;Pointeur1++)
if (*Pointeur1!=' ') if (*Pointeur1!=' ')
*(Pointeur2++)=*Pointeur1; *(Pointeur2++)=*Pointeur1;
*Pointeur2=0; *Pointeur2=0;
@ -2272,7 +2274,7 @@ char * Nom_correspondant_le_mieux_a(char * Nom)
{ {
Lettres_identiques=Compteur; Lettres_identiques=Compteur;
strcpy(FFF_Meilleur_nom,Nom_courant); strcpy(FFF_Meilleur_nom,Nom_courant);
Pointeur_Meilleur_nom=Element_courant->Nom; Pointeur_Meilleur_nom=Element_courant->NomComplet;
} }
} }
} }
@ -2299,10 +2301,10 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
short Largeur_image_initiale; // |- être restaurées en sortant, short Largeur_image_initiale; // |- être restaurées en sortant,
short Hauteur_image_initiale; // | parce que la preview elle les short Hauteur_image_initiale; // | parce que la preview elle les
byte Back_color_initiale; // | fout en l'air (c'te conne). byte Back_color_initiale; // | fout en l'air (c'te conne).
char Nom_fichier_initial[13]; // Sert à laisser le nom courant du fichier en cas de sauvegarde char Nom_fichier_initial[TAILLE_CHEMIN_FICHIER]; // Sert à laisser le nom courant du fichier en cas de sauvegarde
char Repertoire_precedent[13]; // Répertoire d'où l'on vient après un CHDIR char Repertoire_precedent[TAILLE_CHEMIN_FICHIER]; // Répertoire d'où l'on vient après un CHDIR
char Commentaire_initial[TAILLE_COMMENTAIRE+1]; char Commentaire_initial[TAILLE_COMMENTAIRE+1];
char Fichier_recherche[13]=""; char Fichier_recherche[TAILLE_CHEMIN_FICHIER]="";
char * Fichier_le_plus_ressemblant; char * Fichier_le_plus_ressemblant;
Palette_initiale=(struct Composantes *)malloc(sizeof(T_Palette)); Palette_initiale=(struct Composantes *)malloc(sizeof(T_Palette));
@ -2317,18 +2319,18 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
if (Load) if (Load)
{ {
if (Image) if (Image)
Ouvrir_fenetre(310,190,"Load picture"); Ouvrir_fenetre(310,190+FILENAMESPACE,"Load picture");
else else
Ouvrir_fenetre(310,190,"Load brush"); Ouvrir_fenetre(310,190+FILENAMESPACE,"Load brush");
Fenetre_Definir_bouton_normal(125,157,51,14,"Load",0,1,0x001C); // 1 Fenetre_Definir_bouton_normal(125,157+FILENAMESPACE,51,14,"Load",0,1,0x001C); // 1
} }
else else
{ {
if (Image) if (Image)
Ouvrir_fenetre(310,190,"Save picture"); Ouvrir_fenetre(310,190+FILENAMESPACE,"Save picture");
else else
Ouvrir_fenetre(310,190,"Save brush"); Ouvrir_fenetre(310,190+FILENAMESPACE,"Save brush");
Fenetre_Definir_bouton_normal(125,157,51,14,"Save",0,1,0x001C); // 1 Fenetre_Definir_bouton_normal(125,157+FILENAMESPACE,51,14,"Save",0,1,0x001C); // 1
if (Principal_Format==0) // Correction du *.* if (Principal_Format==0) // Correction du *.*
{ {
Principal_Format=Principal_Format_fichier; Principal_Format=Principal_Format_fichier;
@ -2344,41 +2346,44 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
} }
// Affichage du commentaire // Affichage du commentaire
if (Format_Commentaire[Principal_Format-1]) if (Format_Commentaire[Principal_Format-1])
Print_dans_fenetre(46,176,Principal_Commentaire,CM_Noir,CM_Clair); Print_dans_fenetre(46,176+FILENAMESPACE,Principal_Commentaire,CM_Noir,CM_Clair);
} }
Fenetre_Definir_bouton_normal(125,139,51,14,"Cancel",0,1,0x0001); // 2 Fenetre_Definir_bouton_normal(125,139+FILENAMESPACE,51,14,"Cancel",0,1,0x0001); // 2
Fenetre_Definir_bouton_normal(125, 89,51,14,"Delete",0,1,0x0053); // 3 Fenetre_Definir_bouton_normal(125, 89+FILENAMESPACE,51,14,"Delete",0,1,0x0053); // 3
// Câdre autour des formats // Câdre autour des formats
Fenetre_Afficher_cadre( 7, 51,103, 35); Fenetre_Afficher_cadre( 7, 51,103, 35);
// Câdre autour des infos sur le fichier de dessin // Câdre autour des infos sur le fichier de dessin
Fenetre_Afficher_cadre(116, 51,187, 35); Fenetre_Afficher_cadre(116, 51,187, 35);
// Câdre autour de la preview // Câdre autour de la preview
Fenetre_Afficher_cadre_creux(179,88,124,84); Fenetre_Afficher_cadre_creux(179,88+FILENAMESPACE,124,84);
// Câdre autour du fileselector // Câdre autour du fileselector
Fenetre_Afficher_cadre_creux( 7,88,100,84); Fenetre_Afficher_cadre_creux( 7,88+FILENAMESPACE,100,84);
Fenetre_Definir_bouton_special(9,90,96,80); // 4 Fenetre_Definir_bouton_special(9,90+FILENAMESPACE,96,80); // 4
// Scroller du fileselector // Scroller du fileselector
Fenetre_Definir_bouton_scroller(110,89,82,1,10,0); // 5 Fenetre_Definir_bouton_scroller(110,89+FILENAMESPACE,82,1,10,0); // 5
Scroller_de_fichiers=Fenetre_Liste_boutons_scroller; Scroller_de_fichiers=Fenetre_Liste_boutons_scroller;
// Scroller des formats // Scroller des formats
Fenetre_Definir_bouton_scroller(12,55,27,(Load)?NB_FORMATS_LOAD+1:NB_FORMATS_SAVE,1,(Load)?Principal_Format:Principal_Format-1); // 6 Fenetre_Definir_bouton_scroller(12,55,27,(Load)?NB_FORMATS_LOAD+1:NB_FORMATS_SAVE,1,(Load)?Principal_Format:Principal_Format-1); // 6
// Texte de commentaire des dessins // Texte de commentaire des dessins
Print_dans_fenetre(7,176,"Txt:",CM_Fonce,CM_Clair); Print_dans_fenetre(7,176+FILENAMESPACE,"Txt:",CM_Fonce,CM_Clair);
Fenetre_Definir_bouton_saisie(44,174,TAILLE_COMMENTAIRE); // 7 Fenetre_Definir_bouton_saisie(44,174+FILENAMESPACE,TAILLE_COMMENTAIRE); // 7
// Cadre autour du nom de fichier
//Fenetre_Afficher_cadre_creux( 7,87,296,15);
Print_dans_fenetre(9,90,"Filename:",CM_Fonce,CM_Clair);
// Saisie du nom de fichier // Saisie du nom de fichier
Fenetre_Definir_bouton_saisie(200,71,12); // 8 Fenetre_Definir_bouton_saisie(11+9*8,88,27); // 8
Print_dans_fenetre( 27,65,"Format:",CM_Fonce,CM_Clair); Print_dans_fenetre( 27,65,"Format:",CM_Fonce,CM_Clair);
Print_dans_fenetre(120,55,"Image size :",CM_Fonce,CM_Clair); Print_dans_fenetre(120,55,"Image size :",CM_Fonce,CM_Clair);
Print_dans_fenetre(120,63,"File size :",CM_Fonce,CM_Clair); Print_dans_fenetre(120,63,"File size :",CM_Fonce,CM_Clair);
Print_dans_fenetre(120,73,"File name:",CM_Fonce,CM_Clair); Print_dans_fenetre(120,72,"Format :",CM_Fonce,CM_Clair);
Print_Format(); Print_Format();
@ -2441,15 +2446,15 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
// On affiche une demande de confirmation // On affiche une demande de confirmation
if (Principal_File_list_Position+Principal_File_list_Decalage>=Liste_Nb_repertoires) if (Principal_File_list_Position+Principal_File_list_Decalage>=Liste_Nb_repertoires)
{ {
Print_dans_fenetre(127,107,"Delete",CM_Fonce,CM_Clair); Print_dans_fenetre(127,107+FILENAMESPACE,"Delete",CM_Fonce,CM_Clair);
Print_dans_fenetre(127,115,"file ?",CM_Fonce,CM_Clair); Print_dans_fenetre(127,115+FILENAMESPACE,"file ?",CM_Fonce,CM_Clair);
} }
else else
{ {
Print_dans_fenetre(127,107,"Remove",CM_Fonce,CM_Clair); Print_dans_fenetre(127,107+FILENAMESPACE,"Remove",CM_Fonce,CM_Clair);
Print_dans_fenetre(127,115,"dir. ?",CM_Fonce,CM_Clair); Print_dans_fenetre(127,115+FILENAMESPACE,"dir. ?",CM_Fonce,CM_Clair);
} }
Print_dans_fenetre(127,123,"Yes/No",CM_Fonce,CM_Clair); Print_dans_fenetre(127,123+FILENAMESPACE,"Yes/No",CM_Fonce,CM_Clair);
do do
{ {
@ -2457,7 +2462,7 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
} while ((Etat_Du_Clavier[SDLK_y]==0) && (Etat_Du_Clavier[SDLK_n]==0) && (Etat_Du_Clavier[SDLK_ESCAPE]==0)); } while ((Etat_Du_Clavier[SDLK_y]==0) && (Etat_Du_Clavier[SDLK_n]==0) && (Etat_Du_Clavier[SDLK_ESCAPE]==0));
// On efface la demande de confirmation // On efface la demande de confirmation
Block(Fenetre_Pos_X+127*Menu_Facteur_X,Fenetre_Pos_Y+107*Menu_Facteur_Y, Block(Fenetre_Pos_X+127*Menu_Facteur_X,Fenetre_Pos_Y+(107+FILENAMESPACE)*Menu_Facteur_Y,
Menu_Facteur_X*48,Menu_Facteur_Y*24,CM_Clair); Menu_Facteur_X*48,Menu_Facteur_Y*24,CM_Clair);
// Si l'utilisateur confirme, // Si l'utilisateur confirme,
@ -2581,13 +2586,13 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
if ( (!Load) && (Format_Commentaire[Principal_Format-1]) ) if ( (!Load) && (Format_Commentaire[Principal_Format-1]) )
{ {
Effacer_curseur(); Effacer_curseur();
Readline(46,176,Principal_Commentaire,32,0); Readline(46,176+FILENAMESPACE,Principal_Commentaire,32,0);
Afficher_curseur(); Afficher_curseur();
} }
break; break;
case 8 : // Saisie du nom de fichier case 8 : // Saisie du nom de fichier
Effacer_curseur(); Effacer_curseur();
if (Readline(202,73,Principal_Nom_fichier,12,2)) if (Readline(13+9*8,90,Principal_Nom_fichier,27,2))
{ {
// On regarde s'il faut rajouter une extension. C'est-à-dire s'il // On regarde s'il faut rajouter une extension. C'est-à-dire s'il
// n'y a pas de '.' dans le nom du fichier. // n'y a pas de '.' dans le nom du fichier.
@ -2748,14 +2753,11 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
if (Etat_chrono==2) if (Etat_chrono==2)
{ {
Effacer_curseur(); Effacer_curseur();
// On efface le "but is:"
Block(Fenetre_Pos_X+27*Menu_Facteur_X,Fenetre_Pos_Y+74*Menu_Facteur_Y,
Menu_Facteur_X*80,Menu_Facteur_Y<<3,CM_Clair);
// On efface le commentaire précédent // On efface le commentaire précédent
Block(Fenetre_Pos_X+ 46*Menu_Facteur_X,Fenetre_Pos_Y+176*Menu_Facteur_Y, Block(Fenetre_Pos_X+ 46*Menu_Facteur_X,Fenetre_Pos_Y+(176+FILENAMESPACE)*Menu_Facteur_Y,
Menu_Facteur_X<<8,Menu_Facteur_Y<<3,CM_Clair); Menu_Facteur_X<<8,Menu_Facteur_Y<<3,CM_Clair);
// On néttoie la zone où va s'afficher la preview: // On néttoie la zone où va s'afficher la preview:
Block(Fenetre_Pos_X+180*Menu_Facteur_X,Fenetre_Pos_Y+ 89*Menu_Facteur_Y, Block(Fenetre_Pos_X+180*Menu_Facteur_X,Fenetre_Pos_Y+ (89+FILENAMESPACE)*Menu_Facteur_Y,
Menu_Facteur_X*122,Menu_Facteur_Y*82,CM_Clair); Menu_Facteur_X*122,Menu_Facteur_Y*82,CM_Clair);
// On efface les dimensions de l'image // On efface les dimensions de l'image
Block(Fenetre_Pos_X+226*Menu_Facteur_X,Fenetre_Pos_Y+ 55*Menu_Facteur_Y, Block(Fenetre_Pos_X+226*Menu_Facteur_X,Fenetre_Pos_Y+ 55*Menu_Facteur_Y,
@ -2763,12 +2765,15 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
// On efface la taille du fichier // On efface la taille du fichier
Block(Fenetre_Pos_X+226*Menu_Facteur_X,Fenetre_Pos_Y+ 63*Menu_Facteur_Y, Block(Fenetre_Pos_X+226*Menu_Facteur_X,Fenetre_Pos_Y+ 63*Menu_Facteur_Y,
Menu_Facteur_X*72,Menu_Facteur_Y<<3,CM_Clair); Menu_Facteur_X*72,Menu_Facteur_Y<<3,CM_Clair);
// On efface le format du fichier
Block(Fenetre_Pos_X+226*Menu_Facteur_X,Fenetre_Pos_Y+ 72*Menu_Facteur_Y,
Menu_Facteur_X*72,Menu_Facteur_Y<<3,CM_Clair);
// Affichage du commentaire // Affichage du commentaire
if ( (!Load) && (Format_Commentaire[Principal_Format-1]) ) if ( (!Load) && (Format_Commentaire[Principal_Format-1]) )
Print_dans_fenetre(46,176,Principal_Commentaire,CM_Noir,CM_Clair); Print_dans_fenetre(46,176+FILENAMESPACE,Principal_Commentaire,CM_Noir,CM_Clair);
Afficher_curseur(); Afficher_curseur();
SDL_UpdateRect(Ecran_SDL,Fenetre_Pos_X+27*Menu_Facteur_X,Fenetre_Pos_Y+55*Menu_Facteur_Y,Menu_Facteur_X<<9,Menu_Facteur_Y<<4); SDL_UpdateRect(Ecran_SDL,Fenetre_Pos_X+27*Menu_Facteur_X,Fenetre_Pos_Y+(55+FILENAMESPACE)*Menu_Facteur_Y,Menu_Facteur_X<<9,Menu_Facteur_Y<<4);
} }
Nouvelle_preview=0; Nouvelle_preview=0;
@ -2788,7 +2793,7 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
Effacer_curseur(); Effacer_curseur();
Charger_image(Image); Charger_image(Image);
SDL_UpdateRect(Ecran_SDL,ToWinX(179),ToWinY(88),ToWinL(124),ToWinH(84)); SDL_UpdateRect(Ecran_SDL,ToWinX(179),ToWinY(88+FILENAMESPACE),ToWinL(124),ToWinH(84));
Afficher_curseur(); Afficher_curseur();
// Après le chargement de la preview, on restaure tout ce qui aurait // Après le chargement de la preview, on restaure tout ce qui aurait
@ -2947,8 +2952,8 @@ void Load_picture(byte Image)
// Image=0 => On charge/sauve une brosse // Image=0 => On charge/sauve une brosse
{ {
// Données initiales du fichier (au cas où on voudrait annuler) // Données initiales du fichier (au cas où on voudrait annuler)
char Repertoire_fichier_initial[256]; char Repertoire_fichier_initial[TAILLE_CHEMIN_FICHIER];
char Nom_fichier_initial[13]; char Nom_fichier_initial[TAILLE_CHEMIN_FICHIER];
byte Format_fichier_initial; byte Format_fichier_initial;
byte Ne_pas_restaurer; byte Ne_pas_restaurer;
byte Utiliser_palette_brosse = 0; byte Utiliser_palette_brosse = 0;
@ -3240,8 +3245,8 @@ void Save_picture(byte Image)
// Image=0 => On charge/sauve une brosse // Image=0 => On charge/sauve une brosse
{ {
// Données initiales du fichier (au cas où on voudrait annuler) // Données initiales du fichier (au cas où on voudrait annuler)
char Repertoire_fichier_initial[256]; char Repertoire_fichier_initial[TAILLE_CHEMIN_FICHIER];
char Nom_fichier_initial[13]; char Nom_fichier_initial[TAILLE_CHEMIN_FICHIER];
byte Format_fichier_initial; byte Format_fichier_initial;
byte Ne_pas_restaurer; byte Ne_pas_restaurer;
byte Ancienne_forme_curseur; byte Ancienne_forme_curseur;

2
const.h
View File

@ -45,7 +45,7 @@
#define NB_PAGES_UNDO_MAX 99 // Nombre maximal de pages d'undo #define NB_PAGES_UNDO_MAX 99 // Nombre maximal de pages d'undo
#define FACTEUR_DE_ZOOM_PAR_DEFAUT 4 // Facteur de zoom initial #define FACTEUR_DE_ZOOM_PAR_DEFAUT 4 // Facteur de zoom initial
#define NB_SECTIONS_AIDE 3 // Nombre de sections dans l'aide #define NB_SECTIONS_AIDE 3 // Nombre de sections dans l'aide
#define TAILLE_CHEMIN_FICHIER 2048 // Le nombre de caractères maxi pour un nom de fichier avec chemin complet #define TAILLE_CHEMIN_FICHIER 260 // Le nombre de caractères maxi pour un nom de fichier avec chemin complet
// On impose à l'allocation dynamique des pages de backups de conserver un // On impose à l'allocation dynamique des pages de backups de conserver un
// minimum de 256 Ko pour que le reste du programme puisse continuer à // minimum de 256 Ko pour que le reste du programme puisse continuer à

184
files.c
View File

@ -6,7 +6,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <fcntl.h> #include <fcntl.h>
#include <string.h> #include <string.h>
#include <ctype.h>
#include <errno.h> #include <errno.h>
#include <unistd.h> #include <unistd.h>
#include <sys/types.h> #include <sys/types.h>
@ -35,6 +35,7 @@
#define COULEUR_REPERTOIRE_SELECT CM_Clair // Couleur du texte pour une ligne de repértoire sélectionnée #define COULEUR_REPERTOIRE_SELECT CM_Clair // Couleur du texte pour une ligne de repértoire sélectionnée
#define COULEUR_FOND_SELECT CM_Fonce // Couleur du fond pour une ligne sélectionnée #define COULEUR_FOND_SELECT CM_Fonce // Couleur du fond pour une ligne sélectionnée
#define FILENAMESPACE 16
int Determiner_repertoire_courant(void) int Determiner_repertoire_courant(void)
// Modifie Principal_Repertoire_courant en y mettant sa nouvelle valeur (avec le nom du // Modifie Principal_Repertoire_courant en y mettant sa nouvelle valeur (avec le nom du
@ -72,8 +73,8 @@ int Repertoire_existe(char * Repertoire)
int Fichier_existe(char * Fichier) int Fichier_existe(char * Fichier)
// D‚termine si un fichier pass‚ en paramŠtre existe ou non dans le // Détermine si un fichier passé en paramŠtre existe ou non dans le
// r‚pertoire courant. // répertoire courant.
{ {
struct stat buf; struct stat buf;
int Resultat; int Resultat;
@ -90,13 +91,13 @@ int Fichier_existe(char * Fichier)
// Conventions: // Conventions:
// //
// * Le fileselect modifie le r‚pertoire courant. Ceci permet de n'avoir // * Le fileselect modifie le répertoire courant. Ceci permet de n'avoir
// qu'un findfirst dans le r‚pertoire courant … faire: // qu'un findfirst dans le répertoire courant … faire:
// -- D‚struction de la liste chaŒn‚e --------------------------------------- // -- Déstruction de la liste chaŒnée ---------------------------------------
void Detruire_liste_du_fileselect(void) void Detruire_liste_du_fileselect(void)
// Cette proc‚dure d‚truit la chaine des fichiers. Elle doit ˆtre appel‚e // Cette procédure détruit la chaine des fichiers. Elle doit être appelée
// avant de rappeler la fonction Lire_liste_des_fichiers, ainsi qu'en fin de // avant de rappeler la fonction Lire_liste_des_fichiers, ainsi qu'en fin de
// programme. // programme.
{ {
@ -105,17 +106,17 @@ void Detruire_liste_du_fileselect(void)
while (Liste_du_fileselect!=NULL) while (Liste_du_fileselect!=NULL)
{ {
// On m‚morise l'adresse du premier ‚l‚ment de la liste // On mémorise l'adresse du premier élément de la liste
Element_temporaire =Liste_du_fileselect; Element_temporaire =Liste_du_fileselect;
// On fait avancer la tˆte de la liste // On fait avancer la tête de la liste
Liste_du_fileselect=Liste_du_fileselect->Suivant; Liste_du_fileselect=Liste_du_fileselect->Suivant;
// Et on efface l'ancien premier ‚l‚ment de la liste // Et on efface l'ancien premier élément de la liste
free(Element_temporaire); free(Element_temporaire);
} }
} }
// -- Formatage graphique des noms de fichier / r‚pertoire ------------------ // -- Formatage graphique des noms de fichier / répertoire ------------------
char * Nom_formate(char * Nom) char * Nom_formate(char * Nom)
{ {
static char Resultat[13]; static char Resultat[13];
@ -130,7 +131,7 @@ char * Nom_formate(char * Nom)
else else
{ {
strcpy(Resultat," . "); strcpy(Resultat," . ");
// On commence par recopier la partie pr‚c‚dent le point: // On commence par recopier la partie précédent le point:
for (Curseur=0;( (Nom[Curseur]!='.') && (Nom[Curseur]!='\0') );Curseur++) for (Curseur=0;( (Nom[Curseur]!='.') && (Nom[Curseur]!='\0') );Curseur++)
{ {
if (Curseur < 8) if (Curseur < 8)
@ -141,7 +142,7 @@ char * Nom_formate(char * Nom)
if (Nom[Curseur]=='.') if (Nom[Curseur]=='.')
Pos_DernierPoint = Curseur; Pos_DernierPoint = Curseur;
// Ensuite on recopie la partie qui suit le point (si n‚cessaire): // Ensuite on recopie la partie qui suit le point (si nécessaire):
if (Nom[Pos_DernierPoint]) if (Nom[Pos_DernierPoint])
{ {
for (Curseur = Pos_DernierPoint+1,Autre_curseur=9;Nom[Curseur]!='\0' && Autre_curseur < 12;Curseur++,Autre_curseur++) for (Curseur = Pos_DernierPoint+1,Autre_curseur=9;Nom[Curseur]!='\0' && Autre_curseur < 12;Curseur++,Autre_curseur++)
@ -154,7 +155,7 @@ char * Nom_formate(char * Nom)
// -- Rajouter a la liste des elements de la liste un element --------------- // -- Rajouter a la liste des elements de la liste un element ---------------
void Ajouter_element_a_la_liste(struct dirent* Enreg) void Ajouter_element_a_la_liste(struct dirent* Enreg)
// Cette procedure ajoute a la liste chainee un fichier pass‚ en argument. // Cette procedure ajoute a la liste chainee un fichier passé en argument.
{ {
// Pointeur temporaire d'insertion // Pointeur temporaire d'insertion
struct Element_de_liste_de_fileselect * Element_temporaire; struct Element_de_liste_de_fileselect * Element_temporaire;
@ -163,7 +164,8 @@ void Ajouter_element_a_la_liste(struct dirent* Enreg)
Element_temporaire=(struct Element_de_liste_de_fileselect *)malloc(sizeof(struct Element_de_liste_de_fileselect)); Element_temporaire=(struct Element_de_liste_de_fileselect *)malloc(sizeof(struct Element_de_liste_de_fileselect));
// On met a jour le nouvel emplacement: // On met a jour le nouvel emplacement:
strcpy(Element_temporaire->Nom,Nom_formate(Enreg->d_name)); strcpy(Element_temporaire->NomAbrege,Nom_formate(Enreg->d_name));
strcpy(Element_temporaire->NomComplet,Enreg->d_name);
#ifdef __linux__ #ifdef __linux__
Element_temporaire->Type = (Enreg->d_type == DT_DIR); Element_temporaire->Type = (Enreg->d_type == DT_DIR);
#elif __WATCOMC__ #elif __WATCOMC__
@ -182,6 +184,37 @@ void Ajouter_element_a_la_liste(struct dirent* Enreg)
Liste_du_fileselect=Element_temporaire; Liste_du_fileselect=Element_temporaire;
} }
// -- Vérification si un fichier a l'extension demandée.
// Autorise les '?', et '*' si c'est le seul caractère.
int VerifieExtension(const char *NomFichier, char * Filtre)
{
int Pos_DernierPoint = -1;
int Curseur = 0;
if (Filtre[0] == '*')
return 1;
// On recherche la position du dernier . dans le nom
for (Curseur = 0; NomFichier[Curseur]!='\0'; Curseur++)
if (NomFichier[Curseur]=='.')
Pos_DernierPoint = Curseur;
// Fichier sans extension (ca arrive)
if (Pos_DernierPoint == -1)
return (Filtre[0] == '\0');
// Vérification caractère par caractère, case-insensitive.
Curseur = 0;
do
{
if (Filtre[Curseur] != '?' &&
tolower(Filtre[Curseur]) != tolower(NomFichier[Pos_DernierPoint + 1 + Curseur]))
return 0;
Curseur++;
} while (Filtre[Curseur++] != '\0');
return 1;
}
// -- Lecture d'une liste de fichiers --------------------------------------- // -- Lecture d'une liste de fichiers ---------------------------------------
void Lire_liste_des_fichiers(byte Format_demande) void Lire_liste_des_fichiers(byte Format_demande)
@ -190,15 +223,12 @@ void Lire_liste_des_fichiers(byte Format_demande)
{ {
DIR* Repertoire_Courant; //Répertoire courant DIR* Repertoire_Courant; //Répertoire courant
struct dirent* Enreg; // Structure de lecture des éléments struct dirent* Enreg; // Structure de lecture des éléments
char Filtre[6]="*."; // Place pour écrire "*.XXX" et un '\0' char * Filtre = "*"; // Extension demandée
struct stat Infos_enreg; struct stat Infos_enreg;
// Tout d'abord, on déduit du format demandé un filtre à utiliser: // Tout d'abord, on déduit du format demandé un filtre à utiliser:
if (Format_demande) // Format (extension) spécifique if (Format_demande) // Format (extension) spécifique
strcat(Filtre,Format_Extension[Format_demande-1]); Filtre = Format_Extension[Format_demande-1];
else // *.*
strcat(Filtre,"*");
// Ensuite, on vide la liste actuelle: // Ensuite, on vide la liste actuelle:
Detruire_liste_du_fileselect(); Detruire_liste_du_fileselect();
@ -227,12 +257,15 @@ void Lire_liste_des_fichiers(byte Format_demande)
} }
else if (S_ISREG(Infos_enreg.st_mode) //Il s'agit d'un fichier else if (S_ISREG(Infos_enreg.st_mode) //Il s'agit d'un fichier
&& ((!isHidden(Enreg)) || !Config.Lire_les_fichiers_caches)) //Il n'est pas caché && ((!isHidden(Enreg)) || !Config.Lire_les_fichiers_caches)) //Il n'est pas caché
{
if (VerifieExtension(Enreg->d_name, Filtre))
{ {
// On rajoute le fichier à la liste // On rajoute le fichier à la liste
Ajouter_element_a_la_liste(Enreg); Ajouter_element_a_la_liste(Enreg);
Liste_Nb_fichiers++; Liste_Nb_fichiers++;
} }
} }
}
// On cherche l'élément suivant // On cherche l'élément suivant
Enreg=readdir(Repertoire_Courant); Enreg=readdir(Repertoire_Courant);
@ -244,27 +277,27 @@ void Lire_liste_des_fichiers(byte Format_demande)
} }
// -- Tri de la liste des fichiers et r‚pertoires --------------------------- // -- Tri de la liste des fichiers et répertoires ---------------------------
void Trier_la_liste_des_fichiers(void) void Trier_la_liste_des_fichiers(void)
// Tri la liste chain‚e existante dans l'ordre suivant: // Tri la liste chainée existante dans l'ordre suivant:
// //
// * Les r‚pertoires d'abord, dans l'ordre alphab‚tique de leur nom // * Les répertoires d'abord, dans l'ordre alphabétique de leur nom
// * Les fichiers ensuite, dans l'ordre alphab‚tique de leur nom // * Les fichiers ensuite, dans l'ordre alphabétique de leur nom
{ {
byte La_liste_est_triee; // Bool‚en "La liste est tri‚e" byte La_liste_est_triee; // Booléen "La liste est triée"
byte Inversion; // Bool‚en "Il faut inverser les ‚l‚ments" byte Inversion; // Booléen "Il faut inverser les éléments"
struct Element_de_liste_de_fileselect * Element_precedent; struct Element_de_liste_de_fileselect * Element_precedent;
struct Element_de_liste_de_fileselect * Element_courant; struct Element_de_liste_de_fileselect * Element_courant;
struct Element_de_liste_de_fileselect * Element_suivant; struct Element_de_liste_de_fileselect * Element_suivant;
struct Element_de_liste_de_fileselect * Element_suivant_le_suivant; struct Element_de_liste_de_fileselect * Element_suivant_le_suivant;
// Avant de trier quoi que ce soit, on v‚rifie qu'il y ait suffisamment // Avant de trier quoi que ce soit, on vérifie qu'il y ait suffisamment
// d'‚l‚ments pour qu'il soit possibles qu'ils soient en d‚sordre: // d'éléments pour qu'il soit possibles qu'ils soient en désordre:
if (Liste_Nb_elements>1) if (Liste_Nb_elements>1)
{ {
do do
{ {
// Par d‚faut, on considŠre que la liste est tri‚e // Par défaut, on considŠre que la liste est triée
La_liste_est_triee=1; La_liste_est_triee=1;
Element_courant=Liste_du_fileselect; Element_courant=Liste_du_fileselect;
@ -275,55 +308,55 @@ void Trier_la_liste_des_fichiers(void)
// On commence par supposer qu'il n'y pas pas besoin d'inversion // On commence par supposer qu'il n'y pas pas besoin d'inversion
Inversion=0; Inversion=0;
// Ensuite, on v‚rifie si les deux ‚l‚ments sont bien dans l'ordre ou // Ensuite, on vérifie si les deux éléments sont bien dans l'ordre ou
// non: // non:
// Si l'‚l‚ment courant est un fichier est que le suivant est // Si l'élément courant est un fichier est que le suivant est
// un r‚pertoire -> Inversion // un répertoire -> Inversion
if ( (Element_courant->Type==0) && (Element_suivant->Type==1) ) if ( (Element_courant->Type==0) && (Element_suivant->Type==1) )
Inversion=1; Inversion=1;
// Si les deux ‚l‚ments sont de mˆme type et que le nom du suivant // Si les deux éléments sont de même type et que le nom du suivant
// est plus petit que celui du courant -> Inversion // est plus petit que celui du courant -> Inversion
else if ( (Element_courant->Type==Element_suivant->Type) && else if ( (Element_courant->Type==Element_suivant->Type) &&
(strcmp(Element_courant->Nom,Element_suivant->Nom)>0) ) (strcmp(Element_courant->NomComplet,Element_suivant->NomComplet)>0) )
Inversion=1; Inversion=1;
if (Inversion) if (Inversion)
{ {
// Si les deux ‚l‚ments n‚cessitent d'ˆtre invers‚: // Si les deux éléments nécessitent d'être inversé:
// On les inverses: // On les inverses:
// On note avant tout les ‚l‚ments qui encapsulent nos deux amis // On note avant tout les éléments qui encapsulent nos deux amis
Element_precedent =Element_courant->Precedent; Element_precedent =Element_courant->Precedent;
Element_suivant_le_suivant=Element_suivant->Suivant; Element_suivant_le_suivant=Element_suivant->Suivant;
// On permute le chaŒnage des deux ‚l‚ments entree eux // On permute le chaŒnage des deux éléments entree eux
Element_courant->Suivant =Element_suivant_le_suivant; Element_courant->Suivant =Element_suivant_le_suivant;
Element_courant->Precedent=Element_suivant; Element_courant->Precedent=Element_suivant;
Element_suivant->Suivant =Element_courant; Element_suivant->Suivant =Element_courant;
Element_suivant->Precedent=Element_precedent; Element_suivant->Precedent=Element_precedent;
// On tente un chaŒnage des ‚l‚ments encapsulant les compŠres: // On tente un chaŒnage des éléments encapsulant les compŠres:
if (Element_precedent!=NULL) if (Element_precedent!=NULL)
Element_precedent->Suivant=Element_suivant; Element_precedent->Suivant=Element_suivant;
if (Element_suivant_le_suivant!=NULL) if (Element_suivant_le_suivant!=NULL)
Element_suivant_le_suivant->Precedent=Element_courant; Element_suivant_le_suivant->Precedent=Element_courant;
// On fait bien attention … modifier la tˆte de liste en cas de besoin // On fait bien attention … modifier la tête de liste en cas de besoin
if (Element_courant==Liste_du_fileselect) if (Element_courant==Liste_du_fileselect)
Liste_du_fileselect=Element_suivant; Liste_du_fileselect=Element_suivant;
// Ensuite, on se pr‚pare … ‚tudier les ‚l‚ments pr‚c‚dents: // Ensuite, on se prépare … étudier les éléments précédents:
Element_courant=Element_precedent; Element_courant=Element_precedent;
// Et on constate que la liste n'‚tait pas encore g‚nialement tri‚e // Et on constate que la liste n'était pas encore génialement triée
La_liste_est_triee=0; La_liste_est_triee=0;
} }
else else
{ {
// Si les deux ‚l‚ments sont dans l'ordre: // Si les deux éléments sont dans l'ordre:
// On passe aux suivants // On passe aux suivants
Element_courant=Element_courant->Suivant; Element_courant=Element_courant->Suivant;
@ -336,14 +369,14 @@ void Trier_la_liste_des_fichiers(void)
} }
// -- Affichage des ‚l‚ments de la liste de fichier / r‚pertoire ------------ // -- Affichage des éléments de la liste de fichier / répertoire ------------
void Afficher_la_liste_des_fichiers(short Decalage_premier,short Decalage_select) void Afficher_la_liste_des_fichiers(short Decalage_premier,short Decalage_select)
// //
// Decalage_premier = D‚calage entre le premier fichier visible dans le // Decalage_premier = Décalage entre le premier fichier visible dans le
// s‚lecteur et le premier fichier de la liste // sélecteur et le premier fichier de la liste
// //
// Decalage_select = D‚calage entre le premier fichier visible dans le // Decalage_select = Décalage entre le premier fichier visible dans le
// s‚lecteur et le fichier s‚lectionn‚ dans la liste // sélecteur et le fichier sélectionné dans la liste
// //
{ {
struct Element_de_liste_de_fileselect * Element_courant; struct Element_de_liste_de_fileselect * Element_courant;
@ -352,7 +385,7 @@ void Afficher_la_liste_des_fichiers(short Decalage_premier,short Decalage_select
byte Couleur_fond; byte Couleur_fond;
// On v‚rifie s'il y a au moins 1 fichier dans la liste: // On vérifie s'il y a au moins 1 fichier dans la liste:
if (Liste_Nb_elements>0) if (Liste_Nb_elements>0)
{ {
// On commence par chercher … pointer sur le premier fichier visible: // On commence par chercher … pointer sur le premier fichier visible:
@ -360,10 +393,10 @@ void Afficher_la_liste_des_fichiers(short Decalage_premier,short Decalage_select
for (;Decalage_premier>0;Decalage_premier--) for (;Decalage_premier>0;Decalage_premier--)
Element_courant=Element_courant->Suivant; Element_courant=Element_courant->Suivant;
// Pour chacun des 10 ‚l‚ments inscriptibles … l'‚cran // Pour chacun des 10 éléments inscriptibles … l'écran
for (Indice=0;Indice<10;Indice++) for (Indice=0;Indice<10;Indice++)
{ {
// S'il est s‚lectionn‚: // S'il est sélectionné:
if (!Decalage_select) if (!Decalage_select)
{ {
// Si c'est un fichier // Si c'est un fichier
@ -385,8 +418,8 @@ void Afficher_la_liste_des_fichiers(short Decalage_premier,short Decalage_select
Couleur_fond=COULEUR_FOND_NORMAL; Couleur_fond=COULEUR_FOND_NORMAL;
} }
// On affiche l'‚l‚ment // On affiche l'élément
Print_dans_fenetre(9,90+(Indice<<3),Element_courant->Nom,Couleur_texte,Couleur_fond); Print_dans_fenetre(9,90+FILENAMESPACE+(Indice<<3),Element_courant->NomAbrege,Couleur_texte,Couleur_fond);
// On passe … la ligne suivante // On passe … la ligne suivante
Decalage_select--; Decalage_select--;
@ -399,65 +432,62 @@ void Afficher_la_liste_des_fichiers(short Decalage_premier,short Decalage_select
} }
// -- R‚cup‚rer le libell‚ d'un ‚l‚ment de la liste ------------------------- // -- Récupérer le libellé d'un élément de la liste -------------------------
void Determiner_element_de_la_liste(short Decalage_premier,short Decalage_select,char * Libelle) void Determiner_element_de_la_liste(short Decalage_premier,short Decalage_select,char * Libelle)
// //
// Decalage_premier = D‚calage entre le premier fichier visible dans le // Decalage_premier = Décalage entre le premier fichier visible dans le
// s‚lecteur et le premier fichier de la liste // sélecteur et le premier fichier de la liste
// //
// Decalage_select = D‚calage entre le premier fichier visible dans le // Decalage_select = Décalage entre le premier fichier visible dans le
// s‚lecteur et le fichier … r‚cup‚rer // sélecteur et le fichier … récupérer
// //
// Libelle = Chaine de r‚ception du libell‚ de l'‚l‚ment // Libelle = Chaine de réception du libellé de l'élément
// //
{ {
struct Element_de_liste_de_fileselect * Element_courant; struct Element_de_liste_de_fileselect * Element_courant;
char * Curseur; char * Curseur;
// On v‚rifie s'il y a au moins 1 fichier dans la liste: // On vérifie s'il y a au moins 1 fichier dans la liste:
if (Liste_Nb_elements>0) if (Liste_Nb_elements>0)
{ {
// On commence par chercher … pointer sur le premier fichier visible: // On commence par chercher à pointer sur le premier fichier visible:
Element_courant=Liste_du_fileselect; Element_courant=Liste_du_fileselect;
for (;Decalage_premier>0;Decalage_premier--) for (;Decalage_premier>0;Decalage_premier--)
Element_courant=Element_courant->Suivant; Element_courant=Element_courant->Suivant;
// Ensuite, on saute autant d'‚l‚ments que le d‚calage demand‚: // Ensuite, on saute autant d'éléments que le décalage demandé:
for (;Decalage_select>0;Decalage_select--) for (;Decalage_select>0;Decalage_select--)
Element_courant=Element_courant->Suivant; Element_courant=Element_courant->Suivant;
// On recopie la chaŒne en la d‚formatant (i.e. tous les chars sauf ' ') // On recopie la chaîne
for (Curseur=Element_courant->Nom;*Curseur!='\0';Curseur++) strcpy(Libelle, Element_courant->NomComplet);
if (*Curseur!=' ')
*(Libelle++)=*Curseur;
*Libelle='\0';
} // Fin du test d'existence de fichiers } // Fin du test d'existence de fichiers
} }
// ----------------- D‚placements dans la liste de fichiers ----------------- // ----------------- Déplacements dans la liste de fichiers -----------------
void Select_Scroll_Down(short * Decalage_premier,short * Decalage_select) void Select_Scroll_Down(short * Decalage_premier,short * Decalage_select)
// Fait scroller vers le bas le s‚lecteur de fichier... (si possible) // Fait scroller vers le bas le sélecteur de fichier... (si possible)
{ {
if ( ((*Decalage_select)<9) if ( ((*Decalage_select)<9)
&& ( (*Decalage_select)+1 < Liste_Nb_elements ) ) && ( (*Decalage_select)+1 < Liste_Nb_elements ) )
// Si la s‚lection peut descendre // Si la sélection peut descendre
Afficher_la_liste_des_fichiers(*Decalage_premier,++(*Decalage_select)); Afficher_la_liste_des_fichiers(*Decalage_premier,++(*Decalage_select));
else // Sinon, descendre la fenˆtre (si possible) else // Sinon, descendre la fenêtre (si possible)
if ((*Decalage_premier)+10<Liste_Nb_elements) if ((*Decalage_premier)+10<Liste_Nb_elements)
Afficher_la_liste_des_fichiers(++(*Decalage_premier),*Decalage_select); Afficher_la_liste_des_fichiers(++(*Decalage_premier),*Decalage_select);
} }
void Select_Scroll_Up(short * Decalage_premier,short * Decalage_select) void Select_Scroll_Up(short * Decalage_premier,short * Decalage_select)
// Fait scroller vers le haut le s‚lecteur de fichier... (si possible) // Fait scroller vers le haut le sélecteur de fichier... (si possible)
{ {
if ((*Decalage_select)>0) if ((*Decalage_select)>0)
// Si la s‚lection peut monter // Si la sélection peut monter
Afficher_la_liste_des_fichiers(*Decalage_premier,--(*Decalage_select)); Afficher_la_liste_des_fichiers(*Decalage_premier,--(*Decalage_select));
else // Sinon, monter la fenˆtre (si possible) else // Sinon, monter la fenêtre (si possible)
if ((*Decalage_premier)>0) if ((*Decalage_premier)>0)
Afficher_la_liste_des_fichiers(--(*Decalage_premier),*Decalage_select); Afficher_la_liste_des_fichiers(--(*Decalage_premier),*Decalage_select);
} }
@ -534,14 +564,14 @@ void Select_Home(short * Decalage_premier,short * Decalage_select)
short Calculer_decalage_click_dans_fileselector(void) short Calculer_decalage_click_dans_fileselector(void)
/* /*
Renvoie le d‚calage dans le s‚lecteur de fichier sur lequel on a click‚. Renvoie le décalage dans le sélecteur de fichier sur lequel on a clické.
Renvoie le d‚calage du dernier fichier si on a click‚ au del…. Renvoie le décalage du dernier fichier si on a clické au del….
Renvoie -1 si le s‚lecteur est vide. Renvoie -1 si le sélecteur est vide.
*/ */
{ {
short Decalage_calcule; short Decalage_calcule;
Decalage_calcule=(((Mouse_Y-Fenetre_Pos_Y)/Menu_Facteur_Y)-90)>>3; Decalage_calcule=(((Mouse_Y-Fenetre_Pos_Y)/Menu_Facteur_Y)-(90+FILENAMESPACE))>>3;
if (Decalage_calcule>=Liste_Nb_elements) if (Decalage_calcule>=Liste_Nb_elements)
Decalage_calcule=Liste_Nb_elements-1; Decalage_calcule=Liste_Nb_elements-1;

10
global.h
View File

@ -242,13 +242,13 @@ GLOBAL short Brouillon_Decalage_Y; // D
GLOBAL short Ancien_Brouillon_Decalage_X; GLOBAL short Ancien_Brouillon_Decalage_X;
GLOBAL short Ancien_Brouillon_Decalage_Y; GLOBAL short Ancien_Brouillon_Decalage_Y;
GLOBAL char Brouillon_Repertoire_fichier[256]; // |_ Nom complet = GLOBAL char Brouillon_Repertoire_fichier[TAILLE_CHEMIN_FICHIER]; // |_ Nom complet =
GLOBAL char Brouillon_Nom_fichier[13]; // | Repertoire_fichier+"\"+Nom_fichier GLOBAL char Brouillon_Nom_fichier[TAILLE_CHEMIN_FICHIER]; // | Repertoire_fichier+"\"+Nom_fichier
GLOBAL byte Brouillon_Format_fichier; // Format auquel il faut lire et Úcrire le fichier GLOBAL byte Brouillon_Format_fichier; // Format auquel il faut lire et Úcrire le fichier
GLOBAL byte Brouillon_Format; // Format du fileselect GLOBAL byte Brouillon_Format; // Format du fileselect
GLOBAL short Brouillon_File_list_Position; // DÚbut de la partie affichÚe dans la liste de fichiers GLOBAL short Brouillon_File_list_Position; // DÚbut de la partie affichÚe dans la liste de fichiers
GLOBAL short Brouillon_File_list_Decalage; // DÚcalage de la barre de sÚlection dans le fileselector GLOBAL short Brouillon_File_list_Decalage; // DÚcalage de la barre de sÚlection dans le fileselector
GLOBAL char Brouillon_Repertoire_courant[256]; // RÚpertoire actuel sur disque GLOBAL char Brouillon_Repertoire_courant[TAILLE_CHEMIN_FICHIER]; // RÚpertoire actuel sur disque
GLOBAL char Brouillon_Commentaire[TAILLE_COMMENTAIRE+1]; // Commentaire de l'image GLOBAL char Brouillon_Commentaire[TAILLE_COMMENTAIRE+1]; // Commentaire de l'image
GLOBAL short Brouillon_Split; // Position en X du bord gauche du split de la loupe GLOBAL short Brouillon_Split; // Position en X du bord gauche du split de la loupe
@ -279,8 +279,8 @@ GLOBAL word Brosse_Decalage_Y; // Centre vertical de la brosse
GLOBAL word Brosse_Largeur; // Largeur de la brosse GLOBAL word Brosse_Largeur; // Largeur de la brosse
GLOBAL word Brosse_Hauteur; // Hauteur de la brosse GLOBAL word Brosse_Hauteur; // Hauteur de la brosse
GLOBAL char Brosse_Repertoire_fichier[256]; // | GLOBAL char Brosse_Repertoire_fichier[TAILLE_CHEMIN_FICHIER];// |
GLOBAL char Brosse_Nom_fichier[13]; // | GLOBAL char Brosse_Nom_fichier[TAILLE_CHEMIN_FICHIER]; // |
GLOBAL byte Brosse_Format_fichier; // | Infos sur le GLOBAL byte Brosse_Format_fichier; // | Infos sur le
GLOBAL byte Brosse_Format; // |_ sÚlecteur de GLOBAL byte Brosse_Format; // |_ sÚlecteur de
GLOBAL short Brosse_File_list_Position; // | fichiers de la GLOBAL short Brosse_File_list_Position; // | fichiers de la

505
loadsave.c
View File

@ -32,6 +32,8 @@
#define PERMISSIONS_ECRITURE (S_IRUSR|S_IWUSR) #define PERMISSIONS_ECRITURE (S_IRUSR|S_IWUSR)
#endif #endif
#define FILENAMESPACE 16
// Conversion des words d'une structure, si necessaire sur cette plate-forme // Conversion des words d'une structure, si necessaire sur cette plate-forme
void Retraite_Word_LittleEndian(word ** Adresse) void Retraite_Word_LittleEndian(word ** Adresse)
{ {
@ -254,16 +256,15 @@ void Initialiser_preview(short Largeur,short Hauteur,long Taille,int Format)
// Affichage du vrai format // Affichage du vrai format
if (Format!=Principal_Format) if (Format!=Principal_Format)
{ {
Print_dans_fenetre( 27,74,"but is:",CM_Fonce,CM_Clair); Print_dans_fenetre( 274,72,Format_Extension[Format-1],CM_Noir,CM_Clair);
Print_dans_fenetre( 83,74,Format_Extension[Format-1],CM_Noir,CM_Clair);
} }
// On efface le commentaire précédent // On efface le commentaire précédent
Block(Fenetre_Pos_X+46*Menu_Facteur_X,Fenetre_Pos_Y+176*Menu_Facteur_Y, Block(Fenetre_Pos_X+46*Menu_Facteur_X,Fenetre_Pos_Y+(176+FILENAMESPACE)*Menu_Facteur_Y,
Menu_Facteur_X<<8,Menu_Facteur_Y<<3,CM_Clair); Menu_Facteur_X<<8,Menu_Facteur_Y<<3,CM_Clair);
// Affichage du commentaire // Affichage du commentaire
if (Format_Commentaire[Format-1]) if (Format_Commentaire[Format-1])
Print_dans_fenetre(46,176,Principal_Commentaire,CM_Noir,CM_Clair); Print_dans_fenetre(46,176+FILENAMESPACE,Principal_Commentaire,CM_Noir,CM_Clair);
// Calculs des données nécessaires à l'affichage de la preview: // Calculs des données nécessaires à l'affichage de la preview:
Preview_Facteur_X=Round_div_max(Largeur,122*Menu_Facteur_X); Preview_Facteur_X=Round_div_max(Largeur,122*Menu_Facteur_X);
@ -278,7 +279,7 @@ void Initialiser_preview(short Largeur,short Hauteur,long Taille,int Format)
} }
Preview_Pos_X=Fenetre_Pos_X+180*Menu_Facteur_X; Preview_Pos_X=Fenetre_Pos_X+180*Menu_Facteur_X;
Preview_Pos_Y=Fenetre_Pos_Y+ 89*Menu_Facteur_Y; Preview_Pos_Y=Fenetre_Pos_Y+ (89+FILENAMESPACE)*Menu_Facteur_Y;
// On nettoie la zone o— va s'afficher la preview: // On nettoie la zone o— va s'afficher la preview:
Block(Preview_Pos_X,Preview_Pos_Y, Block(Preview_Pos_X,Preview_Pos_Y,
@ -335,7 +336,7 @@ void Dessiner_preview_palette(void)
{ {
short Indice; short Indice;
short Preview_Pos_X=Fenetre_Pos_X+186*Menu_Facteur_X; short Preview_Pos_X=Fenetre_Pos_X+186*Menu_Facteur_X;
short Preview_Pos_Y=Fenetre_Pos_Y+ 90*Menu_Facteur_Y; short Preview_Pos_Y=Fenetre_Pos_Y+ (90+FILENAMESPACE)*Menu_Facteur_Y;
if (Pixel_de_chargement==Pixel_Chargement_dans_preview) if (Pixel_de_chargement==Pixel_Chargement_dans_preview)
for (Indice=0; Indice<256; Indice++) for (Indice=0; Indice<256; Indice++)
@ -745,21 +746,21 @@ void Save_PAL(void)
//////////////////////////////////// IMG //////////////////////////////////// //////////////////////////////////// IMG ////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
typedef struct
// -- Tester si un fichier est au format IMG --------------------------------
void Test_IMG(void)
{
int Handle; // Handle du fichier
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier
struct Header
{ {
byte Filler1[6]; byte Filler1[6];
word Largeur; word Largeur;
word Hauteur; word Hauteur;
byte Filler2[118]; byte Filler2[118];
T_Palette Palette; T_Palette Palette;
} IMG_Header; } T_Header_IMG;
// -- Tester si un fichier est au format IMG --------------------------------
void Test_IMG(void)
{
int Handle; // Handle du fichier
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier
T_Header_IMG IMG_Header;
byte Signature[6]={0x01,0x00,0x47,0x12,0x6D,0xB0}; byte Signature[6]={0x01,0x00,0x47,0x12,0x6D,0xB0};
@ -772,7 +773,7 @@ void Test_IMG(void)
if (Handle!=-1) if (Handle!=-1)
{ {
// Lecture et vérification de la signature // Lecture et vérification de la signature
if ((read(Handle,&IMG_Header,sizeof(struct Header)))==sizeof(struct Header)) if ((read(Handle,&IMG_Header,sizeof(T_Header_IMG)))==sizeof(T_Header_IMG))
{ {
if ( (!memcmp(IMG_Header.Filler1,Signature,6)) if ( (!memcmp(IMG_Header.Filler1,Signature,6))
&& IMG_Header.Largeur && IMG_Header.Hauteur) && IMG_Header.Largeur && IMG_Header.Hauteur)
@ -793,14 +794,7 @@ void Load_IMG(void)
word Pos_X,Pos_Y; word Pos_X,Pos_Y;
long Largeur_lue; long Largeur_lue;
long Taille_du_fichier; long Taille_du_fichier;
struct Header T_Header_IMG IMG_Header;
{
byte Filler1[6];
word Largeur;
word Hauteur;
byte Filler2[118];
T_Palette Palette;
} IMG_Header;
struct stat* Informations_Fichier=NULL; struct stat* Informations_Fichier=NULL;
@ -813,7 +807,7 @@ void Load_IMG(void)
stat(Nom_du_fichier,Informations_Fichier); stat(Nom_du_fichier,Informations_Fichier);
Taille_du_fichier=Informations_Fichier->st_size; Taille_du_fichier=Informations_Fichier->st_size;
if (read(Fichier,&IMG_Header,sizeof(struct Header))==sizeof(struct Header)) if (read(Fichier,&IMG_Header,sizeof(T_Header_IMG))==sizeof(T_Header_IMG))
{ {
Buffer=(byte *)malloc(IMG_Header.Largeur); Buffer=(byte *)malloc(IMG_Header.Largeur);
@ -860,14 +854,7 @@ void Save_IMG(void)
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier
int Fichier; int Fichier;
short Pos_X,Pos_Y; short Pos_X,Pos_Y;
struct Header T_Header_IMG IMG_Header;
{
byte Filler1[6]; // Signature (??!)
word Largeur;
word Hauteur;
byte Filler2[118];
T_Palette Palette;
} IMG_Header;
byte Signature[6]={0x01,0x00,0x47,0x12,0x6D,0xB0}; byte Signature[6]={0x01,0x00,0x47,0x12,0x6D,0xB0};
Nom_fichier_complet(Nom_du_fichier,0); Nom_fichier_complet(Nom_du_fichier,0);
@ -893,7 +880,7 @@ void Save_IMG(void)
memcpy(IMG_Header.Palette,Principal_Palette,sizeof(T_Palette)); memcpy(IMG_Header.Palette,Principal_Palette,sizeof(T_Palette));
Palette_256_to_64(Principal_Palette); Palette_256_to_64(Principal_Palette);
if (write(Fichier,&IMG_Header,sizeof(struct Header))!=-1) if (write(Fichier,&IMG_Header,sizeof(T_Header_IMG))!=-1)
{ {
Init_ecriture(); Init_ecriture();
@ -928,16 +915,9 @@ void Save_IMG(void)
//////////////////////////////////// PKM //////////////////////////////////// //////////////////////////////////// PKM ////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
typedef struct
// -- Tester si un fichier est au format PKM --------------------------------
void Test_PKM(void)
{ {
int Fichier; // Handle du fichier char Ident[3]; // Chaîne "PKM" }
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier
struct Header
{
char Ident[3]; // ChaŒne "PKM" }
byte Methode; // Méthode de compression: byte Methode; // Méthode de compression:
// 0 = compression en ligne (c)KM // 0 = compression en ligne (c)KM
// autres = inconnues pour le moment // autres = inconnues pour le moment
@ -948,7 +928,14 @@ void Test_PKM(void)
T_Palette Palette; // Palette RVB 256*3 T_Palette Palette; // Palette RVB 256*3
word Jump; // Taille du saut entre le header et l'image: word Jump; // Taille du saut entre le header et l'image:
// On va s'en servir pour rajouter un commentaire // On va s'en servir pour rajouter un commentaire
} Head; } T_Header_PKM;
// -- Tester si un fichier est au format PKM --------------------------------
void Test_PKM(void)
{
int Fichier; // Handle du fichier
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier
T_Header_PKM Head;
Nom_fichier_complet(Nom_du_fichier,0); Nom_fichier_complet(Nom_du_fichier,0);
@ -960,7 +947,7 @@ void Test_PKM(void)
if (Fichier!=-1) if (Fichier!=-1)
{ {
// Lecture du header du fichier // Lecture du header du fichier
if (read(Fichier,&Head,sizeof(struct Header))==sizeof(struct Header)) if (read(Fichier,&Head,sizeof(T_Header_PKM))==sizeof(T_Header_PKM))
{ {
// On regarde s'il y a la signature PKM suivie de la méthode 0. // On regarde s'il y a la signature PKM suivie de la méthode 0.
// La constante "PKM" étant un chaŒne, elle se termine toujours par 0. // La constante "PKM" étant un chaŒne, elle se termine toujours par 0.
@ -978,20 +965,7 @@ void Load_PKM(void)
{ {
int Fichier; // Handle du fichier int Fichier; // Handle du fichier
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier
struct Header T_Header_PKM Head;
{
char Ident[3]; // ChaŒne "PKM" }
byte Methode; // Méthode de compression:
// 0 = compression en ligne (c)KM
// autres = inconnues pour le moment
byte Recon1; // Octet de reconnaissance sur 1 octet }
byte Recon2; // Octet de reconnaissance sur 2 octets }
word Largeur; // Largeur de l'image
word Hauteur; // Hauteur de l'image
T_Palette Palette; // Palette RVB 256*3
word Jump; // Taille du saut entre le header et l'image:
// On va s'en servir pour rajouter un commentaire
} Head;
byte Couleur; byte Couleur;
byte Octet; byte Octet;
word Mot; word Mot;
@ -1013,7 +987,7 @@ void Load_PKM(void)
stat(Nom_du_fichier,&Informations_Fichier); stat(Nom_du_fichier,&Informations_Fichier);
Taille_du_fichier=Informations_Fichier.st_size; Taille_du_fichier=Informations_Fichier.st_size;
if (read(Fichier,&Head,sizeof(struct Header))==sizeof(struct Header)) if (read(Fichier,&Head,sizeof(T_Header_PKM))==sizeof(T_Header_PKM))
{ {
Principal_Commentaire[0]='\0'; // On efface le commentaire Principal_Commentaire[0]='\0'; // On efface le commentaire
if (Head.Jump) if (Head.Jump)
@ -1121,7 +1095,7 @@ void Load_PKM(void)
Compteur_de_donnees_packees=0; Compteur_de_donnees_packees=0;
Compteur_de_pixels=0; Compteur_de_pixels=0;
Taille_pack=(Informations_Fichier.st_size)-sizeof(struct Header)-Head.Jump; Taille_pack=(Informations_Fichier.st_size)-sizeof(T_Header_PKM)-Head.Jump;
// Boucle de décompression: // Boucle de décompression:
while ( (Compteur_de_pixels<Taille_image) && (Compteur_de_donnees_packees<Taille_pack) && (!Erreur_fichier) ) while ( (Compteur_de_pixels<Taille_image) && (Compteur_de_donnees_packees<Taille_pack) && (!Erreur_fichier) )
@ -1221,20 +1195,7 @@ void Save_PKM(void)
{ {
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier; int Fichier;
struct Header T_Header_PKM Head;
{
char Ident[3]; // ChaŒne "PKM" }
byte Methode; // Méthode de compression:
// 0 = compression en ligne (c)KM
// autres = inconnues pour le moment
byte Recon1; // Octet de reconnaissance sur 1 octet }
byte Recon2; // Octet de reconnaissance sur 2 octets }
word Largeur; // Largeur de l'image
word Hauteur; // Hauteur de l'image
T_Palette Palette; // Palette RVB 256*3
word Jump; // Taille du saut entre le header et l'image:
// On va s'en servir pour rajouter un commentaire
} Head;
dword Compteur_de_pixels; dword Compteur_de_pixels;
dword Taille_image; dword Taille_image;
word Compteur_de_repetitions; word Compteur_de_repetitions;
@ -1268,7 +1229,7 @@ void Save_PKM(void)
if (Fichier!=-1) if (Fichier!=-1)
{ {
// Ecriture du header // Ecriture du header
if (write(Fichier,&Head,sizeof(struct Header))!=-1) if (write(Fichier,&Head,sizeof(T_Header_PKM))!=-1)
{ {
Init_ecriture(); Init_ecriture();
@ -1380,7 +1341,22 @@ void Save_PKM(void)
//////////////////////////////////// LBM //////////////////////////////////// //////////////////////////////////// LBM ////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
typedef struct
{
word Width;
word Height;
short Xorg; // Inutile
short Yorg; // Inutile
byte BitPlanes;
byte Mask;
byte Compression;
byte Pad1; // Inutile
word Transp_col;
byte Xaspect; // Inutile
byte Yaspect; // Inutile
short Xscreen;
short Yscreen;
} T_Header_LBM;
// -- Tester si un fichier est au format LBM -------------------------------- // -- Tester si un fichier est au format LBM --------------------------------
@ -1650,22 +1626,7 @@ void Load_LBM(void)
{ {
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
//int Fichier; //int Fichier;
struct Header_LBM T_Header_LBM Header;
{
word Width;
word Height;
short Xorg; // Inutile
short Yorg; // Inutile
byte Bit_planes;
byte Mask;
byte Compression;
byte Pad1; // Inutile
word Transp_col;
byte Xaspect; // Inutile
byte Yaspect; // Inutile
short Xscreen;
short Yscreen;
} Header;
char Format[4]; char Format[4];
char Section[4]; char Section[4];
byte Octet; byte Octet;
@ -1704,7 +1665,7 @@ void Load_LBM(void)
&& (read(LBM_Fichier,&Header.Height,sizeof(Header.Height))==sizeof(Header.Height)) && (read(LBM_Fichier,&Header.Height,sizeof(Header.Height))==sizeof(Header.Height))
&& (read(LBM_Fichier,&Header.Xorg,sizeof(Header.Xorg))==sizeof(Header.Xorg)) && (read(LBM_Fichier,&Header.Xorg,sizeof(Header.Xorg))==sizeof(Header.Xorg))
&& (read(LBM_Fichier,&Header.Yorg,sizeof(Header.Yorg))==sizeof(Header.Yorg)) && (read(LBM_Fichier,&Header.Yorg,sizeof(Header.Yorg))==sizeof(Header.Yorg))
&& (read(LBM_Fichier,&Header.Bit_planes,sizeof(Header.Bit_planes))==sizeof(Header.Bit_planes)) && (read(LBM_Fichier,&Header.BitPlanes,sizeof(Header.BitPlanes))==sizeof(Header.BitPlanes))
&& (read(LBM_Fichier,&Header.Mask,sizeof(Header.Mask))==sizeof(Header.Mask)) && (read(LBM_Fichier,&Header.Mask,sizeof(Header.Mask))==sizeof(Header.Mask))
&& (read(LBM_Fichier,&Header.Compression,sizeof(Header.Compression))==sizeof(Header.Compression)) && (read(LBM_Fichier,&Header.Compression,sizeof(Header.Compression))==sizeof(Header.Compression))
&& (read(LBM_Fichier,&Header.Pad1,sizeof(Header.Pad1))==sizeof(Header.Pad1)) && (read(LBM_Fichier,&Header.Pad1,sizeof(Header.Pad1))==sizeof(Header.Pad1))
@ -1715,20 +1676,20 @@ void Load_LBM(void)
&& (read(LBM_Fichier,&Header.Yscreen,sizeof(Header.Yscreen))==sizeof(Header.Yscreen)) && (read(LBM_Fichier,&Header.Yscreen,sizeof(Header.Yscreen))==sizeof(Header.Yscreen))
&& Header.Width && Header.Height) && Header.Width && Header.Height)
{ {
if ( (Header.Bit_planes) && (Wait_for((byte *)"CMAP")) ) if ( (Header.BitPlanes) && (Wait_for((byte *)"CMAP")) )
{ {
Nb_couleurs=Lire_long()/3; Nb_couleurs=Lire_long()/3;
if (((int)1<<Header.Bit_planes)!=Nb_couleurs) if (((int)1<<Header.BitPlanes)!=Nb_couleurs)
{ {
if ((Nb_couleurs==32) && (Header.Bit_planes==6)) if ((Nb_couleurs==32) && (Header.BitPlanes==6))
{ // Ce n'est pas une image HAM mais une image 64 coul. { // Ce n'est pas une image HAM mais une image 64 coul.
Image_HAM=1; // Sauvée en 32 coul. => il faut copier les 32 coul. Image_HAM=1; // Sauvée en 32 coul. => il faut copier les 32 coul.
} // sur les 32 suivantes et assombrir ces derniŠres. } // sur les 32 suivantes et assombrir ces derniŠres.
else else
{ {
if ((Header.Bit_planes==6) || (Header.Bit_planes==8)) if ((Header.BitPlanes==6) || (Header.BitPlanes==8))
Image_HAM=Header.Bit_planes; Image_HAM=Header.BitPlanes;
else else
// Erreur_fichier=1; /* C'est censé ˆtre incorrect mais j'ai */ // Erreur_fichier=1; /* C'est censé ˆtre incorrect mais j'ai */
Image_HAM=0; /* trouvé un fichier comme ‡a, alors... */ Image_HAM=0; /* trouvé un fichier comme ‡a, alors... */
@ -1739,9 +1700,9 @@ void Load_LBM(void)
if ( (!Erreur_fichier) && (Nb_couleurs>=2) && (Nb_couleurs<=256) ) if ( (!Erreur_fichier) && (Nb_couleurs>=2) && (Nb_couleurs<=256) )
{ {
HBPm1=Header.Bit_planes-1; HBPm1=Header.BitPlanes-1;
if (Header.Mask==1) if (Header.Mask==1)
Header.Bit_planes++; Header.BitPlanes++;
// Deluxe paint le fait... alors on le fait... // Deluxe paint le fait... alors on le fait...
Back_color=Header.Transp_col; Back_color=Header.Transp_col;
@ -1785,12 +1746,12 @@ void Load_LBM(void)
if (Principal_Largeur_image & 15) if (Principal_Largeur_image & 15)
{ {
Vraie_taille_ligne=( (Principal_Largeur_image+16) >> 4 ) << 4; Vraie_taille_ligne=( (Principal_Largeur_image+16) >> 4 ) << 4;
Taille_ligne=( (Principal_Largeur_image+16) >> 4 )*(Header.Bit_planes<<1); Taille_ligne=( (Principal_Largeur_image+16) >> 4 )*(Header.BitPlanes<<1);
} }
else else
{ {
Vraie_taille_ligne=Principal_Largeur_image; Vraie_taille_ligne=Principal_Largeur_image;
Taille_ligne=(Principal_Largeur_image>>3)*Header.Bit_planes; Taille_ligne=(Principal_Largeur_image>>3)*Header.BitPlanes;
} }
if (!Header.Compression) if (!Header.Compression)
@ -2019,22 +1980,7 @@ void Load_LBM(void)
void Save_LBM(void) void Save_LBM(void)
{ {
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
struct Header_LBM T_Header_LBM Header;
{
word Width;
word Height;
short Xorg; // Inutile
short Yorg; // Inutile
byte BitPlanes;
byte Mask;
byte Compression;
byte Pad1; // Inutile
word Transp_col; // Inutile
byte Xaspect; // Inutile
byte Yaspect; // Inutile
short Xscreen;
short Yscreen;
} Header;
word Pos_X; word Pos_X;
word Pos_Y; word Pos_Y;
byte Octet; byte Octet;
@ -2073,7 +2019,7 @@ void Save_LBM(void)
swab((byte *)&Largeur_ecran,(byte *)&Header.Xscreen,2); swab((byte *)&Largeur_ecran,(byte *)&Header.Xscreen,2);
swab((byte *)&Hauteur_ecran,(byte *)&Header.Yscreen,2); swab((byte *)&Hauteur_ecran,(byte *)&Header.Yscreen,2);
write(LBM_Fichier,&Header,sizeof(struct Header_LBM)); write(LBM_Fichier,&Header,sizeof(T_Header_LBM));
write(LBM_Fichier,"CMAP",4); write(LBM_Fichier,"CMAP",4);
Ecrire_long(sizeof(T_Palette)); Ecrire_long(sizeof(T_Palette));
@ -2153,7 +2099,7 @@ void Save_LBM(void)
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
struct BMP_Header typedef struct
{ {
word Signature; // ='BM' = 0x4D42 word Signature; // ='BM' = 0x4D42
uint32_t Taille_1; // =Taille du fichier uint32_t Taille_1; // =Taille du fichier
@ -2172,14 +2118,14 @@ struct BMP_Header
uint32_t YPM; uint32_t YPM;
uint32_t Nb_Clr; uint32_t Nb_Clr;
uint32_t Clr_Imprt; uint32_t Clr_Imprt;
}; } T_BMP_Header;
// -- Tester si un fichier est au format BMP -------------------------------- // -- Tester si un fichier est au format BMP --------------------------------
void Test_BMP(void) void Test_BMP(void)
{ {
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier; int Fichier;
struct BMP_Header Header; T_BMP_Header Header;
Erreur_fichier=1; Erreur_fichier=1;
Nom_fichier_complet(Nom_du_fichier,0); Nom_fichier_complet(Nom_du_fichier,0);
@ -2219,7 +2165,7 @@ void Load_BMP(void)
{ {
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier; int Fichier;
struct BMP_Header Header; T_BMP_Header Header;
byte * Buffer; byte * Buffer;
word Indice; word Indice;
byte Palette_locale[256][4]; // R,V,B,0 byte Palette_locale[256][4]; // R,V,B,0
@ -2493,26 +2439,7 @@ void Save_BMP(void)
{ {
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier; int Fichier;
struct BMP_Header T_BMP_Header Header;
{
word Signature; // ='BM' = 0x4D42
long Taille_1; // =Taille du fichier
word Reserv_1; // =0
word Reserv_2; // =0
long Decalage; // Nb octets avant les données bitmap
long Taille_2; // =40
long Largeur;
long Hauteur;
word Plans; // =1
word Nb_bits; // =1,4,8 ou 24
long Compression;
long Taille_3;
long XPM;
long YPM;
long Nb_Clr;
long Clr_Imprt;
} Header;
short Pos_X; short Pos_X;
short Pos_Y; short Pos_Y;
long Taille_ligne; long Taille_ligne;
@ -2549,7 +2476,7 @@ void Save_BMP(void)
Header.Nb_Clr =0; Header.Nb_Clr =0;
Header.Clr_Imprt =0; Header.Clr_Imprt =0;
if (write(Fichier,&Header,sizeof(struct BMP_Header))!=-1) if (write(Fichier,&Header,sizeof(T_BMP_Header))!=-1)
{ {
// Chez Bill, ils ont dit: "On va mettre les couleur dans l'ordre // Chez Bill, ils ont dit: "On va mettre les couleur dans l'ordre
// inverse, et pour faire chier, on va les mettre sur une échelle de // inverse, et pour faire chier, on va les mettre sur une échelle de
@ -2613,7 +2540,24 @@ void Save_BMP(void)
//////////////////////////////////// GIF //////////////////////////////////// //////////////////////////////////// GIF ////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
typedef struct
{
word Largeur; // Largeur de l'écran virtuel
word Hauteur; // Hauteur de l'écran virtuel
byte Resol; // Informations sur la résolution (et autres)
byte Backcol; // Couleur de fond
byte Aspect; // Informations sur l'aspect ratio (et autres)
} T_LSDB; // Logical Screen Descriptor Block
typedef struct
{
word Pos_X; // Abscisse où devrait être affichée l'image
word Pos_Y; // Ordonnée où devrait être affichée l'image
word Largeur_image; // Largeur de l'image
word Hauteur_image; // Hauteur de l'image
byte Indicateur; // Informations diverses sur l'image
byte Nb_bits_pixel; // Nb de bits par pixel
} T_IDB; // Image Descriptor Block
// -- Tester si un fichier est au format GIF -------------------------------- // -- Tester si un fichier est au format GIF --------------------------------
@ -2749,24 +2693,8 @@ void Load_GIF(void)
word Alphabet_Max; // Nombre d'entrées possibles dans l'alphabet word Alphabet_Max; // Nombre d'entrées possibles dans l'alphabet
word Alphabet_Pos_pile; // Position dans la pile de décodage d'un chaîne word Alphabet_Pos_pile; // Position dans la pile de décodage d'un chaîne
struct Type_LSDB T_LSDB LSDB;
{ T_IDB IDB;
word Largeur; // Largeur de l'écran virtuel
word Hauteur; // Hauteur de l'écran virtuel
byte Resol; // Informations sur la résolution (et autres)
byte Backcol; // Couleur de fond
byte Aspect; // Informations sur l'aspect ratio (et autres)
} LSDB; // Logical Screen Descriptor Block
struct Type_IDB
{
word Pos_X; // Abscisse où devrait être affichée l'image
word Pos_Y; // Ordonnée où devrait être affichée l'image
word Largeur_image; // Largeur de l'image
word Hauteur_image; // Hauteur de l'image
byte Indicateur; // Informations diverses sur l'image
byte Nb_bits_pixel; // Nb de bits par pixel
} IDB; // Image Descriptor Block
word Nb_couleurs; // Nombre de couleurs dans l'image word Nb_couleurs; // Nombre de couleurs dans l'image
word Indice_de_couleur; // Indice de traitement d'une couleur word Indice_de_couleur; // Indice de traitement d'une couleur
@ -3147,24 +3075,9 @@ void Save_GIF(void)
word Depart; // Code précédent (sert au linkage des chaŒnes) word Depart; // Code précédent (sert au linkage des chaŒnes)
int Descente; // Booléen "On vient de descendre" int Descente; // Booléen "On vient de descendre"
struct Type_LSDB T_LSDB LSDB;
{ T_IDB IDB;
word Largeur; // Largeur de l'écran virtuel |_ Dimensions de l'image si 1
word Hauteur; // Hauteur de l'écran virtuel | seule image dans le fichier (ce qui est notre cas)
byte Resol; // Informations sur la résolution (et autres)
byte Backcol; // Couleur de fond
byte Aspect; // Informations sur l'aspect ratio (et autres)
} LSDB; // Logical Screen Descriptor Block
struct Type_IDB
{
word Pos_X; // Abscisse o— devrait ˆtre affichée l'image
word Pos_Y; // Ordonnée o— devrait ˆtre affichée l'image
word Largeur_image; // Largeur de l'image
word Hauteur_image; // Hauteur de l'image
byte Indicateur; // Informations diverses sur l'image
byte Nb_bits_pixel; // Nb de bits par pixel
} IDB; // Image Descriptor Block
byte Block_indicateur; // Code indicateur du type de bloc en cours byte Block_indicateur; // Code indicateur du type de bloc en cours
word Chaine_en_cours; // Code de la chaŒne en cours de traitement word Chaine_en_cours; // Code de la chaŒne en cours de traitement
@ -3214,7 +3127,7 @@ void Save_GIF(void)
// On sauve le LSDB dans le fichier // On sauve le LSDB dans le fichier
if (write(GIF_Fichier,&LSDB,sizeof(struct Type_LSDB))==sizeof(struct Type_LSDB)) if (write(GIF_Fichier,&LSDB,sizeof(T_LSDB))==sizeof(T_LSDB))
{ {
// Le LSDB a été correctement écrit. // Le LSDB a été correctement écrit.
@ -3239,7 +3152,7 @@ void Save_GIF(void)
IDB.Nb_bits_pixel=8; // Image 256 couleurs; IDB.Nb_bits_pixel=8; // Image 256 couleurs;
if ( (write(GIF_Fichier,&Block_indicateur,1)==1) && if ( (write(GIF_Fichier,&Block_indicateur,1)==1) &&
(write(GIF_Fichier,&IDB,sizeof(struct Type_IDB))==sizeof(struct Type_IDB)) ) (write(GIF_Fichier,&IDB,sizeof(T_IDB))==sizeof(T_IDB)) )
{ {
// Le block indicateur d'IDB et l'IDB ont étés correctements // Le block indicateur d'IDB et l'IDB ont étés correctements
// écrits. // écrits.
@ -3941,21 +3854,13 @@ void Save_PCX(void)
//////////////////////////////////// CEL //////////////////////////////////// //////////////////////////////////// CEL ////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
typedef struct
// -- Tester si un fichier est au format CEL --------------------------------
void Test_CEL(void)
{
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Taille;
int Fichier;
struct CEL_Header1
{ {
word Width; // Largeur de l'image word Width; // Largeur de l'image
word Height; // Hauteur de l'image word Height; // Hauteur de l'image
} Header1; } T_CEL_Header1;
struct CEL_Header2
typedef struct
{ {
byte Signa[4]; // Signature du format byte Signa[4]; // Signature du format
byte Kind; // Type de fichier ($10=PALette $20=BitMaP) byte Kind; // Type de fichier ($10=PALette $20=BitMaP)
@ -3966,26 +3871,36 @@ void Test_CEL(void)
word Decalage_X; // Decalage en X de l'image word Decalage_X; // Decalage en X de l'image
word Decalage_Y; // Decalage en Y de l'image word Decalage_Y; // Decalage en Y de l'image
byte Filler2[16]; // ??? byte Filler2[16]; // ???
} Header2; } T_CEL_Header2;
// -- Tester si un fichier est au format CEL --------------------------------
void Test_CEL(void)
{
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Taille;
int Fichier;
T_CEL_Header1 Header1;
T_CEL_Header2 Header2;
struct stat Informations_Fichier; struct stat Informations_Fichier;
Erreur_fichier=0; Erreur_fichier=0;
Nom_fichier_complet(Nom_du_fichier,0); Nom_fichier_complet(Nom_du_fichier,0);
if ((Fichier=open(Nom_du_fichier,O_RDONLY|O_BINARY))!=-1) if ((Fichier=open(Nom_du_fichier,O_RDONLY|O_BINARY))!=-1)
{ {
if (read(Fichier,&Header1,sizeof(struct CEL_Header1))==sizeof(struct CEL_Header1)) if (read(Fichier,&Header1,sizeof(T_CEL_Header1))==sizeof(T_CEL_Header1))
{ {
// Vu que ce header n'a pas de signature, il va falloir tester la // 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. // cohérence de la dimension de l'image avec celle du fichier.
if (!stat(Nom_du_fichier,&Informations_Fichier)) if (!stat(Nom_du_fichier,&Informations_Fichier))
Erreur_fichier = 1; // Si on ne peut pas faire de stat il vaut mieux laisser tomber Erreur_fichier = 1; // Si on ne peut pas faire de stat il vaut mieux laisser tomber
Taille=(Informations_Fichier.st_size)-sizeof(struct CEL_Header1); Taille=(Informations_Fichier.st_size)-sizeof(T_CEL_Header1);
if ( (!Taille) || ( (((Header1.Width+1)>>1)*Header1.Height)!=Taille ) ) if ( (!Taille) || ( (((Header1.Width+1)>>1)*Header1.Height)!=Taille ) )
{ {
// Tentative de reconnaissance de la signature des nouveaux fichiers // Tentative de reconnaissance de la signature des nouveaux fichiers
lseek(Fichier,0,SEEK_SET); lseek(Fichier,0,SEEK_SET);
if (read(Fichier,&Header2,sizeof(struct CEL_Header2))==sizeof(struct CEL_Header2)) if (read(Fichier,&Header2,sizeof(T_CEL_Header2))==sizeof(T_CEL_Header2))
{ {
if (memcmp(Header2.Signa,"KiSS",4)==0) if (memcmp(Header2.Signa,"KiSS",4)==0)
{ {
@ -4015,23 +3930,8 @@ void Load_CEL(void)
{ {
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier; int Fichier;
struct CEL_Header1 T_CEL_Header1 Header1;
{ T_CEL_Header2 Header2;
word Width; // Largeur de l'image
word Height; // Hauteur de l'image
} Header1;
struct CEL_Header2
{
byte Signa[4]; // Signature du format
byte Kind; // Type de fichier ($10=PALette $20=BitMaP)
byte Nbbits; // Nombre de bits
word Filler1; // ???
word Largeur; // Largeur de l'image
word Hauteur; // Hauteur de l'image
word Decalage_X; // Decalage en X de l'image
word Decalage_Y; // Decalage en Y de l'image
byte Filler2[16]; // ???
} Header2;
short Pos_X; short Pos_X;
short Pos_Y; short Pos_Y;
byte Dernier_octet=0; byte Dernier_octet=0;
@ -4043,12 +3943,12 @@ void Load_CEL(void)
Nom_fichier_complet(Nom_du_fichier,0); Nom_fichier_complet(Nom_du_fichier,0);
if ((Fichier=open(Nom_du_fichier,O_RDONLY|O_BINARY))!=-1) if ((Fichier=open(Nom_du_fichier,O_RDONLY|O_BINARY))!=-1)
{ {
if (read(Fichier,&Header1,sizeof(struct CEL_Header1))==sizeof(struct CEL_Header1)) if (read(Fichier,&Header1,sizeof(T_CEL_Header1))==sizeof(T_CEL_Header1))
{ {
stat(Nom_du_fichier,Informations_Fichier); stat(Nom_du_fichier,Informations_Fichier);
Taille_du_fichier=Informations_Fichier->st_size; Taille_du_fichier=Informations_Fichier->st_size;
if ( (Taille_du_fichier>sizeof(struct CEL_Header1)) if ( (Taille_du_fichier>sizeof(T_CEL_Header1))
&& ( (((Header1.Width+1)>>1)*Header1.Height)==(Taille_du_fichier-sizeof(struct CEL_Header1)) ) ) && ( (((Header1.Width+1)>>1)*Header1.Height)==(Taille_du_fichier-sizeof(T_CEL_Header1)) ) )
{ {
// Chargement d'un fichier CEL sans signature (vieux fichiers) // Chargement d'un fichier CEL sans signature (vieux fichiers)
Principal_Largeur_image=Header1.Width; Principal_Largeur_image=Header1.Width;
@ -4077,7 +3977,7 @@ void Load_CEL(void)
// On réessaye avec le nouveau format // On réessaye avec le nouveau format
lseek(Fichier,0,SEEK_SET); lseek(Fichier,0,SEEK_SET);
if (read(Fichier,&Header2,sizeof(struct CEL_Header2))==sizeof(struct CEL_Header2)) if (read(Fichier,&Header2,sizeof(T_CEL_Header2))==sizeof(T_CEL_Header2))
{ {
// Chargement d'un fichier CEL avec signature (nouveaux fichiers) // Chargement d'un fichier CEL avec signature (nouveaux fichiers)
@ -4147,23 +4047,8 @@ void Save_CEL(void)
{ {
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier; int Fichier;
struct CEL_Header1 T_CEL_Header1 Header1;
{ T_CEL_Header2 Header2;
word Width; // Largeur de l'image
word Height; // Hauteur de l'image
} Header1;
struct CEL_Header2
{
byte Signa[4]; // Signature du format
byte Kind; // Type de fichier ($10=PALette $20=BitMaP)
byte Nbbits; // Nombre de bits
word Filler1; // ???
word Largeur; // Largeur de l'image
word Hauteur; // Hauteur de l'image
word Decalage_X; // Decalage en X de l'image
word Decalage_Y; // Decalage en Y de l'image
byte Filler2[16]; // ???
} Header2;
short Pos_X; short Pos_X;
short Pos_Y; short Pos_Y;
byte Dernier_octet=0; byte Dernier_octet=0;
@ -4187,7 +4072,7 @@ void Save_CEL(void)
Header1.Width =Principal_Largeur_image; Header1.Width =Principal_Largeur_image;
Header1.Height=Principal_Hauteur_image; Header1.Height=Principal_Hauteur_image;
if (write(Fichier,&Header1,sizeof(struct CEL_Header1))!=-1) if (write(Fichier,&Header1,sizeof(T_CEL_Header1))!=-1)
{ {
// Sauvegarde de l'image // Sauvegarde de l'image
Init_ecriture(); Init_ecriture();
@ -4244,7 +4129,7 @@ void Save_CEL(void)
for (Pos_X=0;Pos_X<16;Pos_X++) // Initialisation du filler 2 (???) for (Pos_X=0;Pos_X<16;Pos_X++) // Initialisation du filler 2 (???)
Header2.Filler2[Pos_X]=0; Header2.Filler2[Pos_X]=0;
if (write(Fichier,&Header2,sizeof(struct CEL_Header2))!=-1) if (write(Fichier,&Header2,sizeof(T_CEL_Header2))!=-1)
{ {
// Sauvegarde de l'image // Sauvegarde de l'image
Init_ecriture(); Init_ecriture();
@ -4271,15 +4156,7 @@ void Save_CEL(void)
//////////////////////////////////// KCF //////////////////////////////////// //////////////////////////////////// KCF ////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
typedef struct
// -- Tester si un fichier est au format KCF --------------------------------
void Test_KCF(void)
{
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier;
struct KCF_Header
{ {
struct struct
{ {
@ -4289,19 +4166,16 @@ void Test_KCF(void)
byte Octet2; byte Octet2;
} Couleur[16]; } Couleur[16];
} Palette[10]; } Palette[10];
} Buffer; } T_KCF_Header;
struct CEL_Header2
// -- Tester si un fichier est au format KCF --------------------------------
void Test_KCF(void)
{ {
byte Signa[4]; // Signature du format char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
byte Kind; // Type de fichier ($10=PALette $20=BitMaP) int Fichier;
byte Nbbits; // Nombre de bits T_KCF_Header Buffer;
word Filler1; // ??? T_CEL_Header2 Header2;
word Largeur; // Largeur de l'image
word Hauteur; // Hauteur de l'image
word Decalage_X; // Decalage en X de l'image
word Decalage_Y; // Decalage en Y de l'image
byte Filler2[16]; // ???
} Header2;
int Indice_palette; int Indice_palette;
int Indice_couleur; int Indice_couleur;
@ -4309,9 +4183,9 @@ void Test_KCF(void)
Nom_fichier_complet(Nom_du_fichier,0); Nom_fichier_complet(Nom_du_fichier,0);
if ((Fichier=open(Nom_du_fichier,O_RDONLY|O_BINARY))!=-1) if ((Fichier=open(Nom_du_fichier,O_RDONLY|O_BINARY))!=-1)
{ {
if (filelength(Fichier)==sizeof(struct KCF_Header)) if (filelength(Fichier)==sizeof(T_KCF_Header))
{ {
read(Fichier,&Buffer,sizeof(struct KCF_Header)); read(Fichier,&Buffer,sizeof(T_KCF_Header));
// On vérifie une propriété de la structure de palette: // On vérifie une propriété de la structure de palette:
for (Indice_palette=0;Indice_palette<10;Indice_palette++) for (Indice_palette=0;Indice_palette<10;Indice_palette++)
for (Indice_couleur=0;Indice_couleur<16;Indice_couleur++) for (Indice_couleur=0;Indice_couleur<16;Indice_couleur++)
@ -4320,7 +4194,7 @@ void Test_KCF(void)
} }
else else
{ {
if (read(Fichier,&Header2,sizeof(struct CEL_Header2))==sizeof(struct CEL_Header2)) if (read(Fichier,&Header2,sizeof(T_CEL_Header2))==sizeof(T_CEL_Header2))
{ {
if (memcmp(Header2.Signa,"KiSS",4)==0) if (memcmp(Header2.Signa,"KiSS",4)==0)
{ {
@ -4346,29 +4220,8 @@ void Load_KCF(void)
{ {
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier; int Fichier;
struct KCF_Header T_KCF_Header Buffer;
{ T_CEL_Header2 Header2;
struct
{
struct
{
byte Octet1;
byte Octet2;
} Couleur[16];
} Palette[10];
} Buffer;
struct CEL_Header2
{
byte Signa[4]; // Signature du format
byte Kind; // Type de fichier ($10=PALette $20=BitMaP)
byte Nbbits; // Nombre de bits
word Filler1; // ???
word Largeur; // Largeur de l'image ou nb de couleurs définies
word Hauteur; // Hauteur de l'image ou nb de palettes définies
word Decalage_X; // Decalage en X de l'image
word Decalage_Y; // Decalage en Y de l'image
byte Filler2[16]; // ???
} Header2;
byte Octet[3]; byte Octet[3];
int Indice_palette; int Indice_palette;
int Indice_couleur; int Indice_couleur;
@ -4381,11 +4234,11 @@ void Load_KCF(void)
if ((Fichier=open(Nom_du_fichier,O_RDONLY|O_BINARY))!=-1) if ((Fichier=open(Nom_du_fichier,O_RDONLY|O_BINARY))!=-1)
{ {
Taille_du_fichier=filelength(Fichier); Taille_du_fichier=filelength(Fichier);
if (Taille_du_fichier==sizeof(struct KCF_Header)) if (Taille_du_fichier==sizeof(T_KCF_Header))
{ {
// Fichier KCF à l'ancien format // Fichier KCF à l'ancien format
if (read(Fichier,&Buffer,sizeof(struct KCF_Header))==sizeof(struct KCF_Header)) if (read(Fichier,&Buffer,sizeof(T_KCF_Header))==sizeof(T_KCF_Header))
{ {
// Initialiser_preview(???); // Pas possible... pas d'image... // Initialiser_preview(???); // Pas possible... pas d'image...
@ -4419,7 +4272,7 @@ void Load_KCF(void)
{ {
// Fichier KCF au nouveau format // Fichier KCF au nouveau format
if (read(Fichier,&Header2,sizeof(struct CEL_Header2))==sizeof(struct CEL_Header2)) if (read(Fichier,&Header2,sizeof(T_CEL_Header2))==sizeof(T_CEL_Header2))
{ {
// Initialiser_preview(???); // Pas possible... pas d'image... // Initialiser_preview(???); // Pas possible... pas d'image...
@ -4481,29 +4334,8 @@ void Save_KCF(void)
{ {
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier; int Fichier;
struct KCF_Header T_KCF_Header Buffer;
{ T_CEL_Header2 Header2;
struct
{
struct
{
byte Octet1;
byte Octet2;
} Couleur[16];
} Palette[10];
} Buffer;
struct CEL_Header2
{
byte Signa[4]; // Signature du format
byte Kind; // Type de fichier ($10=PALette $20=BitMaP)
byte Nbbits; // Nombre de bits
word Filler1; // ???
word Largeur; // Largeur de l'image ou nb de couleurs définies
word Hauteur; // Hauteur de l'image ou nb de palettes définies
word Decalage_X; // Decalage en X de l'image
word Decalage_Y; // Decalage en Y de l'image
byte Filler2[16]; // ???
} Header2;
byte Octet[3]; byte Octet[3];
int Indice_palette; int Indice_palette;
int Indice_couleur; int Indice_couleur;
@ -4534,7 +4366,7 @@ void Save_KCF(void)
Buffer.Palette[Indice_palette].Couleur[Indice_couleur].Octet2=Principal_Palette[Indice].V>>2; Buffer.Palette[Indice_palette].Couleur[Indice_couleur].Octet2=Principal_Palette[Indice].V>>2;
} }
if (write(Fichier,&Buffer,sizeof(struct KCF_Header))!=sizeof(struct KCF_Header)) if (write(Fichier,&Buffer,sizeof(T_KCF_Header))!=sizeof(T_KCF_Header))
Erreur_fichier=1; Erreur_fichier=1;
} }
else else
@ -4552,7 +4384,7 @@ void Save_KCF(void)
for (Indice=0;Indice<16;Indice++) // Initialisation du filler 2 (???) for (Indice=0;Indice<16;Indice++) // Initialisation du filler 2 (???)
Header2.Filler2[Indice]=0; Header2.Filler2[Indice]=0;
if (write(Fichier,&Header2,sizeof(struct CEL_Header2))!=sizeof(struct CEL_Header2)) if (write(Fichier,&Header2,sizeof(T_CEL_Header2))!=sizeof(T_CEL_Header2))
Erreur_fichier=1; Erreur_fichier=1;
for (Indice=0;(Indice<256) && (!Erreur_fichier);Indice++) for (Indice=0;(Indice<256) && (!Erreur_fichier);Indice++)
@ -4583,7 +4415,14 @@ void Save_KCF(void)
//////////////////////////////////// SCx //////////////////////////////////// //////////////////////////////////// SCx ////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
typedef struct
{
byte Filler1[4];
word Largeur;
word Hauteur;
byte Filler2;
byte Plans;
} T_SCx_Header;
// -- Tester si un fichier est au format SCx -------------------------------- // -- Tester si un fichier est au format SCx --------------------------------
void Test_SCx(void) void Test_SCx(void)
@ -4591,14 +4430,7 @@ void Test_SCx(void)
int Handle; // Handle du fichier int Handle; // Handle du fichier
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier
//byte Signature[3]; //byte Signature[3];
struct Header T_SCx_Header SCx_Header;
{
byte Filler1[4];
word Largeur;
word Hauteur;
byte Filler2;
byte Plans;
} SCx_Header;
Nom_fichier_complet(Nom_du_fichier,0); Nom_fichier_complet(Nom_du_fichier,0);
@ -4610,7 +4442,7 @@ void Test_SCx(void)
if (Handle!=-1) if (Handle!=-1)
{ {
// Lecture et vérification de la signature // Lecture et vérification de la signature
if ((read(Handle,&SCx_Header,sizeof(struct Header)))==sizeof(struct Header)) if ((read(Handle,&SCx_Header,sizeof(T_SCx_Header)))==sizeof(T_SCx_Header))
{ {
if ( (!memcmp(SCx_Header.Filler1,"RIX",3)) if ( (!memcmp(SCx_Header.Filler1,"RIX",3))
&& SCx_Header.Largeur && SCx_Header.Hauteur) && SCx_Header.Largeur && SCx_Header.Hauteur)
@ -4630,14 +4462,7 @@ void Load_SCx(void)
word Pos_X,Pos_Y; word Pos_X,Pos_Y;
long Taille,Vraie_taille; long Taille,Vraie_taille;
long Taille_du_fichier; long Taille_du_fichier;
struct Header T_SCx_Header SCx_Header;
{
byte Filler1[4];
word Largeur;
word Hauteur;
byte Filler2;
byte Plans;
} SCx_Header;
T_Palette SCx_Palette; T_Palette SCx_Palette;
@ -4649,7 +4474,7 @@ void Load_SCx(void)
{ {
Taille_du_fichier=filelength(Fichier); Taille_du_fichier=filelength(Fichier);
if ((read(Fichier,&SCx_Header,sizeof(struct Header)))==sizeof(struct Header)) if ((read(Fichier,&SCx_Header,sizeof(T_SCx_Header)))==sizeof(T_SCx_Header))
{ {
Initialiser_preview(SCx_Header.Largeur,SCx_Header.Hauteur,Taille_du_fichier,FORMAT_SCx); Initialiser_preview(SCx_Header.Largeur,SCx_Header.Hauteur,Taille_du_fichier,FORMAT_SCx);
if (Erreur_fichier==0) if (Erreur_fichier==0)
@ -4721,14 +4546,7 @@ void Save_SCx(void)
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier
int Fichier; int Fichier;
short Pos_X,Pos_Y; short Pos_X,Pos_Y;
struct Header T_SCx_Header SCx_Header;
{
byte Filler1[4];
word Largeur;
word Hauteur;
word Filler2;
T_Palette Palette;
} SCx_Header;
Nom_fichier_complet(Nom_du_fichier,1); Nom_fichier_complet(Nom_du_fichier,1);
@ -4741,10 +4559,11 @@ void Save_SCx(void)
memcpy(SCx_Header.Filler1,"RIX3",4); memcpy(SCx_Header.Filler1,"RIX3",4);
SCx_Header.Largeur=Principal_Largeur_image; SCx_Header.Largeur=Principal_Largeur_image;
SCx_Header.Hauteur=Principal_Hauteur_image; SCx_Header.Hauteur=Principal_Hauteur_image;
SCx_Header.Filler2=0x00AF; SCx_Header.Filler2=0xAF;
memcpy(SCx_Header.Palette,Principal_Palette,sizeof(T_Palette)); SCx_Header.Plans=0x00;
if (write(Fichier,&SCx_Header,sizeof(struct Header))!=-1) if (write(Fichier,&SCx_Header,sizeof(T_SCx_Header))!=-1 &&
write(Fichier,&Principal_Palette,sizeof(T_Palette))!=-1)
{ {
Init_ecriture(); Init_ecriture();

4
main.c
View File

@ -216,8 +216,8 @@ void Analyse_de_la_ligne_de_commande(int argc,char * argv[])
Buffer=realpath(argv[1],NULL); Buffer=realpath(argv[1],NULL);
_splitpath(Buffer,Principal_Repertoire_fichier,Principal_Nom_fichier); _splitpath(Buffer,Principal_Repertoire_fichier,Principal_Nom_fichier);
#else #else
Buffer = malloc(MAX_PATH); Buffer = malloc(TAILLE_CHEMIN_FICHIER);
_fullpath(Buffer,argv[1],MAX_PATH); _fullpath(Buffer,argv[1],TAILLE_CHEMIN_FICHIER);
{ {
// Découpage du nom canonique de fichier en chemin + nom. // Découpage du nom canonique de fichier en chemin + nom.
// On croirait que c'est du classique pour la LibC, mais non... // On croirait que c'est du classique pour la LibC, mais non...

7
struct.h
View File

@ -93,7 +93,8 @@ struct T_Drive
// Déclaration du type d'élément qu'on va mémoriser dans la liste: // Déclaration du type d'élément qu'on va mémoriser dans la liste:
struct Element_de_liste_de_fileselect struct Element_de_liste_de_fileselect
{ {
char Nom[13]; // Le nom du fichier ou du répertoire char NomAbrege[13]; // Le nom tel qu'affiché dans le fileselector
char NomComplet[256]; // Le nom du fichier ou du répertoire
byte Type; // Type d'élément : 0 = Fichier, 1 = Répertoire byte Type; // Type d'élément : 0 = Fichier, 1 = Répertoire
// données de chaŒnage de la liste // données de chaŒnage de la liste
@ -179,8 +180,8 @@ typedef struct
char Commentaire[TAILLE_COMMENTAIRE+1]; // Commentaire de l'image char Commentaire[TAILLE_COMMENTAIRE+1]; // Commentaire de l'image
char Repertoire_fichier[256]; // |_ Nom complet = char Repertoire_fichier[TAILLE_CHEMIN_FICHIER]; // |_ Nom complet =
char Nom_fichier[13]; // | Repertoire_fichier+"\"+Nom_fichier char Nom_fichier[TAILLE_CHEMIN_FICHIER]; // | Repertoire_fichier+"\"+Nom_fichier
byte Format_fichier; // Format auquel il faut lire et écrire le fichier byte Format_fichier; // Format auquel il faut lire et écrire le fichier
/* /*