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

more code cleanup to prepare translation

Browse Source 
git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@676 416bcca6-2ee7-4201-b75f-2eb2f807beb1
This commit is contained in:
Yves Rizoud 2009-03-15 17:21:16 +00:00
parent 5883853be4
commit ecafeaace1
15 changed files with 251 additions and 354 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
aide.c
View File

@ -271,16 +271,16 @@ void Afficher_aide(void)
break; break;
} }
// On affiche la ligne // On affiche la ligne
Ligne = Table_d_aide[Section_d_aide_en_cours].Table_aide[Ligne_de_depart + Indice_de_ligne].texte; Ligne = Table_d_aide[Section_d_aide_en_cours].Table_aide[Ligne_de_depart + Indice_de_ligne].Text;
TypeLigne = Table_d_aide[Section_d_aide_en_cours].Table_aide[Ligne_de_depart + Indice_de_ligne].type; TypeLigne = Table_d_aide[Section_d_aide_en_cours].Table_aide[Ligne_de_depart + Indice_de_ligne].Line_type;
// Si c'est une sous-ligne de titre, on utilise le texte de la ligne précédente // Si c'est une sous-ligne de titre, on utilise le texte de la ligne précédente
if (TypeLigne == '-' && (Ligne_de_depart + Indice_de_ligne > 0)) if (TypeLigne == '-' && (Ligne_de_depart + Indice_de_ligne > 0))
Ligne = Table_d_aide[Section_d_aide_en_cours].Table_aide[Ligne_de_depart + Indice_de_ligne - 1].texte; Ligne = Table_d_aide[Section_d_aide_en_cours].Table_aide[Ligne_de_depart + Indice_de_ligne - 1].Text;
else if (TypeLigne == 'K') else if (TypeLigne == 'K')
{ {
const char *Lien; const char *Lien;
Position_lien = strstr(Ligne,"%s") - Ligne; Position_lien = strstr(Ligne,"%s") - Ligne;
Lien=Valeur_Raccourci_Clavier(Table_d_aide[Section_d_aide_en_cours].Table_aide[Ligne_de_depart + Indice_de_ligne].valeur); Lien=Valeur_Raccourci_Clavier(Table_d_aide[Section_d_aide_en_cours].Table_aide[Ligne_de_depart + Indice_de_ligne].Line_parameter);
Taille_lien=strlen(Lien); Taille_lien=strlen(Lien);
snprintf(Buffer, 44, Ligne, Lien); snprintf(Buffer, 44, Ligne, Lien);
if (strlen(Ligne)+Taille_lien-2>44) if (strlen(Ligne)+Taille_lien-2>44)
@ -416,8 +416,8 @@ void Fenetre_aide(int Section, const char *Sous_section)
{ {
int Indice=0; int Indice=0;
for (Indice=0; Indice<Nb_lignes; Indice++) for (Indice=0; Indice<Nb_lignes; Indice++)
if (Table_d_aide[Section_d_aide_en_cours].Table_aide[Indice].type == 'T' && if (Table_d_aide[Section_d_aide_en_cours].Table_aide[Indice].Line_type == 'T' &&
!strcmp(Table_d_aide[Section_d_aide_en_cours].Table_aide[Indice].texte, Sous_section)) !strcmp(Table_d_aide[Section_d_aide_en_cours].Table_aide[Indice].Text, Sous_section))
{ {
Position_d_aide_en_cours = Indice; Position_d_aide_en_cours = Indice;
break; break;
@ -469,10 +469,10 @@ void Fenetre_aide(int Section, const char *Sous_section)
{ {
if (Position_d_aide_en_cours+Ligne<Nb_lignes) if (Position_d_aide_en_cours+Ligne<Nb_lignes)
{ {
switch (Table_d_aide[Section_d_aide_en_cours].Table_aide[Position_d_aide_en_cours+Ligne].type) switch (Table_d_aide[Section_d_aide_en_cours].Table_aide[Position_d_aide_en_cours+Ligne].Line_type)
{ {
case 'K': case 'K':
Fenetre_controle(Table_d_aide[Section_d_aide_en_cours].Table_aide[Position_d_aide_en_cours+Ligne].valeur); Fenetre_controle(Table_d_aide[Section_d_aide_en_cours].Table_aide[Position_d_aide_en_cours+Ligne].Line_parameter);
break; break;
// Ici on peut gérer un cas 'lien hypertexte' // Ici on peut gérer un cas 'lien hypertexte'
default: default:

10
divers.c
View File

@ -599,14 +599,14 @@ void Zoomer_une_ligne(byte* Ligne_originale, byte* Ligne_zoomee,
word Facteur, word Largeur word Facteur, word Largeur
) )
{ {
byte couleur; byte Color;
word larg; word X;
// Pour chaque pixel // Pour chaque pixel
for(larg=0;larg<Largeur;larg++){ for(X=0;X<Largeur;X++){
couleur = *Ligne_originale; Color = *Ligne_originale;
memset(Ligne_zoomee,couleur,Facteur); memset(Ligne_zoomee,Color,Facteur);
Ligne_zoomee+=Facteur; Ligne_zoomee+=Facteur;
Ligne_originale++; Ligne_originale++;

103
init.c
View File

@ -74,110 +74,7 @@
#if defined(__amigaos4__) || defined(__AROS__) || defined(__MORPHOS__) #if defined(__amigaos4__) || defined(__AROS__) || defined(__MORPHOS__)
void bstrtostr( BSTR in, STRPTR out, TEXT max ); void bstrtostr( BSTR in, STRPTR out, TEXT max );
#endif #endif
/*
void Rechercher_drives(void)
{
#if defined(__amigaos4__) || defined(__AROS__) || defined(__MORPHOS__)
struct DosList *dl;
char tmp[256];
dl = LockDosList( LDF_VOLUMES | LDF_READ );
if( dl )
{
while( ( dl = NextDosEntry( dl, LDF_VOLUMES | LDF_READ ) ) )
{
bstrtostr( dl->dol_Name, tmp, 254 );
strcat( tmp, ":" );
Ajouter_lecteur(':',LECTEUR_HDD,tmp);
}
UnLockDosList( LDF_VOLUMES | LDF_READ );
}
#elif defined (__WIN32__)
char NomLecteur[]="A:\\";
int DriveBits = GetLogicalDrives();
int IndiceLecteur;
int IndiceBit;
// Sous Windows, on a la totale, presque aussi bien que sous DOS:
IndiceLecteur = 0;
for (IndiceBit=0; IndiceBit<26 && IndiceLecteur<23; IndiceBit++)
{
if ( (1 << IndiceBit) & DriveBits )
{
// On a ce lecteur, il faut maintenant déterminer son type "physique".
// pour profiter des jolies icones de X-man.
int TypeLecteur;
char CheminLecteur[]="A:\\";
// Cette API Windows est étrange, je dois m'y faire...
CheminLecteur[0]='A'+IndiceBit;
switch (GetDriveType(CheminLecteur))
{
case DRIVE_CDROM:
TypeLecteur=LECTEUR_CDROM;
break;
case DRIVE_REMOTE:
TypeLecteur=LECTEUR_NETWORK;
break;
case DRIVE_REMOVABLE:
TypeLecteur=LECTEUR_FLOPPY_3_5;
break;
case DRIVE_FIXED:
TypeLecteur=LECTEUR_HDD;
break;
default:
TypeLecteur=LECTEUR_NETWORK;
break;
}
NomLecteur[0]='A'+IndiceBit;
Ajouter_lecteur(NomLecteur[0], TypeLecteur,NomLecteur);
IndiceLecteur++;
}
}
#else
//Sous les différents unix, on va mettre
// un disque dur qui pointera vers la racine,
// et un autre vers le home directory de l'utilisateur.
// Ensuite on utilise read_file_system_list pour compléter
struct mount_entry* Liste_points_montage;
struct mount_entry* next;
char lettre = 'A';
#if defined(__BEOS__) || defined(__HAIKU__)
char * Home = getenv("$HOME");
#else
char * Home = getenv("HOME");
#endif
Ajouter_lecteur('/', LECTEUR_HDD, "/");
if(Home)
Ajouter_lecteur('~', LECTEUR_HDD, Home);
Liste_points_montage = read_file_system_list(false);
while(Liste_points_montage != NULL)
{
if(Liste_points_montage->me_dummy == 0 && strcmp(Liste_points_montage->me_mountdir,"/") && strcmp(Liste_points_montage->me_mountdir,"/home"))
{
Ajouter_lecteur(lettre++,
Liste_points_montage->me_remote==1?LECTEUR_NETWORK:LECTEUR_HDD,
Liste_points_montage->me_mountdir);
}
next = Liste_points_montage -> me_next;
#if !(defined(__macosx__) || defined(__FreeBSD__))
free(Liste_points_montage -> me_type);
#endif
free(Liste_points_montage -> me_devname);
free(Liste_points_montage -> me_mountdir);
free(Liste_points_montage);
Liste_points_montage = next;
}
#endif
}
*/
// Fonctions de lecture dans la skin de l'interface graphique // Fonctions de lecture dans la skin de l'interface graphique
void Chercher_bas(SDL_Surface *GUI, int *Debut_X, int *Debut_Y, byte Couleur_neutre,char * Section) void Chercher_bas(SDL_Surface *GUI, int *Debut_X, int *Debut_Y, byte Couleur_neutre,char * Section)
{ {

102
loadsave.c
View File

@ -249,15 +249,15 @@ fonction_afficheur_24b Pixel_Chargement_24b;
// Chargement des pixels dans le buffer 24b // Chargement des pixels dans le buffer 24b
void Pixel_Chargement_dans_buffer_24b(short Pos_X,short Pos_Y,byte R,byte V,byte B) void Pixel_Chargement_dans_buffer_24b(short Pos_X,short Pos_Y,byte R,byte V,byte B)
{ {
int indice; int index;
if ((Pos_X>=0) && (Pos_Y>=0)) if ((Pos_X>=0) && (Pos_Y>=0))
if ((Pos_X<Principal_Largeur_image) && (Pos_Y<Principal_Hauteur_image)) if ((Pos_X<Principal_Largeur_image) && (Pos_Y<Principal_Hauteur_image))
{ {
indice=(Pos_Y*Principal_Largeur_image)+Pos_X; index=(Pos_Y*Principal_Largeur_image)+Pos_X;
Buffer_image_24b[indice].R=R; Buffer_image_24b[index].R=R;
Buffer_image_24b[indice].V=V; Buffer_image_24b[index].V=V;
Buffer_image_24b[indice].B=B; Buffer_image_24b[index].B=B;
} }
} }
@ -1347,7 +1347,7 @@ void Save_PKM(void)
Init_ecriture(); Init_ecriture();
// Ecriture du commentaire // Ecriture du commentaire
// (Compteur_de_pixels est utilisé ici comme simple indice de comptage) // (Compteur_de_pixels est utilisé ici comme simple index de comptage)
if (Taille_commentaire) if (Taille_commentaire)
{ {
Ecrire_octet(Fichier,0); Ecrire_octet(Fichier,0);
@ -3721,15 +3721,15 @@ void Load_PCX(void)
if (read_byte(Fichier,&Octet1)) if (read_byte(Fichier,&Octet1))
if (Octet1==12) // Lire la palette si c'est une image en 256 couleurs if (Octet1==12) // Lire la palette si c'est une image en 256 couleurs
{ {
int indice; int index;
// On lit la palette 256c que ces crétins ont foutue à la fin du fichier // On lit la palette 256c que ces crétins ont foutue à la fin du fichier
for(indice=0;indice<256;indice++) for(index=0;index<256;index++)
if ( ! read_byte(Fichier,&Principal_Palette[indice].R) if ( ! read_byte(Fichier,&Principal_Palette[index].R)
|| ! read_byte(Fichier,&Principal_Palette[indice].V) || ! read_byte(Fichier,&Principal_Palette[index].V)
|| ! read_byte(Fichier,&Principal_Palette[indice].B) ) || ! read_byte(Fichier,&Principal_Palette[index].B) )
{ {
Erreur_fichier=2; Erreur_fichier=2;
DEBUG("ERROR READING PCX PALETTE !",indice); DEBUG("ERROR READING PCX PALETTE !",index);
break; break;
} }
} }
@ -4835,10 +4835,10 @@ void Save_SCx(void)
void PI1_8b_to_16p(byte * Src,byte * Dst) void PI1_8b_to_16p(byte * Src,byte * Dst)
{ {
int i; // Indice du pixel à calculer int i; // Indice du pixel à calculer
word masque; // Masque de decodage word Mask; // Masque de decodage
word w0,w1,w2,w3; // Les 4 words bien ordonnés de la source word w0,w1,w2,w3; // Les 4 words bien ordonnés de la source
masque=0x8000; Mask=0x8000;
w0=(((word)Src[0])<<8) | Src[1]; w0=(((word)Src[0])<<8) | Src[1];
w1=(((word)Src[2])<<8) | Src[3]; w1=(((word)Src[2])<<8) | Src[3];
w2=(((word)Src[4])<<8) | Src[5]; w2=(((word)Src[4])<<8) | Src[5];
@ -4848,11 +4848,11 @@ void PI1_8b_to_16p(byte * Src,byte * Dst)
// Pour décoder le pixel n°i, il faut traiter les 4 words sur leur bit // Pour décoder le pixel n°i, il faut traiter les 4 words sur leur bit
// correspondant à celui du masque // correspondant à celui du masque
Dst[i]=((w0 & masque)?0x01:0x00) | Dst[i]=((w0 & Mask)?0x01:0x00) |
((w1 & masque)?0x02:0x00) | ((w1 & Mask)?0x02:0x00) |
((w2 & masque)?0x04:0x00) | ((w2 & Mask)?0x04:0x00) |
((w3 & masque)?0x08:0x00); ((w3 & Mask)?0x08:0x00);
masque>>=1; Mask>>=1;
} }
} }
@ -4861,21 +4861,21 @@ void PI1_8b_to_16p(byte * Src,byte * Dst)
void PI1_16p_to_8b(byte * Src,byte * Dst) void PI1_16p_to_8b(byte * Src,byte * Dst)
{ {
int i; // Indice du pixel à calculer int i; // Indice du pixel à calculer
word masque; // Masque de codage word Mask; // Masque de codage
word w0,w1,w2,w3; // Les 4 words bien ordonnés de la destination word w0,w1,w2,w3; // Les 4 words bien ordonnés de la destination
masque=0x8000; Mask=0x8000;
w0=w1=w2=w3=0; w0=w1=w2=w3=0;
for (i=0;i<16;i++) for (i=0;i<16;i++)
{ {
// Pour coder le pixel n°i, il faut modifier les 4 words sur leur bit // Pour coder le pixel n°i, il faut modifier les 4 words sur leur bit
// correspondant à celui du masque // correspondant à celui du masque
w0|=(Src[i] & 0x01)?masque:0x00; w0|=(Src[i] & 0x01)?Mask:0x00;
w1|=(Src[i] & 0x02)?masque:0x00; w1|=(Src[i] & 0x02)?Mask:0x00;
w2|=(Src[i] & 0x04)?masque:0x00; w2|=(Src[i] & 0x04)?Mask:0x00;
w3|=(Src[i] & 0x08)?masque:0x00; w3|=(Src[i] & 0x08)?Mask:0x00;
masque>>=1; Mask>>=1;
} }
Dst[0]=w0 >> 8; Dst[0]=w0 >> 8;
Dst[1]=w0 & 0x00FF; Dst[1]=w0 & 0x00FF;
@ -5212,7 +5212,7 @@ void PC1_4pb_to_1lp(byte * Src0,byte * Src1,byte * Src2,byte * Src3,byte * Dst)
{ {
int i,j; // Compteurs int i,j; // Compteurs
int ip; // Indice du pixel à calculer int ip; // Indice du pixel à calculer
byte masque; // Masque de decodage byte Mask; // Masque de decodage
byte b0,b1,b2,b3; // Les 4 octets des plans bits sources byte b0,b1,b2,b3; // Les 4 octets des plans bits sources
ip=0; ip=0;
@ -5224,14 +5224,14 @@ void PC1_4pb_to_1lp(byte * Src0,byte * Src1,byte * Src2,byte * Src3,byte * Dst)
b2=Src2[i]; b2=Src2[i];
b3=Src3[i]; b3=Src3[i];
// Pour chacun des 8 bits des octets // Pour chacun des 8 bits des octets
masque=0x80; Mask=0x80;
for (j=0;j<8;j++) for (j=0;j<8;j++)
{ {
Dst[ip++]=((b0 & masque)?0x01:0x00) | Dst[ip++]=((b0 & Mask)?0x01:0x00) |
((b1 & masque)?0x02:0x00) | ((b1 & Mask)?0x02:0x00) |
((b2 & masque)?0x04:0x00) | ((b2 & Mask)?0x04:0x00) |
((b3 & masque)?0x08:0x00); ((b3 & Mask)?0x08:0x00);
masque>>=1; Mask>>=1;
} }
} }
} }
@ -5244,7 +5244,7 @@ void PC1_1lp_to_4pb(byte * Src,byte * Dst0,byte * Dst1,byte * Dst2,byte * Dst3)
{ {
int i,j; // Compteurs int i,j; // Compteurs
int ip; // Indice du pixel à calculer int ip; // Indice du pixel à calculer
byte masque; // Masque de decodage byte Mask; // Masque de decodage
byte b0,b1,b2,b3; // Les 4 octets des plans bits sources byte b0,b1,b2,b3; // Les 4 octets des plans bits sources
ip=0; ip=0;
@ -5252,16 +5252,16 @@ void PC1_1lp_to_4pb(byte * Src,byte * Dst0,byte * Dst1,byte * Dst2,byte * Dst3)
for (i=0;i<40;i++) for (i=0;i<40;i++)
{ {
// Pour chacun des 8 bits des octets // Pour chacun des 8 bits des octets
masque=0x80; Mask=0x80;
b0=b1=b2=b3=0; b0=b1=b2=b3=0;
for (j=0;j<8;j++) for (j=0;j<8;j++)
{ {
b0|=(Src[ip] & 0x01)?masque:0x00; b0|=(Src[ip] & 0x01)?Mask:0x00;
b1|=(Src[ip] & 0x02)?masque:0x00; b1|=(Src[ip] & 0x02)?Mask:0x00;
b2|=(Src[ip] & 0x04)?masque:0x00; b2|=(Src[ip] & 0x04)?Mask:0x00;
b3|=(Src[ip] & 0x08)?masque:0x00; b3|=(Src[ip] & 0x08)?Mask:0x00;
ip++; ip++;
masque>>=1; Mask>>=1;
} }
Dst0[i]=b0; Dst0[i]=b0;
Dst1[i]=b1; Dst1[i]=b1;
@ -5463,7 +5463,7 @@ void Load_RAW_24B(int Largeur,int Hauteur,Bitmap24B Source)
fclose(Fichier); fclose(Fichier);
} }
void Load_TGA(char * nom,Bitmap24B * dest,int * larg,int * haut) void Load_TGA(char * Nom,Bitmap24B * dest,int * Largeur,int * Hauteur)
{ {
FILE* fichier; FILE* fichier;
struct struct
@ -5484,13 +5484,13 @@ void Load_TGA(char * nom,Bitmap24B * dest,int * larg,int * haut)
int x,y,py,skip,t; int x,y,py,skip,t;
byte * buffer; byte * buffer;
fichier=fopen(nom,"rb"); fichier=fopen(Nom,"rb");
read_bytes(fichier,&TGA_Header,sizeof(TGA_Header)); read_bytes(fichier,&TGA_Header,sizeof(TGA_Header));
if (TGA_Header.Image_type_code==2) if (TGA_Header.Image_type_code==2)
{ {
*larg=TGA_Header.Width; *Largeur=TGA_Header.Width;
*haut=TGA_Header.Height; *Hauteur=TGA_Header.Height;
*dest=(Bitmap24B)malloc((*larg)*(*haut)*3); *dest=(Bitmap24B)malloc((*Largeur)*(*Hauteur)*3);
// On saute l'ID field // On saute l'ID field
fseek(fichier,TGA_Header.Id_field_size,SEEK_CUR); fseek(fichier,TGA_Header.Id_field_size,SEEK_CUR);
@ -5513,7 +5513,7 @@ void Load_TGA(char * nom,Bitmap24B * dest,int * larg,int * haut)
fseek(fichier,skip,SEEK_CUR); fseek(fichier,skip,SEEK_CUR);
// Lecture des pixels // Lecture des pixels
skip=(*larg); skip=(*Largeur);
if (TGA_Header.Pixel_size==16) if (TGA_Header.Pixel_size==16)
skip*=2; skip*=2;
else else
@ -5524,12 +5524,12 @@ void Load_TGA(char * nom,Bitmap24B * dest,int * larg,int * haut)
skip*=4; skip*=4;
buffer=(byte *)malloc(skip); buffer=(byte *)malloc(skip);
for (y=0;y<(*haut);y++) for (y=0;y<(*Hauteur);y++)
{ {
read_bytes(fichier,buffer,skip); read_bytes(fichier,buffer,skip);
// Inversion du rouge et du bleu // Inversion du rouge et du bleu
for (x=0;x<(*larg);x++) for (x=0;x<(*Largeur);x++)
{ {
t=buffer[(x*3)+0]; t=buffer[(x*3)+0];
buffer[(x*3)+0]=buffer[(x*3)+2]; buffer[(x*3)+0]=buffer[(x*3)+2];
@ -5540,13 +5540,13 @@ void Load_TGA(char * nom,Bitmap24B * dest,int * larg,int * haut)
if (TGA_Header.Descriptor & 0x20) if (TGA_Header.Descriptor & 0x20)
py=y; py=y;
else else
py=(*haut)-y-1; py=(*Hauteur)-y-1;
// Prise en compte de l'interleave verticale // Prise en compte de l'interleave verticale
if (TGA_Header.Descriptor & 0xC0) if (TGA_Header.Descriptor & 0xC0)
py=((py % (*haut))*2)+(py/(*haut)); py=((py % (*Hauteur))*2)+(py/(*Hauteur));
memcpy((*dest)+(py*(*larg)),buffer,skip); memcpy((*dest)+(py*(*Largeur)),buffer,skip);
} }
free(buffer); free(buffer);
} }

178
op_c.c
View File

@ -170,7 +170,7 @@ void HSLtoRGB(byte H,byte S,byte L, byte* R, byte* G, byte* B)
Table_conversion * TC_New(int nbb_r,int nbb_v,int nbb_b) Table_conversion * TC_New(int nbb_r,int nbb_v,int nbb_b)
{ {
Table_conversion * n; Table_conversion * n;
int taille; int Taille;
n=(Table_conversion *)malloc(sizeof(Table_conversion)); n=(Table_conversion *)malloc(sizeof(Table_conversion));
if (n!=NULL) if (n!=NULL)
@ -192,11 +192,11 @@ Table_conversion * TC_New(int nbb_r,int nbb_v,int nbb_b)
n->red_b=8-nbb_b; n->red_b=8-nbb_b;
// On tente d'allouer la table // On tente d'allouer la table
taille=(n->rng_r)*(n->rng_v)*(n->rng_b); Taille=(n->rng_r)*(n->rng_v)*(n->rng_b);
n->table=(byte *)malloc(taille); n->table=(byte *)malloc(Taille);
if (n->table!=NULL) if (n->table!=NULL)
// C'est bon! // C'est bon!
memset(n->table,0,taille); // Inutile, mais plus propre memset(n->table,0,Taille); // Inutile, mais plus propre
else else
{ {
// Table impossible … allouer // Table impossible … allouer
@ -216,7 +216,7 @@ void TC_Delete(Table_conversion * t)
byte TC_Get(Table_conversion * t,int r,int v,int b) byte TC_Get(Table_conversion * t,int r,int v,int b)
{ {
int indice; int index;
// On réduit le nombre de bits par couleur // On réduit le nombre de bits par couleur
r=(r>>t->red_r); r=(r>>t->red_r);
@ -224,17 +224,17 @@ byte TC_Get(Table_conversion * t,int r,int v,int b)
b=(b>>t->red_b); b=(b>>t->red_b);
// On recherche la couleur la plus proche dans la table de conversion // On recherche la couleur la plus proche dans la table de conversion
indice=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b); index=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
return t->table[indice]; return t->table[index];
} }
void TC_Set(Table_conversion * t,int r,int v,int b,byte i) void TC_Set(Table_conversion * t,int r,int v,int b,byte i)
{ {
int indice; int index;
indice=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b); index=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
t->table[indice]=i; t->table[index]=i;
} }
@ -245,16 +245,16 @@ void TC_Set(Table_conversion * t,int r,int v,int b,byte i)
void TO_Init(Table_occurence * t) void TO_Init(Table_occurence * t)
{ {
int taille; int Taille;
taille=(t->rng_r)*(t->rng_v)*(t->rng_b)*sizeof(int); Taille=(t->rng_r)*(t->rng_v)*(t->rng_b)*sizeof(int);
memset(t->table,0,taille); // On initialise … 0 memset(t->table,0,Taille); // On initialise … 0
} }
Table_occurence * TO_New(int nbb_r,int nbb_v,int nbb_b) Table_occurence * TO_New(int nbb_r,int nbb_v,int nbb_b)
{ {
Table_occurence * n; Table_occurence * n;
int taille; int Taille;
n=(Table_occurence *)malloc(sizeof(Table_occurence)); n=(Table_occurence *)malloc(sizeof(Table_occurence));
if (n!=0) if (n!=0)
@ -276,8 +276,8 @@ Table_occurence * TO_New(int nbb_r,int nbb_v,int nbb_b)
n->red_b=8-nbb_b; n->red_b=8-nbb_b;
// On tente d'allouer la table // On tente d'allouer la table
taille=(n->rng_r)*(n->rng_v)*(n->rng_b)*sizeof(int); Taille=(n->rng_r)*(n->rng_v)*(n->rng_b)*sizeof(int);
n->table=(int *)malloc(taille); n->table=(int *)malloc(Taille);
if (n->table!=0) if (n->table!=0)
// C'est bon! On initialise … 0 // C'est bon! On initialise … 0
TO_Init(n); TO_Init(n);
@ -300,40 +300,40 @@ void TO_Delete(Table_occurence * t)
int TO_Get(Table_occurence * t,int r,int v,int b) int TO_Get(Table_occurence * t,int r,int v,int b)
{ {
int indice; int index;
indice=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b); index=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
return t->table[indice]; return t->table[index];
} }
void TO_Set(Table_occurence * t,int r,int v,int b,int i) void TO_Set(Table_occurence * t,int r,int v,int b,int i)
{ {
int indice; int index;
r=(r>>t->red_r); r=(r>>t->red_r);
v=(v>>t->red_v); v=(v>>t->red_v);
b=(b>>t->red_b); b=(b>>t->red_b);
indice=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b); index=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
t->table[indice]=i; t->table[index]=i;
} }
void TO_Inc(Table_occurence * t,int r,int v,int b) void TO_Inc(Table_occurence * t,int r,int v,int b)
{ {
int indice; int index;
r=(r>>t->red_r); r=(r>>t->red_r);
v=(v>>t->red_v); v=(v>>t->red_v);
b=(b>>t->red_b); b=(b>>t->red_b);
indice=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b); index=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
t->table[indice]++; t->table[index]++;
} }
void TO_Compter_occurences(Table_occurence * t,Bitmap24B image,int taille) void TO_Compter_occurences(Table_occurence * t,Bitmap24B image,int Taille)
{ {
Bitmap24B ptr; Bitmap24B ptr;
int indice; int index;
for (indice=taille,ptr=image;indice>0;indice--,ptr++) for (index=Taille,ptr=image;index>0;index--,ptr++)
TO_Inc(t,ptr->R,ptr->V,ptr->B); TO_Inc(t,ptr->R,ptr->V,ptr->B);
} }
@ -508,15 +508,15 @@ ENDCRUSH:
} }
} }
void Cluster_Split(Cluster * c,Cluster * c1,Cluster * c2,int teinte,Table_occurence * to) void Cluster_Split(Cluster * c,Cluster * c1,Cluster * c2,int Teinte,Table_occurence * to)
{ {
int limite; int limit;
int cumul; int cumul;
int r,v,b; int r,v,b;
limite=(c->occurences)/2; limit=(c->occurences)/2;
cumul=0; cumul=0;
if (teinte==0) if (Teinte==0)
{ {
for (r=c->rmin<<16;r<=c->rmax<<16;r+=1<<16) for (r=c->rmin<<16;r<=c->rmax<<16;r+=1<<16)
{ {
@ -525,13 +525,13 @@ void Cluster_Split(Cluster * c,Cluster * c1,Cluster * c2,int teinte,Table_occure
for (b=c->bmin;b<=c->bmax;b++) for (b=c->bmin;b<=c->bmax;b++)
{ {
cumul+=to->table[r + v + b]; cumul+=to->table[r + v + b];
if (cumul>=limite) if (cumul>=limit)
break; break;
} }
if (cumul>=limite) if (cumul>=limit)
break; break;
} }
if (cumul>=limite) if (cumul>=limit)
break; break;
} }
@ -556,7 +556,7 @@ void Cluster_Split(Cluster * c,Cluster * c1,Cluster * c2,int teinte,Table_occure
c2->bmin=c->bmin; c2->bmax=c->bmax; c2->bmin=c->bmin; c2->bmax=c->bmax;
} }
else else
if (teinte==1) if (Teinte==1)
{ {
for (v=c->vmin<<8;v<=c->vmax<<8;v+=1<<8) for (v=c->vmin<<8;v<=c->vmax<<8;v+=1<<8)
@ -566,13 +566,13 @@ void Cluster_Split(Cluster * c,Cluster * c1,Cluster * c2,int teinte,Table_occure
for (b=c->bmin;b<=c->bmax;b++) for (b=c->bmin;b<=c->bmax;b++)
{ {
cumul+=to->table[r + v + b]; cumul+=to->table[r + v + b];
if (cumul>=limite) if (cumul>=limit)
break; break;
} }
if (cumul>=limite) if (cumul>=limit)
break; break;
} }
if (cumul>=limite) if (cumul>=limit)
break; break;
} }
@ -605,13 +605,13 @@ void Cluster_Split(Cluster * c,Cluster * c1,Cluster * c2,int teinte,Table_occure
for (r=c->rmin<<16;r<=c->rmax<<16;r+=1<<16) for (r=c->rmin<<16;r<=c->rmax<<16;r+=1<<16)
{ {
cumul+=to->table[r + v + b]; cumul+=to->table[r + v + b];
if (cumul>=limite) if (cumul>=limit)
break; break;
} }
if (cumul>=limite) if (cumul>=limit)
break; break;
} }
if (cumul>=limite) if (cumul>=limit)
break; break;
} }
@ -693,7 +693,7 @@ ClusterSet * CS_New(int nbmax,Table_occurence * to)
// On recopie les paramŠtres demand‚s // On recopie les paramŠtres demand‚s
n->nbmax=TO_Compter_couleurs(to); n->nbmax=TO_Compter_couleurs(to);
// On vient de compter le nombre de couleurs existantes, s'il est plus grand que 256 on limite à 256 (nombre de couleurs voulu au final) // On vient de compter le nombre de couleurs existantes, s'il est plus grand que 256 on limit à 256 (nombre de couleurs voulu au final)
if (n->nbmax>nbmax) if (n->nbmax>nbmax)
{ {
n->nbmax=nbmax; n->nbmax=nbmax;
@ -723,35 +723,35 @@ void CS_Delete(ClusterSet * cs)
void CS_Get(ClusterSet * cs,Cluster * c) void CS_Get(ClusterSet * cs,Cluster * c)
{ {
int indice; int index;
// On cherche un cluster que l'on peut couper en deux, donc avec au moins deux valeurs // On cherche un cluster que l'on peut couper en deux, donc avec au moins deux valeurs
// différentes sur l'une des composantes // différentes sur l'une des composantes
for (indice=0;indice<cs->nb;indice++) for (index=0;index<cs->nb;index++)
if ( (cs->clusters[indice].rmin<cs->clusters[indice].rmax) || if ( (cs->clusters[index].rmin<cs->clusters[index].rmax) ||
(cs->clusters[indice].vmin<cs->clusters[indice].vmax) || (cs->clusters[index].vmin<cs->clusters[index].vmax) ||
(cs->clusters[indice].bmin<cs->clusters[indice].bmax) ) (cs->clusters[index].bmin<cs->clusters[index].bmax) )
break; break;
// On le recopie dans c // On le recopie dans c
*c=cs->clusters[indice]; *c=cs->clusters[index];
// On décrémente le nombre et on décale tous les clusters suivants // On décrémente le nombre et on décale tous les clusters suivants
// Sachant qu'on va réinsérer juste après, il me semble que ça serait une bonne idée de gérer les clusters // Sachant qu'on va réinsérer juste après, il me semble que ça serait une bonne idée de gérer les clusters
// comme une liste chainée... on n'a aucun accès direct dedans, que des parcours ... // comme une liste chainée... on n'a aucun accès direct dedans, que des parcours ...
cs->nb--; cs->nb--;
memcpy((cs->clusters+indice),(cs->clusters+indice+1),(cs->nb-indice)*sizeof(Cluster)); memcpy((cs->clusters+index),(cs->clusters+index+1),(cs->nb-index)*sizeof(Cluster));
} }
void CS_Set(ClusterSet * cs,Cluster * c) void CS_Set(ClusterSet * cs,Cluster * c)
{ {
int indice; int index;
// int decalage; // int decalage;
// Le tableau des clusters est trié par nombre d'occurences. Donc on cherche la position du premier cluster // Le tableau des clusters est trié par nombre d'occurences. Donc on cherche la position du premier cluster
// qui est plus grand que le notre // qui est plus grand que le notre
for (indice=0;indice<cs->nb;indice++) for (index=0;index<cs->nb;index++)
if (cs->clusters[indice].occurences<c->occurences) if (cs->clusters[index].occurences<c->occurences)
/* /*
if (((OPTPAL_Cluster[index].rmax-OPTPAL_Cluster[index].rmin+1)* if (((OPTPAL_Cluster[index].rmax-OPTPAL_Cluster[index].rmin+1)*
(OPTPAL_Cluster[index].gmax-OPTPAL_Cluster[index].gmin+1)* (OPTPAL_Cluster[index].gmax-OPTPAL_Cluster[index].gmin+1)*
@ -764,18 +764,18 @@ void CS_Set(ClusterSet * cs,Cluster * c)
*/ */
break; break;
if (indice<cs->nb) if (index<cs->nb)
{ {
// On distingue ici une insertion plutot qu'un placement en fin de liste. // On distingue ici une insertion plutot qu'un placement en fin de liste.
// On doit donc décaler les ensembles suivants vers la fin pour se faire // On doit donc décaler les ensembles suivants vers la fin pour se faire
// une place dans la liste. // une place dans la liste.
//for (decalage=cs->nb;decalage>indice;decalage--) //for (decalage=cs->nb;decalage>index;decalage--)
// memcpy((cs->clusters+decalage),(cs->clusters+decalage-1),sizeof(Cluster)); // memcpy((cs->clusters+decalage),(cs->clusters+decalage-1),sizeof(Cluster));
memmove(cs->clusters+indice+1,cs->clusters+indice,(cs->nb-indice)*sizeof(Cluster)); memmove(cs->clusters+index+1,cs->clusters+index,(cs->nb-index)*sizeof(Cluster));
} }
cs->clusters[indice]=*c; cs->clusters[index]=*c;
cs->nb++; cs->nb++;
} }
@ -815,10 +815,10 @@ void CS_Generer(ClusterSet * cs,Table_occurence * to)
void CS_Calculer_teintes(ClusterSet * cs,Table_occurence * to) void CS_Calculer_teintes(ClusterSet * cs,Table_occurence * to)
{ {
int indice; int index;
Cluster * c; Cluster * c;
for (indice=0,c=cs->clusters;indice<cs->nb;indice++,c++) for (index=0,c=cs->clusters;index<cs->nb;index++,c++)
Cluster_Calculer_teinte(c,to); Cluster_Calculer_teinte(c,to);
} }
@ -892,19 +892,19 @@ void CS_Trier_par_luminance(ClusterSet * cs)
void CS_Generer_TC_et_Palette(ClusterSet * cs,Table_conversion * tc,Composantes * palette) void CS_Generer_TC_et_Palette(ClusterSet * cs,Table_conversion * tc,Composantes * palette)
{ {
int indice; int index;
int r,v,b; int r,v,b;
for (indice=0;indice<cs->nb;indice++) for (index=0;index<cs->nb;index++)
{ {
palette[indice].R=cs->clusters[indice].r; palette[index].R=cs->clusters[index].r;
palette[indice].V=cs->clusters[indice].v; palette[index].V=cs->clusters[index].v;
palette[indice].B=cs->clusters[indice].b; palette[index].B=cs->clusters[index].b;
for (r=cs->clusters[indice].Rmin;r<=cs->clusters[indice].Rmax;r++) for (r=cs->clusters[index].Rmin;r<=cs->clusters[index].Rmax;r++)
for (v=cs->clusters[indice].Vmin;v<=cs->clusters[indice].Vmax;v++) for (v=cs->clusters[index].Vmin;v<=cs->clusters[index].Vmax;v++)
for (b=cs->clusters[indice].Bmin;b<=cs->clusters[indice].Bmax;b++) for (b=cs->clusters[index].Bmin;b<=cs->clusters[index].Bmax;b++)
TC_Set(tc,r,v,b,indice); TC_Set(tc,r,v,b,index);
} }
} }
@ -956,7 +956,7 @@ void DS_Delete(DegradeSet * ds)
void DS_Generer(DegradeSet * ds,ClusterSet * cs) void DS_Generer(DegradeSet * ds,ClusterSet * cs)
{ {
int ic,id; // Les indices de parcours des ensembles int ic,id; // Les indexs de parcours des ensembles
int mdegr; // Meilleur d‚grad‚ int mdegr; // Meilleur d‚grad‚
int mdiff; // Meilleure diff‚rence de chrominance int mdiff; // Meilleure diff‚rence de chrominance
int diff; // Diff‚rence de chrominance courante int diff; // Diff‚rence de chrominance courante
@ -1012,7 +1012,7 @@ void DS_Generer(DegradeSet * ds,ClusterSet * cs)
Table_conversion * Optimiser_palette(Bitmap24B image,int taille,Composantes * palette,int r,int v,int b) Table_conversion * Optimiser_palette(Bitmap24B image,int Taille,Composantes * palette,int r,int v,int b)
{ {
Table_occurence * to; Table_occurence * to;
Table_conversion * tc; Table_conversion * tc;
@ -1030,7 +1030,7 @@ Table_conversion * Optimiser_palette(Bitmap24B image,int taille,Composantes * pa
{ {
// Première étape : on compte les pixels de chaque couleur pour pouvoir trier là dessus // Première étape : on compte les pixels de chaque couleur pour pouvoir trier là dessus
TO_Compter_occurences(to,image,taille); TO_Compter_occurences(to,image,Taille);
cs=CS_New(256,to); cs=CS_New(256,to);
if (cs!=0) if (cs!=0)
@ -1070,21 +1070,21 @@ Table_conversion * Optimiser_palette(Bitmap24B image,int taille,Composantes * pa
return 0; return 0;
} }
int Valeur_modifiee(int valeur,int modif) int Valeur_modifiee(int Valeur,int modif)
{ {
valeur+=modif; Valeur+=modif;
if (valeur<0) if (Valeur<0)
{ {
valeur=0; Valeur=0;
} }
else if (valeur>255) else if (Valeur>255)
{ {
valeur=255; Valeur=255;
} }
return valeur; return Valeur;
} }
void Convert_bitmap_24B_to_256_Floyd_Steinberg(Bitmap256 Dest,Bitmap24B Source,int largeur,int hauteur,Composantes * palette,Table_conversion * tc) void Convert_bitmap_24B_to_256_Floyd_Steinberg(Bitmap256 Dest,Bitmap24B Source,int Largeur,int Hauteur,Composantes * palette,Table_conversion * tc)
// Cette fonction dégrade au fur et à mesure le bitmap source, donc soit on ne // Cette fonction dégrade au fur et à mesure le bitmap source, donc soit on ne
// s'en ressert pas, soit on passe à la fonction une copie de travail du // s'en ressert pas, soit on passe à la fonction une copie de travail du
// bitmap original. // bitmap original.
@ -1101,16 +1101,16 @@ void Convert_bitmap_24B_to_256_Floyd_Steinberg(Bitmap256 Dest,Bitmap24B Source,i
// On initialise les variables de parcours: // On initialise les variables de parcours:
Courant =Source; // Le pixel dont on s'occupe Courant =Source; // Le pixel dont on s'occupe
Suivant =Courant+largeur; // Le pixel en dessous Suivant =Courant+Largeur; // Le pixel en dessous
C_plus1 =Courant+1; // Le pixel à droite C_plus1 =Courant+1; // Le pixel à droite
S_moins1=Suivant-1; // Le pixel en bas à gauche S_moins1=Suivant-1; // Le pixel en bas à gauche
S_plus1 =Suivant+1; // Le pixel en bas à droite S_plus1 =Suivant+1; // Le pixel en bas à droite
D =Dest; D =Dest;
// On parcours chaque pixel: // On parcours chaque pixel:
for (Pos_Y=0;Pos_Y<hauteur;Pos_Y++) for (Pos_Y=0;Pos_Y<Hauteur;Pos_Y++)
{ {
for (Pos_X=0;Pos_X<largeur;Pos_X++) for (Pos_X=0;Pos_X<Largeur;Pos_X++)
{ {
// On prends la meilleure couleur de la palette qui traduit la couleur // On prends la meilleure couleur de la palette qui traduit la couleur
// 24 bits de la source: // 24 bits de la source:
@ -1130,7 +1130,7 @@ void Convert_bitmap_24B_to_256_Floyd_Steinberg(Bitmap256 Dest,Bitmap24B Source,i
ERouge=(Rouge*7)/16.0; ERouge=(Rouge*7)/16.0;
EVert =(Vert *7)/16.0; EVert =(Vert *7)/16.0;
EBleu =(Bleu *7)/16.0; EBleu =(Bleu *7)/16.0;
if (Pos_X+1<largeur) if (Pos_X+1<Largeur)
{ {
// Valeur_modifiee fait la somme des 2 params en bornant sur [0,255] // Valeur_modifiee fait la somme des 2 params en bornant sur [0,255]
C_plus1->R=Valeur_modifiee(C_plus1->R,ERouge); C_plus1->R=Valeur_modifiee(C_plus1->R,ERouge);
@ -1138,7 +1138,7 @@ void Convert_bitmap_24B_to_256_Floyd_Steinberg(Bitmap256 Dest,Bitmap24B Source,i
C_plus1->B=Valeur_modifiee(C_plus1->B,EBleu ); C_plus1->B=Valeur_modifiee(C_plus1->B,EBleu );
} }
// En bas à gauche: // En bas à gauche:
if (Pos_Y+1<hauteur) if (Pos_Y+1<Hauteur)
{ {
ERouge=(Rouge*3)/16.0; ERouge=(Rouge*3)/16.0;
EVert =(Vert *3)/16.0; EVert =(Vert *3)/16.0;
@ -1157,7 +1157,7 @@ void Convert_bitmap_24B_to_256_Floyd_Steinberg(Bitmap256 Dest,Bitmap24B Source,i
Suivant->V=Valeur_modifiee(Suivant->V,EVert ); Suivant->V=Valeur_modifiee(Suivant->V,EVert );
Suivant->B=Valeur_modifiee(Suivant->B,EBleu ); Suivant->B=Valeur_modifiee(Suivant->B,EBleu );
// En bas à droite: // En bas à droite:
if (Pos_X+1<largeur) if (Pos_X+1<Largeur)
{ {
ERouge=(Rouge/16.0); ERouge=(Rouge/16.0);
EVert =(Vert /16.0); EVert =(Vert /16.0);
@ -1203,16 +1203,16 @@ static const byte precision_24b[]=
// Cette fonction utilise l'algorithme "median cut" (Optimiser_palette) pour trouver la palette, et diffuse les erreurs avec floyd-steinberg. // Cette fonction utilise l'algorithme "median cut" (Optimiser_palette) pour trouver la palette, et diffuse les erreurs avec floyd-steinberg.
int Convert_bitmap_24B_to_256(Bitmap256 Dest,Bitmap24B Source,int largeur,int hauteur,Composantes * palette) int Convert_bitmap_24B_to_256(Bitmap256 Dest,Bitmap24B Source,int Largeur,int Hauteur,Composantes * palette)
{ {
Table_conversion * table; // table de conversion Table_conversion * table; // table de conversion
int ip; // Indice de précision pour la conversion int ip; // index de précision pour la conversion
// On essaye d'obtenir une table de conversion qui loge en mémoire, avec la // On essaye d'obtenir une table de conversion qui loge en mémoire, avec la
// meilleure précision possible // meilleure précision possible
for (ip=0;ip<(10*3);ip+=3) for (ip=0;ip<(10*3);ip+=3)
{ {
table=Optimiser_palette(Source,largeur*hauteur,palette,precision_24b[ip+0], table=Optimiser_palette(Source,Largeur*Hauteur,palette,precision_24b[ip+0],
precision_24b[ip+1],precision_24b[ip+2]); precision_24b[ip+1],precision_24b[ip+2]);
if (table!=0) if (table!=0)
break; break;
@ -1220,7 +1220,7 @@ int Convert_bitmap_24B_to_256(Bitmap256 Dest,Bitmap24B Source,int largeur,int ha
if (table!=0) if (table!=0)
{ {
Convert_bitmap_24B_to_256_Floyd_Steinberg(Dest,Source,largeur,hauteur,palette,table); Convert_bitmap_24B_to_256_Floyd_Steinberg(Dest,Source,Largeur,Hauteur,palette,table);
TC_Delete(table); TC_Delete(table);
return 0; return 0;
} }

6
op_c.h
View File

@ -161,7 +161,7 @@ void TO_Delete(Table_occurence * t);
int TO_Get(Table_occurence * t,int r,int v,int b); int TO_Get(Table_occurence * t,int r,int v,int b);
void TO_Set(Table_occurence * t,int r,int v,int b,int i); void TO_Set(Table_occurence * t,int r,int v,int b,int i);
void TO_Inc(Table_occurence * t,int r,int v,int b); void TO_Inc(Table_occurence * t,int r,int v,int b);
void TO_Compter_occurences(Table_occurence * t,Bitmap24B image,int taille); void TO_Compter_occurences(Table_occurence * t,Bitmap24B image,int Taille);
@ -170,7 +170,7 @@ void TO_Compter_occurences(Table_occurence * t,Bitmap24B image,int taille);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
void Cluster_Analyser(Cluster * c,Table_occurence * to); void Cluster_Analyser(Cluster * c,Table_occurence * to);
void Cluster_Split(Cluster * c,Cluster * c1,Cluster * c2,int teinte,Table_occurence * to); void Cluster_Split(Cluster * c,Cluster * c1,Cluster * c2,int Teinte,Table_occurence * to);
void Cluster_Calculer_teinte(Cluster * c,Table_occurence * to); void Cluster_Calculer_teinte(Cluster * c,Table_occurence * to);
@ -201,7 +201,7 @@ void DS_Generer(DegradeSet * ds,ClusterSet * cs);
// Convertie avec le plus de précision possible une image 24b en 256c // Convertie avec le plus de précision possible une image 24b en 256c
// Renvoie s'il y a eu une erreur ou pas.. // Renvoie s'il y a eu une erreur ou pas..
int Convert_bitmap_24B_to_256(Bitmap256 Dest,Bitmap24B Source,int largeur,int hauteur,Composantes * palette); int Convert_bitmap_24B_to_256(Bitmap256 Dest,Bitmap24B Source,int Largeur,int Hauteur,Composantes * palette);

84
operatio.c
View File

@ -4342,7 +4342,7 @@ void Rectangle_Degrade_0_5(void)
short RAX; short RAX;
short RAY; short RAY;
short RBX; short RBX;
short RBY, largeur,hauteur; short RBY, Largeur,Hauteur;
short decalage_largeur = 0; short decalage_largeur = 0;
short decalage_hauteur = 0; short decalage_hauteur = 0;
short decalage_gauche = 0; short decalage_gauche = 0;
@ -4359,8 +4359,8 @@ void Rectangle_Degrade_0_5(void)
Pinceau_Y = RAY; Pinceau_Y = RAY;
Effacer_curseur(); Effacer_curseur();
largeur = abs(RBX-RAX); Largeur = abs(RBX-RAX);
hauteur = abs(RBY-RAY); Hauteur = abs(RBY-RAY);
if (Max(RAX,RBX)-Principal_Decalage_X > Min(Principal_Largeur_image,Loupe_Mode?Principal_Split:Largeur_ecran)) // Tous les clippings à gérer sont là if (Max(RAX,RBX)-Principal_Decalage_X > Min(Principal_Largeur_image,Loupe_Mode?Principal_Split:Largeur_ecran)) // Tous les clippings à gérer sont là
decalage_largeur = Max(RAX,RBX) - Min(Principal_Largeur_image,Loupe_Mode?Principal_Split:Largeur_ecran); decalage_largeur = Max(RAX,RBX) - Min(Principal_Largeur_image,Loupe_Mode?Principal_Split:Largeur_ecran);
@ -4369,15 +4369,15 @@ void Rectangle_Degrade_0_5(void)
decalage_hauteur = Max(RAY,RBY) - Min(Principal_Hauteur_image,Menu_Ordonnee); decalage_hauteur = Max(RAY,RBY) - Min(Principal_Hauteur_image,Menu_Ordonnee);
// Dessin dans la zone de dessin normale // Dessin dans la zone de dessin normale
Ligne_horizontale_XOR(Min(RAX,RBX)-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,largeur - decalage_largeur); Ligne_horizontale_XOR(Min(RAX,RBX)-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,Largeur - decalage_largeur);
if(decalage_hauteur == 0) if(decalage_hauteur == 0)
Ligne_horizontale_XOR(Min(RAX,RBX)-Principal_Decalage_X,Max(RAY,RBY)-1-Principal_Decalage_Y,largeur - decalage_largeur); Ligne_horizontale_XOR(Min(RAX,RBX)-Principal_Decalage_X,Max(RAY,RBY)-1-Principal_Decalage_Y,Largeur - decalage_largeur);
Ligne_verticale_XOR(Min(RAX,RBX)-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,hauteur-decalage_hauteur); Ligne_verticale_XOR(Min(RAX,RBX)-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,Hauteur-decalage_hauteur);
if (decalage_largeur == 0) // Sinon cette ligne est en dehors de la zone image, inutile de la dessiner if (decalage_largeur == 0) // Sinon cette ligne est en dehors de la zone image, inutile de la dessiner
Ligne_verticale_XOR(Max(RAX,RBX)-1-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,hauteur-decalage_hauteur); Ligne_verticale_XOR(Max(RAX,RBX)-1-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,Hauteur-decalage_hauteur);
UpdateRect(Min(RAX,RBX)-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,largeur+1-decalage_largeur,hauteur+1-decalage_hauteur); UpdateRect(Min(RAX,RBX)-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,Largeur+1-decalage_largeur,Hauteur+1-decalage_hauteur);
// Dessin dans la zone zoomée // Dessin dans la zone zoomée
if(Loupe_Mode && Min(RAX,RBX)<Limite_visible_Droite_Zoom && Max(RAX,RBX)>Limite_Gauche_Zoom && Min(RAY,RBY)<Limite_visible_Bas_Zoom && Max(RAY,RBY)>Limite_Haut_Zoom ) if(Loupe_Mode && Min(RAX,RBX)<Limite_visible_Droite_Zoom && Max(RAX,RBX)>Limite_Gauche_Zoom && Min(RAY,RBY)<Limite_visible_Bas_Zoom && Max(RAY,RBY)>Limite_Haut_Zoom )
@ -4403,22 +4403,22 @@ void Rectangle_Degrade_0_5(void)
if(Max(RAY,RBY)>Limite_visible_Bas_Zoom) // On dépasse du zoom en bas if(Max(RAY,RBY)>Limite_visible_Bas_Zoom) // On dépasse du zoom en bas
decalage_hauteur += Max(RAY,RBY) - Limite_visible_Bas_Zoom; decalage_hauteur += Max(RAY,RBY) - Limite_visible_Bas_Zoom;
if(largeur > decalage_largeur) if(Largeur > decalage_largeur)
{ {
if(decalage_haut==0) // La ligne du haut est visible if(decalage_haut==0) // La ligne du haut est visible
Ligne_horizontale_XOR_Zoom(decalage_gauche>0?decalage_gauche:Min(RAX,RBX),Min(RAY,RBY),largeur-decalage_largeur); Ligne_horizontale_XOR_Zoom(decalage_gauche>0?decalage_gauche:Min(RAX,RBX),Min(RAY,RBY),Largeur-decalage_largeur);
if(Max(RAY,RBY)<Limite_visible_Bas_Zoom) // La ligne du bas est visible if(Max(RAY,RBY)<Limite_visible_Bas_Zoom) // La ligne du bas est visible
Ligne_horizontale_XOR_Zoom(decalage_gauche>0?decalage_gauche:Min(RAX,RBX),Max(RAY,RBY),largeur-decalage_largeur); Ligne_horizontale_XOR_Zoom(decalage_gauche>0?decalage_gauche:Min(RAX,RBX),Max(RAY,RBY),Largeur-decalage_largeur);
} }
if(hauteur>decalage_hauteur) if(Hauteur>decalage_hauteur)
{ {
if(decalage_gauche==0) // La ligne de gauche est visible if(decalage_gauche==0) // La ligne de gauche est visible
Ligne_verticale_XOR_Zoom(Min(RAX,RBX),decalage_haut>0?decalage_haut:Min(RAY,RBY),hauteur-decalage_hauteur); Ligne_verticale_XOR_Zoom(Min(RAX,RBX),decalage_haut>0?decalage_haut:Min(RAY,RBY),Hauteur-decalage_hauteur);
if(Max(RAX,RBX)<Limite_visible_Droite_Zoom) // La ligne de droite est visible if(Max(RAX,RBX)<Limite_visible_Droite_Zoom) // La ligne de droite est visible
Ligne_verticale_XOR_Zoom(Max(RAX,RBX),decalage_haut>0?decalage_haut:Min(RAY,RBY),hauteur-decalage_hauteur); Ligne_verticale_XOR_Zoom(Max(RAX,RBX),decalage_haut>0?decalage_haut:Min(RAY,RBY),Hauteur-decalage_hauteur);
} }
} }
@ -4487,14 +4487,14 @@ void Rectangle_Degrade_12_7(void)
{ {
// Mauvais bouton > anulation de l'opération. // Mauvais bouton > anulation de l'opération.
// On a déjà vidé la pile, il reste à effacer le rectangle XOR // On a déjà vidé la pile, il reste à effacer le rectangle XOR
short largeur, hauteur; short Largeur, Hauteur;
short decalage_largeur = 0; short decalage_largeur = 0;
short decalage_hauteur = 0; short decalage_hauteur = 0;
short decalage_gauche = 0; short decalage_gauche = 0;
short decalage_haut = 0; short decalage_haut = 0;
largeur = abs(RBX-RAX); Largeur = abs(RBX-RAX);
hauteur = abs(RBY-RAY); Hauteur = abs(RBY-RAY);
if (Max(RAX,RBX)-Principal_Decalage_X > Min(Principal_Largeur_image,Loupe_Mode?Principal_Split:Largeur_ecran)) // Tous les clippings à gérer sont là if (Max(RAX,RBX)-Principal_Decalage_X > Min(Principal_Largeur_image,Loupe_Mode?Principal_Split:Largeur_ecran)) // Tous les clippings à gérer sont là
decalage_largeur = Max(RAX,RBX) - Min(Principal_Largeur_image,Loupe_Mode?Principal_Split:Largeur_ecran); decalage_largeur = Max(RAX,RBX) - Min(Principal_Largeur_image,Loupe_Mode?Principal_Split:Largeur_ecran);
@ -4503,15 +4503,15 @@ void Rectangle_Degrade_12_7(void)
decalage_hauteur = Max(RAY,RBY) - Min(Principal_Hauteur_image,Menu_Ordonnee); decalage_hauteur = Max(RAY,RBY) - Min(Principal_Hauteur_image,Menu_Ordonnee);
// Dessin dans la zone de dessin normale // Dessin dans la zone de dessin normale
Ligne_horizontale_XOR(Min(RAX,RBX)-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,largeur - decalage_largeur); Ligne_horizontale_XOR(Min(RAX,RBX)-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,Largeur - decalage_largeur);
if(decalage_hauteur == 0) if(decalage_hauteur == 0)
Ligne_horizontale_XOR(Min(RAX,RBX)-Principal_Decalage_X,Max(RAY,RBY)-1-Principal_Decalage_Y,largeur - decalage_largeur); Ligne_horizontale_XOR(Min(RAX,RBX)-Principal_Decalage_X,Max(RAY,RBY)-1-Principal_Decalage_Y,Largeur - decalage_largeur);
Ligne_verticale_XOR(Min(RAX,RBX)-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,hauteur-decalage_hauteur); Ligne_verticale_XOR(Min(RAX,RBX)-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,Hauteur-decalage_hauteur);
if (decalage_largeur == 0) // Sinon cette ligne est en dehors de la zone image, inutile de la dessiner if (decalage_largeur == 0) // Sinon cette ligne est en dehors de la zone image, inutile de la dessiner
Ligne_verticale_XOR(Max(RAX,RBX)-1-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,hauteur-decalage_hauteur); Ligne_verticale_XOR(Max(RAX,RBX)-1-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,Hauteur-decalage_hauteur);
UpdateRect(Min(RAX,RBX)-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,largeur+1-decalage_largeur,hauteur+1-decalage_hauteur); UpdateRect(Min(RAX,RBX)-Principal_Decalage_X,Min(RAY,RBY)-Principal_Decalage_Y,Largeur+1-decalage_largeur,Hauteur+1-decalage_hauteur);
// Dessin dans la zone zoomée // Dessin dans la zone zoomée
if(Loupe_Mode && Min(RAX,RBX)<Limite_visible_Droite_Zoom && Max(RAX,RBX)>Limite_Gauche_Zoom && Min(RAY,RBY)<Limite_visible_Bas_Zoom && Max(RAY,RBY)>Limite_Haut_Zoom ) if(Loupe_Mode && Min(RAX,RBX)<Limite_visible_Droite_Zoom && Max(RAX,RBX)>Limite_Gauche_Zoom && Min(RAY,RBY)<Limite_visible_Bas_Zoom && Max(RAY,RBY)>Limite_Haut_Zoom )
@ -4537,22 +4537,22 @@ void Rectangle_Degrade_12_7(void)
if(Max(RAY,RBY)>Limite_visible_Bas_Zoom) // On dépasse du zoom en bas if(Max(RAY,RBY)>Limite_visible_Bas_Zoom) // On dépasse du zoom en bas
decalage_hauteur += Max(RAY,RBY) - Limite_visible_Bas_Zoom; decalage_hauteur += Max(RAY,RBY) - Limite_visible_Bas_Zoom;
if(largeur > decalage_largeur) if(Largeur > decalage_largeur)
{ {
if(decalage_haut==0) // La ligne du haut est visible if(decalage_haut==0) // La ligne du haut est visible
Ligne_horizontale_XOR_Zoom(decalage_gauche>0?decalage_gauche:Min(RAX,RBX),Min(RAY,RBY),largeur-decalage_largeur); Ligne_horizontale_XOR_Zoom(decalage_gauche>0?decalage_gauche:Min(RAX,RBX),Min(RAY,RBY),Largeur-decalage_largeur);
if(Max(RAY,RBY)<Limite_visible_Bas_Zoom) // La ligne du bas est visible if(Max(RAY,RBY)<Limite_visible_Bas_Zoom) // La ligne du bas est visible
Ligne_horizontale_XOR_Zoom(decalage_gauche>0?decalage_gauche:Min(RAX,RBX),Max(RAY,RBY),largeur-decalage_largeur); Ligne_horizontale_XOR_Zoom(decalage_gauche>0?decalage_gauche:Min(RAX,RBX),Max(RAY,RBY),Largeur-decalage_largeur);
} }
if(hauteur>decalage_hauteur) if(Hauteur>decalage_hauteur)
{ {
if(decalage_gauche==0) // La ligne de gauche est visible if(decalage_gauche==0) // La ligne de gauche est visible
Ligne_verticale_XOR_Zoom(Min(RAX,RBX),decalage_haut>0?decalage_haut:Min(RAY,RBY),hauteur-decalage_hauteur); Ligne_verticale_XOR_Zoom(Min(RAX,RBX),decalage_haut>0?decalage_haut:Min(RAY,RBY),Hauteur-decalage_hauteur);
if(Max(RAX,RBX)<Limite_visible_Droite_Zoom) // La ligne de droite est visible if(Max(RAX,RBX)<Limite_visible_Droite_Zoom) // La ligne de droite est visible
Ligne_verticale_XOR_Zoom(Max(RAX,RBX),decalage_haut>0?decalage_haut:Min(RAY,RBY),hauteur-decalage_hauteur); Ligne_verticale_XOR_Zoom(Max(RAX,RBX),decalage_haut>0?decalage_haut:Min(RAY,RBY),Hauteur-decalage_hauteur);
} }
} }
} }
@ -4635,14 +4635,14 @@ void Rectangle_Degrade_0_9(void)
{ {
// Vecteur nul > pas de rectangle tracé // Vecteur nul > pas de rectangle tracé
// Du coup on doit effacer la preview xor ... // Du coup on doit effacer la preview xor ...
short largeur, hauteur; short Largeur, Hauteur;
short decalage_largeur = 0; short decalage_largeur = 0;
short decalage_hauteur = 0; short decalage_hauteur = 0;
short decalage_gauche = 0; short decalage_gauche = 0;
short decalage_haut = 0; short decalage_haut = 0;
largeur = abs(Rect_Fin_X-Rect_Debut_X); Largeur = abs(Rect_Fin_X-Rect_Debut_X);
hauteur = abs(Rect_Fin_Y-Rect_Debut_Y); Hauteur = abs(Rect_Fin_Y-Rect_Debut_Y);
if (Max(Rect_Debut_X,Rect_Fin_X)-Principal_Decalage_X > Min(Principal_Largeur_image,Loupe_Mode?Principal_Split:Largeur_ecran)) // Tous les clippings à gérer sont là if (Max(Rect_Debut_X,Rect_Fin_X)-Principal_Decalage_X > Min(Principal_Largeur_image,Loupe_Mode?Principal_Split:Largeur_ecran)) // Tous les clippings à gérer sont là
decalage_largeur = Max(Rect_Debut_X,Rect_Fin_X) - Min(Principal_Largeur_image,Loupe_Mode?Principal_Split:Largeur_ecran); decalage_largeur = Max(Rect_Debut_X,Rect_Fin_X) - Min(Principal_Largeur_image,Loupe_Mode?Principal_Split:Largeur_ecran);
@ -4651,15 +4651,15 @@ void Rectangle_Degrade_0_9(void)
decalage_hauteur = Max(Rect_Debut_Y,Rect_Fin_Y) - Min(Principal_Hauteur_image,Menu_Ordonnee); decalage_hauteur = Max(Rect_Debut_Y,Rect_Fin_Y) - Min(Principal_Hauteur_image,Menu_Ordonnee);
// Dessin dans la zone de dessin normale // Dessin dans la zone de dessin normale
Ligne_horizontale_XOR(Min(Rect_Debut_X,Rect_Fin_X)-Principal_Decalage_X,Min(Rect_Debut_Y,Rect_Fin_Y)-Principal_Decalage_Y,largeur - decalage_largeur); Ligne_horizontale_XOR(Min(Rect_Debut_X,Rect_Fin_X)-Principal_Decalage_X,Min(Rect_Debut_Y,Rect_Fin_Y)-Principal_Decalage_Y,Largeur - decalage_largeur);
if(decalage_hauteur == 0) if(decalage_hauteur == 0)
Ligne_horizontale_XOR(Min(Rect_Debut_X,Rect_Fin_X)-Principal_Decalage_X,Max(Rect_Debut_Y,Rect_Fin_Y)-1-Principal_Decalage_Y,largeur - decalage_largeur); Ligne_horizontale_XOR(Min(Rect_Debut_X,Rect_Fin_X)-Principal_Decalage_X,Max(Rect_Debut_Y,Rect_Fin_Y)-1-Principal_Decalage_Y,Largeur - decalage_largeur);
Ligne_verticale_XOR(Min(Rect_Debut_X,Rect_Fin_X)-Principal_Decalage_X,Min(Rect_Debut_Y,Rect_Fin_Y)-Principal_Decalage_Y,hauteur-decalage_hauteur); Ligne_verticale_XOR(Min(Rect_Debut_X,Rect_Fin_X)-Principal_Decalage_X,Min(Rect_Debut_Y,Rect_Fin_Y)-Principal_Decalage_Y,Hauteur-decalage_hauteur);
if (decalage_largeur == 0) // Sinon cette ligne est en dehors de la zone image, inutile de la dessiner if (decalage_largeur == 0) // Sinon cette ligne est en dehors de la zone image, inutile de la dessiner
Ligne_verticale_XOR(Max(Rect_Debut_X,Rect_Fin_X)-1-Principal_Decalage_X,Min(Rect_Debut_Y,Rect_Fin_Y)-Principal_Decalage_Y,hauteur-decalage_hauteur); Ligne_verticale_XOR(Max(Rect_Debut_X,Rect_Fin_X)-1-Principal_Decalage_X,Min(Rect_Debut_Y,Rect_Fin_Y)-Principal_Decalage_Y,Hauteur-decalage_hauteur);
UpdateRect(Min(Rect_Debut_X,Rect_Fin_X)-Principal_Decalage_X,Min(Rect_Debut_Y,Rect_Fin_Y)-Principal_Decalage_Y,largeur+1-decalage_largeur,hauteur+1-decalage_hauteur); UpdateRect(Min(Rect_Debut_X,Rect_Fin_X)-Principal_Decalage_X,Min(Rect_Debut_Y,Rect_Fin_Y)-Principal_Decalage_Y,Largeur+1-decalage_largeur,Hauteur+1-decalage_hauteur);
// Dessin dans la zone zoomée // Dessin dans la zone zoomée
if(Loupe_Mode && Min(Rect_Debut_X,Rect_Fin_X)<Limite_visible_Droite_Zoom && Max(Rect_Debut_X,Rect_Fin_X)>Limite_Gauche_Zoom && Min(Rect_Debut_Y,Rect_Fin_Y)<Limite_visible_Bas_Zoom && Max(Rect_Debut_Y,Rect_Fin_Y)>Limite_Haut_Zoom ) if(Loupe_Mode && Min(Rect_Debut_X,Rect_Fin_X)<Limite_visible_Droite_Zoom && Max(Rect_Debut_X,Rect_Fin_X)>Limite_Gauche_Zoom && Min(Rect_Debut_Y,Rect_Fin_Y)<Limite_visible_Bas_Zoom && Max(Rect_Debut_Y,Rect_Fin_Y)>Limite_Haut_Zoom )
@ -4685,22 +4685,22 @@ void Rectangle_Degrade_0_9(void)
if(Max(Rect_Debut_Y,Rect_Fin_Y)>Limite_visible_Bas_Zoom) // On dépasse du zoom en bas if(Max(Rect_Debut_Y,Rect_Fin_Y)>Limite_visible_Bas_Zoom) // On dépasse du zoom en bas
decalage_hauteur += Max(Rect_Debut_Y,Rect_Fin_Y) - Limite_visible_Bas_Zoom; decalage_hauteur += Max(Rect_Debut_Y,Rect_Fin_Y) - Limite_visible_Bas_Zoom;
if(largeur > decalage_largeur) if(Largeur > decalage_largeur)
{ {
if(decalage_haut==0) // La ligne du haut est visible if(decalage_haut==0) // La ligne du haut est visible
Ligne_horizontale_XOR_Zoom(decalage_gauche>0?decalage_gauche:Min(Rect_Debut_X,Rect_Fin_X),Min(Rect_Debut_Y,Rect_Fin_Y),largeur-decalage_largeur); Ligne_horizontale_XOR_Zoom(decalage_gauche>0?decalage_gauche:Min(Rect_Debut_X,Rect_Fin_X),Min(Rect_Debut_Y,Rect_Fin_Y),Largeur-decalage_largeur);
if(Max(Rect_Debut_Y,Rect_Fin_Y)<Limite_visible_Bas_Zoom) // La ligne du bas est visible if(Max(Rect_Debut_Y,Rect_Fin_Y)<Limite_visible_Bas_Zoom) // La ligne du bas est visible
Ligne_horizontale_XOR_Zoom(decalage_gauche>0?decalage_gauche:Min(Rect_Debut_X,Rect_Fin_X),Max(Rect_Debut_Y,Rect_Fin_Y),largeur-decalage_largeur); Ligne_horizontale_XOR_Zoom(decalage_gauche>0?decalage_gauche:Min(Rect_Debut_X,Rect_Fin_X),Max(Rect_Debut_Y,Rect_Fin_Y),Largeur-decalage_largeur);
} }
if(hauteur>decalage_hauteur) if(Hauteur>decalage_hauteur)
{ {
if(decalage_gauche==0) // La ligne de gauche est visible if(decalage_gauche==0) // La ligne de gauche est visible
Ligne_verticale_XOR_Zoom(Min(Rect_Debut_X,Rect_Fin_X),decalage_haut>0?decalage_haut:Min(Rect_Debut_Y,Rect_Fin_Y),hauteur-decalage_hauteur); Ligne_verticale_XOR_Zoom(Min(Rect_Debut_X,Rect_Fin_X),decalage_haut>0?decalage_haut:Min(Rect_Debut_Y,Rect_Fin_Y),Hauteur-decalage_hauteur);
if(Max(Rect_Debut_X,Rect_Fin_X)<Limite_visible_Droite_Zoom) // La ligne de droite est visible if(Max(Rect_Debut_X,Rect_Fin_X)<Limite_visible_Droite_Zoom) // La ligne de droite est visible
Ligne_verticale_XOR_Zoom(Max(Rect_Debut_X,Rect_Fin_X),decalage_haut>0?decalage_haut:Min(Rect_Debut_Y,Rect_Fin_Y),hauteur-decalage_hauteur); Ligne_verticale_XOR_Zoom(Max(Rect_Debut_X,Rect_Fin_X),decalage_haut>0?decalage_haut:Min(Rect_Debut_Y,Rect_Fin_Y),Hauteur-decalage_hauteur);
} }
} }
} }

16
pages.c
View File

@ -956,7 +956,7 @@ void Interchanger_image_principale_et_brouillon(void)
} }
int Emprunt_memoire_de_page_possible(int taille) int Emprunt_memoire_de_page_possible(int Taille)
{ {
int Taille_immediatement_disponible; int Taille_immediatement_disponible;
int Taille_liste_courante; int Taille_liste_courante;
@ -976,30 +976,30 @@ int Emprunt_memoire_de_page_possible(int taille)
+Taille_liste_courante +Taille_liste_courante
+Taille_liste_brouillon +Taille_liste_brouillon
-Taille_page_courante -Taille_page_courante
-Taille_page_brouillon)<taille) -Taille_page_brouillon)<Taille)
return 0; return 0;
return 1; return 1;
} }
void * Emprunter_memoire_de_page(int taille) void * Emprunter_memoire_de_page(int Taille)
{ {
int Il_faut_liberer; int Il_faut_liberer;
S_Liste_de_pages * Liste_a_raboter; S_Liste_de_pages * Liste_a_raboter;
S_Page * Page_a_supprimer; S_Page * Page_a_supprimer;
//int Indice; //int Indice;
if (Emprunt_memoire_de_page_possible(taille)) if (Emprunt_memoire_de_page_possible(Taille))
{ {
// On regarde s'il faut libérer des pages: // On regarde s'il faut libérer des pages:
Il_faut_liberer= Il_faut_liberer=
(Memoire_libre()-QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER)<(unsigned long)taille; (Memoire_libre()-QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER)<(unsigned long)Taille;
if (!Il_faut_liberer) if (!Il_faut_liberer)
{ {
// On a assez de place pour allouer une page. On n'a donc aucune page // On a assez de place pour allouer une page. On n'a donc aucune page
// à supprimer. On peut allouer de la mémoire directement. // à supprimer. On peut allouer de la mémoire directement.
return malloc(taille); return malloc(Taille);
} }
else else
{ {
@ -1042,12 +1042,12 @@ void * Emprunter_memoire_de_page(int taille)
// On regarde s'il faut continuer à libérer de la place // On regarde s'il faut continuer à libérer de la place
Il_faut_liberer= Il_faut_liberer=
(Memoire_libre()-QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER)<(unsigned long)taille; (Memoire_libre()-QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER)<(unsigned long)Taille;
// S'il ne faut pas, c'est qu'on peut allouer un bitmap // S'il ne faut pas, c'est qu'on peut allouer un bitmap
// pour la Nouvelle_page // pour la Nouvelle_page
if (!Il_faut_liberer) if (!Il_faut_liberer)
return malloc(taille); return malloc(Taille);
} }
} }
} }

4
pages.h
View File

@ -83,8 +83,8 @@ void Interchanger_image_principale_et_brouillon(void);
/// GESTION DES EMPRUNTS DE MEMOIRE DE PAGE /// GESTION DES EMPRUNTS DE MEMOIRE DE PAGE
/// ///
int Emprunt_memoire_de_page_possible(int taille); int Emprunt_memoire_de_page_possible(int Taille);
void * Emprunter_memoire_de_page(int taille); void * Emprunter_memoire_de_page(int Taille);

14
pxdouble.c
View File

@ -106,19 +106,19 @@ void Pixel_Preview_Loupe_Double (word X,word Y,byte Couleur)
&& X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom) && X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom)
{ {
// On est dedans // On est dedans
int hauteur; int Hauteur;
int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y]; int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y];
if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur) if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur)
// On ne doit dessiner qu'un morceau du pixel // On ne doit dessiner qu'un morceau du pixel
// sinon on dépasse sur le menu // sinon on dépasse sur le menu
hauteur = Menu_Ordonnee - Y_Zoom; Hauteur = Menu_Ordonnee - Y_Zoom;
else else
hauteur = Loupe_Facteur; Hauteur = Loupe_Facteur;
Block_Double( Block_Double(
Table_mul_facteur_zoom[X-Loupe_Decalage_X]+Principal_X_Zoom, Table_mul_facteur_zoom[X-Loupe_Decalage_X]+Principal_X_Zoom,
Y_Zoom, Loupe_Facteur, hauteur, Couleur Y_Zoom, Loupe_Facteur, Hauteur, Couleur
); );
} }
} }
@ -128,10 +128,10 @@ void Ligne_horizontale_XOR_Double(word Pos_X,word Pos_Y,word Largeur)
//On calcule la valeur initiale de Dest: //On calcule la valeur initiale de Dest:
byte* Dest=Pos_Y*4*Largeur_ecran+Pos_X*2+Ecran; byte* Dest=Pos_Y*4*Largeur_ecran+Pos_X*2+Ecran;
int ecx; int X;
for (ecx=0;ecx<Largeur*2;ecx+=2) for (X=0;X<Largeur*2;X+=2)
*(Dest+ecx+2*Largeur_ecran+1)=*(Dest+ecx+2*Largeur_ecran)=*(Dest+ecx+1)=*(Dest+ecx)=~*(Dest+ecx); *(Dest+X+2*Largeur_ecran+1)=*(Dest+X+2*Largeur_ecran)=*(Dest+X+1)=*(Dest+X)=~*(Dest+X);
} }
void Ligne_verticale_XOR_Double(word Pos_X,word Pos_Y,word Hauteur) void Ligne_verticale_XOR_Double(word Pos_X,word Pos_Y,word Hauteur)

20
pxsimple.c
View File

@ -91,19 +91,19 @@ void Pixel_Preview_Loupe_Simple (word X,word Y,byte Couleur)
&& X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom) && X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom)
{ {
// On est dedans // On est dedans
int hauteur; int Hauteur;
int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y]; int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y];
if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur) if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur)
// On ne doit dessiner qu'un morceau du pixel // On ne doit dessiner qu'un morceau du pixel
// sinon on dépasse sur le menu // sinon on dépasse sur le menu
hauteur = Menu_Ordonnee - Y_Zoom; Hauteur = Menu_Ordonnee - Y_Zoom;
else else
hauteur = Loupe_Facteur; Hauteur = Loupe_Facteur;
Block_Simple( Block_Simple(
Table_mul_facteur_zoom[X-Loupe_Decalage_X]+Principal_X_Zoom, Table_mul_facteur_zoom[X-Loupe_Decalage_X]+Principal_X_Zoom,
Y_Zoom, Loupe_Facteur, hauteur, Couleur Y_Zoom, Loupe_Facteur, Hauteur, Couleur
); );
} }
} }
@ -113,20 +113,20 @@ void Ligne_horizontale_XOR_Simple(word Pos_X,word Pos_Y,word Largeur)
//On calcule la valeur initiale de Dest: //On calcule la valeur initiale de Dest:
byte* Dest=Pos_Y*Largeur_ecran+Pos_X+Ecran; byte* Dest=Pos_Y*Largeur_ecran+Pos_X+Ecran;
int ecx; int X;
for (ecx=0;ecx<Largeur;ecx++) for (X=0;X<Largeur;X++)
*(Dest+ecx)=~*(Dest+ecx); *(Dest+X)=~*(Dest+X);
} }
void Ligne_verticale_XOR_Simple(word Pos_X,word Pos_Y,word Hauteur) void Ligne_verticale_XOR_Simple(word Pos_X,word Pos_Y,word Hauteur)
{ {
int i; int i;
byte color; byte Color;
for (i=Pos_Y;i<Pos_Y+Hauteur;i++) for (i=Pos_Y;i<Pos_Y+Hauteur;i++)
{ {
color=*(Ecran+Pos_X+i*Largeur_ecran); Color=*(Ecran+Pos_X+i*Largeur_ecran);
*(Ecran+Pos_X+i*Largeur_ecran)=~color; *(Ecran+Pos_X+i*Largeur_ecran)=~Color;
} }
} }

24
pxtall.c
View File

@ -95,19 +95,19 @@ void Pixel_Preview_Loupe_Tall (word X,word Y,byte Couleur)
&& X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom) && X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom)
{ {
// On est dedans // On est dedans
int hauteur; int Hauteur;
int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y]; int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y];
if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur) if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur)
// On ne doit dessiner qu'un morceau du pixel // On ne doit dessiner qu'un morceau du pixel
// sinon on dépasse sur le menu // sinon on dépasse sur le menu
hauteur = Menu_Ordonnee - Y_Zoom; Hauteur = Menu_Ordonnee - Y_Zoom;
else else
hauteur = Loupe_Facteur; Hauteur = Loupe_Facteur;
Block_Tall( Block_Tall(
Table_mul_facteur_zoom[X-Loupe_Decalage_X]+Principal_X_Zoom, Table_mul_facteur_zoom[X-Loupe_Decalage_X]+Principal_X_Zoom,
Y_Zoom, Loupe_Facteur, hauteur, Couleur Y_Zoom, Loupe_Facteur, Hauteur, Couleur
); );
} }
} }
@ -117,24 +117,24 @@ void Ligne_horizontale_XOR_Tall(word Pos_X,word Pos_Y,word Largeur)
//On calcule la valeur initiale de Dest: //On calcule la valeur initiale de Dest:
byte* Dest=Pos_Y*2*Largeur_ecran+Pos_X+Ecran; byte* Dest=Pos_Y*2*Largeur_ecran+Pos_X+Ecran;
int ecx; int X;
for (ecx=0;ecx<Largeur;ecx++) for (X=0;X<Largeur;X++)
*(Dest+ecx)=~*(Dest+ecx); *(Dest+X)=~*(Dest+X);
Dest=(Pos_Y*2+1)*Largeur_ecran+Pos_X+Ecran; Dest=(Pos_Y*2+1)*Largeur_ecran+Pos_X+Ecran;
for (ecx=0;ecx<Largeur;ecx++) for (X=0;X<Largeur;X++)
*(Dest+ecx)=~*(Dest+ecx); *(Dest+X)=~*(Dest+X);
} }
void Ligne_verticale_XOR_Tall(word Pos_X,word Pos_Y,word Hauteur) void Ligne_verticale_XOR_Tall(word Pos_X,word Pos_Y,word Hauteur)
{ {
int i; int i;
byte color; byte Color;
for (i=Pos_Y*2;i<(Pos_Y+Hauteur)*2;i++) for (i=Pos_Y*2;i<(Pos_Y+Hauteur)*2;i++)
{ {
color=*(Ecran+Pos_X+i*Largeur_ecran); Color=*(Ecran+Pos_X+i*Largeur_ecran);
*(Ecran+Pos_X+i*Largeur_ecran)=~color; *(Ecran+Pos_X+i*Largeur_ecran)=~Color;
} }
} }

22
pxwide.c
View File

@ -98,19 +98,19 @@ void Pixel_Preview_Loupe_Wide (word X,word Y,byte Couleur)
&& X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom) && X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom)
{ {
// On est dedans // On est dedans
int hauteur; int Hauteur;
int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y]; int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y];
if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur) if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur)
// On ne doit dessiner qu'un morceau du pixel // On ne doit dessiner qu'un morceau du pixel
// sinon on dépasse sur le menu // sinon on dépasse sur le menu
hauteur = Menu_Ordonnee - Y_Zoom; Hauteur = Menu_Ordonnee - Y_Zoom;
else else
hauteur = Loupe_Facteur; Hauteur = Loupe_Facteur;
Block_Wide( Block_Wide(
Table_mul_facteur_zoom[X-Loupe_Decalage_X]+Principal_X_Zoom, Table_mul_facteur_zoom[X-Loupe_Decalage_X]+Principal_X_Zoom,
Y_Zoom, Loupe_Facteur, hauteur, Couleur Y_Zoom, Loupe_Facteur, Hauteur, Couleur
); );
} }
} }
@ -120,22 +120,22 @@ void Ligne_horizontale_XOR_Wide(word Pos_X,word Pos_Y,word Largeur)
//On calcule la valeur initiale de Dest: //On calcule la valeur initiale de Dest:
byte* Dest=Pos_Y*2*Largeur_ecran+Pos_X*2+Ecran; byte* Dest=Pos_Y*2*Largeur_ecran+Pos_X*2+Ecran;
int ecx; int X;
for (ecx=0;ecx<Largeur*2;ecx+=2) for (X=0;X<Largeur*2;X+=2)
*(Dest+ecx+1)=*(Dest+ecx)=~*(Dest+ecx); *(Dest+X+1)=*(Dest+X)=~*(Dest+X);
} }
void Ligne_verticale_XOR_Wide(word Pos_X,word Pos_Y,word Hauteur) void Ligne_verticale_XOR_Wide(word Pos_X,word Pos_Y,word Hauteur)
{ {
int i; int i;
byte color; byte Color;
byte *Dest=Ecran+Pos_X*2+Pos_Y*Largeur_ecran*2; byte *Dest=Ecran+Pos_X*2+Pos_Y*Largeur_ecran*2;
for (i=Hauteur;i>0;i--) for (i=Hauteur;i>0;i--)
{ {
color=~*Dest; Color=~*Dest;
*Dest=color; *Dest=Color;
*(Dest+1)=color; *(Dest+1)=Color;
Dest+=Largeur_ecran*2; Dest+=Largeur_ecran*2;
} }
} }

6
struct.h
View File

@ -141,9 +141,9 @@ typedef struct Element_de_liste_de_fileselect
} Element_de_liste_de_fileselect; } Element_de_liste_de_fileselect;
typedef struct { typedef struct {
char type; char Line_type;
char * texte; char * Text;
int valeur; int Line_parameter;
} T_TABLEAIDE; } T_TABLEAIDE;
// Déclaration d'une section d'aide: // Déclaration d'une section d'aide:

BIN
translat/translations.xls
View File

Binary file not shown.