more code cleanup to prepare translation
git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@676 416bcca6-2ee7-4201-b75f-2eb2f807beb1
This commit is contained in:
Yves Rizoud
parent
5883853be4
commit
ecafeaace1
16
aide.c
16
aide.c
@ -271,16 +271,16 @@ void Afficher_aide(void)
|
||||
break;
|
||||
}
|
||||
// On affiche la ligne
|
||||
Ligne = Table_d_aide[Section_d_aide_en_cours].Table_aide[Ligne_de_depart + Indice_de_ligne].texte;
|
||||
TypeLigne = Table_d_aide[Section_d_aide_en_cours].Table_aide[Ligne_de_depart + Indice_de_ligne].type;
|
||||
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].Line_type;
|
||||
// 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))
|
||||
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')
|
||||
{
|
||||
const char *Lien;
|
||||
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);
|
||||
snprintf(Buffer, 44, Ligne, Lien);
|
||||
if (strlen(Ligne)+Taille_lien-2>44)
|
||||
@ -416,8 +416,8 @@ void Fenetre_aide(int Section, const char *Sous_section)
|
||||
{
|
||||
int Indice=0;
|
||||
for (Indice=0; Indice<Nb_lignes; Indice++)
|
||||
if (Table_d_aide[Section_d_aide_en_cours].Table_aide[Indice].type == 'T' &&
|
||||
!strcmp(Table_d_aide[Section_d_aide_en_cours].Table_aide[Indice].texte, Sous_section))
|
||||
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].Text, Sous_section))
|
||||
{
|
||||
Position_d_aide_en_cours = Indice;
|
||||
break;
|
||||
@ -469,10 +469,10 @@ void Fenetre_aide(int Section, const char *Sous_section)
|
||||
{
|
||||
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':
|
||||
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;
|
||||
// Ici on peut gérer un cas 'lien hypertexte'
|
||||
default:
|
||||
|
||||
10
divers.c
10
divers.c
@ -599,14 +599,14 @@ void Zoomer_une_ligne(byte* Ligne_originale, byte* Ligne_zoomee,
|
||||
word Facteur, word Largeur
|
||||
)
|
||||
{
|
||||
byte couleur;
|
||||
word larg;
|
||||
byte Color;
|
||||
word X;
|
||||
|
||||
// Pour chaque pixel
|
||||
for(larg=0;larg<Largeur;larg++){
|
||||
couleur = *Ligne_originale;
|
||||
for(X=0;X<Largeur;X++){
|
||||
Color = *Ligne_originale;
|
||||
|
||||
memset(Ligne_zoomee,couleur,Facteur);
|
||||
memset(Ligne_zoomee,Color,Facteur);
|
||||
Ligne_zoomee+=Facteur;
|
||||
|
||||
Ligne_originale++;
|
||||
|
||||
103
init.c
103
init.c
@ -74,110 +74,7 @@
|
||||
#if defined(__amigaos4__) || defined(__AROS__) || defined(__MORPHOS__)
|
||||
void bstrtostr( BSTR in, STRPTR out, TEXT max );
|
||||
#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
|
||||
void Chercher_bas(SDL_Surface *GUI, int *Debut_X, int *Debut_Y, byte Couleur_neutre,char * Section)
|
||||
{
|
||||
|
||||
102
loadsave.c
102
loadsave.c
@ -249,15 +249,15 @@ fonction_afficheur_24b Pixel_Chargement_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)
|
||||
{
|
||||
int indice;
|
||||
int index;
|
||||
|
||||
if ((Pos_X>=0) && (Pos_Y>=0))
|
||||
if ((Pos_X<Principal_Largeur_image) && (Pos_Y<Principal_Hauteur_image))
|
||||
{
|
||||
indice=(Pos_Y*Principal_Largeur_image)+Pos_X;
|
||||
Buffer_image_24b[indice].R=R;
|
||||
Buffer_image_24b[indice].V=V;
|
||||
Buffer_image_24b[indice].B=B;
|
||||
index=(Pos_Y*Principal_Largeur_image)+Pos_X;
|
||||
Buffer_image_24b[index].R=R;
|
||||
Buffer_image_24b[index].V=V;
|
||||
Buffer_image_24b[index].B=B;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1347,7 +1347,7 @@ void Save_PKM(void)
|
||||
Init_ecriture();
|
||||
|
||||
// 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)
|
||||
{
|
||||
Ecrire_octet(Fichier,0);
|
||||
@ -3721,15 +3721,15 @@ void Load_PCX(void)
|
||||
if (read_byte(Fichier,&Octet1))
|
||||
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
|
||||
for(indice=0;indice<256;indice++)
|
||||
if ( ! read_byte(Fichier,&Principal_Palette[indice].R)
|
||||
|| ! read_byte(Fichier,&Principal_Palette[indice].V)
|
||||
|| ! read_byte(Fichier,&Principal_Palette[indice].B) )
|
||||
for(index=0;index<256;index++)
|
||||
if ( ! read_byte(Fichier,&Principal_Palette[index].R)
|
||||
|| ! read_byte(Fichier,&Principal_Palette[index].V)
|
||||
|| ! read_byte(Fichier,&Principal_Palette[index].B) )
|
||||
{
|
||||
Erreur_fichier=2;
|
||||
DEBUG("ERROR READING PCX PALETTE !",indice);
|
||||
DEBUG("ERROR READING PCX PALETTE !",index);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -4835,10 +4835,10 @@ void Save_SCx(void)
|
||||
void PI1_8b_to_16p(byte * Src,byte * Dst)
|
||||
{
|
||||
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
|
||||
|
||||
masque=0x8000;
|
||||
Mask=0x8000;
|
||||
w0=(((word)Src[0])<<8) | Src[1];
|
||||
w1=(((word)Src[2])<<8) | Src[3];
|
||||
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
|
||||
// correspondant à celui du masque
|
||||
|
||||
Dst[i]=((w0 & masque)?0x01:0x00) |
|
||||
((w1 & masque)?0x02:0x00) |
|
||||
((w2 & masque)?0x04:0x00) |
|
||||
((w3 & masque)?0x08:0x00);
|
||||
masque>>=1;
|
||||
Dst[i]=((w0 & Mask)?0x01:0x00) |
|
||||
((w1 & Mask)?0x02:0x00) |
|
||||
((w2 & Mask)?0x04:0x00) |
|
||||
((w3 & Mask)?0x08:0x00);
|
||||
Mask>>=1;
|
||||
}
|
||||
}
|
||||
|
||||
@ -4861,21 +4861,21 @@ void PI1_8b_to_16p(byte * Src,byte * Dst)
|
||||
void PI1_16p_to_8b(byte * Src,byte * Dst)
|
||||
{
|
||||
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
|
||||
|
||||
masque=0x8000;
|
||||
Mask=0x8000;
|
||||
w0=w1=w2=w3=0;
|
||||
for (i=0;i<16;i++)
|
||||
{
|
||||
// Pour coder le pixel n°i, il faut modifier les 4 words sur leur bit
|
||||
// correspondant à celui du masque
|
||||
|
||||
w0|=(Src[i] & 0x01)?masque:0x00;
|
||||
w1|=(Src[i] & 0x02)?masque:0x00;
|
||||
w2|=(Src[i] & 0x04)?masque:0x00;
|
||||
w3|=(Src[i] & 0x08)?masque:0x00;
|
||||
masque>>=1;
|
||||
w0|=(Src[i] & 0x01)?Mask:0x00;
|
||||
w1|=(Src[i] & 0x02)?Mask:0x00;
|
||||
w2|=(Src[i] & 0x04)?Mask:0x00;
|
||||
w3|=(Src[i] & 0x08)?Mask:0x00;
|
||||
Mask>>=1;
|
||||
}
|
||||
Dst[0]=w0 >> 8;
|
||||
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 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
|
||||
|
||||
ip=0;
|
||||
@ -5224,14 +5224,14 @@ void PC1_4pb_to_1lp(byte * Src0,byte * Src1,byte * Src2,byte * Src3,byte * Dst)
|
||||
b2=Src2[i];
|
||||
b3=Src3[i];
|
||||
// Pour chacun des 8 bits des octets
|
||||
masque=0x80;
|
||||
Mask=0x80;
|
||||
for (j=0;j<8;j++)
|
||||
{
|
||||
Dst[ip++]=((b0 & masque)?0x01:0x00) |
|
||||
((b1 & masque)?0x02:0x00) |
|
||||
((b2 & masque)?0x04:0x00) |
|
||||
((b3 & masque)?0x08:0x00);
|
||||
masque>>=1;
|
||||
Dst[ip++]=((b0 & Mask)?0x01:0x00) |
|
||||
((b1 & Mask)?0x02:0x00) |
|
||||
((b2 & Mask)?0x04:0x00) |
|
||||
((b3 & Mask)?0x08:0x00);
|
||||
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 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
|
||||
|
||||
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++)
|
||||
{
|
||||
// Pour chacun des 8 bits des octets
|
||||
masque=0x80;
|
||||
Mask=0x80;
|
||||
b0=b1=b2=b3=0;
|
||||
for (j=0;j<8;j++)
|
||||
{
|
||||
b0|=(Src[ip] & 0x01)?masque:0x00;
|
||||
b1|=(Src[ip] & 0x02)?masque:0x00;
|
||||
b2|=(Src[ip] & 0x04)?masque:0x00;
|
||||
b3|=(Src[ip] & 0x08)?masque:0x00;
|
||||
b0|=(Src[ip] & 0x01)?Mask:0x00;
|
||||
b1|=(Src[ip] & 0x02)?Mask:0x00;
|
||||
b2|=(Src[ip] & 0x04)?Mask:0x00;
|
||||
b3|=(Src[ip] & 0x08)?Mask:0x00;
|
||||
ip++;
|
||||
masque>>=1;
|
||||
Mask>>=1;
|
||||
}
|
||||
Dst0[i]=b0;
|
||||
Dst1[i]=b1;
|
||||
@ -5463,7 +5463,7 @@ void Load_RAW_24B(int Largeur,int Hauteur,Bitmap24B Source)
|
||||
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;
|
||||
struct
|
||||
@ -5484,13 +5484,13 @@ void Load_TGA(char * nom,Bitmap24B * dest,int * larg,int * haut)
|
||||
int x,y,py,skip,t;
|
||||
byte * buffer;
|
||||
|
||||
fichier=fopen(nom,"rb");
|
||||
fichier=fopen(Nom,"rb");
|
||||
read_bytes(fichier,&TGA_Header,sizeof(TGA_Header));
|
||||
if (TGA_Header.Image_type_code==2)
|
||||
{
|
||||
*larg=TGA_Header.Width;
|
||||
*haut=TGA_Header.Height;
|
||||
*dest=(Bitmap24B)malloc((*larg)*(*haut)*3);
|
||||
*Largeur=TGA_Header.Width;
|
||||
*Hauteur=TGA_Header.Height;
|
||||
*dest=(Bitmap24B)malloc((*Largeur)*(*Hauteur)*3);
|
||||
|
||||
// On saute l'ID field
|
||||
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);
|
||||
|
||||
// Lecture des pixels
|
||||
skip=(*larg);
|
||||
skip=(*Largeur);
|
||||
if (TGA_Header.Pixel_size==16)
|
||||
skip*=2;
|
||||
else
|
||||
@ -5524,12 +5524,12 @@ void Load_TGA(char * nom,Bitmap24B * dest,int * larg,int * haut)
|
||||
skip*=4;
|
||||
|
||||
buffer=(byte *)malloc(skip);
|
||||
for (y=0;y<(*haut);y++)
|
||||
for (y=0;y<(*Hauteur);y++)
|
||||
{
|
||||
read_bytes(fichier,buffer,skip);
|
||||
|
||||
// Inversion du rouge et du bleu
|
||||
for (x=0;x<(*larg);x++)
|
||||
for (x=0;x<(*Largeur);x++)
|
||||
{
|
||||
t=buffer[(x*3)+0];
|
||||
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)
|
||||
py=y;
|
||||
else
|
||||
py=(*haut)-y-1;
|
||||
py=(*Hauteur)-y-1;
|
||||
|
||||
// Prise en compte de l'interleave verticale
|
||||
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);
|
||||
}
|
||||
|
||||
178
op_c.c
178
op_c.c
@ -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 * n;
|
||||
int taille;
|
||||
int Taille;
|
||||
|
||||
n=(Table_conversion *)malloc(sizeof(Table_conversion));
|
||||
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;
|
||||
|
||||
// On tente d'allouer la table
|
||||
taille=(n->rng_r)*(n->rng_v)*(n->rng_b);
|
||||
n->table=(byte *)malloc(taille);
|
||||
Taille=(n->rng_r)*(n->rng_v)*(n->rng_b);
|
||||
n->table=(byte *)malloc(Taille);
|
||||
if (n->table!=NULL)
|
||||
// C'est bon!
|
||||
memset(n->table,0,taille); // Inutile, mais plus propre
|
||||
memset(n->table,0,Taille); // Inutile, mais plus propre
|
||||
else
|
||||
{
|
||||
// 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)
|
||||
{
|
||||
int indice;
|
||||
int index;
|
||||
|
||||
// On réduit le nombre de bits par couleur
|
||||
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);
|
||||
|
||||
// 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)
|
||||
{
|
||||
int indice;
|
||||
int index;
|
||||
|
||||
indice=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
|
||||
t->table[indice]=i;
|
||||
index=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
|
||||
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)
|
||||
{
|
||||
int taille;
|
||||
int Taille;
|
||||
|
||||
taille=(t->rng_r)*(t->rng_v)*(t->rng_b)*sizeof(int);
|
||||
memset(t->table,0,taille); // On initialise … 0
|
||||
Taille=(t->rng_r)*(t->rng_v)*(t->rng_b)*sizeof(int);
|
||||
memset(t->table,0,Taille); // On initialise … 0
|
||||
}
|
||||
|
||||
Table_occurence * TO_New(int nbb_r,int nbb_v,int nbb_b)
|
||||
{
|
||||
Table_occurence * n;
|
||||
int taille;
|
||||
int Taille;
|
||||
|
||||
n=(Table_occurence *)malloc(sizeof(Table_occurence));
|
||||
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;
|
||||
|
||||
// On tente d'allouer la table
|
||||
taille=(n->rng_r)*(n->rng_v)*(n->rng_b)*sizeof(int);
|
||||
n->table=(int *)malloc(taille);
|
||||
Taille=(n->rng_r)*(n->rng_v)*(n->rng_b)*sizeof(int);
|
||||
n->table=(int *)malloc(Taille);
|
||||
if (n->table!=0)
|
||||
// C'est bon! On initialise … 0
|
||||
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 indice;
|
||||
int index;
|
||||
|
||||
indice=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
|
||||
return t->table[indice];
|
||||
index=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
|
||||
return t->table[index];
|
||||
}
|
||||
|
||||
void TO_Set(Table_occurence * t,int r,int v,int b,int i)
|
||||
{
|
||||
int indice;
|
||||
int index;
|
||||
|
||||
r=(r>>t->red_r);
|
||||
v=(v>>t->red_v);
|
||||
b=(b>>t->red_b);
|
||||
indice=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
|
||||
t->table[indice]=i;
|
||||
index=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
|
||||
t->table[index]=i;
|
||||
}
|
||||
|
||||
void TO_Inc(Table_occurence * t,int r,int v,int b)
|
||||
{
|
||||
int indice;
|
||||
int index;
|
||||
|
||||
r=(r>>t->red_r);
|
||||
v=(v>>t->red_v);
|
||||
b=(b>>t->red_b);
|
||||
indice=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
|
||||
t->table[indice]++;
|
||||
index=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
|
||||
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;
|
||||
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);
|
||||
}
|
||||
|
||||
@ -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 r,v,b;
|
||||
|
||||
limite=(c->occurences)/2;
|
||||
limit=(c->occurences)/2;
|
||||
cumul=0;
|
||||
if (teinte==0)
|
||||
if (Teinte==0)
|
||||
{
|
||||
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++)
|
||||
{
|
||||
cumul+=to->table[r + v + b];
|
||||
if (cumul>=limite)
|
||||
if (cumul>=limit)
|
||||
break;
|
||||
}
|
||||
if (cumul>=limite)
|
||||
if (cumul>=limit)
|
||||
break;
|
||||
}
|
||||
if (cumul>=limite)
|
||||
if (cumul>=limit)
|
||||
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;
|
||||
}
|
||||
else
|
||||
if (teinte==1)
|
||||
if (Teinte==1)
|
||||
{
|
||||
|
||||
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++)
|
||||
{
|
||||
cumul+=to->table[r + v + b];
|
||||
if (cumul>=limite)
|
||||
if (cumul>=limit)
|
||||
break;
|
||||
}
|
||||
if (cumul>=limite)
|
||||
if (cumul>=limit)
|
||||
break;
|
||||
}
|
||||
if (cumul>=limite)
|
||||
if (cumul>=limit)
|
||||
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)
|
||||
{
|
||||
cumul+=to->table[r + v + b];
|
||||
if (cumul>=limite)
|
||||
if (cumul>=limit)
|
||||
break;
|
||||
}
|
||||
if (cumul>=limite)
|
||||
if (cumul>=limit)
|
||||
break;
|
||||
}
|
||||
if (cumul>=limite)
|
||||
if (cumul>=limit)
|
||||
break;
|
||||
}
|
||||
|
||||
@ -693,7 +693,7 @@ ClusterSet * CS_New(int nbmax,Table_occurence * to)
|
||||
// On recopie les paramŠtres demand‚s
|
||||
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)
|
||||
{
|
||||
n->nbmax=nbmax;
|
||||
@ -723,35 +723,35 @@ void CS_Delete(ClusterSet * cs)
|
||||
|
||||
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
|
||||
// différentes sur l'une des composantes
|
||||
for (indice=0;indice<cs->nb;indice++)
|
||||
if ( (cs->clusters[indice].rmin<cs->clusters[indice].rmax) ||
|
||||
(cs->clusters[indice].vmin<cs->clusters[indice].vmax) ||
|
||||
(cs->clusters[indice].bmin<cs->clusters[indice].bmax) )
|
||||
for (index=0;index<cs->nb;index++)
|
||||
if ( (cs->clusters[index].rmin<cs->clusters[index].rmax) ||
|
||||
(cs->clusters[index].vmin<cs->clusters[index].vmax) ||
|
||||
(cs->clusters[index].bmin<cs->clusters[index].bmax) )
|
||||
break;
|
||||
|
||||
// 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
|
||||
// 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 ...
|
||||
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)
|
||||
{
|
||||
int indice;
|
||||
int index;
|
||||
// int decalage;
|
||||
|
||||
// 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
|
||||
for (indice=0;indice<cs->nb;indice++)
|
||||
if (cs->clusters[indice].occurences<c->occurences)
|
||||
for (index=0;index<cs->nb;index++)
|
||||
if (cs->clusters[index].occurences<c->occurences)
|
||||
/*
|
||||
if (((OPTPAL_Cluster[index].rmax-OPTPAL_Cluster[index].rmin+1)*
|
||||
(OPTPAL_Cluster[index].gmax-OPTPAL_Cluster[index].gmin+1)*
|
||||
@ -764,18 +764,18 @@ void CS_Set(ClusterSet * cs,Cluster * c)
|
||||
*/
|
||||
break;
|
||||
|
||||
if (indice<cs->nb)
|
||||
if (index<cs->nb)
|
||||
{
|
||||
// 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
|
||||
// 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));
|
||||
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++;
|
||||
}
|
||||
|
||||
@ -815,10 +815,10 @@ void CS_Generer(ClusterSet * cs,Table_occurence * to)
|
||||
|
||||
void CS_Calculer_teintes(ClusterSet * cs,Table_occurence * to)
|
||||
{
|
||||
int indice;
|
||||
int index;
|
||||
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);
|
||||
}
|
||||
|
||||
@ -892,19 +892,19 @@ void CS_Trier_par_luminance(ClusterSet * cs)
|
||||
|
||||
void CS_Generer_TC_et_Palette(ClusterSet * cs,Table_conversion * tc,Composantes * palette)
|
||||
{
|
||||
int indice;
|
||||
int index;
|
||||
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[indice].V=cs->clusters[indice].v;
|
||||
palette[indice].B=cs->clusters[indice].b;
|
||||
palette[index].R=cs->clusters[index].r;
|
||||
palette[index].V=cs->clusters[index].v;
|
||||
palette[index].B=cs->clusters[index].b;
|
||||
|
||||
for (r=cs->clusters[indice].Rmin;r<=cs->clusters[indice].Rmax;r++)
|
||||
for (v=cs->clusters[indice].Vmin;v<=cs->clusters[indice].Vmax;v++)
|
||||
for (b=cs->clusters[indice].Bmin;b<=cs->clusters[indice].Bmax;b++)
|
||||
TC_Set(tc,r,v,b,indice);
|
||||
for (r=cs->clusters[index].Rmin;r<=cs->clusters[index].Rmax;r++)
|
||||
for (v=cs->clusters[index].Vmin;v<=cs->clusters[index].Vmax;v++)
|
||||
for (b=cs->clusters[index].Bmin;b<=cs->clusters[index].Bmax;b++)
|
||||
TC_Set(tc,r,v,b,index);
|
||||
}
|
||||
}
|
||||
|
||||
@ -956,7 +956,7 @@ void DS_Delete(DegradeSet * ds)
|
||||
|
||||
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 mdiff; // Meilleure diff‚rence de chrominance
|
||||
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_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
|
||||
TO_Compter_occurences(to,image,taille);
|
||||
TO_Compter_occurences(to,image,Taille);
|
||||
|
||||
cs=CS_New(256,to);
|
||||
if (cs!=0)
|
||||
@ -1070,21 +1070,21 @@ Table_conversion * Optimiser_palette(Bitmap24B image,int taille,Composantes * pa
|
||||
return 0;
|
||||
}
|
||||
|
||||
int Valeur_modifiee(int valeur,int modif)
|
||||
int Valeur_modifiee(int Valeur,int modif)
|
||||
{
|
||||
valeur+=modif;
|
||||
if (valeur<0)
|
||||
Valeur+=modif;
|
||||
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
|
||||
// s'en ressert pas, soit on passe à la fonction une copie de travail du
|
||||
// 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:
|
||||
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
|
||||
S_moins1=Suivant-1; // Le pixel en bas à gauche
|
||||
S_plus1 =Suivant+1; // Le pixel en bas à droite
|
||||
D =Dest;
|
||||
|
||||
// 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
|
||||
// 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;
|
||||
EVert =(Vert *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]
|
||||
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 );
|
||||
}
|
||||
// En bas à gauche:
|
||||
if (Pos_Y+1<hauteur)
|
||||
if (Pos_Y+1<Hauteur)
|
||||
{
|
||||
ERouge=(Rouge*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->B=Valeur_modifiee(Suivant->B,EBleu );
|
||||
// En bas à droite:
|
||||
if (Pos_X+1<largeur)
|
||||
if (Pos_X+1<Largeur)
|
||||
{
|
||||
ERouge=(Rouge/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.
|
||||
|
||||
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
|
||||
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
|
||||
// meilleure précision possible
|
||||
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]);
|
||||
if (table!=0)
|
||||
break;
|
||||
@ -1220,7 +1220,7 @@ int Convert_bitmap_24B_to_256(Bitmap256 Dest,Bitmap24B Source,int largeur,int ha
|
||||
|
||||
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);
|
||||
return 0;
|
||||
}
|
||||
|
||||
6
op_c.h
6
op_c.h
@ -161,7 +161,7 @@ void TO_Delete(Table_occurence * t);
|
||||
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_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_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);
|
||||
|
||||
|
||||
@ -201,7 +201,7 @@ void DS_Generer(DegradeSet * ds,ClusterSet * cs);
|
||||
|
||||
// Convertie avec le plus de précision possible une image 24b en 256c
|
||||
// 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
84
operatio.c
@ -4342,7 +4342,7 @@ void Rectangle_Degrade_0_5(void)
|
||||
short RAX;
|
||||
short RAY;
|
||||
short RBX;
|
||||
short RBY, largeur,hauteur;
|
||||
short RBY, Largeur,Hauteur;
|
||||
short decalage_largeur = 0;
|
||||
short decalage_hauteur = 0;
|
||||
short decalage_gauche = 0;
|
||||
@ -4359,8 +4359,8 @@ void Rectangle_Degrade_0_5(void)
|
||||
Pinceau_Y = RAY;
|
||||
Effacer_curseur();
|
||||
|
||||
largeur = abs(RBX-RAX);
|
||||
hauteur = abs(RBY-RAY);
|
||||
Largeur = abs(RBX-RAX);
|
||||
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à
|
||||
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);
|
||||
|
||||
// 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)
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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.
|
||||
// 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_hauteur = 0;
|
||||
short decalage_gauche = 0;
|
||||
short decalage_haut = 0;
|
||||
|
||||
largeur = abs(RBX-RAX);
|
||||
hauteur = abs(RBY-RAY);
|
||||
Largeur = abs(RBX-RAX);
|
||||
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à
|
||||
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);
|
||||
|
||||
// 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)
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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é
|
||||
// Du coup on doit effacer la preview xor ...
|
||||
short largeur, hauteur;
|
||||
short Largeur, Hauteur;
|
||||
short decalage_largeur = 0;
|
||||
short decalage_hauteur = 0;
|
||||
short decalage_gauche = 0;
|
||||
short decalage_haut = 0;
|
||||
|
||||
largeur = abs(Rect_Fin_X-Rect_Debut_X);
|
||||
hauteur = abs(Rect_Fin_Y-Rect_Debut_Y);
|
||||
Largeur = abs(Rect_Fin_X-Rect_Debut_X);
|
||||
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à
|
||||
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);
|
||||
|
||||
// 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)
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
16
pages.c
@ -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_liste_courante;
|
||||
@ -976,30 +976,30 @@ int Emprunt_memoire_de_page_possible(int taille)
|
||||
+Taille_liste_courante
|
||||
+Taille_liste_brouillon
|
||||
-Taille_page_courante
|
||||
-Taille_page_brouillon)<taille)
|
||||
-Taille_page_brouillon)<Taille)
|
||||
return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void * Emprunter_memoire_de_page(int taille)
|
||||
void * Emprunter_memoire_de_page(int Taille)
|
||||
{
|
||||
int Il_faut_liberer;
|
||||
S_Liste_de_pages * Liste_a_raboter;
|
||||
S_Page * Page_a_supprimer;
|
||||
//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:
|
||||
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)
|
||||
{
|
||||
// On a assez de place pour allouer une page. On n'a donc aucune page
|
||||
// à supprimer. On peut allouer de la mémoire directement.
|
||||
return malloc(taille);
|
||||
return malloc(Taille);
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -1042,12 +1042,12 @@ void * Emprunter_memoire_de_page(int taille)
|
||||
|
||||
// On regarde s'il faut continuer à libérer de la place
|
||||
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
|
||||
// pour la Nouvelle_page
|
||||
if (!Il_faut_liberer)
|
||||
return malloc(taille);
|
||||
return malloc(Taille);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
4
pages.h
4
pages.h
@ -83,8 +83,8 @@ void Interchanger_image_principale_et_brouillon(void);
|
||||
/// GESTION DES EMPRUNTS DE MEMOIRE DE PAGE
|
||||
///
|
||||
|
||||
int Emprunt_memoire_de_page_possible(int taille);
|
||||
void * Emprunter_memoire_de_page(int taille);
|
||||
int Emprunt_memoire_de_page_possible(int Taille);
|
||||
void * Emprunter_memoire_de_page(int Taille);
|
||||
|
||||
|
||||
|
||||
|
||||
14
pxdouble.c
14
pxdouble.c
@ -106,19 +106,19 @@ void Pixel_Preview_Loupe_Double (word X,word Y,byte Couleur)
|
||||
&& X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom)
|
||||
{
|
||||
// On est dedans
|
||||
int hauteur;
|
||||
int Hauteur;
|
||||
int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y];
|
||||
|
||||
if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur)
|
||||
// On ne doit dessiner qu'un morceau du pixel
|
||||
// sinon on dépasse sur le menu
|
||||
hauteur = Menu_Ordonnee - Y_Zoom;
|
||||
Hauteur = Menu_Ordonnee - Y_Zoom;
|
||||
else
|
||||
hauteur = Loupe_Facteur;
|
||||
Hauteur = Loupe_Facteur;
|
||||
|
||||
Block_Double(
|
||||
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:
|
||||
byte* Dest=Pos_Y*4*Largeur_ecran+Pos_X*2+Ecran;
|
||||
|
||||
int ecx;
|
||||
int X;
|
||||
|
||||
for (ecx=0;ecx<Largeur*2;ecx+=2)
|
||||
*(Dest+ecx+2*Largeur_ecran+1)=*(Dest+ecx+2*Largeur_ecran)=*(Dest+ecx+1)=*(Dest+ecx)=~*(Dest+ecx);
|
||||
for (X=0;X<Largeur*2;X+=2)
|
||||
*(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)
|
||||
|
||||
20
pxsimple.c
20
pxsimple.c
@ -91,19 +91,19 @@ void Pixel_Preview_Loupe_Simple (word X,word Y,byte Couleur)
|
||||
&& X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom)
|
||||
{
|
||||
// On est dedans
|
||||
int hauteur;
|
||||
int Hauteur;
|
||||
int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y];
|
||||
|
||||
if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur)
|
||||
// On ne doit dessiner qu'un morceau du pixel
|
||||
// sinon on dépasse sur le menu
|
||||
hauteur = Menu_Ordonnee - Y_Zoom;
|
||||
Hauteur = Menu_Ordonnee - Y_Zoom;
|
||||
else
|
||||
hauteur = Loupe_Facteur;
|
||||
Hauteur = Loupe_Facteur;
|
||||
|
||||
Block_Simple(
|
||||
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:
|
||||
byte* Dest=Pos_Y*Largeur_ecran+Pos_X+Ecran;
|
||||
|
||||
int ecx;
|
||||
int X;
|
||||
|
||||
for (ecx=0;ecx<Largeur;ecx++)
|
||||
*(Dest+ecx)=~*(Dest+ecx);
|
||||
for (X=0;X<Largeur;X++)
|
||||
*(Dest+X)=~*(Dest+X);
|
||||
}
|
||||
|
||||
void Ligne_verticale_XOR_Simple(word Pos_X,word Pos_Y,word Hauteur)
|
||||
{
|
||||
int i;
|
||||
byte color;
|
||||
byte Color;
|
||||
for (i=Pos_Y;i<Pos_Y+Hauteur;i++)
|
||||
{
|
||||
color=*(Ecran+Pos_X+i*Largeur_ecran);
|
||||
*(Ecran+Pos_X+i*Largeur_ecran)=~color;
|
||||
Color=*(Ecran+Pos_X+i*Largeur_ecran);
|
||||
*(Ecran+Pos_X+i*Largeur_ecran)=~Color;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
24
pxtall.c
24
pxtall.c
@ -95,19 +95,19 @@ void Pixel_Preview_Loupe_Tall (word X,word Y,byte Couleur)
|
||||
&& X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom)
|
||||
{
|
||||
// On est dedans
|
||||
int hauteur;
|
||||
int Hauteur;
|
||||
int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y];
|
||||
|
||||
if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur)
|
||||
// On ne doit dessiner qu'un morceau du pixel
|
||||
// sinon on dépasse sur le menu
|
||||
hauteur = Menu_Ordonnee - Y_Zoom;
|
||||
Hauteur = Menu_Ordonnee - Y_Zoom;
|
||||
else
|
||||
hauteur = Loupe_Facteur;
|
||||
Hauteur = Loupe_Facteur;
|
||||
|
||||
Block_Tall(
|
||||
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:
|
||||
byte* Dest=Pos_Y*2*Largeur_ecran+Pos_X+Ecran;
|
||||
|
||||
int ecx;
|
||||
int X;
|
||||
|
||||
for (ecx=0;ecx<Largeur;ecx++)
|
||||
*(Dest+ecx)=~*(Dest+ecx);
|
||||
for (X=0;X<Largeur;X++)
|
||||
*(Dest+X)=~*(Dest+X);
|
||||
|
||||
Dest=(Pos_Y*2+1)*Largeur_ecran+Pos_X+Ecran;
|
||||
for (ecx=0;ecx<Largeur;ecx++)
|
||||
*(Dest+ecx)=~*(Dest+ecx);
|
||||
for (X=0;X<Largeur;X++)
|
||||
*(Dest+X)=~*(Dest+X);
|
||||
}
|
||||
|
||||
void Ligne_verticale_XOR_Tall(word Pos_X,word Pos_Y,word Hauteur)
|
||||
{
|
||||
int i;
|
||||
byte color;
|
||||
byte Color;
|
||||
for (i=Pos_Y*2;i<(Pos_Y+Hauteur)*2;i++)
|
||||
{
|
||||
color=*(Ecran+Pos_X+i*Largeur_ecran);
|
||||
*(Ecran+Pos_X+i*Largeur_ecran)=~color;
|
||||
Color=*(Ecran+Pos_X+i*Largeur_ecran);
|
||||
*(Ecran+Pos_X+i*Largeur_ecran)=~Color;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
22
pxwide.c
22
pxwide.c
@ -98,19 +98,19 @@ void Pixel_Preview_Loupe_Wide (word X,word Y,byte Couleur)
|
||||
&& X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom)
|
||||
{
|
||||
// On est dedans
|
||||
int hauteur;
|
||||
int Hauteur;
|
||||
int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y];
|
||||
|
||||
if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur)
|
||||
// On ne doit dessiner qu'un morceau du pixel
|
||||
// sinon on dépasse sur le menu
|
||||
hauteur = Menu_Ordonnee - Y_Zoom;
|
||||
Hauteur = Menu_Ordonnee - Y_Zoom;
|
||||
else
|
||||
hauteur = Loupe_Facteur;
|
||||
Hauteur = Loupe_Facteur;
|
||||
|
||||
Block_Wide(
|
||||
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:
|
||||
byte* Dest=Pos_Y*2*Largeur_ecran+Pos_X*2+Ecran;
|
||||
|
||||
int ecx;
|
||||
int X;
|
||||
|
||||
for (ecx=0;ecx<Largeur*2;ecx+=2)
|
||||
*(Dest+ecx+1)=*(Dest+ecx)=~*(Dest+ecx);
|
||||
for (X=0;X<Largeur*2;X+=2)
|
||||
*(Dest+X+1)=*(Dest+X)=~*(Dest+X);
|
||||
}
|
||||
|
||||
void Ligne_verticale_XOR_Wide(word Pos_X,word Pos_Y,word Hauteur)
|
||||
{
|
||||
int i;
|
||||
byte color;
|
||||
byte Color;
|
||||
byte *Dest=Ecran+Pos_X*2+Pos_Y*Largeur_ecran*2;
|
||||
for (i=Hauteur;i>0;i--)
|
||||
{
|
||||
color=~*Dest;
|
||||
*Dest=color;
|
||||
*(Dest+1)=color;
|
||||
Color=~*Dest;
|
||||
*Dest=Color;
|
||||
*(Dest+1)=Color;
|
||||
Dest+=Largeur_ecran*2;
|
||||
}
|
||||
}
|
||||
|
||||
6
struct.h
6
struct.h
@ -141,9 +141,9 @@ typedef struct Element_de_liste_de_fileselect
|
||||
} Element_de_liste_de_fileselect;
|
||||
|
||||
typedef struct {
|
||||
char type;
|
||||
char * texte;
|
||||
int valeur;
|
||||
char Line_type;
|
||||
char * Text;
|
||||
int Line_parameter;
|
||||
} T_TABLEAIDE;
|
||||
|
||||
// Déclaration d'une section d'aide:
|
||||
|
||||
Binary file not shown.
Loading…
x
Reference in New Issue
Block a user