m/grafX2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
grafX2/palette.c
Yves Rizoud 09ba984aa6 On all screens that display a palette, the grey columns are no longer "dead", you can 
click them to pick the color to its right.
Added help text for HSL mode in Palette, and Grad rectangle
Fixed display of colored rectangles in Palette screen (issue 64)
Fixed more missing refreshes in the Palette screen
Fixed wrong shortcuts in Palette screen
Removed an obsolete message ("Sensibilite Souris") and dead code


git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@370 416bcca6-2ee7-4201-b75f-2eb2f807beb1
2008-12-04 21:44:59 +00:00

2102 lines
80 KiB
C
Raw Blame History

/* Grafx2 - The Ultimate 256-color bitmap paint program
Copyright 2007 Adrien Destugues
Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud)
Grafx2 is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2
of the License.
Grafx2 is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Grafx2; if not, see <http://www.gnu.org/licenses/> or
write to the Free Software Foundation, Inc.,
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "const.h"
#include "struct.h"
#include "global.h"
#include "divers.h"
#include "graph.h"
#include "moteur.h"
#include "readline.h"
#include "boutons.h"
#include "pages.h"
#include "aide.h"
#include "sdlscreen.h"
#include "erreurs.h"
#include "op_c.h"
byte Palette_mode_RGB = 1; // Indique si on est en HSL ou en RGB
// --------------------------- Menu des palettes -----------------------------
char * Libelle_reduction_palette[7]=
{
"128"," 64"," 32"," 16"," 8"," 4"," 2"
};
// Nombre de graduations pour une composante RGB
const int Graduations_RGB =256; // 24bit
//const int Graduations_RGB = 64; // VGA
//const int Graduations_RGB = 16; // Amiga
//const int Graduations_RGB = 3; // Amstrad CPC
// Nombre de graduations pour une composante dans le mode actuel
int Color_Count;
// Les composantes vont de 0 à (Color_Count-1)
int Color_Max;
// Le demi-pas est une quantité que l'on ajoute à une composante
// avant de faire un arrondi par division.
int Color_DemiPas;
// Définir les unités pour les graduationss R G B ou H S V
void Unite_Composantes(int Count)
{
Color_Count = Count;
Color_Max = Count-1;
Color_DemiPas = 256/Count/2;
}
void Modifier_HSL(T_Palette Palette_depart, T_Palette Palette_arrivee, byte Couleur, short Difference_H, short Difference_S, short Difference_L)
{
byte H, S, L;
RGBtoHSL(Palette_depart[Couleur].R,Palette_depart[Couleur].V,Palette_depart[Couleur].B,&H,&S,&L);
// La teinte (Hue) est cyclique
H=(Difference_H+256+H);
// Pour les autres (Saturation, Lightness), au lieu d'additionner,
// on va faire un ratio, cela utilise mieux la plage de valeurs 0-255
if (Difference_S<0)
S=(255+Difference_S)*S/255;
else if (Difference_S>0)
S=255-(255-Difference_S)*(255-S)/255;
if (Difference_L<0)
L=(255+Difference_L)*L/255;
else if (Difference_L>0)
L=255-(255-Difference_L)*(255-L)/255;
HSLtoRGB(H,S,L,&Palette_arrivee[Couleur].R,&Palette_arrivee[Couleur].V,&Palette_arrivee[Couleur].B);
}
void Modifier_Rouge(byte Couleur, short Nouvelle_teinte, T_Palette Palette)
{
if (Nouvelle_teinte< 0)
Nouvelle_teinte= 0;
if (Nouvelle_teinte>255)
Nouvelle_teinte=255;
// Arrondi
Nouvelle_teinte=255*((Nouvelle_teinte+Color_DemiPas)*Color_Max/255)/Color_Max;
Palette[Couleur].R=Nouvelle_teinte;
Set_color(Couleur,Palette[Couleur].R,Palette[Couleur].V,Palette[Couleur].B);
}
void Modifier_Vert(byte Couleur, short Nouvelle_teinte, T_Palette Palette)
{
if (Nouvelle_teinte< 0)
Nouvelle_teinte= 0;
if (Nouvelle_teinte>255)
Nouvelle_teinte=255;
// Arrondi
Nouvelle_teinte=255*((Nouvelle_teinte+Color_DemiPas)*Color_Max/255)/Color_Max;
Palette[Couleur].V=Nouvelle_teinte;
Set_color(Couleur,Palette[Couleur].R,Palette[Couleur].V,Palette[Couleur].B);
}
void Modifier_Bleu(byte Couleur, short Nouvelle_teinte, T_Palette Palette)
{
if (Nouvelle_teinte< 0)
Nouvelle_teinte= 0;
if (Nouvelle_teinte>255)
Nouvelle_teinte=255;
// Arrondi
Nouvelle_teinte=255*((Nouvelle_teinte+Color_DemiPas)*Color_Max/255)/Color_Max;
Palette[Couleur].B=Nouvelle_teinte;
Set_color(Couleur,Palette[Couleur].R,Palette[Couleur].V,Palette[Couleur].B);
}
void Formate_composante(byte Valeur, char *Chaine)
// Formate une chaine de 4 caractères+\0 : "nnn "
{
Num2str(Valeur,Chaine,3);
Chaine[3]=' ';
Chaine[4]='\0';
}
void Degrader_palette(short Debut,short Fin,T_Palette Palette)
// Modifie la palette pour obtenir un dégradé de couleur entre les deux bornes
// passées en paramètre
{
short Debut_Rouge;
short Debut_Vert;
short Debut_Bleu;
short Fin_Rouge;
short Fin_Vert;
short Fin_Bleu;
short Indice;
// On vérifie qu'il y ait assez de couleurs entre le début et la fin pour
// pouvoir faire un dégradé:
if ( (Debut!=Fin) && (Debut+1!=Fin) )
{
Debut_Rouge=Palette[Debut].R;
Debut_Vert =Palette[Debut].V;
Debut_Bleu =Palette[Debut].B;
Fin_Rouge =Palette[Fin ].R;
Fin_Vert =Palette[Fin ].V;
Fin_Bleu =Palette[Fin ].B;
for (Indice=Debut+1;Indice<Fin;Indice++)
{
Modifier_Rouge(Indice, ((Fin_Rouge-Debut_Rouge) * (Indice-Debut))/(Fin-Debut) + Debut_Rouge,Palette);
Modifier_Vert (Indice, ((Fin_Vert -Debut_Vert ) * (Indice-Debut))/(Fin-Debut) + Debut_Vert ,Palette);
Modifier_Bleu (Indice, ((Fin_Bleu -Debut_Bleu ) * (Indice-Debut))/(Fin-Debut) + Debut_Bleu ,Palette);
}
}
}
void Compter_nb_couleurs_utilisees(short * Nb_couleurs_utilisees, dword * Utilisation_couleur)
{
char Chaine[10];
Effacer_curseur();
Forme_curseur=FORME_CURSEUR_SABLIER;
Afficher_curseur();
*Nb_couleurs_utilisees=Palette_Compter_nb_couleurs_utilisees(Utilisation_couleur);
strcpy(Chaine,"Used: ");
Num2str(*Nb_couleurs_utilisees,Chaine+6,3);
Effacer_curseur();
Fenetre_Dessiner_bouton_normal(132,20,83,14,Chaine,4,1);
Forme_curseur=FORME_CURSEUR_FLECHE;
Afficher_curseur();
}
void Remap_zone_HIGH(short X1, short Y1, short X2, short Y2,
byte * Table_de_conversion)
// Attention: Remappe une zone de coins X1,Y1 et X2-1,Y2-1 !!!
{
short Pos_X;
short Pos_Y;
for (Pos_Y=Y1;Pos_Y<Y2;Pos_Y++)
for (Pos_X=X1;Pos_X<X2;Pos_X++)
{
if ((Pos_Y>=Fenetre_Pos_Y) && (Pos_Y<Fenetre_Pos_Y+(Fenetre_Hauteur*Menu_Facteur_Y)) &&
(Pos_X>=Fenetre_Pos_X) && (Pos_X<Fenetre_Pos_X+(Fenetre_Largeur*Menu_Facteur_X)) )
Pos_X=Fenetre_Pos_X+(Fenetre_Largeur*Menu_Facteur_X)-1;
else
Pixel(Pos_X,Pos_Y,Table_de_conversion[Lit_pixel(Pos_X,Pos_Y)]);
}
}
void Remap_image_HIGH(byte * Table_de_conversion)
{
short Fin_X;
short Fin_Y;
short Fin_X_Loupe=0;
short Fin_Y_Loupe=0;
// On s'occupe de faire la traduction dans l'image
Remap_general_LOWLEVEL(Table_de_conversion,Principal_Ecran,
Principal_Largeur_image,Principal_Hauteur_image,Principal_Largeur_image);
// On calcule les limites à l'écran de l'image
if (Principal_Hauteur_image>=Menu_Ordonnee_avant_fenetre)
Fin_Y=Menu_Ordonnee_avant_fenetre;
else
Fin_Y=Principal_Hauteur_image;
if (!Loupe_Mode)
{
if (Principal_Largeur_image>=Largeur_ecran)
Fin_X=Largeur_ecran;
else
Fin_X=Principal_Largeur_image;
}
else
{
if (Principal_Largeur_image>=Principal_Split)
Fin_X=Principal_Split;
else
Fin_X=Principal_Largeur_image;
if ((Principal_X_Zoom+(Principal_Largeur_image*Loupe_Facteur))>=Largeur_ecran)
Fin_X_Loupe=Largeur_ecran;
else
Fin_X_Loupe=(Principal_X_Zoom+(Principal_Largeur_image*Loupe_Facteur));
if (Principal_Hauteur_image*Loupe_Facteur>=Menu_Ordonnee_avant_fenetre)
Fin_Y_Loupe=Menu_Ordonnee_avant_fenetre;
else
Fin_Y_Loupe=Principal_Hauteur_image*Loupe_Facteur;
}
// On doit maintenant faire la traduction à l'écran
Remap_zone_HIGH(0,0,Fin_X,Fin_Y,Table_de_conversion);
if (Loupe_Mode)
{
Remap_zone_HIGH(Principal_Split,0,Fin_X_Loupe,Fin_Y_Loupe,Table_de_conversion);
// Il peut encore rester le bas de la barre de split à remapper si la
// partie zoomée ne descend pas jusqu'en bas...
Remap_zone_HIGH(Principal_Split,Fin_Y_Loupe,
(Principal_Split+(LARGEUR_BARRE_SPLIT*Menu_Facteur_X)),
Menu_Ordonnee_avant_fenetre,Table_de_conversion);
}
// Remappe tous les fonds de fenetre (qui doivent contenir un bout d'écran)
Remappe_fond_fenetres(Table_de_conversion, 0, Menu_Ordonnee_avant_fenetre);
}
void Swap(int X_Swap,short Debut_Bloc_1,short Debut_Bloc_2,short Taille_du_bloc,T_Palette Palette, dword * Utilisation_couleur)
{
short Pos_1;
short Pos_2;
short Fin_1;
short Fin_2;
dword Tempo;
byte Table_de_conversion[256];
struct Composantes Palette_temporaire[256];
dword Utilisation_temporaire[256];
// On fait une copie de la palette
memcpy(Palette_temporaire, Palette, sizeof(T_Palette));
// On fait une copie de la table d'utilisation des couleurs
memcpy(Utilisation_temporaire, Utilisation_couleur, sizeof(dword) * 256);
// On commence à initialiser la table de conversion à un état où elle ne
// fera aucune conversion.
for (Pos_1=0;Pos_1<=255;Pos_1++)
Table_de_conversion[Pos_1]=Pos_1;
// On calcul les dernières couleurs de chaque bloc.
Fin_1=Debut_Bloc_1+Taille_du_bloc-1;
Fin_2=Debut_Bloc_2+Taille_du_bloc-1;
if ((Debut_Bloc_2>=Debut_Bloc_1) && (Debut_Bloc_2<=Fin_1))
{
// Le bloc destination commence dans le bloc source.
for (Pos_1=Debut_Bloc_1,Pos_2=Fin_1+1;Pos_1<=Fin_2;Pos_1++)
{
// Il faut transformer la couleur Pos_1 en Pos_2:
Table_de_conversion[Pos_2]=Pos_1;
Utilisation_couleur[Pos_1]=Utilisation_temporaire[Pos_2];
Palette[Pos_1].R=Palette_temporaire[Pos_2].R;
Palette[Pos_1].V=Palette_temporaire[Pos_2].V;
Palette[Pos_1].B=Palette_temporaire[Pos_2].B;
// On gère la mise à jour de Pos_2
if (Pos_2==Fin_2)
Pos_2=Debut_Bloc_1;
else
Pos_2++;
}
}
else
if ((Debut_Bloc_2<Debut_Bloc_1) && (Fin_2>=Debut_Bloc_1))
{
// Le bloc destination déborde dans le bloc source.
for (Pos_1=Debut_Bloc_2,Pos_2=Debut_Bloc_1;Pos_1<=Fin_1;Pos_1++)
{
// Il faut transformer la couleur Pos_1 en Pos_2:
Table_de_conversion[Pos_2]=Pos_1;
Utilisation_couleur[Pos_1]=Utilisation_temporaire[Pos_2];
Palette[Pos_1].R=Palette_temporaire[Pos_2].R;
Palette[Pos_1].V=Palette_temporaire[Pos_2].V;
Palette[Pos_1].B=Palette_temporaire[Pos_2].B;
// On gère la mise à jour de Pos_2
if (Pos_2==Fin_1)
Pos_2=Debut_Bloc_2;
else
Pos_2++;
}
}
else
{
// Le bloc source et le bloc destination sont distincts.
for (Pos_1=Debut_Bloc_1,Pos_2=Debut_Bloc_2;Pos_1<=Fin_1;Pos_1++,Pos_2++)
{
// Il va falloir permutter la couleur Pos_1 avec la couleur Pos_2
Table_de_conversion[Pos_1]=Pos_2;
Table_de_conversion[Pos_2]=Pos_1;
// On intervertit le nombre d'utilisation des couleurs pour garder une
// cohérence lors d'un éventuel "Zap unused".
Tempo =Utilisation_couleur[Pos_1];
Utilisation_couleur[Pos_1]=Utilisation_couleur[Pos_2];
Utilisation_couleur[Pos_2]=Tempo;
// On fait un changement de teinte:
Tempo =Palette[Pos_1].R;
Palette[Pos_1].R=Palette[Pos_2].R;
Palette[Pos_2].R=Tempo;
Tempo =Palette[Pos_1].V;
Palette[Pos_1].V=Palette[Pos_2].V;
Palette[Pos_2].V=Tempo;
Tempo =Palette[Pos_1].B;
Palette[Pos_1].B=Palette[Pos_2].B;
Palette[Pos_2].B=Tempo;
}
}
if (X_Swap)
{
Remap_image_HIGH(Table_de_conversion);
}
}
void Remettre_proprement_les_couleurs_du_menu(dword * Utilisation_couleur)
{
short Indice,Indice2;
byte Couleur;
byte Table_de_remplacement[256];
struct Composantes RVB[4];
short Nouvelles[4]={255,254,253,252};
// On initialise la table de remplacement
for (Indice=0; Indice<256; Indice++)
Table_de_remplacement[Indice]=Indice;
// On recherche les 4 couleurs les moins utilisées dans l'image pour pouvoir
// les remplacer par les nouvelles couleurs.
for (Indice2=0; Indice2<4; Indice2++)
for (Indice=255; Indice>=0; Indice--)
{
if ((Indice!=Nouvelles[0]) && (Indice!=Nouvelles[1])
&& (Indice!=Nouvelles[2]) && (Indice!=Nouvelles[3])
&& (Utilisation_couleur[Indice]<Utilisation_couleur[Nouvelles[Indice2]]))
Nouvelles[Indice2]=Indice;
}
// On trie maintenant la table dans le sens décroissant.
// (Ce n'est pas indispensable, mais ça fera plus joli dans la palette).
do
{
Couleur=0; // Booléen qui dit si le tri n'est pas terminé.
for (Indice=0; Indice<3; Indice++)
{
if (Nouvelles[Indice]>Nouvelles[Indice+1])
{
Indice2 =Nouvelles[Indice];
Nouvelles[Indice] =Nouvelles[Indice+1];
Nouvelles[Indice+1]=Indice2;
Couleur=1;
}
}
} while (Couleur);
// On sauvegarde dans RVB les teintes qu'on va remplacer et on met les
// couleurs du menu par défaut
for (Indice=0; Indice<4; Indice++)
{
Couleur=Nouvelles[Indice];
RVB[Indice].R=Principal_Palette[Couleur].R;
RVB[Indice].V=Principal_Palette[Couleur].V;
RVB[Indice].B=Principal_Palette[Couleur].B;
Principal_Palette[Couleur].R=Coul_menu_pref[Indice].R;
Principal_Palette[Couleur].V=Coul_menu_pref[Indice].V;
Principal_Palette[Couleur].B=Coul_menu_pref[Indice].B;
}
// Maintenant qu'on a placé notre nouvelle palette, on va chercher quelles
// sont les couleurs qui peuvent remplacer les anciennes
Effacer_curseur();
for (Indice=0; Indice<4; Indice++)
Table_de_remplacement[Nouvelles[Indice]]=Meilleure_couleur_sans_exclusion
(RVB[Indice].R,RVB[Indice].V,RVB[Indice].B);
// On fait un changement des couleurs visibles à l'écran et dans l'image
Remap_image_HIGH(Table_de_remplacement);
Afficher_curseur();
}
void Reduce_palette(short * Nb_couleurs_utilisees,int Nb_couleurs_demandees,T_Palette Palette,dword * Utilisation_couleur)
{
char Chaine[5]; // Buffer d'affichage du compteur
byte Table_de_conversion[256]; // Table de conversion
int Couleur_1; // |_ Variables de balayages
int Couleur_2; // | de la palette
int Meilleure_couleur_1=0;
int Meilleure_couleur_2=0;
int Difference;
int Meilleure_difference;
dword Utilisation;
dword Meilleure_utilisation;
// On commence par initialiser la table de conversion dans un état où
// aucune conversion ne sera effectuée.
for (Couleur_1=0; Couleur_1<=255; Couleur_1++)
Table_de_conversion[Couleur_1]=Couleur_1;
// Si on ne connait pas encore le nombre de couleurs utilisées, on le
// calcule! (!!! La fonction appelée Efface puis Affiche le curseur !!!)
if ((*Nb_couleurs_utilisees)<0)
Compter_nb_couleurs_utilisees(Nb_couleurs_utilisees,Utilisation_couleur);
Effacer_curseur();
// On tasse la palette vers le début parce qu'elle doit ressembler à
// du Gruyère (et comme Papouille il aime pas le fromage...)
// Pour cela, on va scruter la couleur Couleur_1 et se servir de l'indice
// Couleur_2 comme position de destination.
for (Couleur_1=Couleur_2=0;Couleur_1<=255;Couleur_1++)
{
if (Utilisation_couleur[Couleur_1])
{
// On commence par s'occuper des teintes de la palette
Palette[Couleur_2].R=Palette[Couleur_1].R;
Palette[Couleur_2].V=Palette[Couleur_1].V;
Palette[Couleur_2].B=Palette[Couleur_1].B;
// Ensuite, on met à jour le tableau d'occupation des couleurs.
Utilisation_couleur[Couleur_2]=Utilisation_couleur[Couleur_1];
// On va maintenant s'occuper de la table de conversion:
Table_de_conversion[Couleur_1]=Couleur_2;
// Maintenant, la place désignée par Couleur_2 est occupée, alors on
// doit passer à un indice de destination suivant.
Couleur_2++;
}
}
// On met toutes les couleurs inutilisées en noir
for (;Couleur_2<256;Couleur_2++)
{
Palette[Couleur_2].R=0;
Palette[Couleur_2].V=0;
Palette[Couleur_2].B=0;
Utilisation_couleur[Couleur_2]=0;
}
// Maintenant qu'on a une palette clean, on va boucler en réduisant
// le nombre de couleurs jusqu'à ce qu'on atteigne le nombre désiré.
while ((*Nb_couleurs_utilisees)>Nb_couleurs_demandees)
{
// Il s'agit de trouver les 2 couleurs qui se ressemblent le plus
// parmis celles qui sont utilisées (bien sûr) et de les remplacer par
// une seule couleur qui est la moyenne pondérée de ces 2 couleurs
// en fonction de leur utilisation dans l'image.
Meilleure_difference =0x7FFF;
Meilleure_utilisation=0x7FFFFFFF;
for (Couleur_1=0;Couleur_1<(*Nb_couleurs_utilisees);Couleur_1++)
for (Couleur_2=Couleur_1+1;Couleur_2<(*Nb_couleurs_utilisees);Couleur_2++)
if (Couleur_1!=Couleur_2)
{
Difference =abs((short)Palette[Couleur_1].R-Palette[Couleur_2].R)+
abs((short)Palette[Couleur_1].V-Palette[Couleur_2].V)+
abs((short)Palette[Couleur_1].B-Palette[Couleur_2].B);
if (Difference<=Meilleure_difference)
{
Utilisation=Utilisation_couleur[Couleur_1]+Utilisation_couleur[Couleur_2];
if ((Difference<Meilleure_difference) || (Utilisation<Meilleure_utilisation))
{
Meilleure_difference =Difference;
Meilleure_utilisation=Utilisation;
Meilleure_couleur_1 =Couleur_1;
Meilleure_couleur_2 =Couleur_2;
}
}
}
// Maintenant qu'on les a trouvées, on va pouvoir mettre à jour nos
// données pour que le remplacement se fasse sans encombres.
// En somme, on va remplacer Meilleure_couleur_2 par Meilleure_couleur_1,
// mais attention, on ne remplace pas Meilleure_couleur_1 par
// Meilleure_couleur_2 !
// On met à jour la palette.
Palette[Meilleure_couleur_1].R=Round_div((Utilisation_couleur[Meilleure_couleur_1]*Palette[Meilleure_couleur_1].R)+
(Utilisation_couleur[Meilleure_couleur_2]*Palette[Meilleure_couleur_2].R),
Meilleure_utilisation);
Palette[Meilleure_couleur_1].V=Round_div((Utilisation_couleur[Meilleure_couleur_1]*Palette[Meilleure_couleur_1].V)+
(Utilisation_couleur[Meilleure_couleur_2]*Palette[Meilleure_couleur_2].V),
Meilleure_utilisation);
Palette[Meilleure_couleur_1].B=Round_div((Utilisation_couleur[Meilleure_couleur_1]*Palette[Meilleure_couleur_1].B)+
(Utilisation_couleur[Meilleure_couleur_2]*Palette[Meilleure_couleur_2].B),
Meilleure_utilisation);
// On met à jour la table d'utilisation.
Utilisation_couleur[Meilleure_couleur_1]+=Utilisation_couleur[Meilleure_couleur_2];
Utilisation_couleur[Meilleure_couleur_2]=0;
// On met à jour la table de conversion.
for (Couleur_1=0;Couleur_1<=255;Couleur_1++)
{
if (Table_de_conversion[Couleur_1]==Meilleure_couleur_2)
{
// La Couleur_1 avait déjà prévue de se faire remplacer par la
// couleur que l'on veut maintenant éliminer. On va maintenant
// demander à ce que la Couleur_1 se fasse remplacer par la
// Meilleure_couleur_1.
Table_de_conversion[Couleur_1]=Meilleure_couleur_1;
}
}
// Bon, maintenant que l'on a fait bouger nos petites choses concernants
// la couleur à éliminer, on va s'occuper de faire bouger les couleurs
// situées après la couleur à éliminer pour qu'elles se déplaçent d'une
// couleur en arrière.
for (Couleur_1=0;Couleur_1<=255;Couleur_1++)
{
// Commençons par nous occuper des tables d'utilisation et de la
// palette.
if (Couleur_1>Meilleure_couleur_2)
{
// La Couleur_1 va scroller en arrière.
// Donc on transfère son utilisation dans l'utilisation de la
// couleur qui la précède.
Utilisation_couleur[Couleur_1-1]=Utilisation_couleur[Couleur_1];
// Et on transfère ses teintes dans les teintes de la couleur qui
// la précède.
Palette[Couleur_1-1].R=Palette[Couleur_1].R;
Palette[Couleur_1-1].V=Palette[Couleur_1].V;
Palette[Couleur_1-1].B=Palette[Couleur_1].B;
}
// Une fois la palette et la table d'utilisation gérées, on peut
// s'occuper de notre table de conversion.
if (Table_de_conversion[Couleur_1]>Meilleure_couleur_2)
// La Couleur_1 avait l'intention de se faire remplacer par une
// couleur que l'on va (ou que l'on a déjà) bouger en arrière.
Table_de_conversion[Couleur_1]--;
}
// On vient d'éjecter une couleur, donc on peut mettre à jour le nombre
// de couleurs utilisées.
(*Nb_couleurs_utilisees)--;
// A la fin, on doit passer (dans la palette) les teintes du dernier
// élément de notre ensemble en noir.
Palette[*Nb_couleurs_utilisees].R=0;
Palette[*Nb_couleurs_utilisees].V=0;
Palette[*Nb_couleurs_utilisees].B=0;
// Au passage, on va s'assurer que l'on a pas oublié de la mettre à une
// utilisation nulle.
Utilisation_couleur[*Nb_couleurs_utilisees]=0;
// Après avoir éjecté une couleur, on le fait savoir à l'utilisateur par
// l'intermédiaire du compteur de nombre utilisées.
Num2str(*Nb_couleurs_utilisees,Chaine,3);
Print_dans_fenetre(186,23,Chaine,CM_Noir,CM_Clair);
}
// Maintenant, tous ces calculs doivent êtres pris en compte dans la
// palette, l'image et à l'écran.
Remap_image_HIGH(Table_de_conversion); // Et voila pour l'image et l'écran
Afficher_curseur();
}
void Palette_Modifier_jauge(struct Fenetre_Bouton_scroller * Jauge,
word Nb_elements, word Position,
char * Valeur, short Pos_X)
{
Jauge->Nb_elements=Nb_elements;
Jauge->Position=Position;
Calculer_hauteur_curseur_jauge(Jauge);
Fenetre_Dessiner_jauge(Jauge);
Print_compteur(Pos_X,172,Valeur,CM_Noir,CM_Clair);
}
void Afficher_les_jauges(struct Fenetre_Bouton_scroller * Jauge_rouge,
struct Fenetre_Bouton_scroller * Jauge_verte,
struct Fenetre_Bouton_scroller * Jauge_bleue,
byte Bloc_selectionne, struct Composantes * Palette)
{
char Chaine[5];
if (Bloc_selectionne)
{
Palette_Modifier_jauge(Jauge_rouge,Color_Max*2+1,Color_Max,"± 0",176);
Palette_Modifier_jauge(Jauge_verte,Color_Max*2+1,Color_Max,"± 0",203);
Palette_Modifier_jauge(Jauge_bleue,Color_Max*2+1,Color_Max,"± 0",230);
}
else
{
byte j1, j2, j3;
j1= Palette[Fore_color].R;
j2= Palette[Fore_color].V;
j3= Palette[Fore_color].B;
if (!Palette_mode_RGB)
{
RGBtoHSL(j1,j2,j3,&j1,&j2,&j3);
}
Formate_composante(j1*Color_Max/255,Chaine);
Palette_Modifier_jauge(Jauge_rouge,Color_Count,Color_Max-j1*Color_Max/255,Chaine,176);
Formate_composante(j2*Color_Max/255,Chaine);
Palette_Modifier_jauge(Jauge_verte,Color_Count,Color_Max-j2*Color_Max/255,Chaine,203);
Formate_composante(j3*Color_Max/255,Chaine);
Palette_Modifier_jauge(Jauge_bleue,Color_Count,Color_Max-j3*Color_Max/255,Chaine,230);
}
}
void Palette_Reafficher_jauges(struct Fenetre_Bouton_scroller * Jauge_rouge,
struct Fenetre_Bouton_scroller * Jauge_verte,
struct Fenetre_Bouton_scroller * Jauge_bleue,
T_Palette Palette,byte Debut,byte Fin)
{
char Chaine[5];
Effacer_curseur();
// Réaffichage des jauges:
if (Debut!=Fin)
{
// Dans le cas d'un bloc, tout à 0.
Jauge_rouge->Position =Color_Max;
Fenetre_Dessiner_jauge(Jauge_rouge);
Print_compteur(176,172,"± 0",CM_Noir,CM_Clair);
Jauge_verte->Position =Color_Max;
Fenetre_Dessiner_jauge(Jauge_verte);
Print_compteur(203,172,"± 0",CM_Noir,CM_Clair);
Jauge_bleue->Position =Color_Max;
Fenetre_Dessiner_jauge(Jauge_bleue);
Print_compteur(230,172,"± 0",CM_Noir,CM_Clair);
}
else
{
// Dans le cas d'une seule couleur, composantes.
byte j1, j2, j3;
j1= Palette[Debut].R;
j2= Palette[Debut].V;
j3= Palette[Debut].B;
if (!Palette_mode_RGB)
{
RGBtoHSL(j1,j2,j3,&j1,&j2,&j3);
}
Formate_composante(j1*Color_Max/255,Chaine);
Jauge_rouge->Position=Color_Max-j1*Color_Max/255;
Fenetre_Dessiner_jauge(Jauge_rouge);
Print_compteur(176,172,Chaine,CM_Noir,CM_Clair);
Formate_composante(j2*Color_Max/255,Chaine);
Jauge_verte->Position=Color_Max-j2*Color_Max/255;
Fenetre_Dessiner_jauge(Jauge_verte);
Print_compteur(203,172,Chaine,CM_Noir,CM_Clair);
Formate_composante(j3*Color_Max/255,Chaine);
Jauge_bleue->Position=Color_Max-j3*Color_Max/255;
Fenetre_Dessiner_jauge(Jauge_bleue);
Print_compteur(230,172,Chaine,CM_Noir,CM_Clair);
}
Afficher_curseur();
}
void Bouton_Palette(void)
{
static short Indice_Reduction_palette=0;
static short Reduce_Nb_couleurs=256;
short Couleur_temporaire; // Variable pouvant reservir pour différents calculs intermédiaires
dword Temp;
byte Couleur,Click; // Variables pouvant reservir pour différents calculs intermédiaires
short Bouton_clicke;
word Ancien_Mouse_X;
word Ancien_Mouse_Y;
byte Ancien_Mouse_K;
byte Debut_block;
byte Fin_block;
byte Premiere_couleur;
byte Derniere_couleur;
char Chaine[10];
word i;
//short Pos_X,Pos_Y;
struct Fenetre_Bouton_normal * Bouton_Used;
struct Fenetre_Bouton_scroller * Jauge_rouge;
struct Fenetre_Bouton_scroller * Jauge_verte;
struct Fenetre_Bouton_scroller * Jauge_bleue;
struct Fenetre_Bouton_scroller * Jauge_Reduction;
byte Backup_de_l_image_effectue=0;
byte Il_faut_remapper=0;
dword Utilisation_couleur[256];
short Nb_couleurs_utilisees=-1; // -1 <=> Inconnu
byte Table_de_conversion[256];
struct Composantes * Palette_backup;
struct Composantes * Palette_temporaire;
struct Composantes * Palette_de_travail;
Palette_backup =(struct Composantes *)malloc(sizeof(T_Palette));
Palette_temporaire=(struct Composantes *)malloc(sizeof(T_Palette));
Palette_de_travail=(struct Composantes *)malloc(sizeof(T_Palette));
Unite_Composantes(Graduations_RGB);
Ouvrir_fenetre(299,188,"Palette");
memcpy(Palette_de_travail,Principal_Palette,sizeof(T_Palette));
memcpy(Palette_backup ,Principal_Palette,sizeof(T_Palette));
memcpy(Palette_temporaire,Principal_Palette,sizeof(T_Palette));
Fenetre_Definir_bouton_palette(5,79); // 1
Fenetre_Afficher_cadre (173, 67,121,116);
Fenetre_Afficher_cadre (128, 16, 91, 39);
Fenetre_Afficher_cadre (221, 16, 73, 39);
// Cadre creux destiné à l'affichage de la(les) couleur(s) sélectionnée(s)
Fenetre_Afficher_cadre_creux(259, 88, 26, 74);
// Graduation des jauges de couleur
Block(Fenetre_Pos_X+(Menu_Facteur_X*179),Fenetre_Pos_Y+(Menu_Facteur_Y*109),Menu_Facteur_X*17,Menu_Facteur_Y,CM_Fonce);
Block(Fenetre_Pos_X+(Menu_Facteur_X*206),Fenetre_Pos_Y+(Menu_Facteur_Y*109),Menu_Facteur_X*17,Menu_Facteur_Y,CM_Fonce);
Block(Fenetre_Pos_X+(Menu_Facteur_X*233),Fenetre_Pos_Y+(Menu_Facteur_Y*109),Menu_Facteur_X*17,Menu_Facteur_Y,CM_Fonce);
Block(Fenetre_Pos_X+(Menu_Facteur_X*179),Fenetre_Pos_Y+(Menu_Facteur_Y*125),Menu_Facteur_X*17,Menu_Facteur_Y,CM_Fonce);
Block(Fenetre_Pos_X+(Menu_Facteur_X*206),Fenetre_Pos_Y+(Menu_Facteur_Y*125),Menu_Facteur_X*17,Menu_Facteur_Y,CM_Fonce);
Block(Fenetre_Pos_X+(Menu_Facteur_X*233),Fenetre_Pos_Y+(Menu_Facteur_Y*125),Menu_Facteur_X*17,Menu_Facteur_Y,CM_Fonce);
Block(Fenetre_Pos_X+(Menu_Facteur_X*179),Fenetre_Pos_Y+(Menu_Facteur_Y*141),Menu_Facteur_X*17,Menu_Facteur_Y,CM_Fonce);
Block(Fenetre_Pos_X+(Menu_Facteur_X*206),Fenetre_Pos_Y+(Menu_Facteur_Y*141),Menu_Facteur_X*17,Menu_Facteur_Y,CM_Fonce);
Block(Fenetre_Pos_X+(Menu_Facteur_X*233),Fenetre_Pos_Y+(Menu_Facteur_Y*141),Menu_Facteur_X*17,Menu_Facteur_Y,CM_Fonce);
// Jauges de couleur
Palette_mode_RGB=1;
Fenetre_Definir_bouton_scroller(182, 81, 88,Color_Count,1,Color_Max-Palette_de_travail[Fore_color].R*Color_Max/255);// 2
Jauge_rouge=Fenetre_Liste_boutons_scroller;
Fenetre_Definir_bouton_scroller(209, 81, 88,Color_Count,1,Color_Max-Palette_de_travail[Fore_color].V*Color_Max/255);// 3
Jauge_verte=Fenetre_Liste_boutons_scroller;
Fenetre_Definir_bouton_scroller(236, 81, 88,Color_Count,1,Color_Max-Palette_de_travail[Fore_color].B*Color_Max/255);// 4
Jauge_bleue=Fenetre_Liste_boutons_scroller;
Print_dans_fenetre(184,71,"R",CM_Fonce,CM_Clair);
Print_dans_fenetre(211,71,"G",CM_Fonce,CM_Clair);
Print_dans_fenetre(238,71,"B",CM_Fonce,CM_Clair);
Premiere_couleur=Derniere_couleur=Debut_block=Fin_block=Fore_color;
Tagger_intervalle_palette(Debut_block,Fin_block);
// Affichage dans le block de visu de la couleur en cours
Block(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y*89),Menu_Facteur_X*24,Menu_Facteur_Y*72,Back_color);
Block(Fenetre_Pos_X+(Menu_Facteur_X*264),Fenetre_Pos_Y+(Menu_Facteur_Y*93),Menu_Facteur_X<<4,Menu_Facteur_Y*64,Fore_color);
// Affichage des valeurs de la couleur courante (pour 1 couleur)
Formate_composante(Principal_Palette[Fore_color].R*Color_Max/255,Chaine);
Print_compteur(176,172,Chaine,CM_Noir,CM_Clair);
Formate_composante(Principal_Palette[Fore_color].V*Color_Max/255,Chaine);
Print_compteur(203,172,Chaine,CM_Noir,CM_Clair);
Formate_composante(Principal_Palette[Fore_color].B*Color_Max/255,Chaine);
Print_compteur(230,172,Chaine,CM_Noir,CM_Clair);
Print_dans_fenetre(129,58,"Color number:",CM_Fonce,CM_Clair);
Num2str(Fore_color,Chaine,3);
Print_dans_fenetre(237,58,Chaine,CM_Noir,CM_Clair);
Fenetre_Definir_bouton_normal( 6,17,59,14,"Default",3,1,SDLK_f); // 5
Fenetre_Definir_bouton_normal(66,17,29,14,"Gry" ,1,1,SDLK_g); // 6
Fenetre_Definir_bouton_normal(66,47,29,14,"Swp" ,1,1,SDLK_s); // 7
Fenetre_Definir_bouton_normal( 6,47,59,14,"X-Swap" ,1,1,SDLK_x); // 8
Fenetre_Definir_bouton_normal(66,32,29,14,"Cpy" ,1,1,SDLK_c); // 9
Fenetre_Definir_bouton_normal( 6,32,59,14,"Spread" ,4,1,SDLK_e); // 10
Fenetre_Definir_bouton_normal(239,20,51,14,"Reduce" ,1,1,SDLK_r); // 11
Print_dans_fenetre(241,41,"to",CM_Fonce,CM_Clair);
Fenetre_Definir_bouton_normal( 6,168,35,14,"Undo" ,1,1,SDLK_u); // 12
Fenetre_Definir_bouton_normal( 62,168,51,14,"Cancel",0,1,SDLK_ESCAPE); // 13
Fenetre_Definir_bouton_normal(117,168,51,14,"OK" ,0,1,SDLK_RETURN); // 14
Fenetre_Definir_bouton_normal(132,20,83,14,"Used: ???",4,1,SDLK_d);// 15
Bouton_Used=Fenetre_Liste_boutons_normal;
Fenetre_Definir_bouton_normal(132,37,83,14,"Zap unused",0,1,SDLK_DELETE);//16
// Jauge de réduction de palette
Fenetre_Definir_bouton_scroller(225,20,31,7,1,Indice_Reduction_palette);// 17
Jauge_Reduction=Fenetre_Liste_boutons_scroller;
Fenetre_Definir_bouton_normal(266, 74,12,11,"+",0,1,SDLK_KP_PLUS); // 18
Fenetre_Definir_bouton_normal(266,165,12,11,"-",0,1,SDLK_KP_MINUS); // 19
Fenetre_Definir_bouton_normal(96,17,29,14,"Neg" ,1,1,SDLK_n); // 20
Fenetre_Definir_bouton_normal(66,62,29,14,"Inv" ,1,1,SDLK_i); // 21
Fenetre_Definir_bouton_normal( 6,62,59,14,"X-Inv." ,5,1,SDLK_v); // 22
Fenetre_Definir_bouton_saisie(263,39,3); // 23
Fenetre_Definir_bouton_normal(96,32,29,14,"HSL" ,1,1,SDLK_h); // 24
Fenetre_Definir_bouton_normal(96,47,29,14,"Srt" ,1,1,SDLK_s); // 25
// Affichage du facteur de réduction de la palette
Num2str(Reduce_Nb_couleurs,Chaine,3);
Print_dans_fenetre(265,41,Chaine,CM_Noir,CM_Clair);
// Dessin des petits effets spéciaux pour les boutons [+] et [-]
Dessiner_zigouigoui(263, 74,CM_Blanc,-1);
Dessiner_zigouigoui(280, 74,CM_Blanc,+1);
Dessiner_zigouigoui(263,165,CM_Fonce,-1);
Dessiner_zigouigoui(280,165,CM_Fonce,+1);
UpdateRect(Fenetre_Pos_X,Fenetre_Pos_Y,299*Menu_Facteur_X,188*Menu_Facteur_Y);
Afficher_curseur();
if (Config.Auto_nb_used)
Compter_nb_couleurs_utilisees(&Nb_couleurs_utilisees,Utilisation_couleur);
do
{
Ancien_Mouse_X=Mouse_X;
Ancien_Mouse_Y=Mouse_Y;
Ancien_Mouse_K=Mouse_K;
Bouton_clicke=Fenetre_Bouton_clicke();
switch (Bouton_clicke)
{
case 0 : // Nulle part
break;
case -1 : // Hors de la fenêtre
case 1 : // Palette
if ( (Mouse_X!=Ancien_Mouse_X) || (Mouse_Y!=Ancien_Mouse_Y) || (Mouse_K!=Ancien_Mouse_K) )
{
Effacer_curseur();
Couleur_temporaire=(Bouton_clicke==1) ? Fenetre_Attribut2 : Lit_pixel(Mouse_X,Mouse_Y);
if (Mouse_K==A_DROITE)
{
if (Back_color!=Couleur_temporaire)
{
Back_color=Couleur_temporaire;
// 4 blocks de back_color entourant la fore_color
Block(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y* 89),Menu_Facteur_X*24,Menu_Facteur_Y<<2,Back_color);
Block(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y*157),Menu_Facteur_X*24,Menu_Facteur_Y<<2,Back_color);
Block(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y* 93),Menu_Facteur_X<<2,Menu_Facteur_Y<<6,Back_color);
Block(Fenetre_Pos_X+(Menu_Facteur_X*280),Fenetre_Pos_Y+(Menu_Facteur_Y* 93),Menu_Facteur_X<<2,Menu_Facteur_Y<<6,Back_color);
UpdateRect(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y* 89),Menu_Facteur_X*32,Menu_Facteur_Y*72);
}
}
else
{
if (!Ancien_Mouse_K)
{
// On vient de clicker sur une couleur (et une seule)
if ( (Fore_color!=Couleur_temporaire) || (Debut_block!=Fin_block) )
{
// La couleur en question est nouvelle ou elle annule un
// ancien bloc. Il faut donc sélectionner cette couleur comme
// unique couleur choisie.
Fore_color=Premiere_couleur=Derniere_couleur=Debut_block=Fin_block=Couleur_temporaire;
Tagger_intervalle_palette(Debut_block,Fin_block);
// Affichage du n° de la couleur sélectionnée
Block(Fenetre_Pos_X+(Menu_Facteur_X*261),Fenetre_Pos_Y+(Menu_Facteur_Y*58),Menu_Facteur_X*32,Menu_Facteur_Y*7,CM_Clair);
Num2str(Fore_color,Chaine,3);
Print_dans_fenetre(237,58,Chaine,CM_Noir,CM_Clair);
// Affichage des jauges
Block(Fenetre_Pos_X+(Menu_Facteur_X*176),Fenetre_Pos_Y+(Menu_Facteur_Y*172),Menu_Facteur_X*84,Menu_Facteur_Y*7,CM_Clair);
Afficher_les_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,0,Palette_de_travail);
// Affichage dans le block de visu de la couleur en cours
Block(Fenetre_Pos_X+(Menu_Facteur_X*264),Fenetre_Pos_Y+(Menu_Facteur_Y*93),Menu_Facteur_X<<4,Menu_Facteur_Y*64,Fore_color);
UpdateRect(Fenetre_Pos_X+(Menu_Facteur_X*264),Fenetre_Pos_Y+(Menu_Facteur_Y*93),Menu_Facteur_X<<4,Menu_Facteur_Y*64);
memcpy(Palette_backup ,Palette_de_travail,sizeof(T_Palette));
memcpy(Palette_temporaire,Palette_de_travail,sizeof(T_Palette));
}
}
else
{
// On maintient le click, on va donc tester si le curseur bouge
if (Couleur_temporaire!=Derniere_couleur)
{
// On commence par ordonner la 1ère et dernière couleur du bloc
if (Premiere_couleur<Couleur_temporaire)
{
Debut_block=Premiere_couleur;
Fin_block=Couleur_temporaire;
// Affichage du n° de la couleur sélectionnée
Num2str(Debut_block,Chaine ,3);
Num2str(Fin_block ,Chaine+4,3);
Chaine[3]=26; // Flèche vers la droite
Print_dans_fenetre(237,58,Chaine,CM_Noir,CM_Clair);
// Affichage des jauges
Afficher_les_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,1,NULL);
// Affichage dans le block de visu du bloc (dégradé) en cours
Bloc_degrade_dans_fenetre(264,93,Debut_block,Fin_block);
}
else if (Premiere_couleur>Couleur_temporaire)
{
Debut_block=Couleur_temporaire;
Fin_block=Premiere_couleur;
// Affichage du n° de la couleur sélectionnée
Num2str(Debut_block,Chaine ,3);
Num2str(Fin_block ,Chaine+4,3);
Chaine[3]=26; // Flèche vers la droite
Print_dans_fenetre(237,58,Chaine,CM_Noir,CM_Clair);
// Affichage des jauges
Afficher_les_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,1,NULL);
// Affichage dans le block de visu du bloc (dégradé) en cours
Bloc_degrade_dans_fenetre(264,93,Debut_block,Fin_block);
}
else
{
Debut_block=Fin_block=Premiere_couleur;
Block(Fenetre_Pos_X+(Menu_Facteur_X*176),Fenetre_Pos_Y+(Menu_Facteur_Y*172),Menu_Facteur_X*84,Menu_Facteur_Y*7,CM_Clair);
// Affichage du n° de la couleur sélectionnée
Block(Fenetre_Pos_X+(Menu_Facteur_X*261),Fenetre_Pos_Y+(Menu_Facteur_Y*58),Menu_Facteur_X*32,Menu_Facteur_Y*7,CM_Clair);
Num2str(Fore_color,Chaine,3);
Print_dans_fenetre(237,58,Chaine,CM_Noir,CM_Clair);
// Affichage des jauges
Afficher_les_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,0,Palette_de_travail);
// Affichage dans le block de visu de la couleur en cours
Block(Fenetre_Pos_X+(Menu_Facteur_X*264),Fenetre_Pos_Y+(Menu_Facteur_Y*93),Menu_Facteur_X<<4,Menu_Facteur_Y*64,Fore_color);
UpdateRect(Fenetre_Pos_X+(Menu_Facteur_X*264),Fenetre_Pos_Y+(Menu_Facteur_Y*93),Menu_Facteur_X<<4,Menu_Facteur_Y*64);
}
// On tagge le bloc (ou la couleur)
Tagger_intervalle_palette(Debut_block,Fin_block);
}
Derniere_couleur=Couleur_temporaire;
}
}
Afficher_curseur();
}
break;
case 2 : // Jauge rouge
Effacer_curseur();
if (Debut_block==Fin_block)
{
if(Palette_mode_RGB)
{
Modifier_Rouge(Fore_color,(Color_Max-Jauge_rouge->Position)*255/Color_Max,Palette_de_travail);
Formate_composante(Palette_de_travail[Fore_color].R*Color_Max/255,Chaine);
}
else
{
HSLtoRGB(
255-Jauge_rouge->Position,
255-Jauge_verte->Position,
255-Jauge_bleue->Position,
&Palette_de_travail[Fore_color].R,
&Palette_de_travail[Fore_color].V,
&Palette_de_travail[Fore_color].B);
Formate_composante((int)255-Jauge_rouge->Position,Chaine);
}
Print_compteur(176,172,Chaine,CM_Noir,CM_Clair);
}
else
{
if(Palette_mode_RGB)
{
for (i=Debut_block; i<=Fin_block; i++)
Modifier_Rouge(i,Palette_temporaire[i].R+(Color_Max-Jauge_rouge->Position)*255/Color_Max,Palette_de_travail);
}
else
{
for (i=Debut_block; i<=Fin_block; i++)
Modifier_HSL(
Palette_temporaire,
Palette_de_travail,
i,
Color_Max-Jauge_rouge->Position,
Color_Max-Jauge_verte->Position,
Color_Max-Jauge_bleue->Position
);
}
if (Jauge_rouge->Position>Color_Max)
{
// Jauge dans les négatifs:
Num2str(-(Color_Max-Jauge_rouge->Position),Chaine,4);
Chaine[0]='-';
}
else if (Jauge_rouge->Position<Color_Max)
{
// Jauge dans les positifs:
Num2str( Color_Max-Jauge_rouge->Position ,Chaine,4);
Chaine[0]='+';
}
else
{
// Jauge nulle:
strcpy(Chaine,"± 0");
}
Print_compteur(176,172,Chaine,CM_Noir,CM_Clair);
}
Il_faut_remapper=1;
Afficher_curseur();
Set_palette(Palette_de_travail);
break;
case 3 : // Jauge verte
Effacer_curseur();
if (Debut_block==Fin_block)
{
if(Palette_mode_RGB)
{
Modifier_Vert (Fore_color,(Color_Max-Jauge_verte->Position)*255/Color_Max,Palette_de_travail);
Formate_composante(Palette_de_travail[Fore_color].V*Color_Max/255,Chaine);
}
else
{
HSLtoRGB(
255-Jauge_rouge->Position,
255-Jauge_verte->Position,
255-Jauge_bleue->Position,
&Palette_de_travail[Fore_color].R,
&Palette_de_travail[Fore_color].V,
&Palette_de_travail[Fore_color].B);
Formate_composante((int)255-Jauge_verte->Position,Chaine);
}
Print_compteur(203,172,Chaine,CM_Noir,CM_Clair);
}
else
{
if(Palette_mode_RGB)
{
for (i=Debut_block; i<=Fin_block; i++)
Modifier_Vert (i,Palette_temporaire[i].V+(Color_Max-Jauge_verte->Position)*255/Color_Max,Palette_de_travail);
}
else
{
for (i=Debut_block; i<=Fin_block; i++)
Modifier_HSL(
Palette_temporaire,
Palette_de_travail,
i,
Color_Max-Jauge_rouge->Position,
Color_Max-Jauge_verte->Position,
Color_Max-Jauge_bleue->Position
);
}
if (Jauge_verte->Position>Color_Max)
{
// Jauge dans les négatifs:
Num2str(-(Color_Max-Jauge_verte->Position),Chaine,4);
Chaine[0]='-';
}
else if (Jauge_verte->Position<Color_Max)
{
// Jauge dans les positifs:
Num2str( Color_Max-Jauge_verte->Position ,Chaine,4);
Chaine[0]='+';
}
else
{
// Jauge nulle:
strcpy(Chaine,"± 0");
}
Print_compteur(203,172,Chaine,CM_Noir,CM_Clair);
}
Il_faut_remapper=1;
Afficher_curseur();
Set_palette(Palette_de_travail);
break;
case 4 : // Jauge bleue
Effacer_curseur();
if (Debut_block==Fin_block)
{
if(Palette_mode_RGB)
{
Modifier_Bleu (Fore_color,(Color_Max-Jauge_bleue->Position)*255/Color_Max,Palette_de_travail);
Formate_composante(Palette_de_travail[Fore_color].B*Color_Max/255,Chaine);
}
else
{
HSLtoRGB(
255-Jauge_rouge->Position,
255-Jauge_verte->Position,
255-Jauge_bleue->Position,
&Palette_de_travail[Fore_color].R,
&Palette_de_travail[Fore_color].V,
&Palette_de_travail[Fore_color].B);
Formate_composante((int)255-Jauge_bleue->Position,Chaine);
}
Print_compteur(230,172,Chaine,CM_Noir,CM_Clair);
}
else
{
if(Palette_mode_RGB)
{
for (i=Debut_block; i<=Fin_block; i++)
Modifier_Bleu(i,Palette_temporaire[i].B+(Color_Max-Jauge_bleue->Position)*255/Color_Max,Palette_de_travail);
}
else
{
for (i=Debut_block; i<=Fin_block; i++)
Modifier_HSL(
Palette_temporaire,
Palette_de_travail,
i,
Color_Max-Jauge_rouge->Position,
Color_Max-Jauge_verte->Position,
Color_Max-Jauge_bleue->Position
);
}
if (Jauge_bleue->Position>Color_Max)
{
// Jauge dans les négatifs:
Num2str(-(Color_Max-Jauge_bleue->Position),Chaine,4);
Chaine[0]='-';
}
else if (Jauge_bleue->Position<Color_Max)
{
// Jauge dans les positifs:
Num2str( Color_Max-Jauge_bleue->Position ,Chaine,4);
Chaine[0]='+';
}
else
{
// Jauge nulle:
strcpy(Chaine,"± 0");
}
Print_compteur(230,172,Chaine,CM_Noir,CM_Clair);
}
Il_faut_remapper=1;
Afficher_curseur();
Set_palette(Palette_de_travail);
break;
case 5 : // Default
memcpy(Palette_backup,Palette_de_travail,sizeof(T_Palette));
memcpy(Palette_de_travail,Palette_defaut,sizeof(T_Palette));
memcpy(Palette_temporaire,Palette_defaut,sizeof(T_Palette));
Set_palette(Palette_defaut);
Palette_Reafficher_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,Palette_de_travail,Debut_block,Fin_block);
// On prépare la "modifiabilité" des nouvelles couleurs
memcpy(Palette_temporaire,Palette_de_travail,sizeof(T_Palette));
Il_faut_remapper=1;
break;
case 6 : // Grey scale
// Backup
memcpy(Palette_backup,Palette_de_travail,sizeof(T_Palette));
// Grey Scale
for (i=Debut_block;i<=Fin_block;i++)
{
Couleur_temporaire=(dword)( ((dword)Palette_de_travail[i].R*30) + ((dword)Palette_de_travail[i].V*59) + ((dword)Palette_de_travail[i].B*11) )/100;
Modifier_Rouge(i,Couleur_temporaire,Palette_de_travail);
Modifier_Vert (i,Couleur_temporaire,Palette_de_travail);
Modifier_Bleu (i,Couleur_temporaire,Palette_de_travail);
}
Palette_Reafficher_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,Palette_de_travail,Debut_block,Fin_block);
// On prépare la "modifiabilité" des nouvelles couleurs
Set_palette(Palette_de_travail);
memcpy(Palette_temporaire,Palette_de_travail,sizeof(T_Palette));
Il_faut_remapper=1;
break;
case 7 : // Swap
case 8 : // X-Swap
Couleur_temporaire=Attendre_click_dans_palette(Fenetre_Liste_boutons_palette);
if ((Couleur_temporaire>=0)
&& (Couleur_temporaire!=Debut_block))
{
Effacer_curseur();
memcpy(Palette_backup,Palette_de_travail,sizeof(T_Palette));
// On calcule le nombre de couleurs a swapper sans risquer de sortir
// de la palette (La var. Premiere_couleur est utilisée pour économiser 1 var; c'est tout)
Premiere_couleur=(Couleur_temporaire+Fin_block-Debut_block<=255)?Fin_block+1-Debut_block:256-Couleur_temporaire;
if (Bouton_clicke==8) // On ne fait de backup de l'image que si on
// est en mode X-SWAP.
if (!Backup_de_l_image_effectue)
{
Backup();
Backup_de_l_image_effectue=1;
}
Swap(Bouton_clicke==8,Debut_block,Couleur_temporaire,Premiere_couleur,Palette_de_travail,Utilisation_couleur);
memcpy(Palette_temporaire,Palette_de_travail,sizeof(T_Palette));
// On déplace le bloc vers les modifs:
Derniere_couleur=Fin_block=Couleur_temporaire+Premiere_couleur-1;
Fore_color=Premiere_couleur=Debut_block=Couleur_temporaire;
// On raffiche le n° des bornes du bloc:
if (Debut_block!=Fin_block)
{
// Cas d'un bloc multi-couleur
Num2str(Debut_block,Chaine ,3);
Num2str(Fin_block ,Chaine+4,3);
Chaine[3]=26; // Flèche vers la droite
// Affichage dans le block de visu du bloc (dégradé) en cours
Bloc_degrade_dans_fenetre(264,93,Debut_block,Fin_block);
}
else
{
// Cas d'une seule couleur
Num2str(Fore_color,Chaine,3);
Block(Fenetre_Pos_X+(Menu_Facteur_X*237),Fenetre_Pos_Y+(Menu_Facteur_Y*58),Menu_Facteur_X*56,Menu_Facteur_Y* 7,CM_Clair);
// Affichage dans le block de visu de la couleur en cours
Block(Fenetre_Pos_X+(Menu_Facteur_X*264),Fenetre_Pos_Y+(Menu_Facteur_Y*93),Menu_Facteur_X<<4,Menu_Facteur_Y*64,Fore_color);
}
Print_dans_fenetre(237,58,Chaine,CM_Noir,CM_Clair);
// On tag le bloc (ou la couleur)
Tagger_intervalle_palette(Debut_block,Fin_block);
Il_faut_remapper=1;
Set_palette(Palette_de_travail);
Afficher_curseur();
Palette_Reafficher_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,Palette_de_travail,Debut_block,Fin_block);
// En cas de X-Swap, tout l'ecran a pu changer de couleur.
if (Bouton_clicke==8)
UpdateRect(0, 0, Largeur_ecran, Menu_Ordonnee_avant_fenetre);
}
break;
case 9 : // Copy
Couleur_temporaire=Attendre_click_dans_palette(Fenetre_Liste_boutons_palette);
if ((Couleur_temporaire>=0) && (Couleur_temporaire!=Debut_block))
{
Effacer_curseur();
memcpy(Palette_backup,Palette_de_travail,sizeof(T_Palette));
memcpy(Palette_de_travail+Couleur_temporaire,Palette_backup+Debut_block,
((Couleur_temporaire+Fin_block-Debut_block<=255)?Fin_block+1-Debut_block:256-Couleur_temporaire)*3);
memcpy(Palette_temporaire,Palette_de_travail,sizeof(T_Palette));
Set_palette(Palette_de_travail);
// On déplace le bloc vers les modifs:
Derniere_couleur=Fin_block=((Couleur_temporaire+Fin_block-Debut_block<=255)?(Couleur_temporaire+Fin_block-Debut_block):255);
Fore_color=Premiere_couleur=Debut_block=Couleur_temporaire;
// On raffiche le n° des bornes du bloc:
if (Debut_block!=Fin_block)
{
// Cas d'un bloc multi-couleur
Num2str(Debut_block,Chaine ,3);
Num2str(Fin_block ,Chaine+4,3);
Chaine[3]=26; // Flèche vers la droite
// Affichage dans le block de visu du bloc (dégradé) en cours
Bloc_degrade_dans_fenetre(264,93,Debut_block,Fin_block);
}
else
{
// Cas d'une seule couleur
Num2str(Fore_color,Chaine,3);
Block(Fenetre_Pos_X+(Menu_Facteur_X*237),Fenetre_Pos_Y+(Menu_Facteur_Y*58),Menu_Facteur_X*56,Menu_Facteur_Y* 7,CM_Clair);
// Affichage dans le block de visu de la couleur en cours
Block(Fenetre_Pos_X+(Menu_Facteur_X*264),Fenetre_Pos_Y+(Menu_Facteur_Y*93),Menu_Facteur_X<<4,Menu_Facteur_Y*64,Fore_color);
}
Print_dans_fenetre(237,58,Chaine,CM_Noir,CM_Clair);
// On tag le bloc (ou la couleur)
Tagger_intervalle_palette(Debut_block,Fin_block);
Il_faut_remapper=1;
Afficher_curseur();
Palette_Reafficher_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,Palette_de_travail,Debut_block,Fin_block);
}
break;
case 10 : // Spread
if (Debut_block!=Fin_block)
{
memcpy(Palette_backup,Palette_de_travail,sizeof(T_Palette));
Degrader_palette(Debut_block,Fin_block,Palette_de_travail);
}
else
{
Couleur_temporaire=Attendre_click_dans_palette(Fenetre_Liste_boutons_palette);
if (Couleur_temporaire>=0)
{
memcpy(Palette_backup,Palette_de_travail,sizeof(T_Palette));
if (Couleur_temporaire<Fore_color)
Degrader_palette(Couleur_temporaire,Fore_color,Palette_de_travail);
else
Degrader_palette(Fore_color,Couleur_temporaire,Palette_de_travail);
}
}
Palette_Reafficher_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,Palette_de_travail,Debut_block,Fin_block);
// On prépare la "modifiabilité" des nouvelles couleurs
Set_palette(Palette_de_travail);
memcpy(Palette_temporaire,Palette_de_travail,sizeof(T_Palette));
Il_faut_remapper=1;
break;
case 11: // Reduce
memcpy(Palette_backup,Palette_de_travail,sizeof(T_Palette));
if (!Backup_de_l_image_effectue)
{
Backup();
Backup_de_l_image_effectue=1;
}
Reduce_palette(&Nb_couleurs_utilisees,Reduce_Nb_couleurs,Palette_de_travail,Utilisation_couleur);
if ((Config.Safety_colors) && (Nb_couleurs_utilisees<4))
{
memcpy(Palette_temporaire,Principal_Palette,sizeof(T_Palette));
memcpy(Principal_Palette,Palette_de_travail,sizeof(T_Palette));
Remettre_proprement_les_couleurs_du_menu(Utilisation_couleur);
memcpy(Palette_de_travail,Principal_Palette,sizeof(T_Palette));
memcpy(Principal_Palette,Palette_temporaire,sizeof(T_Palette));
}
Set_palette(Palette_de_travail); // On définit la nouvelle palette
Palette_Reafficher_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,Palette_de_travail,Debut_block,Fin_block);
memcpy(Palette_temporaire,Palette_de_travail,sizeof(T_Palette));
Il_faut_remapper=1;
break;
case 12: // Undo
memcpy(Palette_temporaire,Palette_backup ,sizeof(T_Palette));
memcpy(Palette_backup ,Palette_de_travail,sizeof(T_Palette));
memcpy(Palette_de_travail,Palette_temporaire,sizeof(T_Palette));
Palette_Reafficher_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,Palette_de_travail,Debut_block,Fin_block);
Set_palette(Palette_de_travail);
Il_faut_remapper=1;
break;
case 15 : // Used
if (Nb_couleurs_utilisees==-1)
Compter_nb_couleurs_utilisees(&Nb_couleurs_utilisees,Utilisation_couleur);
break;
case 16 : // Zap unused
memcpy(Palette_backup,Palette_de_travail,sizeof(T_Palette));
if (Nb_couleurs_utilisees==-1)
Compter_nb_couleurs_utilisees(&Nb_couleurs_utilisees,Utilisation_couleur);
for (i=0; i<256; i++)
{
if (!Utilisation_couleur[i])
{
Couleur_temporaire=Debut_block+(i % (Fin_block+1-Debut_block));
Palette_de_travail[i].R=Palette_backup[Couleur_temporaire].R;
Palette_de_travail[i].V=Palette_backup[Couleur_temporaire].V;
Palette_de_travail[i].B=Palette_backup[Couleur_temporaire].B;
}
}
if ((Config.Safety_colors) && (Nb_couleurs_utilisees<4) && (Fin_block==Debut_block))
{
memcpy(Palette_temporaire,Principal_Palette,sizeof(T_Palette));
memcpy(Principal_Palette,Palette_de_travail,sizeof(T_Palette));
Remettre_proprement_les_couleurs_du_menu(Utilisation_couleur);
memcpy(Palette_de_travail,Principal_Palette,sizeof(T_Palette));
memcpy(Principal_Palette,Palette_temporaire,sizeof(T_Palette));
}
Set_palette(Palette_de_travail);
Palette_Reafficher_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,Palette_de_travail,Debut_block,Fin_block);
Il_faut_remapper=1;
break;
case 17 : // Jauge de réduction de palette
if (Indice_Reduction_palette!=Jauge_Reduction->Position)
{
Indice_Reduction_palette=Jauge_Reduction->Position;
// Affichage du facteur de réduction de la palette
Effacer_curseur();
Print_dans_fenetre(265,41,Libelle_reduction_palette[Indice_Reduction_palette],CM_Noir,CM_Clair);
Afficher_curseur();
Reduce_Nb_couleurs=atoi(Libelle_reduction_palette[Indice_Reduction_palette]);
}
break;
case 18 : // [+]
if (!Palette_mode_RGB)
break;
Effacer_curseur();
if (Debut_block==Fin_block)
{
if (Jauge_rouge->Position)
{
(Jauge_rouge->Position)--;
Fenetre_Dessiner_jauge(Jauge_rouge);
Modifier_Rouge(Fore_color,(Color_Max-Jauge_rouge->Position)*255/Color_Max,Palette_de_travail);
Formate_composante(Palette_de_travail[Fore_color].R*Color_Max/255,Chaine);
Print_compteur(176,172,Chaine,CM_Noir,CM_Clair);
}
if (Jauge_verte->Position)
{
(Jauge_verte->Position)--;
Fenetre_Dessiner_jauge(Jauge_verte);
Modifier_Vert (Fore_color,(Color_Max-Jauge_verte->Position)*255/Color_Max,Palette_de_travail);
Formate_composante(Palette_de_travail[Fore_color].V*Color_Max/255,Chaine);
Print_compteur(203,172,Chaine,CM_Noir,CM_Clair);
}
if (Jauge_bleue->Position)
{
(Jauge_bleue->Position)--;
Fenetre_Dessiner_jauge(Jauge_bleue);
Modifier_Bleu (Fore_color,(Color_Max-Jauge_bleue->Position)*255/Color_Max,Palette_de_travail);
Formate_composante(Palette_de_travail[Fore_color].B*Color_Max/255,Chaine);
Print_compteur(230,172,Chaine,CM_Noir,CM_Clair);
}
}
else
{
if (Jauge_rouge->Position)
{
(Jauge_rouge->Position)--;
Fenetre_Dessiner_jauge(Jauge_rouge);
}
if (Jauge_verte->Position)
{
(Jauge_verte->Position)--;
Fenetre_Dessiner_jauge(Jauge_verte);
}
if (Jauge_bleue->Position)
{
(Jauge_bleue->Position)--;
Fenetre_Dessiner_jauge(Jauge_bleue);
}
for (i=Debut_block; i<=Fin_block; i++)
{
Modifier_Rouge(i,Palette_temporaire[i].R+(Color_Max-Jauge_rouge->Position)*255/Color_Max,Palette_de_travail);
Modifier_Vert (i,Palette_temporaire[i].V+(Color_Max-Jauge_verte->Position)*255/Color_Max,Palette_de_travail);
Modifier_Bleu (i,Palette_temporaire[i].B+(Color_Max-Jauge_bleue->Position)*255/Color_Max,Palette_de_travail);
}
// -- Rouge --
if (Jauge_rouge->Position>Color_Max)
{
// Jauge dans les négatifs:
Num2str(-(Color_Max-Jauge_rouge->Position),Chaine,4);
Chaine[0]='-';
}
else if (Jauge_rouge->Position<Color_Max)
{
// Jauge dans les positifs:
Num2str( Color_Max-Jauge_rouge->Position ,Chaine,4);
Chaine[0]='+';
}
else
{
// Jauge nulle:
strcpy(Chaine,"± 0");
}
Print_compteur(176,172,Chaine,CM_Noir,CM_Clair);
// -- Vert --
if (Jauge_verte->Position>Color_Max)
{
// Jauge dans les négatifs:
Num2str(-(Color_Max-Jauge_verte->Position),Chaine,4);
Chaine[0]='-';
}
else if (Jauge_verte->Position<Color_Max)
{
// Jauge dans les positifs:
Num2str( Color_Max-Jauge_verte->Position ,Chaine,4);
Chaine[0]='+';
}
else
{
// Jauge nulle:
strcpy(Chaine,"± 0");
}
Print_compteur(203,172,Chaine,CM_Noir,CM_Clair);
// -- Bleu --
if (Jauge_bleue->Position>Color_Max)
{
// Jauge dans les négatifs:
Num2str(-(Color_Max-Jauge_bleue->Position),Chaine,4);
Chaine[0]='-';
}
else if (Jauge_bleue->Position<Color_Max)
{
// Jauge dans les positifs:
Num2str( Color_Max-Jauge_bleue->Position ,Chaine,4);
Chaine[0]='+';
}
else
{
// Jauge nulle:
strcpy(Chaine,"± 0");
}
Print_compteur(230,172,Chaine,CM_Noir,CM_Clair);
}
Il_faut_remapper=1;
Afficher_curseur();
Set_palette(Palette_de_travail);
break;
case 19 : // [-]
if (!Palette_mode_RGB)
break;
Effacer_curseur();
if (Debut_block==Fin_block)
{
if (Jauge_rouge->Position<Color_Max)
{
(Jauge_rouge->Position)++;
Fenetre_Dessiner_jauge(Jauge_rouge);
Modifier_Rouge(Fore_color,(Color_Max-Jauge_rouge->Position)*255/Color_Max,Palette_de_travail);
Formate_composante(Palette_de_travail[Fore_color].R*Color_Max/255,Chaine);
Print_compteur(176,172,Chaine,CM_Noir,CM_Clair);
}
if (Jauge_verte->Position<Color_Max)
{
(Jauge_verte->Position)++;
Fenetre_Dessiner_jauge(Jauge_verte);
Modifier_Vert (Fore_color,(Color_Max-Jauge_verte->Position)*255/Color_Max,Palette_de_travail);
Formate_composante(Palette_de_travail[Fore_color].V*Color_Max/255,Chaine);
Print_compteur(203,172,Chaine,CM_Noir,CM_Clair);
}
if (Jauge_bleue->Position<Color_Max)
{
(Jauge_bleue->Position)++;
Fenetre_Dessiner_jauge(Jauge_bleue);
Modifier_Bleu (Fore_color,(Color_Max-Jauge_bleue->Position)*255/Color_Max,Palette_de_travail);
Formate_composante(Palette_de_travail[Fore_color].B*Color_Max/255,Chaine);
Print_compteur(230,172,Chaine,CM_Noir,CM_Clair);
}
}
else
{
if (Jauge_rouge->Position<(Color_Max*2))
{
(Jauge_rouge->Position)++;
Fenetre_Dessiner_jauge(Jauge_rouge);
}
if (Jauge_verte->Position<(Color_Max*2))
{
(Jauge_verte->Position)++;
Fenetre_Dessiner_jauge(Jauge_verte);
}
if (Jauge_bleue->Position<(Color_Max*2))
{
(Jauge_bleue->Position)++;
Fenetre_Dessiner_jauge(Jauge_bleue);
}
for (i=Debut_block; i<=Fin_block; i++)
{
Modifier_Rouge(i,Palette_temporaire[i].R+(Color_Max-Jauge_rouge->Position)*255/Color_Max,Palette_de_travail);
Modifier_Vert (i,Palette_temporaire[i].V+(Color_Max-Jauge_verte->Position)*255/Color_Max,Palette_de_travail);
Modifier_Bleu (i,Palette_temporaire[i].B+(Color_Max-Jauge_bleue->Position)*255/Color_Max,Palette_de_travail);
}
// -- Rouge --
if (Jauge_rouge->Position>Color_Max)
{
// Jauge dans les négatifs:
Num2str(-(Color_Max-Jauge_rouge->Position),Chaine,4);
Chaine[0]='-';
}
else if (Jauge_rouge->Position<Color_Max)
{
// Jauge dans les positifs:
Num2str( Color_Max-Jauge_rouge->Position ,Chaine,4);
Chaine[0]='+';
}
else
{
// Jauge nulle:
strcpy(Chaine,"± 0");
}
Print_compteur(176,172,Chaine,CM_Noir,CM_Clair);
// -- Vert --
if (Jauge_verte->Position>Color_Max)
{
// Jauge dans les négatifs:
Num2str(-(Color_Max-Jauge_verte->Position),Chaine,4);
Chaine[0]='-';
}
else if (Jauge_verte->Position<Color_Max)
{
// Jauge dans les positifs:
Num2str( Color_Max-Jauge_verte->Position ,Chaine,4);
Chaine[0]='+';
}
else
{
// Jauge nulle:
strcpy(Chaine,"± 0");
}
Print_compteur(203,172,Chaine,CM_Noir,CM_Clair);
// -- Bleu --
if (Jauge_bleue->Position>Color_Max)
{
// Jauge dans les négatifs:
Num2str(-(Color_Max-Jauge_bleue->Position),Chaine,4);
Chaine[0]='-';
}
else if (Jauge_bleue->Position<Color_Max)
{
// Jauge dans les positifs:
Num2str( Color_Max-Jauge_bleue->Position ,Chaine,4);
Chaine[0]='+';
}
else
{
// Jauge nulle:
strcpy(Chaine,"± 0");
}
Print_compteur(230,172,Chaine,CM_Noir,CM_Clair);
}
Il_faut_remapper=1;
Afficher_curseur();
Set_palette(Palette_de_travail);
break;
case 20 : // Negative
// Backup
memcpy(Palette_backup,Palette_de_travail,sizeof(T_Palette));
// Negative
for (i=Debut_block;i<=Fin_block;i++)
{
Modifier_Rouge(i,255-Palette_de_travail[i].R,Palette_de_travail);
Modifier_Vert (i,255-Palette_de_travail[i].V,Palette_de_travail);
Modifier_Bleu (i,255-Palette_de_travail[i].B,Palette_de_travail);
}
Palette_Reafficher_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,Palette_de_travail,Debut_block,Fin_block);
Set_palette(Palette_de_travail);
// On prépare la "modifiabilité" des nouvelles couleurs
memcpy(Palette_temporaire,Palette_de_travail,sizeof(T_Palette));
Il_faut_remapper=1;
break;
case 21 : // Inversion
case 22 : // X-Inversion
// Backup
memcpy(Palette_backup,Palette_de_travail,sizeof(T_Palette));
// On initialise la table de conversion
for (i=0; i<=255; i++)
Table_de_conversion[i]=i;
// Inversion
for (i=Debut_block;i<=Fin_block;i++)
{
Couleur_temporaire=Fin_block-(i-Debut_block);
Modifier_Rouge(i,Palette_backup[Couleur_temporaire].R,Palette_de_travail);
Modifier_Vert (i,Palette_backup[Couleur_temporaire].V,Palette_de_travail);
Modifier_Bleu (i,Palette_backup[Couleur_temporaire].B,Palette_de_travail);
if (Bouton_clicke==22)
{
Table_de_conversion[i]=Couleur_temporaire;
Table_de_conversion[Couleur_temporaire]=i;
Temp=Utilisation_couleur[i];
Utilisation_couleur[i]=Utilisation_couleur[Couleur_temporaire];
Utilisation_couleur[Couleur_temporaire]=Temp;
}
}
Palette_Reafficher_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,Palette_de_travail,Debut_block,Fin_block);
// Si on est en X-Invert, on remap l'image (=> on fait aussi 1 backup)
if (Bouton_clicke==22)
{
if (!Backup_de_l_image_effectue)
{
Backup();
Backup_de_l_image_effectue=1;
}
Effacer_curseur();
Remap_image_HIGH(Table_de_conversion);
Afficher_curseur();
}
// On prépare la "modifiabilité" des nouvelles couleurs
Set_palette(Palette_de_travail);
memcpy(Palette_temporaire,Palette_de_travail,sizeof(T_Palette));
Il_faut_remapper=1;
break;
case 23 : // Saisie du nombre de couleurs pour la réduction de palette
Num2str(Reduce_Nb_couleurs,Chaine,3);
Effacer_curseur();
if (Readline(265,41,Chaine,3,1))
{
Couleur_temporaire=atoi(Chaine);
// Correction de la valeur lue
if ( (Couleur_temporaire>256) || (Couleur_temporaire<2) )
{
if (Couleur_temporaire>256)
Couleur_temporaire=256;
else
Couleur_temporaire=2;
Num2str(Couleur_temporaire,Chaine,3);
Fenetre_Contenu_bouton_saisie(Fenetre_Liste_boutons_special,Chaine);
}
Reduce_Nb_couleurs=Couleur_temporaire;
}
Afficher_curseur();
break;
case 24 : // HSL <> RGB
// Acte les changements en cours sur une ou plusieurs couleurs
memcpy(Palette_temporaire,Palette_de_travail,sizeof(T_Palette));
memcpy(Palette_backup ,Palette_de_travail,sizeof(T_Palette));
Palette_mode_RGB = !Palette_mode_RGB;
if(! Palette_mode_RGB)
{
// On passe en HSL
Print_dans_fenetre(184,71,"H",CM_Fonce,CM_Clair);
Print_dans_fenetre(211,71,"S",CM_Fonce,CM_Clair);
Print_dans_fenetre(238,71,"L",CM_Fonce,CM_Clair);
Unite_Composantes(256);
}
else
{
// On passe en RGB
Print_dans_fenetre(184,71,"R",CM_Fonce,CM_Clair);
Print_dans_fenetre(211,71,"G",CM_Fonce,CM_Clair);
Print_dans_fenetre(238,71,"B",CM_Fonce,CM_Clair);
Unite_Composantes(Graduations_RGB);
}
Afficher_les_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,(Debut_block!=Fin_block),Palette_de_travail);
break;
case 25 : // Sort palette
{
byte h = 0, l = 0, s=0;
byte oh=0,ol=0,os=0; // Valeur pour la couleur précédente
int swap=1;
while(swap==1)
{
swap=0;
h=0;l=0;s=0;
for(Couleur_temporaire=0;Couleur_temporaire<256;Couleur_temporaire++)
{
oh=h; ol=l; os=s;
// On trie par Chrominance (H) et Luminance (L)
RGBtoHSL(Palette_de_travail[Couleur_temporaire].R,
Palette_de_travail[Couleur_temporaire].V,
Palette_de_travail[Couleur_temporaire].B,&h,&s,&l);
if(
((s==0) && (os>0)) // Un gris passe devant une couleur saturée
|| (((s>0 && os > 0) || (s==os && s==0)) // Deux couleurs saturées ou deux gris...
&& (h<oh || (h==oh && l<ol)))) // Dans ce cas on décide avec chroma puis lumi
{
// On échange la couleur avec la précédente
Swap(0,Couleur_temporaire,Couleur_temporaire-1,1,Palette_de_travail,Utilisation_couleur);
swap=1;
}
}
}
// Maintenant, tous ces calculs doivent êtres pris en compte dans la
// palette, l'image et à l'écran.
Set_palette(Palette_de_travail);
Il_faut_remapper=1;
}
break;
}
if (!Mouse_K)
{
switch (Touche)
{
case SDLK_LEFTBRACKET : // Décaler Forecolor vers la gauche
if (Debut_block==Fin_block)
{
Fore_color--;
Premiere_couleur--;
Derniere_couleur--;
Debut_block--;
Fin_block--;
Palette_Reafficher_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,Palette_de_travail,Debut_block,Fin_block);
Effacer_curseur();
Tagger_intervalle_palette(Debut_block,Fin_block);
// Affichage du n° de la couleur sélectionnée
Num2str(Fore_color,Chaine,3);
Print_dans_fenetre(237,58,Chaine,CM_Noir,CM_Clair);
// Affichage dans le block de visu de la couleur en cours
Block(Fenetre_Pos_X+(Menu_Facteur_X*264),Fenetre_Pos_Y+(Menu_Facteur_Y*93),Menu_Facteur_X<<4,Menu_Facteur_Y*64,Fore_color);
UpdateRect(Fenetre_Pos_X+(Menu_Facteur_X*264),Fenetre_Pos_Y+(Menu_Facteur_Y*93),Menu_Facteur_X<<4,Menu_Facteur_Y*64);
Afficher_curseur();
}
break;
case SDLK_RIGHTBRACKET : // Décaler Forecolor vers la droite
if (Debut_block==Fin_block)
{
Fore_color++;
Premiere_couleur++;
Derniere_couleur++;
Debut_block++;
Fin_block++;
Palette_Reafficher_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,Palette_de_travail,Debut_block,Fin_block);
Effacer_curseur();
Tagger_intervalle_palette(Debut_block,Fin_block);
// Affichage du n° de la couleur sélectionnée
Num2str(Fore_color,Chaine,3);
Print_dans_fenetre(237,58,Chaine,CM_Noir,CM_Clair);
// Affichage dans le block de visu de la couleur en cours
Block(Fenetre_Pos_X+(Menu_Facteur_X*264),Fenetre_Pos_Y+(Menu_Facteur_Y*93),Menu_Facteur_X<<4,Menu_Facteur_Y*64,Fore_color);
UpdateRect(Fenetre_Pos_X+(Menu_Facteur_X*264),Fenetre_Pos_Y+(Menu_Facteur_Y*93),Menu_Facteur_X<<4,Menu_Facteur_Y*64);
Afficher_curseur();
}
break;
case (SDLK_LEFTBRACKET|MOD_SHIFT) : // Decaler Backcolor vers la gauche
Back_color--;
case (SDLK_RIGHTBRACKET|MOD_SHIFT) : // Decaler Backcolor vers la droite
// attention: pas de break ci-dessus
if (Touche==(SDLK_RIGHTBRACKET|MOD_SHIFT))
Back_color++;
Effacer_curseur();
Block(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y* 89),Menu_Facteur_X*24,Menu_Facteur_Y<<2,Back_color);
Block(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y*157),Menu_Facteur_X*24,Menu_Facteur_Y<<2,Back_color);
Block(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y* 93),Menu_Facteur_X<<2,Menu_Facteur_Y<<6,Back_color);
Block(Fenetre_Pos_X+(Menu_Facteur_X*280),Fenetre_Pos_Y+(Menu_Facteur_Y* 93),Menu_Facteur_X<<2,Menu_Facteur_Y<<6,Back_color);
UpdateRect(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y* 89),Menu_Facteur_X*32,Menu_Facteur_Y*72);
Afficher_curseur();
break;
case SDLK_BACKSPACE : // Remise des couleurs du menu à l'état normal en essayant
// de ne pas trop modifier l'image.
if (!Backup_de_l_image_effectue)
{
Backup();
Backup_de_l_image_effectue=1;
}
if (Nb_couleurs_utilisees==-1)
Compter_nb_couleurs_utilisees(&Nb_couleurs_utilisees,Utilisation_couleur);
memcpy(Palette_backup,Palette_de_travail,sizeof(T_Palette));
memcpy(Palette_temporaire,Principal_Palette,sizeof(T_Palette));
memcpy(Principal_Palette,Palette_de_travail,sizeof(T_Palette));
Remettre_proprement_les_couleurs_du_menu(Utilisation_couleur);
memcpy(Palette_de_travail,Principal_Palette,sizeof(T_Palette));
memcpy(Principal_Palette,Palette_temporaire,sizeof(T_Palette));
Set_palette(Palette_de_travail);
memcpy(Palette_temporaire,Palette_de_travail,sizeof(T_Palette));
Palette_Reafficher_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,Palette_de_travail,Debut_block,Fin_block);
Compter_nb_couleurs_utilisees(&Nb_couleurs_utilisees,Utilisation_couleur);
Il_faut_remapper=1;
break;
case SDLK_BACKQUOTE : // Récupération d'une couleur derrière le menu
case SDLK_COMMA :
Recuperer_couleur_derriere_fenetre(&Couleur,&Click);
if (Click)
{
Effacer_curseur();
if (Click==A_DROITE)
{
if (Back_color!=Couleur)
{
Back_color=Couleur;
// 4 blocks de back_color entourant la fore_color
Block(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y* 89),Menu_Facteur_X*24,Menu_Facteur_Y<<2,Back_color);
Block(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y*157),Menu_Facteur_X*24,Menu_Facteur_Y<<2,Back_color);
Block(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y* 93),Menu_Facteur_X<<2,Menu_Facteur_Y<<6,Back_color);
Block(Fenetre_Pos_X+(Menu_Facteur_X*280),Fenetre_Pos_Y+(Menu_Facteur_Y* 93),Menu_Facteur_X<<2,Menu_Facteur_Y<<6,Back_color);
UpdateRect(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y* 89),Menu_Facteur_X*32,Menu_Facteur_Y*72);
}
}
else
{
Fore_color=Premiere_couleur=Derniere_couleur=Debut_block=Fin_block=Couleur;
Tagger_intervalle_palette(Debut_block,Fin_block);
// Affichage du n° de la couleur sélectionnée
Block(Fenetre_Pos_X+(Menu_Facteur_X*261),Fenetre_Pos_Y+(Menu_Facteur_Y*58),Menu_Facteur_X*32,Menu_Facteur_Y*7,CM_Clair);
Num2str(Fore_color,Chaine,3);
Print_dans_fenetre(237,58,Chaine,CM_Noir,CM_Clair);
// Affichage des jauges
Afficher_les_jauges(Jauge_rouge,Jauge_verte,Jauge_bleue,0,Palette_de_travail);
// Affichage dans le block de visu de la couleur en cours
Block(Fenetre_Pos_X+(Menu_Facteur_X*264),Fenetre_Pos_Y+(Menu_Facteur_Y*93),Menu_Facteur_X<<4,Menu_Facteur_Y*64,Fore_color);
UpdateRect(Fenetre_Pos_X+(Menu_Facteur_X*264),Fenetre_Pos_Y+(Menu_Facteur_Y*93),Menu_Facteur_X<<4,Menu_Facteur_Y*64);
memcpy(Palette_backup ,Palette_de_travail,sizeof(T_Palette));
memcpy(Palette_temporaire,Palette_de_travail,sizeof(T_Palette));
}
Afficher_curseur();
}
break;
default:
if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche)
{
Fenetre_aide(BOUTON_PALETTE, NULL);
break;
}
}
if (Il_faut_remapper)
{
Effacer_curseur();
Calculer_couleurs_menu_optimales(Palette_de_travail);
// On remappe brutalement
Remapper_ecran_apres_changement_couleurs_menu();
// Puis on remet les trucs qui ne devaient pas changer
Fenetre_Dessiner_bouton_palette(5,79);
Block(Fenetre_Pos_X+(Menu_Facteur_X*260),Fenetre_Pos_Y+(Menu_Facteur_Y*89),Menu_Facteur_X*24,Menu_Facteur_Y*72,Back_color);
Bloc_degrade_dans_fenetre(264,93,Debut_block,Fin_block);
UpdateRect(Fenetre_Pos_X+8*Menu_Facteur_X,Fenetre_Pos_Y+82*Menu_Facteur_Y,Menu_Facteur_X*16*10,Menu_Facteur_Y*5*16);
Afficher_curseur();
Il_faut_remapper=0;
}
}
}
while ((Bouton_clicke!=13) && (Bouton_clicke!=14));
if (Bouton_clicke==14) // Sortie par OK
{
if ( (!Backup_de_l_image_effectue)
&& memcmp(Principal_Palette,Palette_de_travail,sizeof(T_Palette)) )
Backup();
memcpy(Principal_Palette,Palette_de_travail,sizeof(T_Palette));
}
Calculer_couleurs_menu_optimales(Principal_Palette);
// La variable employée ici n'a pas vraiment de rapport avec son nom...
Il_faut_remapper=(Fenetre_Pos_Y+(Fenetre_Hauteur*Menu_Facteur_Y)<Menu_Ordonnee_avant_fenetre);
Fermer_fenetre();
Desenclencher_bouton(BOUTON_PALETTE);
Recadrer_palette();
// On affiche les "ForeBack" car le menu n'est raffiché que si la fenêtre
// empiétait sur le menu. Mais si les couleurs on été modifiées, il faut
// rafficher tout le menu remappé.
if (Il_faut_remapper)
Afficher_menu();
Afficher_curseur();
if (Bouton_clicke==13) // Sortie par CANCEL
{
Set_palette(Principal_Palette);
if (Backup_de_l_image_effectue)
Enclencher_bouton(BOUTON_UNDO,A_GAUCHE);
}
free(Palette_backup);
free(Palette_temporaire);
free(Palette_de_travail);
}
//---------------------- Menu de palettes secondaires ------------------------
void Bouton_Palette_secondaire(void)
{
short Bouton_clicke;
byte Dummy;
Ouvrir_fenetre(200,80,"Palettes");
Fenetre_Definir_bouton_normal(10,20,180,14,"Colors for best match",12,1,SDLK_b); // 1
Fenetre_Definir_bouton_normal(10,37,180,14,"User's color series" ,14,0,SDLK_s); // 2
Fenetre_Definir_bouton_normal(60,60, 80,14,"Cancel" , 0,1,SDLK_ESCAPE); // 3
UpdateRect(Fenetre_Pos_X,Fenetre_Pos_Y,Menu_Facteur_X*200,Menu_Facteur_Y*80);
Afficher_curseur();
do
{
Bouton_clicke=Fenetre_Bouton_clicke();
if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche)
Fenetre_aide(BOUTON_PALETTE, NULL);
}
while (Bouton_clicke<=0);
Fermer_fenetre();
Desenclencher_bouton(BOUTON_PALETTE);
Afficher_curseur();
if (Bouton_clicke==1)
{
Menu_Tag_couleurs("Tag colors to exclude",Exclude_color,&Dummy,1, NULL);
}
/*
else
{
if (Bouton_clicke==2)
{
}
}
*/
}
Reference in New Issue View Git Blame Copy Permalink