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)
#endif
#define FILENAMESPACE 16
//-- MODELE DE BOUTON DE MENU ------------------------------------------------
/*
void Bouton_***(void)
@ -2130,8 +2132,8 @@ void Print_Nom_fichier_dans_selecteur(void)
// 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);
Print_dans_fenetre(202,73,Principal_Nom_fichier,CM_Noir,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(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);
Fenetre_Dessiner_jauge(Enreg);
// 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:
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)
{
char Ancien_nom_de_fichier[13];
char Ancien_nom_de_fichier[TAILLE_CHEMIN_FICHIER];
strcpy(Ancien_nom_de_fichier,Principal_Nom_fichier);
@ -2207,7 +2209,7 @@ short Position_fichier_dans_liste(char * Nom)
short Indice;
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);
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_courant[13];
char Nom_courant[TAILLE_CHEMIN_FICHIER];
char * Pointeur1;
char * Pointeur2;
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
// 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!=' ')
*(Pointeur2++)=*Pointeur1;
*Pointeur2=0;
@ -2272,7 +2274,7 @@ char * Nom_correspondant_le_mieux_a(char * Nom)
{
Lettres_identiques=Compteur;
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 Hauteur_image_initiale; // | parce que la preview elle les
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 Repertoire_precedent[13]; // Répertoire d'où l'on vient après un CHDIR
char Nom_fichier_initial[TAILLE_CHEMIN_FICHIER]; // Sert à laisser le nom courant du fichier en cas de sauvegarde
char Repertoire_precedent[TAILLE_CHEMIN_FICHIER]; // Répertoire d'où l'on vient après un CHDIR
char Commentaire_initial[TAILLE_COMMENTAIRE+1];
char Fichier_recherche[13]="";
char Fichier_recherche[TAILLE_CHEMIN_FICHIER]="";
char * Fichier_le_plus_ressemblant;
Palette_initiale=(struct Composantes *)malloc(sizeof(T_Palette));
@ -2317,18 +2319,18 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
if (Load)
{
if (Image)
Ouvrir_fenetre(310,190,"Load picture");
Ouvrir_fenetre(310,190+FILENAMESPACE,"Load picture");
else
Ouvrir_fenetre(310,190,"Load brush");
Fenetre_Definir_bouton_normal(125,157,51,14,"Load",0,1,0x001C); // 1
Ouvrir_fenetre(310,190+FILENAMESPACE,"Load brush");
Fenetre_Definir_bouton_normal(125,157+FILENAMESPACE,51,14,"Load",0,1,0x001C); // 1
}
else
{
if (Image)
Ouvrir_fenetre(310,190,"Save picture");
Ouvrir_fenetre(310,190+FILENAMESPACE,"Save picture");
else
Ouvrir_fenetre(310,190,"Save brush");
Fenetre_Definir_bouton_normal(125,157,51,14,"Save",0,1,0x001C); // 1
Ouvrir_fenetre(310,190+FILENAMESPACE,"Save brush");
Fenetre_Definir_bouton_normal(125,157+FILENAMESPACE,51,14,"Save",0,1,0x001C); // 1
if (Principal_Format==0) // Correction du *.*
{
Principal_Format=Principal_Format_fichier;
@ -2344,41 +2346,44 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
}
// Affichage du commentaire
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, 89,51,14,"Delete",0,1,0x0053); // 3
Fenetre_Definir_bouton_normal(125,139+FILENAMESPACE,51,14,"Cancel",0,1,0x0001); // 2
Fenetre_Definir_bouton_normal(125, 89+FILENAMESPACE,51,14,"Delete",0,1,0x0053); // 3
// Câdre autour des formats
Fenetre_Afficher_cadre( 7, 51,103, 35);
// Câdre autour des infos sur le fichier de dessin
Fenetre_Afficher_cadre(116, 51,187, 35);
// 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
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
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 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
// Texte de commentaire des dessins
Print_dans_fenetre(7,176,"Txt:",CM_Fonce,CM_Clair);
Fenetre_Definir_bouton_saisie(44,174,TAILLE_COMMENTAIRE); // 7
Print_dans_fenetre(7,176+FILENAMESPACE,"Txt:",CM_Fonce,CM_Clair);
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
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(120,55,"Image 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();
@ -2441,15 +2446,15 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
// On affiche une demande de confirmation
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,115,"file ?",CM_Fonce,CM_Clair);
Print_dans_fenetre(127,107+FILENAMESPACE,"Delete",CM_Fonce,CM_Clair);
Print_dans_fenetre(127,115+FILENAMESPACE,"file ?",CM_Fonce,CM_Clair);
}
else
{
Print_dans_fenetre(127,107,"Remove",CM_Fonce,CM_Clair);
Print_dans_fenetre(127,115,"dir. ?",CM_Fonce,CM_Clair);
Print_dans_fenetre(127,107+FILENAMESPACE,"Remove",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
{
@ -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));
// 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);
// Si l'utilisateur confirme,
@ -2581,13 +2586,13 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
if ( (!Load) && (Format_Commentaire[Principal_Format-1]) )
{
Effacer_curseur();
Readline(46,176,Principal_Commentaire,32,0);
Readline(46,176+FILENAMESPACE,Principal_Commentaire,32,0);
Afficher_curseur();
}
break;
case 8 : // Saisie du nom de fichier
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
// 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)
{
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
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);
// 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);
// On efface les dimensions de l'image
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
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);
// 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
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();
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;
@ -2788,7 +2793,7 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
Effacer_curseur();
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();
// 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
{
// Données initiales du fichier (au cas où on voudrait annuler)
char Repertoire_fichier_initial[256];
char Nom_fichier_initial[13];
char Repertoire_fichier_initial[TAILLE_CHEMIN_FICHIER];
char Nom_fichier_initial[TAILLE_CHEMIN_FICHIER];
byte Format_fichier_initial;
byte Ne_pas_restaurer;
byte Utiliser_palette_brosse = 0;
@ -3240,8 +3245,8 @@ void Save_picture(byte Image)
// Image=0 => On charge/sauve une brosse
{
// Données initiales du fichier (au cas où on voudrait annuler)
char Repertoire_fichier_initial[256];
char Nom_fichier_initial[13];
char Repertoire_fichier_initial[TAILLE_CHEMIN_FICHIER];
char Nom_fichier_initial[TAILLE_CHEMIN_FICHIER];
byte Format_fichier_initial;
byte Ne_pas_restaurer;
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 FACTEUR_DE_ZOOM_PAR_DEFAUT 4 // Facteur de zoom initial
#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
// minimum de 256 Ko pour que le reste du programme puisse continuer à

202
files.c
View File

@ -6,7 +6,7 @@
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <unistd.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_FOND_SELECT CM_Fonce // Couleur du fond pour une ligne sélectionnée
#define FILENAMESPACE 16
int Determiner_repertoire_courant(void)
// 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)
// D‚termine si un fichier pass‚ en paramŠtre existe ou non dans le
// r‚pertoire courant.
// Détermine si un fichier passé en paramŠtre existe ou non dans le
// répertoire courant.
{
struct stat buf;
int Resultat;
@ -90,13 +91,13 @@ int Fichier_existe(char * Fichier)
// Conventions:
//
// * Le fileselect modifie le r‚pertoire courant. Ceci permet de n'avoir
// qu'un findfirst dans le r‚pertoire courant … faire:
// * Le fileselect modifie le répertoire courant. Ceci permet de n'avoir
// 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)
// 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
// programme.
{
@ -105,17 +106,17 @@ void Detruire_liste_du_fileselect(void)
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;
// 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;
// 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);
}
}
// -- Formatage graphique des noms de fichier / r‚pertoire ------------------
// -- Formatage graphique des noms de fichier / répertoire ------------------
char * Nom_formate(char * Nom)
{
static char Resultat[13];
@ -130,7 +131,7 @@ char * Nom_formate(char * Nom)
else
{
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++)
{
if (Curseur < 8)
@ -141,7 +142,7 @@ char * Nom_formate(char * Nom)
if (Nom[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])
{
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 ---------------
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
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));
// 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__
Element_temporaire->Type = (Enreg->d_type == DT_DIR);
#elif __WATCOMC__
@ -182,6 +184,37 @@ void Ajouter_element_a_la_liste(struct dirent* Enreg)
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 ---------------------------------------
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
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;
// Tout d'abord, on déduit du format demandé un filtre à utiliser:
if (Format_demande) // Format (extension) spécifique
strcat(Filtre,Format_Extension[Format_demande-1]);
else // *.*
strcat(Filtre,"*");
Filtre = Format_Extension[Format_demande-1];
// Ensuite, on vide la liste actuelle:
Detruire_liste_du_fileselect();
@ -218,19 +248,22 @@ void Lire_liste_des_fichiers(byte Format_demande)
stat(Enreg->d_name,&Infos_enreg);
// et que l'élément trouvé est un répertoire
if( S_ISDIR(Infos_enreg.st_mode) &&
// et qu'il n'est pas caché
((!isHidden(Enreg)) || !Config.Lire_les_repertoires_caches))
// et qu'il n'est pas caché
((!isHidden(Enreg)) || !Config.Lire_les_repertoires_caches))
{
// On rajoute le répertore à la liste
Ajouter_element_a_la_liste(Enreg);
Liste_Nb_repertoires++;
// On rajoute le répertore à la liste
Ajouter_element_a_la_liste(Enreg);
Liste_Nb_repertoires++;
}
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é
{
// On rajoute le fichier à la liste
Ajouter_element_a_la_liste(Enreg);
Liste_Nb_fichiers++;
if (VerifieExtension(Enreg->d_name, Filtre))
{
// On rajoute le fichier à la liste
Ajouter_element_a_la_liste(Enreg);
Liste_Nb_fichiers++;
}
}
}
@ -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)
// 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 fichiers ensuite, 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
{
byte La_liste_est_triee; // Bool‚en "La liste est tri‚e"
byte Inversion; // Bool‚en "Il faut inverser les ‚l‚ments"
byte La_liste_est_triee; // Booléen "La liste est triée"
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_courant;
struct Element_de_liste_de_fileselect * Element_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
// d'‚l‚ments pour qu'il soit possibles qu'ils soient en d‚sordre:
// 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:
if (Liste_Nb_elements>1)
{
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;
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
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:
// Si l'‚l‚ment courant est un fichier est que le suivant est
// un r‚pertoire -> Inversion
// Si l'élément courant est un fichier est que le suivant est
// un répertoire -> Inversion
if ( (Element_courant->Type==0) && (Element_suivant->Type==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
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;
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 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_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->Precedent=Element_suivant;
Element_suivant->Suivant =Element_courant;
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)
Element_precedent->Suivant=Element_suivant;
if (Element_suivant_le_suivant!=NULL)
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)
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;
// 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;
}
else
{
// Si les deux ‚l‚ments sont dans l'ordre:
// Si les deux éléments sont dans l'ordre:
// On passe aux suivants
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)
//
// Decalage_premier = D‚calage entre le premier fichier visible dans le
// s‚lecteur et le premier fichier de la liste
// Decalage_premier = Décalage entre le premier fichier visible dans le
// sélecteur et le premier fichier de la liste
//
// Decalage_select = D‚calage entre le premier fichier visible dans le
// s‚lecteur et le fichier s‚lectionn‚ dans la liste
// Decalage_select = Décalage entre le premier fichier visible dans le
// sélecteur et le fichier sélectionné dans la liste
//
{
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;
// 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)
{
// 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--)
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++)
{
// S'il est s‚lectionn‚:
// S'il est sélectionné:
if (!Decalage_select)
{
// 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;
}
// On affiche l'‚l‚ment
Print_dans_fenetre(9,90+(Indice<<3),Element_courant->Nom,Couleur_texte,Couleur_fond);
// On affiche l'élément
Print_dans_fenetre(9,90+FILENAMESPACE+(Indice<<3),Element_courant->NomAbrege,Couleur_texte,Couleur_fond);
// On passe … la ligne suivante
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)
//
// Decalage_premier = D‚calage entre le premier fichier visible dans le
// s‚lecteur et le premier fichier de la liste
// Decalage_premier = Décalage entre le premier fichier visible dans le
// sélecteur et le premier fichier de la liste
//
// Decalage_select = D‚calage entre le premier fichier visible dans le
// s‚lecteur et le fichier … r‚cup‚rer
// Decalage_select = Décalage entre le premier fichier visible dans le
// 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;
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)
{
// 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;
for (;Decalage_premier>0;Decalage_premier--)
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--)
Element_courant=Element_courant->Suivant;
// On recopie la chaŒne en la d‚formatant (i.e. tous les chars sauf ' ')
for (Curseur=Element_courant->Nom;*Curseur!='\0';Curseur++)
if (*Curseur!=' ')
*(Libelle++)=*Curseur;
*Libelle='\0';
// On recopie la chaîne
strcpy(Libelle, Element_courant->NomComplet);
} // 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)
// 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)
&& ( (*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));
else // Sinon, descendre la fenˆtre (si possible)
else // Sinon, descendre la fenêtre (si possible)
if ((*Decalage_premier)+10<Liste_Nb_elements)
Afficher_la_liste_des_fichiers(++(*Decalage_premier),*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)
// Si la s‚lection peut monter
// Si la sélection peut monter
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)
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)
/*
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 -1 si le s‚lecteur est vide.
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 -1 si le sélecteur est vide.
*/
{
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)
Decalage_calcule=Liste_Nb_elements-1;

22
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_Y;
GLOBAL char Brouillon_Repertoire_fichier[256]; // |_ Nom complet =
GLOBAL char Brouillon_Nom_fichier[13]; // | Repertoire_fichier+"\"+Nom_fichier
GLOBAL char Brouillon_Repertoire_fichier[TAILLE_CHEMIN_FICHIER]; // |_ Nom complet =
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; // 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_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 short Brouillon_Split; // Position en X du bord gauche du split de la loupe
@ -279,14 +279,14 @@ GLOBAL word Brosse_Decalage_Y; // Centre vertical de la brosse
GLOBAL word Brosse_Largeur; // Largeur de la brosse
GLOBAL word Brosse_Hauteur; // Hauteur de la brosse
GLOBAL char Brosse_Repertoire_fichier[256]; // |
GLOBAL char Brosse_Nom_fichier[13]; // |
GLOBAL byte Brosse_Format_fichier; // | Infos sur le
GLOBAL byte Brosse_Format; // |_ sÚlecteur de
GLOBAL short Brosse_File_list_Position; // | fichiers de la
GLOBAL short Brosse_File_list_Decalage; // | brosse.
GLOBAL char Brosse_Repertoire_courant[256]; // |
GLOBAL char Brosse_Commentaire[TAILLE_COMMENTAIRE+1]; // |
GLOBAL char Brosse_Repertoire_fichier[TAILLE_CHEMIN_FICHIER];// |
GLOBAL char Brosse_Nom_fichier[TAILLE_CHEMIN_FICHIER]; // |
GLOBAL byte Brosse_Format_fichier; // | Infos sur le
GLOBAL byte Brosse_Format; // |_ sÚlecteur de
GLOBAL short Brosse_File_list_Position; // | fichiers de la
GLOBAL short Brosse_File_list_Decalage; // | brosse.
GLOBAL char Brosse_Repertoire_courant[256]; // |
GLOBAL char Brosse_Commentaire[TAILLE_COMMENTAIRE+1]; // |
GLOBAL byte Brosse_Centre_rotation_defini; // | Infos sur le
GLOBAL short Brosse_Centre_rotation_X; // |- centre de rotation

529
loadsave.c
View File

@ -32,6 +32,8 @@
#define PERMISSIONS_ECRITURE (S_IRUSR|S_IWUSR)
#endif
#define FILENAMESPACE 16
// Conversion des words d'une structure, si necessaire sur cette plate-forme
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
if (Format!=Principal_Format)
{
Print_dans_fenetre( 27,74,"but is:",CM_Fonce,CM_Clair);
Print_dans_fenetre( 83,74,Format_Extension[Format-1],CM_Noir,CM_Clair);
Print_dans_fenetre( 274,72,Format_Extension[Format-1],CM_Noir,CM_Clair);
}
// 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);
// Affichage du commentaire
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:
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_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:
Block(Preview_Pos_X,Preview_Pos_Y,
@ -335,7 +336,7 @@ void Dessiner_preview_palette(void)
{
short Indice;
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)
for (Indice=0; Indice<256; Indice++)
@ -745,21 +746,21 @@ void Save_PAL(void)
//////////////////////////////////// IMG ////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
typedef struct
{
byte Filler1[6];
word Largeur;
word Hauteur;
byte Filler2[118];
T_Palette Palette;
} 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
struct Header
{
byte Filler1[6];
word Largeur;
word Hauteur;
byte Filler2[118];
T_Palette Palette;
} IMG_Header;
T_Header_IMG IMG_Header;
byte Signature[6]={0x01,0x00,0x47,0x12,0x6D,0xB0};
@ -772,7 +773,7 @@ void Test_IMG(void)
if (Handle!=-1)
{
// 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))
&& IMG_Header.Largeur && IMG_Header.Hauteur)
@ -793,14 +794,7 @@ void Load_IMG(void)
word Pos_X,Pos_Y;
long Largeur_lue;
long Taille_du_fichier;
struct Header
{
byte Filler1[6];
word Largeur;
word Hauteur;
byte Filler2[118];
T_Palette Palette;
} IMG_Header;
T_Header_IMG IMG_Header;
struct stat* Informations_Fichier=NULL;
@ -813,7 +807,7 @@ void Load_IMG(void)
stat(Nom_du_fichier,Informations_Fichier);
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);
@ -860,14 +854,7 @@ void Save_IMG(void)
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier
int Fichier;
short Pos_X,Pos_Y;
struct Header
{
byte Filler1[6]; // Signature (??!)
word Largeur;
word Hauteur;
byte Filler2[118];
T_Palette Palette;
} IMG_Header;
T_Header_IMG IMG_Header;
byte Signature[6]={0x01,0x00,0x47,0x12,0x6D,0xB0};
Nom_fichier_complet(Nom_du_fichier,0);
@ -893,7 +880,7 @@ void Save_IMG(void)
memcpy(IMG_Header.Palette,Principal_Palette,sizeof(T_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();
@ -928,27 +915,27 @@ void Save_IMG(void)
//////////////////////////////////// PKM ////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
typedef struct
{
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
} 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
struct Header
{
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;
T_Header_PKM Head;
Nom_fichier_complet(Nom_du_fichier,0);
@ -960,7 +947,7 @@ void Test_PKM(void)
if (Fichier!=-1)
{
// 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.
// 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
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:
// 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;
T_Header_PKM Head;
byte Couleur;
byte Octet;
word Mot;
@ -1013,7 +987,7 @@ void Load_PKM(void)
stat(Nom_du_fichier,&Informations_Fichier);
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
if (Head.Jump)
@ -1121,7 +1095,7 @@ void Load_PKM(void)
Compteur_de_donnees_packees=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:
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];
int Fichier;
struct Header
{
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;
T_Header_PKM Head;
dword Compteur_de_pixels;
dword Taille_image;
word Compteur_de_repetitions;
@ -1268,7 +1229,7 @@ void Save_PKM(void)
if (Fichier!=-1)
{
// Ecriture du header
if (write(Fichier,&Head,sizeof(struct Header))!=-1)
if (write(Fichier,&Head,sizeof(T_Header_PKM))!=-1)
{
Init_ecriture();
@ -1380,7 +1341,22 @@ void Save_PKM(void)
//////////////////////////////////// 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 --------------------------------
@ -1650,22 +1626,7 @@ void Load_LBM(void)
{
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
//int Fichier;
struct Header_LBM
{
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;
T_Header_LBM Header;
char Format[4];
char Section[4];
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.Xorg,sizeof(Header.Xorg))==sizeof(Header.Xorg))
&& (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.Compression,sizeof(Header.Compression))==sizeof(Header.Compression))
&& (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))
&& Header.Width && Header.Height)
{
if ( (Header.Bit_planes) && (Wait_for((byte *)"CMAP")) )
if ( (Header.BitPlanes) && (Wait_for((byte *)"CMAP")) )
{
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.
Image_HAM=1; // Sauvée en 32 coul. => il faut copier les 32 coul.
} // sur les 32 suivantes et assombrir ces derniŠres.
else
{
if ((Header.Bit_planes==6) || (Header.Bit_planes==8))
Image_HAM=Header.Bit_planes;
if ((Header.BitPlanes==6) || (Header.BitPlanes==8))
Image_HAM=Header.BitPlanes;
else
// Erreur_fichier=1; /* C'est censé ˆtre incorrect mais j'ai */
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) )
{
HBPm1=Header.Bit_planes-1;
HBPm1=Header.BitPlanes-1;
if (Header.Mask==1)
Header.Bit_planes++;
Header.BitPlanes++;
// Deluxe paint le fait... alors on le fait...
Back_color=Header.Transp_col;
@ -1785,12 +1746,12 @@ void Load_LBM(void)
if (Principal_Largeur_image & 15)
{
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
{
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)
@ -2019,22 +1980,7 @@ void Load_LBM(void)
void Save_LBM(void)
{
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
struct Header_LBM
{
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;
T_Header_LBM Header;
word Pos_X;
word Pos_Y;
byte Octet;
@ -2073,7 +2019,7 @@ void Save_LBM(void)
swab((byte *)&Largeur_ecran,(byte *)&Header.Xscreen,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);
Ecrire_long(sizeof(T_Palette));
@ -2153,7 +2099,7 @@ void Save_LBM(void)
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
struct BMP_Header
typedef struct
{
word Signature; // ='BM' = 0x4D42
uint32_t Taille_1; // =Taille du fichier
@ -2172,14 +2118,14 @@ struct BMP_Header
uint32_t YPM;
uint32_t Nb_Clr;
uint32_t Clr_Imprt;
};
} T_BMP_Header;
// -- Tester si un fichier est au format BMP --------------------------------
void Test_BMP(void)
{
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier;
struct BMP_Header Header;
T_BMP_Header Header;
Erreur_fichier=1;
Nom_fichier_complet(Nom_du_fichier,0);
@ -2219,7 +2165,7 @@ void Load_BMP(void)
{
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier;
struct BMP_Header Header;
T_BMP_Header Header;
byte * Buffer;
word Indice;
byte Palette_locale[256][4]; // R,V,B,0
@ -2493,26 +2439,7 @@ void Save_BMP(void)
{
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier;
struct BMP_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;
T_BMP_Header Header;
short Pos_X;
short Pos_Y;
long Taille_ligne;
@ -2549,7 +2476,7 @@ void Save_BMP(void)
Header.Nb_Clr =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
// inverse, et pour faire chier, on va les mettre sur une échelle de
@ -2613,7 +2540,24 @@ void Save_BMP(void)
//////////////////////////////////// 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 --------------------------------
@ -2749,24 +2693,8 @@ void Load_GIF(void)
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
struct Type_LSDB
{
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
T_LSDB LSDB;
T_IDB IDB;
word Nb_couleurs; // Nombre de couleurs dans l'image
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)
int Descente; // Booléen "On vient de descendre"
struct Type_LSDB
{
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
T_LSDB LSDB;
T_IDB IDB;
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
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
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.
@ -3239,7 +3152,7 @@ void Save_GIF(void)
IDB.Nb_bits_pixel=8; // Image 256 couleurs;
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
// écrits.
@ -3941,7 +3854,24 @@ void Save_PCX(void)
//////////////////////////////////// CEL ////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
typedef struct
{
word Width; // Largeur de l'image
word Height; // Hauteur de l'image
} T_CEL_Header1;
typedef struct
{
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]; // ???
} T_CEL_Header2;
// -- Tester si un fichier est au format CEL --------------------------------
@ -3950,42 +3880,27 @@ 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 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;
T_CEL_Header1 Header1;
T_CEL_Header2 Header2;
struct stat Informations_Fichier;
Erreur_fichier=0;
Nom_fichier_complet(Nom_du_fichier,0);
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
// cohérence de la dimension de l'image avec celle du fichier.
if (!stat(Nom_du_fichier,&Informations_Fichier))
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 ) )
{
// Tentative de reconnaissance de la signature des nouveaux fichiers
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)
{
@ -4015,23 +3930,8 @@ void Load_CEL(void)
{
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier;
struct CEL_Header1
{
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;
T_CEL_Header1 Header1;
T_CEL_Header2 Header2;
short Pos_X;
short Pos_Y;
byte Dernier_octet=0;
@ -4043,12 +3943,12 @@ void Load_CEL(void)
Nom_fichier_complet(Nom_du_fichier,0);
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);
Taille_du_fichier=Informations_Fichier->st_size;
if ( (Taille_du_fichier>sizeof(struct CEL_Header1))
&& ( (((Header1.Width+1)>>1)*Header1.Height)==(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(T_CEL_Header1)) ) )
{
// Chargement d'un fichier CEL sans signature (vieux fichiers)
Principal_Largeur_image=Header1.Width;
@ -4077,7 +3977,7 @@ void Load_CEL(void)
// On réessaye avec le nouveau format
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)
@ -4147,23 +4047,8 @@ void Save_CEL(void)
{
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier;
struct CEL_Header1
{
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;
T_CEL_Header1 Header1;
T_CEL_Header2 Header2;
short Pos_X;
short Pos_Y;
byte Dernier_octet=0;
@ -4187,7 +4072,7 @@ void Save_CEL(void)
Header1.Width =Principal_Largeur_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
Init_ecriture();
@ -4244,7 +4129,7 @@ void Save_CEL(void)
for (Pos_X=0;Pos_X<16;Pos_X++) // Initialisation du filler 2 (???)
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
Init_ecriture();
@ -4271,7 +4156,17 @@ void Save_CEL(void)
//////////////////////////////////// KCF ////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
typedef struct
{
struct
{
struct
{
byte Octet1;
byte Octet2;
} Couleur[16];
} Palette[10];
} T_KCF_Header;
// -- Tester si un fichier est au format KCF --------------------------------
@ -4279,29 +4174,8 @@ void Test_KCF(void)
{
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier;
struct KCF_Header
{
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
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;
T_KCF_Header Buffer;
T_CEL_Header2 Header2;
int Indice_palette;
int Indice_couleur;
@ -4309,9 +4183,9 @@ void Test_KCF(void)
Nom_fichier_complet(Nom_du_fichier,0);
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:
for (Indice_palette=0;Indice_palette<10;Indice_palette++)
for (Indice_couleur=0;Indice_couleur<16;Indice_couleur++)
@ -4320,7 +4194,7 @@ void Test_KCF(void)
}
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)
{
@ -4346,29 +4220,8 @@ void Load_KCF(void)
{
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier;
struct KCF_Header
{
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;
T_KCF_Header Buffer;
T_CEL_Header2 Header2;
byte Octet[3];
int Indice_palette;
int Indice_couleur;
@ -4381,11 +4234,11 @@ void Load_KCF(void)
if ((Fichier=open(Nom_du_fichier,O_RDONLY|O_BINARY))!=-1)
{
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
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...
@ -4419,7 +4272,7 @@ void Load_KCF(void)
{
// 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...
@ -4481,29 +4334,8 @@ void Save_KCF(void)
{
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER];
int Fichier;
struct KCF_Header
{
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;
T_KCF_Header Buffer;
T_CEL_Header2 Header2;
byte Octet[3];
int Indice_palette;
int Indice_couleur;
@ -4534,7 +4366,7 @@ void Save_KCF(void)
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;
}
else
@ -4552,7 +4384,7 @@ void Save_KCF(void)
for (Indice=0;Indice<16;Indice++) // Initialisation du filler 2 (???)
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;
for (Indice=0;(Indice<256) && (!Erreur_fichier);Indice++)
@ -4583,7 +4415,14 @@ void Save_KCF(void)
//////////////////////////////////// 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 --------------------------------
void Test_SCx(void)
@ -4591,14 +4430,7 @@ void Test_SCx(void)
int Handle; // Handle du fichier
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier
//byte Signature[3];
struct Header
{
byte Filler1[4];
word Largeur;
word Hauteur;
byte Filler2;
byte Plans;
} SCx_Header;
T_SCx_Header SCx_Header;
Nom_fichier_complet(Nom_du_fichier,0);
@ -4610,7 +4442,7 @@ void Test_SCx(void)
if (Handle!=-1)
{
// 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))
&& SCx_Header.Largeur && SCx_Header.Hauteur)
@ -4630,14 +4462,7 @@ void Load_SCx(void)
word Pos_X,Pos_Y;
long Taille,Vraie_taille;
long Taille_du_fichier;
struct Header
{
byte Filler1[4];
word Largeur;
word Hauteur;
byte Filler2;
byte Plans;
} SCx_Header;
T_SCx_Header SCx_Header;
T_Palette SCx_Palette;
@ -4649,7 +4474,7 @@ void Load_SCx(void)
{
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);
if (Erreur_fichier==0)
@ -4721,14 +4546,7 @@ void Save_SCx(void)
char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier
int Fichier;
short Pos_X,Pos_Y;
struct Header
{
byte Filler1[4];
word Largeur;
word Hauteur;
word Filler2;
T_Palette Palette;
} SCx_Header;
T_SCx_Header SCx_Header;
Nom_fichier_complet(Nom_du_fichier,1);
@ -4741,10 +4559,11 @@ void Save_SCx(void)
memcpy(SCx_Header.Filler1,"RIX3",4);
SCx_Header.Largeur=Principal_Largeur_image;
SCx_Header.Hauteur=Principal_Hauteur_image;
SCx_Header.Filler2=0x00AF;
memcpy(SCx_Header.Palette,Principal_Palette,sizeof(T_Palette));
SCx_Header.Filler2=0xAF;
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();

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);
_splitpath(Buffer,Principal_Repertoire_fichier,Principal_Nom_fichier);
#else
Buffer = malloc(MAX_PATH);
_fullpath(Buffer,argv[1],MAX_PATH);
Buffer = malloc(TAILLE_CHEMIN_FICHIER);
_fullpath(Buffer,argv[1],TAILLE_CHEMIN_FICHIER);
{
// Découpage du nom canonique de fichier en chemin + nom.
// 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:
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
// données de chaŒnage de la liste
@ -179,8 +180,8 @@ typedef struct
char Commentaire[TAILLE_COMMENTAIRE+1]; // Commentaire de l'image
char Repertoire_fichier[256]; // |_ Nom complet =
char Nom_fichier[13]; // | Repertoire_fichier+"\"+Nom_fichier
char Repertoire_fichier[TAILLE_CHEMIN_FICHIER]; // |_ Nom complet =
char Nom_fichier[TAILLE_CHEMIN_FICHIER]; // | Repertoire_fichier+"\"+Nom_fichier
byte Format_fichier; // Format auquel il faut lire et écrire le fichier
/*