m/grafX2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
grafX2/moteur.c
Yves Rizoud 994c1ce713 Text tool: fixed font selection, was off by 2 pixels. 
Menus: scrollbars are now dark, to make iLKke happy.


git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@694 416bcca6-2ee7-4201-b75f-2eb2f807beb1
2009-03-24 14:39:19 +00:00

2562 lines
79 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.
*/
//
// Ce fichier contient la gestion du moteur
//
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "const.h"
#include "struct.h"
#include "global.h"
#include "graph.h"
#include "divers.h"
#include "special.h"
#include "boutons.h"
#include "operatio.h"
#include "shade.h"
#include "erreurs.h"
#include "sdlscreen.h"
#include "windows.h"
#include "brush.h"
#include "input.h"
#include "moteur.h"
// we need this as global
short Old_MX = -1;
short Old_MY = -1;
//---------- Annuler les effets des modes de dessin (sauf la grille) ---------
// Variables mémorisants les anciens effets
byte Shade_Mode_avant_annulation;
byte Quick_shade_Mode_avant_annulation;
byte Stencil_Mode_avant_annulation;
byte Trame_Mode_avant_annulation;
byte Colorize_Mode_avant_annulation;
byte Smooth_Mode_avant_annulation;
byte Tiling_Mode_avant_annulation;
fonction_effet Fonction_effet_avant_annulation;
byte* Fond_fenetre[8];
void Annuler_les_effets(void)
{
Shade_Mode_avant_annulation=Shade_Mode;
Shade_Mode=0;
Quick_shade_Mode_avant_annulation=Quick_shade_Mode;
Quick_shade_Mode=0;
Stencil_Mode_avant_annulation=Stencil_Mode;
Stencil_Mode=0;
Trame_Mode_avant_annulation=Trame_Mode;
Trame_Mode=0;
Colorize_Mode_avant_annulation=Colorize_Mode;
Colorize_Mode=0;
Smooth_Mode_avant_annulation=Smooth_Mode;
Smooth_Mode=0;
Tiling_Mode_avant_annulation=Tiling_Mode;
Tiling_Mode=0;
Fonction_effet_avant_annulation=Fonction_effet;
Fonction_effet=Aucun_effet;
}
//----------------- Restaurer les effets des modes de dessin -----------------
void Restaurer_les_effets(void)
{
Shade_Mode =Shade_Mode_avant_annulation;
Quick_shade_Mode=Quick_shade_Mode_avant_annulation;
Stencil_Mode =Stencil_Mode_avant_annulation;
Trame_Mode =Trame_Mode_avant_annulation;
Colorize_Mode =Colorize_Mode_avant_annulation;
Smooth_Mode =Smooth_Mode_avant_annulation;
Tiling_Mode =Tiling_Mode_avant_annulation;
Fonction_effet =Fonction_effet_avant_annulation;
}
char * TITRE_BOUTON[NB_BOUTONS]=
{
"Paintbrush choice ",
"Adjust picture / Effects",
"Freehand draw. / Toggle ",
"Splines / Toggle ",
"Lines / Toggle ",
"Spray / Menu ",
"Floodfill / Replace col.",
"Polylines / Polyforms ",
"Polyfill / Filled Pforms",
"Empty rectangles ",
"Filled rectangles ",
"Empty circles / ellipses",
"Filled circles / ellips.",
"Grad. rectangles ",
"Gradation menu ",
"Grad. spheres / ellipses",
"Brush grab. / Restore ",
"Lasso / Restore brush ",
"Brush effects ",
"Drawing modes (effects) ",
"Text ",
"Magnify mode / Menu ",
"Pipette / Invert colors ",
"Screen size / Safe. res.",
"Go / Copy to other page ",
"Save as / Save ",
"Load / Re-load ",
"Settings ",
"Clear / with backcolor ",
"Help / Statistics ",
"Undo / Redo ",
"Kill current page ",
"Quit ",
"Palette editor ",
"Scroll pal. left / Fast ",
"Scroll pal. right / Fast",
"Color #" ,
"Hide tool bar "
};
// Sauvegarde un bloc (généralement l'arrière-plan d'une fenêtre)
void Sauve_fond(byte **Buffer, int x_pos, int y_pos, int width, int height)
{
int Indice;
if(*Buffer != NULL) DEBUG("WARNING : Buffer already allocated !!!",0);
*Buffer=(byte *) malloc(width*Menu_Facteur_X*height*Menu_Facteur_Y*Pixel_width);
for (Indice=0; Indice<(height*Menu_Facteur_Y); Indice++)
Lire_ligne(x_pos,y_pos+Indice,width*Menu_Facteur_X,(*Buffer)+((int)Indice*width*Menu_Facteur_X*Pixel_width));
}
// Restaure de ce que la fenêtre cachait
void Restaure_fond(byte *Buffer, int x_pos, int y_pos, int width, int height)
{
int Indice;
for (Indice=0; Indice<height*Menu_Facteur_Y; Indice++)
Afficher_ligne_fast(x_pos,y_pos+Indice,width*Menu_Facteur_X,Buffer+((int)Indice*width*Menu_Facteur_X*Pixel_width));
free(Buffer);
}
// Ecrit un pixel dans un fond de fenêtre
void Pixel_fond(int x_pos, int y_pos, byte Couleur)
{
int Repetitions_X=Pixel_width;
while (Repetitions_X--)
(Fond_fenetre[0][x_pos*Pixel_width+Repetitions_X+y_pos*Fenetre_Largeur*Pixel_width*Menu_Facteur_X])=Couleur;
}
int Numero_bouton_sous_souris(void)
{
int btn_number;
short x_pos;
short y_pos;
x_pos=(Mouse_X )/Menu_Facteur_X;
y_pos=(Mouse_Y-Menu_Ordonnee)/Menu_Facteur_Y;
for (btn_number=0;btn_number<NB_BOUTONS;btn_number++)
{
switch(Bouton[btn_number].Shape)
{
case FORME_BOUTON_SANS_CADRE :
case FORME_BOUTON_RECTANGLE :
if ((x_pos>=Bouton[btn_number].Decalage_X) &&
(y_pos>=Bouton[btn_number].Decalage_Y) &&
(x_pos<=Bouton[btn_number].Decalage_X+Bouton[btn_number].Width) &&
(y_pos<=Bouton[btn_number].Decalage_Y+Bouton[btn_number].Height))
return btn_number;
break;
case FORME_BOUTON_TRIANGLE_HAUT_GAUCHE:
if ((x_pos>=Bouton[btn_number].Decalage_X) &&
(y_pos>=Bouton[btn_number].Decalage_Y) &&
(x_pos+y_pos-(short)Bouton[btn_number].Decalage_Y-(short)Bouton[btn_number].Decalage_X<=Bouton[btn_number].Width))
return btn_number;
break;
case FORME_BOUTON_TRIANGLE_BAS_DROITE:
if ((x_pos<=Bouton[btn_number].Decalage_X+Bouton[btn_number].Width) &&
(y_pos<=Bouton[btn_number].Decalage_Y+Bouton[btn_number].Height) &&
(x_pos+y_pos-(short)Bouton[btn_number].Decalage_Y-(short)Bouton[btn_number].Decalage_X>=Bouton[btn_number].Width))
return btn_number;
break;
}
}
return -1;
}
void Tracer_cadre_de_bouton_du_menu(byte btn_number,byte pressed)
{
byte Couleur_Haut_gauche;
byte Couleur_Bas_droite;
byte Couleur_Diagonale;
word Debut_X;
word Debut_Y;
word Fin_X;
word Fin_Y;
word x_pos;
word y_pos;
Debut_X=Bouton[btn_number].Decalage_X;
Debut_Y=Bouton[btn_number].Decalage_Y;
Fin_X =Debut_X+Bouton[btn_number].Width;
Fin_Y =Debut_Y+Bouton[btn_number].Height;
if (!pressed)
{
Couleur_Haut_gauche=CM_Blanc;
Couleur_Bas_droite=CM_Fonce;
Couleur_Diagonale=CM_Clair;
}
else
{
Couleur_Haut_gauche=CM_Fonce;
Couleur_Bas_droite=CM_Noir;
Couleur_Diagonale=CM_Fonce;
}
switch(Bouton[btn_number].Shape)
{
case FORME_BOUTON_SANS_CADRE :
break;
case FORME_BOUTON_RECTANGLE :
// On colorie le point haut droit
Pixel_dans_menu(Fin_X,Debut_Y,Couleur_Diagonale);
BLOCK_MENU[Debut_Y][Fin_X]=Couleur_Diagonale;
// On colorie le point bas gauche
Pixel_dans_menu(Debut_X,Fin_Y,Couleur_Diagonale);
BLOCK_MENU[Fin_Y][Debut_X]=Couleur_Diagonale;
// On colorie la partie haute
for (x_pos=Debut_X;x_pos<=Fin_X-1;x_pos++)
{
Pixel_dans_menu(x_pos,Debut_Y,Couleur_Haut_gauche);
BLOCK_MENU[Debut_Y][x_pos]=Couleur_Haut_gauche;
}
for (y_pos=Debut_Y+1;y_pos<=Fin_Y-1;y_pos++)
{
// On colorie la partie gauche
Pixel_dans_menu(Debut_X,y_pos,Couleur_Haut_gauche);
BLOCK_MENU[y_pos][Debut_X]=Couleur_Haut_gauche;
// On colorie la partie droite
Pixel_dans_menu(Fin_X,y_pos,Couleur_Bas_droite);
BLOCK_MENU[y_pos][Fin_X]=Couleur_Bas_droite;
}
// On colorie la partie basse
for (x_pos=Debut_X+1;x_pos<=Fin_X;x_pos++)
{
Pixel_dans_menu(x_pos,Fin_Y,Couleur_Bas_droite);
BLOCK_MENU[Fin_Y][x_pos]=Couleur_Bas_droite;
}
break;
case FORME_BOUTON_TRIANGLE_HAUT_GAUCHE:
// On colorie le point haut droit
Pixel_dans_menu(Fin_X,Debut_Y,Couleur_Diagonale);
BLOCK_MENU[Debut_Y][Fin_X]=Couleur_Diagonale;
// On colorie le point bas gauche
Pixel_dans_menu(Debut_X,Fin_Y,Couleur_Diagonale);
BLOCK_MENU[Fin_Y][Debut_X]=Couleur_Diagonale;
// On colorie le coin haut gauche
for (x_pos=0;x_pos<Bouton[btn_number].Width;x_pos++)
{
Pixel_dans_menu(Debut_X+x_pos,Debut_Y,Couleur_Haut_gauche);
BLOCK_MENU[Debut_Y][Debut_X+x_pos]=Couleur_Haut_gauche;
Pixel_dans_menu(Debut_X,Debut_Y+x_pos,Couleur_Haut_gauche);
BLOCK_MENU[Debut_Y+x_pos][Debut_X]=Couleur_Haut_gauche;
}
// On colorie la diagonale
for (x_pos=1;x_pos<Bouton[btn_number].Width;x_pos++)
{
Pixel_dans_menu(Debut_X+x_pos,Fin_Y-x_pos,Couleur_Bas_droite);
BLOCK_MENU[Fin_Y-x_pos][Debut_X+x_pos]=Couleur_Bas_droite;
}
break;
case FORME_BOUTON_TRIANGLE_BAS_DROITE:
// On colorie le point haut droit
Pixel_dans_menu(Fin_X,Debut_Y,Couleur_Diagonale);
BLOCK_MENU[Debut_Y][Fin_X]=Couleur_Diagonale;
// On colorie le point bas gauche
Pixel_dans_menu(Debut_X,Fin_Y,Couleur_Diagonale);
BLOCK_MENU[Fin_Y][Debut_X]=Couleur_Diagonale;
// On colorie la diagonale
for (x_pos=1;x_pos<Bouton[btn_number].Width;x_pos++)
{
Pixel_dans_menu(Debut_X+x_pos,Fin_Y-x_pos,Couleur_Haut_gauche);
BLOCK_MENU[Fin_Y-x_pos][Debut_X+x_pos]=Couleur_Haut_gauche;
}
// On colorie le coin bas droite
for (x_pos=0;x_pos<Bouton[btn_number].Width;x_pos++)
{
Pixel_dans_menu(Fin_X-x_pos,Fin_Y,Couleur_Bas_droite);
BLOCK_MENU[Fin_Y][Fin_X-x_pos]=Couleur_Bas_droite;
Pixel_dans_menu(Fin_X,Fin_Y-x_pos,Couleur_Bas_droite);
BLOCK_MENU[Fin_Y-x_pos][Fin_X]=Couleur_Bas_droite;
}
}
if (Menu_visible)
{
UpdateRect(
Debut_X*Menu_Facteur_X,
Debut_Y*Menu_Facteur_Y + Menu_Ordonnee,
(Fin_X+1-Debut_X)*Menu_Facteur_X,
(Fin_Y+1-Debut_Y)*Menu_Facteur_Y);
}
}
//---------------------- Désenclenchement d'un bouton ------------------------
void Desenclencher_bouton(int btn_number)
{
if (Bouton[btn_number].Enfonce)
{
// On affiche le cadre autour du bouton de façon à ce qu'il paraisse relâché
Tracer_cadre_de_bouton_du_menu(btn_number,BOUTON_RELACHE);
// On considère que le bouton est relâché
Bouton[btn_number].Enfonce=BOUTON_RELACHE;
// On appelle le désenclenchement particulier au bouton:
Bouton[btn_number].Desenclencher();
}
}
//-Enclenchement d'un bouton (et désenclenchement de ceux de la même famille)-
void Enclencher_bouton(int btn_number,byte click)
{
int family;
int b;
int Icone;
Effacer_curseur();
// Certains boutons ont deux icones
Icone=-1;
switch(btn_number)
{
case BOUTON_POLYGONES:
case BOUTON_POLYFILL:
Icone=12;break;
case BOUTON_FLOODFILL:
Icone=14;break;
case BOUTON_CERCLES:
case BOUTON_FILLCERC:
Icone=10;break;
case BOUTON_SPHERES:
Icone=16;break;
}
if (Icone!=-1)
Afficher_sprite_dans_menu(btn_number,Icone+(click==A_DROITE));
// On note déjà la famille du bouton (La "Famiglia" c'est sacré)
family=Bouton[btn_number].Famille;
switch (family)
{
case FAMILLE_TOOLBAR: // On ne fait rien (on préserve les interruptions)
break;
case FAMILLE_INTERRUPTION: // Petit cas spécial dans la famille "Interruption":
if ((btn_number!=BOUTON_LOUPE) || (!Loupe_Mode))
// Pour chaque bouton:
for (b=0; b<NB_BOUTONS; b++)
// S'il est de la même famille
if (
(b!=btn_number) &&
(Bouton[b].Famille==FAMILLE_INTERRUPTION) &&
( (b!=BOUTON_LOUPE) ||
((b==BOUTON_LOUPE) && (!Loupe_Mode)) )
)
// Alors on désenclenche le bouton
Desenclencher_bouton(b);
break;
default:
// On désenclenche D'ABORD les interruptions
// Pour chaque bouton:
for (b=0; b<NB_BOUTONS; b++)
// S'il est de la famille interruption
if ( (b!=btn_number)
&& (Bouton[b].Famille==FAMILLE_INTERRUPTION)
// Et que ce n'est pas la loupe, ou alors qu'on n'est pas en mode loupe
&& (!(Loupe_Mode && (b==BOUTON_LOUPE))) )
// Alors on désenclenche le bouton
Desenclencher_bouton(b);
// Pour chaque bouton:
for (b=0; b<NB_BOUTONS; b++)
// S'il est de la même famille
if ( (b!=btn_number)
&& (Bouton[b].Famille==family) )
// Alors on désenclenche le bouton
Desenclencher_bouton(b);
}
// On affiche le cadre autour du bouton de façon à ce qu'il paraisse enfoncé
Tracer_cadre_de_bouton_du_menu(btn_number,BOUTON_ENFONCE);
Afficher_curseur();
// On attend ensuite que l'utilisateur lâche son bouton:
Attendre_fin_de_click();
// On considère que le bouton est enfoncé
Bouton[btn_number].Enfonce=BOUTON_ENFONCE;
// Puis on se contente d'appeler l'action correspondant au bouton:
if (click==1)
Bouton[btn_number].Gauche();
else
Bouton[btn_number].Droite();
}
//--- Déplacer la barre de séparation entre la partie zoomée et la partie ----
//------------------ non-zoomée lorsqu'on est en mode loupe ------------------
void Deplacer_Split(void)
{
short Ancien_Split=Principal_Split;
short Ancien_X_Zoom=Principal_X_Zoom;
short offset=Principal_X_Zoom-Mouse_X;
byte Ancienne_forme_curseur=Forme_curseur;
short Ancien_Mouse_X=-1;
// Afficher la barre en XOR
Effacer_curseur();
Fenetre=1;
Forme_curseur=FORME_CURSEUR_HORIZONTAL;
Ligne_verticale_XOR(Principal_Split,0,Menu_Ordonnee);
Ligne_verticale_XOR(Principal_X_Zoom-1,0,Menu_Ordonnee);
Afficher_curseur();
UpdateRect(Principal_Split,0,abs(Principal_Split-Principal_X_Zoom)+1,Menu_Ordonnee);
while (Mouse_K)
{
if (Mouse_X!=Ancien_Mouse_X)
{
Ancien_Mouse_X=Mouse_X;
Principal_Proportion_split=(float)(Mouse_X+offset)/Largeur_ecran;
Calculer_split();
if (Principal_X_Zoom!=Ancien_X_Zoom)
{
Effacer_curseur();
// Effacer la barre en XOR
Ligne_verticale_XOR(Ancien_Split,0,Menu_Ordonnee);
Ligne_verticale_XOR(Ancien_X_Zoom-1,0,Menu_Ordonnee);
UpdateRect(Ancien_Split,0,abs(Ancien_Split-Ancien_X_Zoom)+1,Menu_Ordonnee);
Ancien_Split=Principal_Split;
Ancien_X_Zoom=Principal_X_Zoom;
// Rafficher la barre en XOR
Ligne_verticale_XOR(Principal_Split,0,Menu_Ordonnee);
Ligne_verticale_XOR(Principal_X_Zoom-1,0,Menu_Ordonnee);
UpdateRect(Principal_Split,0,abs(Principal_Split-Principal_X_Zoom)+1,Menu_Ordonnee);
Afficher_curseur();
}
}
if(!Get_input())Wait_VBL();
}
// Effacer la barre en XOR
Effacer_curseur();
Ligne_verticale_XOR(Principal_Split,0,Menu_Ordonnee);
Ligne_verticale_XOR(Principal_X_Zoom-1,0,Menu_Ordonnee);
Fenetre=0;
Forme_curseur=Ancienne_forme_curseur;
Calculer_donnees_loupe();
Recadrer_ecran_par_rapport_au_zoom();
Calculer_limites();
Afficher_ecran();
Afficher_curseur();
}
//======================= Gestion principale du moteur =======================
void Gestion_principale(void)
{
static byte Temp_color;
int Indice_bouton; // Numéro de bouton de menu en cours
int Indice_bouton_precedent=0; // Numéro de bouton de menu sur lequel on était précédemment
byte Blink; // L'opération demande un effacement du curseur
int Bouton_Touche; // Bouton à enclencher d'après la touche de raccourci enfoncée
byte Bouton_Cote = 0; // Côté du bouton à enclencher d'après la touche de raccourci enfoncée
int Indice_Touche; // Indice du tableau de touches spéciales correspondant à la touche enfoncée
char Chaine[25];
byte Temp;
do
{
if(Get_input())
{
// Redimensionnement demandé
if (Resize_Largeur || Resize_Hauteur)
{
Effacer_curseur();
Initialiser_mode_video(Resize_Largeur, Resize_Hauteur, 0);
Mode_video[0].Width = Largeur_ecran*Pixel_width;
Mode_video[0].Height = Hauteur_ecran*Pixel_height;
// Remise à zero des variables indiquant le Redimensionnement demandé
Afficher_menu();
Afficher_ecran();
Afficher_curseur();
}
// Evenement de fermeture
if (Quit_demande)
{
Quit_demande=0;
Bouton_Quit();
}
// Gestion des touches
if (Touche)
{
for (Indice_Touche=0;(Indice_Touche<NB_TOUCHES_SPECIALES) && !Est_Raccourci(Touche,Indice_Touche);Indice_Touche++);
// Gestion des touches spéciales:
if (Indice_Touche>SPECIAL_CLICK_RIGHT)
switch(Indice_Touche)
{
case SPECIAL_SCROLL_UP : // Scroll up
if (Loupe_Mode)
Scroller_loupe(0,-(Loupe_Hauteur>>2));
else
Scroller_ecran(0,-(Hauteur_ecran>>3));
Touche=0;
break;
case SPECIAL_SCROLL_DOWN : // Scroll down
if (Loupe_Mode)
Scroller_loupe(0,(Loupe_Hauteur>>2));
else
Scroller_ecran(0,(Hauteur_ecran>>3));
Touche=0;
break;
case SPECIAL_SCROLL_LEFT : // Scroll left
if (Loupe_Mode)
Scroller_loupe(-(Loupe_Largeur>>2),0);
else
Scroller_ecran(-(Largeur_ecran>>3),0);
Touche=0;
break;
case SPECIAL_SCROLL_RIGHT : // Scroll right
if (Loupe_Mode)
Scroller_loupe((Loupe_Largeur>>2),0);
else
Scroller_ecran((Largeur_ecran>>3),0);
Touche=0;
break;
case SPECIAL_SCROLL_UP_FAST : // Scroll up faster
if (Loupe_Mode)
Scroller_loupe(0,-(Loupe_Hauteur>>1));
else
Scroller_ecran(0,-(Hauteur_ecran>>2));
Touche=0;
break;
case SPECIAL_SCROLL_DOWN_FAST : // Scroll down faster
if (Loupe_Mode)
Scroller_loupe(0,(Loupe_Hauteur>>1));
else
Scroller_ecran(0,(Hauteur_ecran>>2));
Touche=0;
break;
case SPECIAL_SCROLL_LEFT_FAST : // Scroll left faster
if (Loupe_Mode)
Scroller_loupe(-(Loupe_Largeur>>1),0);
else
Scroller_ecran(-(Largeur_ecran>>2),0);
Touche=0;
break;
case SPECIAL_SCROLL_RIGHT_FAST : // Scroll right faster
if (Loupe_Mode)
Scroller_loupe((Loupe_Largeur>>1),0);
else
Scroller_ecran((Largeur_ecran>>2),0);
Touche=0;
break;
case SPECIAL_SCROLL_UP_SLOW : // Scroll up slower
if (Loupe_Mode)
Scroller_loupe(0,-1);
else
Scroller_ecran(0,-1);
Touche=0;
break;
case SPECIAL_SCROLL_DOWN_SLOW : // Scroll down slower
if (Loupe_Mode)
Scroller_loupe(0,1);
else
Scroller_ecran(0,1);
Touche=0;
break;
case SPECIAL_SCROLL_LEFT_SLOW : // Scroll left slower
if (Loupe_Mode)
Scroller_loupe(-1,0);
else
Scroller_ecran(-1,0);
Touche=0;
break;
case SPECIAL_SCROLL_RIGHT_SLOW : // Scroll right slower
if (Loupe_Mode)
Scroller_loupe(1,0);
else
Scroller_ecran(1,0);
Touche=0;
break;
case SPECIAL_NEXT_FORECOLOR : // Next foreground color
Special_Next_forecolor();
Touche=0;
break;
case SPECIAL_PREVIOUS_FORECOLOR : // Previous foreground color
Special_Previous_forecolor();
Touche=0;
break;
case SPECIAL_NEXT_BACKCOLOR : // Next background color
Special_Next_backcolor();
Touche=0;
break;
case SPECIAL_PREVIOUS_BACKCOLOR : // Previous background color
Special_Previous_backcolor();
Touche=0;
break;
case SPECIAL_RETRECIR_PINCEAU: // Rétrécir le pinceau
Retrecir_pinceau();
Touche=0;
break;
case SPECIAL_GROSSIR_PINCEAU: // Grossir le pinceau
Grossir_pinceau();
Touche=0;
break;
case SPECIAL_NEXT_USER_FORECOLOR : // Next user-defined foreground color
Message_Non_disponible(); // !!! TEMPORAIRE !!!
//Special_Next_user_forecolor();
Touche=0;
break;
case SPECIAL_PREVIOUS_USER_FORECOLOR : // Previous user-defined foreground color
Message_Non_disponible(); // !!! TEMPORAIRE !!!
//Special_Previous_user_forecolor();
Touche=0;
break;
case SPECIAL_NEXT_USER_BACKCOLOR : // Next user-defined background color
Message_Non_disponible(); // !!! TEMPORAIRE !!!
//Special_Next_user_backcolor();
Touche=0;
break;
case SPECIAL_PREVIOUS_USER_BACKCOLOR : // Previous user-defined background color
Message_Non_disponible(); // !!! TEMPORAIRE !!!
//Special_Previous_user_backcolor();
Touche=0;
break;
case SPECIAL_SHOW_HIDE_CURSOR : // Show / Hide cursor
Effacer_curseur();
Cacher_curseur=!Cacher_curseur;
Afficher_curseur();
Touche=0;
break;
case SPECIAL_PINCEAU_POINT : // Paintbrush = "."
Effacer_curseur();
Pinceau_Forme=FORME_PINCEAU_ROND;
Modifier_pinceau(1,1);
Changer_la_forme_du_pinceau(FORME_PINCEAU_ROND);
Afficher_curseur();
Touche=0;
break;
case SPECIAL_DESSIN_CONTINU : // Continuous freehand drawing
Enclencher_bouton(BOUTON_DESSIN,A_GAUCHE);
// ATTENTION CE TRUC EST MOCHE ET VA MERDER SI ON SE MET A UTILISER DES BOUTONS POPUPS
while (Operation_en_cours!=OPERATION_DESSIN_CONTINU)
Enclencher_bouton(BOUTON_DESSIN,A_DROITE);
Touche=0;
break;
case SPECIAL_FLIP_X : // Flip X
Effacer_curseur();
Flip_X_LOWLEVEL();
Afficher_curseur();
Touche=0;
break;
case SPECIAL_FLIP_Y : // Flip Y
Effacer_curseur();
Flip_Y_LOWLEVEL();
Afficher_curseur();
Touche=0;
break;
case SPECIAL_ROTATE_90 : // 90° brush rotation
Effacer_curseur();
Rotate_90_deg();
Afficher_curseur();
Touche=0;
break;
case SPECIAL_ROTATE_180 : // 180° brush rotation
Effacer_curseur();
if (Brosse_Hauteur&1)
{
// Brosse de hauteur impaire
Flip_X_LOWLEVEL();
Flip_Y_LOWLEVEL();
}
else
Rotate_180_deg_LOWLEVEL();
Brosse_Decalage_X=(Brosse_Largeur>>1);
Brosse_Decalage_Y=(Brosse_Hauteur>>1);
Afficher_curseur();
Touche=0;
break;
case SPECIAL_STRETCH : // Stretch brush
Effacer_curseur();
Demarrer_pile_operation(OPERATION_ETIRER_BROSSE);
Afficher_curseur();
Touche=0;
break;
case SPECIAL_DISTORT : // Distort brush
Message_Non_disponible(); // !!! TEMPORAIRE !!!
Touche=0;
break;
case SPECIAL_ROTATE_ANY_ANGLE : // Rotate brush by any angle
Effacer_curseur();
Demarrer_pile_operation(OPERATION_TOURNER_BROSSE);
Afficher_curseur();
Touche=0;
break;
case SPECIAL_OUTLINE : // Outline brush
Effacer_curseur();
Outline_brush();
Afficher_curseur();
Touche=0;
break;
case SPECIAL_NIBBLE : // Nibble brush
Effacer_curseur();
Nibble_brush();
Afficher_curseur();
Touche=0;
break;
case SPECIAL_GET_BRUSH_COLORS : // Get colors from brush
Get_colors_from_brush();
Touche=0;
break;
case SPECIAL_RECOLORIZE_BRUSH : // Recolorize brush
Effacer_curseur();
Remap_brosse();
Afficher_curseur();
Touche=0;
break;
case SPECIAL_LOAD_BRUSH :
Load_picture(0);
Touche=0;
break;
case SPECIAL_SAVE_BRUSH :
Save_picture(0);
Touche=0;
break;
case SPECIAL_ZOOM_IN : // Zoom in
Zoom(+1);
Touche=0;
break;
case SPECIAL_ZOOM_OUT : // Zoom out
Zoom(-1);
Touche=0;
break;
case SPECIAL_CENTER_ATTACHMENT : // Center brush attachment
Effacer_curseur();
Brosse_Decalage_X=(Brosse_Largeur>>1);
Brosse_Decalage_Y=(Brosse_Hauteur>>1);
Afficher_curseur();
Touche=0;
break;
case SPECIAL_TOP_LEFT_ATTACHMENT : // Top-left brush attachment
Effacer_curseur();
Brosse_Decalage_X=0;
Brosse_Decalage_Y=0;
Afficher_curseur();
Touche=0;
break;
case SPECIAL_TOP_RIGHT_ATTACHMENT : // Top-right brush attachment
Effacer_curseur();
Brosse_Decalage_X=(Brosse_Largeur-1);
Brosse_Decalage_Y=0;
Afficher_curseur();
Touche=0;
break;
case SPECIAL_BOTTOM_LEFT_ATTACHMENT : // Bottom-left brush attachment
Effacer_curseur();
Brosse_Decalage_X=0;
Brosse_Decalage_Y=(Brosse_Hauteur-1);
Afficher_curseur();
Touche=0;
break;
case SPECIAL_BOTTOM_RIGHT_ATTACHMENT : // Bottom right brush attachment
Effacer_curseur();
Brosse_Decalage_X=(Brosse_Largeur-1);
Brosse_Decalage_Y=(Brosse_Hauteur-1);
Afficher_curseur();
Touche=0;
break;
case SPECIAL_EXCLUDE_COLORS_MENU : // Exclude colors menu
Menu_Tag_couleurs("Tag colors to exclude",Exclude_color,&Temp,1, NULL);
Touche=0;
break;
case SPECIAL_INVERT_SIEVE :
Inverser_trame();
Touche=0;
break;
case SPECIAL_SHADE_MODE :
Bouton_Shade_Mode();
Touche=0;
break;
case SPECIAL_SHADE_MENU :
Bouton_Shade_Menu();
Touche=0;
break;
case SPECIAL_QUICK_SHADE_MODE :
Bouton_Quick_shade_Mode();
Touche=0;
break;
case SPECIAL_QUICK_SHADE_MENU :
Bouton_Quick_shade_Menu();
Touche=0;
break;
case SPECIAL_STENCIL_MODE :
Bouton_Stencil_Mode();
Touche=0;
break;
case SPECIAL_STENCIL_MENU :
Bouton_Menu_Stencil();
Touche=0;
break;
case SPECIAL_MASK_MODE :
Bouton_Mask_Mode();
Touche=0;
break;
case SPECIAL_MASK_MENU :
Bouton_Mask_Menu();
Touche=0;
break;
case SPECIAL_GRID_MODE :
Bouton_Snap_Mode();
Touche=0;
break;
case SPECIAL_GRID_MENU :
Bouton_Menu_Grille();
Touche=0;
break;
case SPECIAL_SIEVE_MODE :
Bouton_Trame_Mode();
Touche=0;
break;
case SPECIAL_SIEVE_MENU :
Bouton_Trame_Menu();
Touche=0;
break;
case SPECIAL_COLORIZE_MODE :
Bouton_Colorize_Mode();
Touche=0;
break;
case SPECIAL_COLORIZE_MENU :
Bouton_Colorize_Menu();
Touche=0;
break;
case SPECIAL_SMOOTH_MODE :
Bouton_Smooth_Mode();
Touche=0;
break;
case SPECIAL_SMOOTH_MENU :
Bouton_Smooth_Menu();
Touche=0;
break;
case SPECIAL_SMEAR_MODE :
Bouton_Smear_Mode();
Touche=0;
break;
case SPECIAL_TILING_MODE :
Bouton_Tiling_Mode();
Touche=0;
break;
case SPECIAL_TILING_MENU :
Bouton_Tiling_Menu();
Touche=0;
break;
default : // Gestion des touches de raccourci de bouton:
// Pour chaque bouton
Bouton_Touche=-1;
for (Indice_bouton=0;Indice_bouton<NB_BOUTONS;Indice_bouton++)
{
if (Est_Raccourci(Touche,0x100+Indice_bouton))
{
Bouton_Touche=Indice_bouton;
Bouton_Cote =A_GAUCHE;
Indice_bouton=NB_BOUTONS;
}
else if (Est_Raccourci(Touche,0x200+Indice_bouton))
{
Bouton_Touche=Indice_bouton;
Bouton_Cote =A_DROITE;
Indice_bouton=NB_BOUTONS;
}
}
// Après avoir scruté les boutons, si la recherche a été fructueuse,
// on lance le bouton.
if (Bouton_Touche!=-1)
{
Enclencher_bouton(Bouton_Touche,Bouton_Cote);
Indice_bouton_precedent=-1;
}
}
// Si on a modifié un effet, il faut rafficher le bouton des effets en
// conséquence.
if ((Indice_Touche>=SPECIAL_SHADE_MODE)
&& (Indice_Touche<=SPECIAL_TILING_MENU))
{
Effacer_curseur();
Tracer_cadre_de_bouton_du_menu(BOUTON_EFFETS,
(Shade_Mode||Quick_shade_Mode||Colorize_Mode||Smooth_Mode||Tiling_Mode||Smear_Mode||Stencil_Mode||Mask_Mode||Trame_Mode||Snap_Mode));
Afficher_curseur();
}
}
}
else Wait_VBL(); // S'il n'y a pas d'évènement, on ne gère pas tout ça et on attend un peu. La partie en dessous doit être exécutée quand
// même pour les trucs asynchrones, par exemple le spray.
// Gestion de la souris
Curseur_dans_menu=(Mouse_Y>=Menu_Ordonnee) ||
( (Loupe_Mode) && (Mouse_X>=Principal_Split) &&
(Mouse_X<Principal_X_Zoom) );
if (Curseur_dans_menu)
{
// Le curseur se trouve dans le menu
// On cherche sur quel bouton du menu se trouve la souris:
Indice_bouton=Numero_bouton_sous_souris();
// Si le curseur vient de changer de zone
if ( (Indice_bouton!=Indice_bouton_precedent)
|| (!Curseur_dans_menu_precedent)
|| (Indice_bouton_precedent==BOUTON_CHOIX_COL) )
{
// Si le curseur n'est pas sur un bouton
if (Indice_bouton==-1)
{
if (Menu_visible)
{
// On nettoie les coordonnées
Effacer_curseur();
Block(18*Menu_Facteur_X,Menu_Ordonnee_Texte,192*Menu_Facteur_X,Menu_Facteur_Y<<3,CM_Clair);
UpdateRect(18*Menu_Facteur_X,Menu_Ordonnee_Texte,192*Menu_Facteur_X,Menu_Facteur_Y<<3);
Afficher_curseur();
}
}
else
{
if ( (Indice_bouton_precedent!=BOUTON_CHOIX_COL)
|| (Temp_color!=Couleur_debut_palette)
|| (Old_MX!=Mouse_X) || (Old_MY!=Mouse_Y) )
{
// Le curseur est sur un nouveau bouton
if (Indice_bouton!=BOUTON_CHOIX_COL)
{
Effacer_curseur();
Print_dans_menu(TITRE_BOUTON[Indice_bouton],0);
Afficher_curseur();
}
else
{ // Le curseur est-il sur une couleur de la palette?
int Couleur;
if ((Couleur=Couleur_palette())!=-1)
{
Effacer_curseur();
strcpy(Chaine,TITRE_BOUTON[Indice_bouton]);
sprintf(Chaine+strlen(Chaine),"%d (%d,%d,%d)",Couleur,Principal_Palette[Couleur].R,Principal_Palette[Couleur].G,Principal_Palette[Couleur].B);
for (Temp=strlen(Chaine); Temp<24; Temp++)
Chaine[Temp]=' ';
Chaine[24]=0;
Print_dans_menu(Chaine,0);
Afficher_curseur();
}
else
{
if ( (Old_MX!=Mouse_X) || (Old_MY!=Mouse_Y) )
{
Effacer_curseur();
Block(18*Menu_Facteur_X,Menu_Ordonnee_Texte,192*Menu_Facteur_X,Menu_Facteur_Y<<3,CM_Clair);
UpdateRect(18*Menu_Facteur_X,Menu_Ordonnee_Texte,192*Menu_Facteur_X,8*Menu_Facteur_Y);
Afficher_curseur();
}
}
}
}
}
}
Indice_bouton_precedent=Indice_bouton;
// Gestion des clicks
if (Mouse_K)
{
if (Mouse_Y>=Menu_Ordonnee)
{
if (Indice_bouton>=0)
{
Enclencher_bouton(Indice_bouton,Mouse_K);
Indice_bouton_precedent=-1;
}
}
else
if (Loupe_Mode) Deplacer_Split();
}
}
// we need to refresh that one as we may come from a sub window
Curseur_dans_menu=(Mouse_Y>=Menu_Ordonnee) ||
( (Loupe_Mode) && (Mouse_X>=Principal_Split) &&
(Mouse_X<Principal_X_Zoom) );
// Le curseur se trouve dans l'image
if ( (!Curseur_dans_menu) && (Menu_visible) && (Old_MY != Mouse_Y || Old_MX != Mouse_X || Touche || Mouse_K)) // On ne met les coordonnées à jour que si l'utilisateur a fait un truc
{
if ( (Operation_en_cours!=OPERATION_PIPETTE) && (Operation_en_cours!=OPERATION_REMPLACER) )
{
if(Curseur_dans_menu_precedent)
{
Print_dans_menu("X: Y: ",0);
}
}
else
{
if(Curseur_dans_menu_precedent)
{
Print_dans_menu("X: Y: ( )",0);
}
}
Curseur_dans_menu_precedent = 0;
}
if(Curseur_dans_menu)
{
Curseur_dans_menu_precedent = 1;
}
else
{
Blink=Operation[Operation_en_cours][Mouse_K_Unique][Operation_Taille_pile].Effacer_curseur;
if (Blink) Effacer_curseur();
Operation[Operation_en_cours][Mouse_K_Unique][Operation_Taille_pile].Action();
if (Blink) Afficher_curseur();
}
Old_MX=Mouse_X;
Old_MY=Mouse_Y;
}
while (!Sortir_du_programme);
}
//////////////////////////////////////////////////////////////////////////////
// Différentes fonctions d'affichage utilisées dans les fenêtres //
//////////////////////////////////////////////////////////////////////////////
//----------------------- Tracer une fenêtre d'options -----------------------
void Ouvrir_fenetre(word width,word height, char * title)
// Lors de l'appel à cette procédure, la souris doit être affichée.
// En sortie de cette procedure, la souris est effacée.
{
//word i,j;
Effacer_curseur();
Fenetre++;
Fenetre_Largeur=width;
Fenetre_Hauteur=height;
// Positionnement de la fenêtre
Fenetre_Pos_X=(Largeur_ecran-(width*Menu_Facteur_X))>>1;
Fenetre_Pos_Y=(Hauteur_ecran-(height*Menu_Facteur_Y))>>1;
// Sauvegarde de ce que la fenêtre remplace
Sauve_fond(&(Fond_fenetre[Fenetre-1]), Fenetre_Pos_X, Fenetre_Pos_Y, width, height);
// Fenêtre grise
Block(Fenetre_Pos_X+(Menu_Facteur_X<<1),Fenetre_Pos_Y+(Menu_Facteur_Y<<1),(width-4)*Menu_Facteur_X,(height-4)*Menu_Facteur_Y,CM_Clair);
// -- Cadre de la fenêtre ----- --- -- - -
// Cadre noir puis en relief
Fenetre_Afficher_cadre_mono(0,0,width,height,CM_Noir);
Fenetre_Afficher_cadre_bombe(1,1,width-2,height-2);
// Barre sous le titre
Block(Fenetre_Pos_X+(Menu_Facteur_X<<3),Fenetre_Pos_Y+(11*Menu_Facteur_Y),(width-16)*Menu_Facteur_X,Menu_Facteur_Y,CM_Fonce);
Block(Fenetre_Pos_X+(Menu_Facteur_X<<3),Fenetre_Pos_Y+(12*Menu_Facteur_Y),(width-16)*Menu_Facteur_X,Menu_Facteur_Y,CM_Blanc);
Print_dans_fenetre((width-(strlen(title)<<3))>>1,3,title,CM_Noir,CM_Clair);
if (Fenetre == 1)
{
Menu_visible_avant_fenetre=Menu_visible;
Menu_visible=0;
Menu_Ordonnee_avant_fenetre=Menu_Ordonnee;
Menu_Ordonnee=Hauteur_ecran;
Forme_curseur_avant_fenetre=Forme_curseur;
Forme_curseur=FORME_CURSEUR_FLECHE;
Cacher_pinceau_avant_fenetre=Cacher_pinceau;
Cacher_pinceau=1;
}
// Initialisation des listes de boutons de la fenêtre
Fenetre_Liste_boutons_normal =NULL;
Fenetre_Liste_boutons_palette =NULL;
Fenetre_Liste_boutons_scroller=NULL;
Fenetre_Liste_boutons_special =NULL;
Fenetre_Liste_boutons_dropdown=NULL;
Nb_boutons_fenetre =0;
}
//----------------------- Fermer une fenêtre d'options -----------------------
void Fermer_fenetre(void)
// Lors de l'appel à cette procedure, la souris doit être affichée.
// En sortie de cette procedure, la souris est effacée.
{
T_Bouton_normal * Temp1;
T_Bouton_palette * Temp2;
T_Bouton_scroller * Temp3;
T_Bouton_special * Temp4;
T_Bouton_dropdown * Temp5;
Effacer_curseur();
while (Fenetre_Liste_boutons_normal)
{
Temp1=Fenetre_Liste_boutons_normal->Next;
free(Fenetre_Liste_boutons_normal);
Fenetre_Liste_boutons_normal=Temp1;
}
while (Fenetre_Liste_boutons_palette)
{
Temp2=Fenetre_Liste_boutons_palette->Next;
free(Fenetre_Liste_boutons_palette);
Fenetre_Liste_boutons_palette=Temp2;
}
while (Fenetre_Liste_boutons_scroller)
{
Temp3=Fenetre_Liste_boutons_scroller->Next;
free(Fenetre_Liste_boutons_scroller);
Fenetre_Liste_boutons_scroller=Temp3;
}
while (Fenetre_Liste_boutons_special)
{
Temp4=Fenetre_Liste_boutons_special->Next;
free(Fenetre_Liste_boutons_special);
Fenetre_Liste_boutons_special=Temp4;
}
while (Fenetre_Liste_boutons_dropdown)
{
Temp5=Fenetre_Liste_boutons_dropdown->Next;
Fenetre_Dropdown_vider_choix(Fenetre_Liste_boutons_dropdown);
free(Fenetre_Liste_boutons_dropdown);
Fenetre_Liste_boutons_dropdown=Temp5;
}
if (Fenetre != 1)
{
// Restore de ce que la fenêtre cachait
Restaure_fond(Fond_fenetre[Fenetre-1], Fenetre_Pos_X, Fenetre_Pos_Y, Fenetre_Largeur, Fenetre_Hauteur);
Fond_fenetre[Fenetre-1]=NULL;
UpdateRect(Fenetre_Pos_X,Fenetre_Pos_Y,Fenetre_Largeur*Menu_Facteur_X,Fenetre_Hauteur*Menu_Facteur_Y);
Fenetre--;
}
else
{
free(Fond_fenetre[Fenetre-1]);
Fond_fenetre[Fenetre-1]=NULL;
Fenetre--;
Cacher_pinceau=Cacher_pinceau_avant_fenetre;
Calculer_coordonnees_pinceau();
Menu_Ordonnee=Menu_Ordonnee_avant_fenetre;
Menu_visible=Menu_visible_avant_fenetre;
Forme_curseur=Forme_curseur_avant_fenetre;
Afficher_ecran();
Afficher_menu();
}
Touche=0;
Mouse_K=0;
Old_MX = -1;
Old_MY = -1;
}
//---------------- Dessiner un bouton normal dans une fenêtre ----------------
void Fenetre_Dessiner_bouton_normal(word x_pos,word y_pos,word width,word height,
char * title,byte Lettre_soulignee,byte clickable)
{
byte Couleur_titre;
word Pos_texte_X,Pos_texte_Y;
if (clickable)
{
Fenetre_Afficher_cadre_bombe(x_pos,y_pos,width,height);
Fenetre_Afficher_cadre_general(x_pos-1,y_pos-1,width+2,height+2,CM_Noir,CM_Noir,CM_Fonce,CM_Fonce,CM_Fonce);
Couleur_titre=CM_Noir;
}
else
{
Fenetre_Afficher_cadre_bombe(x_pos,y_pos,width,height);
Fenetre_Afficher_cadre_mono(x_pos-1,y_pos-1,width+2,height+2,CM_Clair);
Couleur_titre=CM_Fonce;
}
Pos_texte_X=x_pos+( (width-(strlen(title)<<3)+1) >>1 );
Pos_texte_Y=y_pos+((height-7)>>1);
Print_dans_fenetre(Pos_texte_X,Pos_texte_Y,title,Couleur_titre,CM_Clair);
if (Lettre_soulignee)
Block(Fenetre_Pos_X+((Pos_texte_X+((Lettre_soulignee-1)<<3))*Menu_Facteur_X),
Fenetre_Pos_Y+((Pos_texte_Y+8)*Menu_Facteur_Y),
Menu_Facteur_X<<3,Menu_Facteur_Y,CM_Fonce);
}
// -- Bouton normal enfoncé dans la fenêtre --
void Fenetre_Enfoncer_bouton_normal(word x_pos,word y_pos,word width,word height)
{
Fenetre_Afficher_cadre_general(x_pos,y_pos,width,height,CM_Fonce,CM_Noir,CM_Fonce,CM_Fonce,CM_Noir);
UpdateRect(Fenetre_Pos_X+x_pos*Menu_Facteur_X, Fenetre_Pos_Y+y_pos*Menu_Facteur_Y, width*Menu_Facteur_X, height*Menu_Facteur_Y);
}
// -- Bouton normal désenfoncé dans la fenêtre --
void Fenetre_Desenfoncer_bouton_normal(word x_pos,word y_pos,word width,word height)
{
Fenetre_Afficher_cadre_bombe(x_pos,y_pos,width,height);
UpdateRect(Fenetre_Pos_X+x_pos*Menu_Facteur_X, Fenetre_Pos_Y+y_pos*Menu_Facteur_Y, width*Menu_Facteur_X, height*Menu_Facteur_Y);
}
//--------------- Dessiner un bouton palette dans une fenêtre ----------------
void Fenetre_Dessiner_bouton_palette(word x_pos,word y_pos)
{
word Couleur;
for (Couleur=0; Couleur<=255; Couleur++)
Block( Fenetre_Pos_X+((((Couleur >> 4)*10)+x_pos+6)*Menu_Facteur_X),Fenetre_Pos_Y+((((Couleur & 15)*5)+y_pos+3)*Menu_Facteur_Y),Menu_Facteur_X*5,Menu_Facteur_Y*5,Couleur);
Fenetre_Afficher_cadre(x_pos,y_pos,164,86);
}
// -------------------- Effacer les TAGs sur les palette ---------------------
// Cette fonct° ne sert plus que lorsqu'on efface les tags dans le menu Spray.
void Fenetre_Effacer_tags(void)
{
word Origine_X;
word Origine_Y;
word x_pos;
word Pos_fenetre_X;
//word Pos_fenetre_Y;
Origine_X=Fenetre_Pos_X+(Fenetre_Liste_boutons_palette->Pos_X+3)*Menu_Facteur_X;
Origine_Y=Fenetre_Pos_Y+(Fenetre_Liste_boutons_palette->Pos_Y+3)*Menu_Facteur_Y;
for (x_pos=0,Pos_fenetre_X=Origine_X;x_pos<16;x_pos++,Pos_fenetre_X+=(Menu_Facteur_X*10))
Block(Pos_fenetre_X,Origine_Y,Menu_Facteur_X*3,Menu_Facteur_Y*80,CM_Clair);
UpdateRect(Origine_X,Origine_Y,ToWinL(160),ToWinH(80));
}
// ---- Tracer les TAGs sur les palettes du menu Palette ou du menu Shade ----
void Tagger_intervalle_palette(byte start,byte end)
{
word Origine_X;
word Origine_Y;
//word x_pos;
word y_pos;
//word Pos_fenetre_X;
word Pos_fenetre_Y;
word Indice;
// On efface les anciens TAGs
for (Indice=0;Indice<=start;Indice++)
Block(Fenetre_Pos_X+(Fenetre_Liste_boutons_palette->Pos_X+3+((Indice>>4)*10))*Menu_Facteur_X,
Fenetre_Pos_Y+(Fenetre_Liste_boutons_palette->Pos_Y+3+((Indice&15)* 5))*Menu_Facteur_Y,
Menu_Facteur_X*3,Menu_Facteur_Y*5,CM_Clair);
for (Indice=end;Indice<256;Indice++)
Block(Fenetre_Pos_X+(Fenetre_Liste_boutons_palette->Pos_X+3+((Indice>>4)*10))*Menu_Facteur_X,
Fenetre_Pos_Y+(Fenetre_Liste_boutons_palette->Pos_Y+3+((Indice&15)* 5))*Menu_Facteur_Y,
Menu_Facteur_X*3,Menu_Facteur_Y*5,CM_Clair);
// On affiche le 1er TAG
Origine_X=(Fenetre_Liste_boutons_palette->Pos_X+3)+(start>>4)*10;
Origine_Y=(Fenetre_Liste_boutons_palette->Pos_Y+3)+(start&15)* 5;
for (y_pos=0,Pos_fenetre_Y=Origine_Y ;y_pos<5;y_pos++,Pos_fenetre_Y++)
Pixel_dans_fenetre(Origine_X ,Pos_fenetre_Y,CM_Noir);
for (y_pos=0,Pos_fenetre_Y=Origine_Y+1;y_pos<3;y_pos++,Pos_fenetre_Y++)
Pixel_dans_fenetre(Origine_X+1,Pos_fenetre_Y,CM_Noir);
Pixel_dans_fenetre(Origine_X+2,Origine_Y+2,CM_Noir);
if (start!=end)
{
// On complète le 1er TAG
Pixel_dans_fenetre(Origine_X+1,Origine_Y+4,CM_Noir);
// On affiche le 2ème TAG
Origine_X=(Fenetre_Liste_boutons_palette->Pos_X+3)+(end>>4)*10;
Origine_Y=(Fenetre_Liste_boutons_palette->Pos_Y+3)+(end&15)* 5;
for (y_pos=0,Pos_fenetre_Y=Origine_Y; y_pos<5; y_pos++,Pos_fenetre_Y++)
Pixel_dans_fenetre(Origine_X ,Pos_fenetre_Y,CM_Noir);
for (y_pos=0,Pos_fenetre_Y=Origine_Y; y_pos<4; y_pos++,Pos_fenetre_Y++)
Pixel_dans_fenetre(Origine_X+1,Pos_fenetre_Y,CM_Noir);
Pixel_dans_fenetre(Origine_X+2,Origine_Y+2,CM_Noir);
// On TAG toutes les couleurs intermédiaires
for (Indice=start+1;Indice<end;Indice++)
{
Block(Fenetre_Pos_X+(Fenetre_Liste_boutons_palette->Pos_X+3+((Indice>>4)*10))*Menu_Facteur_X,
Fenetre_Pos_Y+(Fenetre_Liste_boutons_palette->Pos_Y+3+((Indice&15)* 5))*Menu_Facteur_Y,
Menu_Facteur_X*2,Menu_Facteur_Y*5,CM_Noir);
// On efface l'éventuelle pointe d'une ancienne extrémité de l'intervalle
Pixel_dans_fenetre(Fenetre_Liste_boutons_palette->Pos_X+5+((Indice>>4)*10),
Fenetre_Liste_boutons_palette->Pos_Y+5+((Indice&15)* 5),
CM_Clair);
}
}
UpdateRect(ToWinX(Fenetre_Liste_boutons_palette->Pos_X+3),ToWinY(Fenetre_Liste_boutons_palette->Pos_Y+3),ToWinL(12*16),ToWinH(5*16));
}
//------------------ Dessiner un scroller dans une fenêtre -------------------
void Calculer_hauteur_curseur_jauge(T_Bouton_scroller * button)
{
if (button->Nb_elements>button->Nb_visibles)
{
button->Hauteur_curseur=(button->Nb_visibles*(button->Height-24))/button->Nb_elements;
if (!(button->Hauteur_curseur))
button->Hauteur_curseur=1;
}
else
{
button->Hauteur_curseur=button->Height-24;
}
}
void Fenetre_Dessiner_jauge(T_Bouton_scroller * button)
{
word Position_curseur_jauge;
Position_curseur_jauge=button->Pos_Y+12;
Block(Fenetre_Pos_X+(button->Pos_X*Menu_Facteur_X),
Fenetre_Pos_Y+(Position_curseur_jauge*Menu_Facteur_Y),
11*Menu_Facteur_X,(button->Height-24)*Menu_Facteur_Y,CM_Noir/*CM_Fonce*/);
if (button->Nb_elements>button->Nb_visibles)
Position_curseur_jauge+=Round_div(button->Position*(button->Height-24-button->Hauteur_curseur),button->Nb_elements-button->Nb_visibles);
Block(Fenetre_Pos_X+(button->Pos_X*Menu_Facteur_X),
Fenetre_Pos_Y+(Position_curseur_jauge*Menu_Facteur_Y),
11*Menu_Facteur_X,button->Hauteur_curseur*Menu_Facteur_Y,CM_Fonce/*CM_Blanc*/);
UpdateRect(Fenetre_Pos_X+(button->Pos_X*Menu_Facteur_X),
Fenetre_Pos_Y+button->Pos_Y*Menu_Facteur_Y,
11*Menu_Facteur_X,(button->Height)*Menu_Facteur_Y);
}
void Fenetre_Dessiner_bouton_scroller(T_Bouton_scroller * button)
{
Fenetre_Afficher_cadre_general(button->Pos_X-1,button->Pos_Y-1,13,button->Height+2,CM_Noir,CM_Noir,CM_Fonce,CM_Fonce,CM_Fonce);
Fenetre_Afficher_cadre_mono(button->Pos_X-1,button->Pos_Y+11,13,button->Height-22,CM_Noir);
Fenetre_Afficher_cadre_bombe(button->Pos_X,button->Pos_Y,11,11);
Fenetre_Afficher_cadre_bombe(button->Pos_X,button->Pos_Y+button->Height-11,11,11);
Print_dans_fenetre(button->Pos_X+2,button->Pos_Y+2,"\030",CM_Noir,CM_Clair);
Print_dans_fenetre(button->Pos_X+2,button->Pos_Y+button->Height-9,"\031",CM_Noir,CM_Clair);
Fenetre_Dessiner_jauge(button);
}
//--------------- Dessiner une zone de saisie dans une fenêtre ---------------
void Fenetre_Dessiner_bouton_saisie(word x_pos,word y_pos,word Largeur_en_caracteres)
{
Fenetre_Afficher_cadre_creux(x_pos,y_pos,(Largeur_en_caracteres<<3)+3,11);
}
//------------ Modifier le contenu (caption) d'une zone de saisie ------------
void Fenetre_Contenu_bouton_saisie(T_Bouton_special * button, char * content)
{
Print_dans_fenetre_limite(button->Pos_X+2,button->Pos_Y+2,content,button->Width/8,CM_Noir,CM_Clair);
}
//------------ Effacer le contenu (caption) d'une zone de saisie ------------
void Fenetre_Effacer_bouton_saisie(T_Bouton_special * button)
{
Block((button->Pos_X+2)*Menu_Facteur_X+Fenetre_Pos_X,(button->Pos_Y+2)*Menu_Facteur_Y+Fenetre_Pos_Y,(button->Width/8)*8*Menu_Facteur_X,8*Menu_Facteur_Y,CM_Clair);
UpdateRect((button->Pos_X+2)*Menu_Facteur_X+Fenetre_Pos_X,(button->Pos_Y+2)*Menu_Facteur_Y+Fenetre_Pos_Y,button->Width/8*8*Menu_Facteur_X,8*Menu_Facteur_Y);
}
//------ Rajout d'un bouton à la liste de ceux présents dans la fenêtre ------
T_Bouton_normal * Fenetre_Definir_bouton_normal(word x_pos, word y_pos,
word width, word height,
char * title, byte Lettre_soulignee,
byte clickable, word shortcut)
{
T_Bouton_normal * Temp=NULL;
Nb_boutons_fenetre++;
if (clickable)
{
Temp=(T_Bouton_normal *)malloc(sizeof(T_Bouton_normal));
Temp->Number =Nb_boutons_fenetre;
Temp->Pos_X =x_pos;
Temp->Pos_Y =y_pos;
Temp->Width =width;
Temp->Height =height;
Temp->Raccourci=shortcut;
Temp->Repetable=0;
Temp->Next=Fenetre_Liste_boutons_normal;
Fenetre_Liste_boutons_normal=Temp;
}
Fenetre_Dessiner_bouton_normal(x_pos,y_pos,width,height,title,Lettre_soulignee,clickable);
return Temp;
}
//------ Rajout d'un bouton à la liste de ceux présents dans la fenêtre ------
T_Bouton_normal * Fenetre_Definir_bouton_repetable(word x_pos, word y_pos,
word width, word height,
char * title, byte Lettre_soulignee,
byte clickable, word shortcut)
{
T_Bouton_normal * Temp=NULL;
Nb_boutons_fenetre++;
if (clickable)
{
Temp=(T_Bouton_normal *)malloc(sizeof(T_Bouton_normal));
Temp->Number =Nb_boutons_fenetre;
Temp->Pos_X =x_pos;
Temp->Pos_Y =y_pos;
Temp->Width =width;
Temp->Height =height;
Temp->Raccourci=shortcut;
Temp->Repetable=1;
Temp->Next=Fenetre_Liste_boutons_normal;
Fenetre_Liste_boutons_normal=Temp;
}
Fenetre_Dessiner_bouton_normal(x_pos,y_pos,width,height,title,Lettre_soulignee,clickable);
return Temp;
}
T_Bouton_palette * Fenetre_Definir_bouton_palette(word x_pos, word y_pos)
{
T_Bouton_palette * Temp;
Temp=(T_Bouton_palette *)malloc(sizeof(T_Bouton_palette));
Temp->Number =++Nb_boutons_fenetre;
Temp->Pos_X =x_pos;
Temp->Pos_Y =y_pos;
Temp->Next=Fenetre_Liste_boutons_palette;
Fenetre_Liste_boutons_palette=Temp;
Fenetre_Dessiner_bouton_palette(x_pos,y_pos);
return Temp;
}
T_Bouton_scroller * Fenetre_Definir_bouton_scroller(word x_pos, word y_pos,
word height,
word nb_elements,
word nb_elements_visible,
word Position_initiale)
{
T_Bouton_scroller * Temp;
Temp=(T_Bouton_scroller *)malloc(sizeof(T_Bouton_scroller));
Temp->Number =++Nb_boutons_fenetre;
Temp->Pos_X =x_pos;
Temp->Pos_Y =y_pos;
Temp->Height =height;
Temp->Nb_elements =nb_elements;
Temp->Nb_visibles =nb_elements_visible;
Temp->Position =Position_initiale;
Calculer_hauteur_curseur_jauge(Temp);
Temp->Next=Fenetre_Liste_boutons_scroller;
Fenetre_Liste_boutons_scroller=Temp;
Fenetre_Dessiner_bouton_scroller(Temp);
return Temp;
}
T_Bouton_special * Fenetre_Definir_bouton_special(word x_pos,word y_pos,word width,word height)
{
T_Bouton_special * Temp;
Temp=(T_Bouton_special *)malloc(sizeof(T_Bouton_special));
Temp->Number =++Nb_boutons_fenetre;
Temp->Pos_X =x_pos;
Temp->Pos_Y =y_pos;
Temp->Width =width;
Temp->Height =height;
Temp->Next=Fenetre_Liste_boutons_special;
Fenetre_Liste_boutons_special=Temp;
return Temp;
}
T_Bouton_special * Fenetre_Definir_bouton_saisie(word x_pos,word y_pos,word Largeur_en_caracteres)
{
T_Bouton_special *Temp;
Temp=Fenetre_Definir_bouton_special(x_pos,y_pos,(Largeur_en_caracteres<<3)+3,11);
Fenetre_Dessiner_bouton_saisie(x_pos,y_pos,Largeur_en_caracteres);
return Temp;
}
T_Bouton_dropdown * Fenetre_Definir_bouton_dropdown(word x_pos,word y_pos,word width,word height,word dropdown_width,char *label,byte display_choice,byte display_centered,byte display_arrow,byte active_button)
{
T_Bouton_dropdown *Temp;
Temp=(T_Bouton_dropdown *)malloc(sizeof(T_Bouton_dropdown));
Temp->Number =++Nb_boutons_fenetre;
Temp->Pos_X =x_pos;
Temp->Pos_Y =y_pos;
Temp->Width =width;
Temp->Height =height;
Temp->Affiche_choix =display_choice;
Temp->Premier_choix=NULL;
Temp->Largeur_choix=dropdown_width?dropdown_width:width;
Temp->Affiche_centre=display_centered;
Temp->Affiche_fleche=display_arrow;
Temp->Bouton_actif=active_button;
Temp->Next=Fenetre_Liste_boutons_dropdown;
Fenetre_Liste_boutons_dropdown=Temp;
Fenetre_Dessiner_bouton_normal(x_pos,y_pos,width,height,"",-1,1);
if (label && label[0])
Print_dans_fenetre(Temp->Pos_X+2,Temp->Pos_Y+(Temp->Height-7)/2,label,CM_Noir,CM_Clair);
if (display_arrow)
Fenetre_Afficher_sprite_drive(Temp->Pos_X+Temp->Width-10,Temp->Pos_Y+(Temp->Height-7)/2,6);
return Temp;
}
// Ajoute un choix à une dropdown. Le libellé est seulement référencé,
// il doit pointer sur une zone qui doit être encore valide à la fermeture
// de la fenêtre (comprise).
void Fenetre_Dropdown_choix(T_Bouton_dropdown * dropdown, word btn_number, const char *label)
{
T_Dropdown_choix *Temp;
T_Dropdown_choix *last;
Temp=(T_Dropdown_choix *)malloc(sizeof(T_Dropdown_choix));
Temp->Number =btn_number;
Temp->Label=label;
Temp->Next=NULL;
last=dropdown->Premier_choix;
if (last)
{
// On cherche le dernier élément
for (;last->Next;last=last->Next)
;
last->Next=Temp;
}
else
{
dropdown->Premier_choix=Temp;
}
}
// ------------- Suppression de tous les choix d'une dropdown ---------
void Fenetre_Dropdown_vider_choix(T_Bouton_dropdown * dropdown)
{
T_Dropdown_choix * Choix_suivant;
while (dropdown->Premier_choix)
{
Choix_suivant=dropdown->Premier_choix->Next;
free(dropdown->Premier_choix);
dropdown->Premier_choix=Choix_suivant;
}
}
//----------------------- Ouverture d'un pop-up -----------------------
void Ouvrir_popup(word x_pos, word y_pos, word width,word height)
// Lors de l'appel à cette procédure, la souris doit être affichée.
// En sortie de cette procedure, la souris est effacée.
// Note : les pop-ups sont gérés comme s'ils étaient des sous-fenêtres, ils ont donc leur propre boucle d'évènements et tout, on peut ajouter des widgets dedans, ...
// Les différences sont surtout graphiques :
// -Possibilité de préciser la position XY
// -Pas de titre
// -Pas de cadre en relief mais seulement un plat, et il est blanc au lieu de noir.
{
Fenetre++;
Fenetre_Largeur=width;
Fenetre_Hauteur=height;
Fenetre_Pos_X=x_pos;
Fenetre_Pos_Y=y_pos;
// Sauvegarde de ce que la fenêtre remplace
Sauve_fond(&(Fond_fenetre[Fenetre-1]), Fenetre_Pos_X, Fenetre_Pos_Y, width, height);
/*
// Fenêtre grise
Block(Fenetre_Pos_X+1*Menu_Facteur_X,
Fenetre_Pos_Y+1*Menu_Facteur_Y,
(width-2)*Menu_Facteur_X,(height-2)*Menu_Facteur_Y,CM_Clair);
// Cadre noir puis en relief
Fenetre_Afficher_cadre_mono(0,0,width,height,CM_Blanc);
*/
if (Fenetre == 1)
{
Menu_visible_avant_fenetre=Menu_visible;
Menu_visible=0;
Menu_Ordonnee_avant_fenetre=Menu_Ordonnee;
Menu_Ordonnee=Hauteur_ecran;
Forme_curseur_avant_fenetre=Forme_curseur;
Forme_curseur=FORME_CURSEUR_FLECHE;
Cacher_pinceau_avant_fenetre=Cacher_pinceau;
Cacher_pinceau=1;
}
// Initialisation des listes de boutons de la fenêtre
Fenetre_Liste_boutons_normal =NULL;
Fenetre_Liste_boutons_palette =NULL;
Fenetre_Liste_boutons_scroller=NULL;
Fenetre_Liste_boutons_special =NULL;
Fenetre_Liste_boutons_dropdown =NULL;
Nb_boutons_fenetre =0;
}
//----------------------- Fermer une fenêtre d'options -----------------------
void Fermer_popup(void)
// Lors de l'appel à cette procedure, la souris doit être affichée.
// En sortie de cette procedure, la souris est effacée.
{
T_Bouton_normal * Temp1;
T_Bouton_palette * Temp2;
T_Bouton_scroller * Temp3;
T_Bouton_special * Temp4;
T_Bouton_dropdown * Temp5;
Effacer_curseur();
while (Fenetre_Liste_boutons_normal)
{
Temp1=Fenetre_Liste_boutons_normal->Next;
free(Fenetre_Liste_boutons_normal);
Fenetre_Liste_boutons_normal=Temp1;
}
while (Fenetre_Liste_boutons_palette)
{
Temp2=Fenetre_Liste_boutons_palette->Next;
free(Fenetre_Liste_boutons_palette);
Fenetre_Liste_boutons_palette=Temp2;
}
while (Fenetre_Liste_boutons_scroller)
{
Temp3=Fenetre_Liste_boutons_scroller->Next;
free(Fenetre_Liste_boutons_scroller);
Fenetre_Liste_boutons_scroller=Temp3;
}
while (Fenetre_Liste_boutons_special)
{
Temp4=Fenetre_Liste_boutons_special->Next;
free(Fenetre_Liste_boutons_special);
Fenetre_Liste_boutons_special=Temp4;
}
while (Fenetre_Liste_boutons_dropdown)
{
Fenetre_Dropdown_vider_choix(Fenetre_Liste_boutons_dropdown);
Temp5=Fenetre_Liste_boutons_dropdown->Next;
free(Fenetre_Liste_boutons_dropdown);
Fenetre_Liste_boutons_dropdown=Temp5;
}
if (Fenetre != 1)
{
// Restore de ce que la fenêtre cachait
Restaure_fond(Fond_fenetre[Fenetre-1], Fenetre_Pos_X, Fenetre_Pos_Y, Fenetre_Largeur, Fenetre_Hauteur);
Fond_fenetre[Fenetre-1]=NULL;
UpdateRect(Fenetre_Pos_X,Fenetre_Pos_Y,Fenetre_Largeur*Menu_Facteur_X,Fenetre_Hauteur*Menu_Facteur_Y);
Fenetre--;
}
else
{
free(Fond_fenetre[Fenetre-1]);
Fenetre--;
Cacher_pinceau=Cacher_pinceau_avant_fenetre;
Calculer_coordonnees_pinceau();
Menu_Ordonnee=Menu_Ordonnee_avant_fenetre;
Menu_visible=Menu_visible_avant_fenetre;
Forme_curseur=Forme_curseur_avant_fenetre;
Afficher_ecran();
Afficher_menu();
}
Touche=0;
Mouse_K=0;
Old_MX = -1;
Old_MY = -1;
}
//////////////////////////////////////////////////////////////////////////////
// //
// Mini-MOTEUR utilisé dans les fenêtres (menus des boutons...) //
// //
//////////////////////////////////////////////////////////////////////////////
// -- Indique si on a cliqué dans une zone définie par deux points extremes --
byte Fenetre_click_dans_zone(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y)
{
short x_pos,y_pos;
x_pos=((short)Mouse_X-Fenetre_Pos_X)/Menu_Facteur_X;
y_pos=((short)Mouse_Y-Fenetre_Pos_Y)/Menu_Facteur_Y;
return ((x_pos>=Debut_X) &&
(y_pos>=Debut_Y) &&
(x_pos<=Fin_X) &&
(y_pos<=Fin_Y));
}
// --- Attend que l'on clique dans la palette pour renvoyer la couleur choisie
// ou bien renvoie -1 si on a annulé l'action pas click-droit ou Escape ------
short Attendre_click_dans_palette(T_Bouton_palette * button)
{
short Debut_X=button->Pos_X+5;
short Debut_Y=button->Pos_Y+3;
short Fin_X =button->Pos_X+160;
short Fin_Y =button->Pos_Y+82;
byte Couleur_choisie;
byte Ancien_Cacher_curseur;
byte Ancien_Loupe_Mode;
Effacer_curseur();
Ancien_Cacher_curseur=Cacher_curseur;
Ancien_Loupe_Mode=Loupe_Mode;
Loupe_Mode=0;
Cacher_curseur=0;
Forme_curseur=FORME_CURSEUR_CIBLE;
Afficher_curseur();
for (;;)
{
while(!Get_input())Wait_VBL();
if (Mouse_K==A_GAUCHE)
{
if (Fenetre_click_dans_zone(Debut_X,Debut_Y,Fin_X,Fin_Y))
{
Effacer_curseur();
Couleur_choisie=(((Mouse_X-Fenetre_Pos_X)/Menu_Facteur_X)-(button->Pos_X+2)) / 10 * 16 +
(((Mouse_Y-Fenetre_Pos_Y)/Menu_Facteur_Y)-(button->Pos_Y+3)) / 5;
Forme_curseur=FORME_CURSEUR_FLECHE;
Cacher_curseur=Ancien_Cacher_curseur;
Loupe_Mode=Ancien_Loupe_Mode;
Afficher_curseur();
return Couleur_choisie;
}
if ((Mouse_X<Fenetre_Pos_X) || (Mouse_Y<Fenetre_Pos_Y) ||
(Mouse_X>=Fenetre_Pos_X+(Fenetre_Largeur*Menu_Facteur_X)) ||
(Mouse_Y>=Fenetre_Pos_Y+(Fenetre_Hauteur*Menu_Facteur_Y)) )
{
Effacer_curseur();
Couleur_choisie=Lit_pixel(Mouse_X,Mouse_Y);
Forme_curseur=FORME_CURSEUR_FLECHE;
Cacher_curseur=Ancien_Cacher_curseur;
Loupe_Mode=Ancien_Loupe_Mode;
Afficher_curseur();
return Couleur_choisie;
}
}
if ((Mouse_K==A_DROITE) || (Touche==TOUCHE_ESC))
{
Effacer_curseur();
Forme_curseur=FORME_CURSEUR_FLECHE;
Cacher_curseur=Ancien_Cacher_curseur;
Loupe_Mode=Ancien_Loupe_Mode;
Afficher_curseur();
return -1;
}
}
}
// -------------- Récupération d'une couleur derrière un menu ----------------
void Recuperer_couleur_derriere_fenetre(byte * Couleur, byte * click)
{
short width=Fenetre_Largeur*Menu_Facteur_X;
short height=Fenetre_Hauteur*Menu_Facteur_Y;
short Ancien_X=-1;
short Ancien_Y=-1;
short Indice;
short a,b,c,d; // Variables temporaires et multitâches...
byte * Buffer;
char Chaine[25];
byte Cacher_curseur_avant_recuperation;
if ((Buffer=(byte *) malloc(width*height)))
{
Effacer_curseur();
Cacher_curseur_avant_recuperation=Cacher_curseur;
Cacher_curseur=0;
for (Indice=0; Indice<height; Indice++)
Lire_ligne(Fenetre_Pos_X,Fenetre_Pos_Y+Indice,width,Buffer+((int)Indice*width*Pixel_width));
a=Menu_Ordonnee;
Menu_Ordonnee=Menu_Ordonnee_avant_fenetre;
b=Menu_visible;
Menu_visible=Menu_visible_avant_fenetre;
Afficher_ecran();
Afficher_menu();
Menu_Ordonnee=a;
Menu_visible=b;
Forme_curseur=FORME_CURSEUR_CIBLE_PIPETTE;
b=Cacher_pinceau;
Cacher_pinceau=1;
c=-1; // Couleur pointée: au début aucune, comme ça on initialise tout
if (Menu_visible_avant_fenetre)
Print_dans_menu(TITRE_BOUTON[BOUTON_CHOIX_COL],0);
Afficher_curseur();
do
{
if(!Get_input())Wait_VBL();
if ((Mouse_X!=Ancien_X) || (Mouse_Y!=Ancien_Y))
{
Effacer_curseur();
a=Lit_pixel(Mouse_X,Mouse_Y);
if (a!=c)
{
c=a; // Mise à jour de la couleur pointée
if (Menu_visible_avant_fenetre)
{
sprintf(Chaine,"%d",a);
d=strlen(Chaine);
strcat(Chaine," (");
sprintf(Chaine+strlen(Chaine),"%d",Principal_Palette[a].R);
strcat(Chaine,",");
sprintf(Chaine+strlen(Chaine),"%d",Principal_Palette[a].G);
strcat(Chaine,",");
sprintf(Chaine+strlen(Chaine),"%d",Principal_Palette[a].B);
strcat(Chaine,")");
a=24-d;
for (Indice=strlen(Chaine); Indice<a; Indice++)
Chaine[Indice]=' ';
Chaine[a]=0;
Print_dans_menu(Chaine,strlen(TITRE_BOUTON[BOUTON_CHOIX_COL]));
Print_general((26+((d+strlen(TITRE_BOUTON[BOUTON_CHOIX_COL]))<<3))*Menu_Facteur_X,
Menu_Ordonnee_Texte," ",0,c);
}
}
Afficher_curseur();
}
Ancien_X=Mouse_X;
Ancien_Y=Mouse_Y;
} while (!(Mouse_K || (Touche==TOUCHE_ESC)));
if (Mouse_K)
{
Effacer_curseur();
*click=Mouse_K;
*Couleur=Lit_pixel(Mouse_X,Mouse_Y);
}
else
{
*click=0;
Effacer_curseur();
}
for (Indice=0; Indice<height; Indice++)
Afficher_ligne(Fenetre_Pos_X,Fenetre_Pos_Y+Indice,width,Buffer+((int)Indice*width));
UpdateRect(Fenetre_Pos_X, Fenetre_Pos_Y, Fenetre_Largeur*Menu_Facteur_X, Fenetre_Hauteur*Menu_Facteur_Y);
Forme_curseur=FORME_CURSEUR_FLECHE;
Cacher_pinceau=b;
Cacher_curseur=Cacher_curseur_avant_recuperation;
Afficher_curseur();
free(Buffer);
}
else
{
Erreur(0);
}
}
// ------------ Opération de déplacement de la fenêtre à l'écran -------------
void Deplacer_fenetre(short Dx, short Dy)
{
short Nouveau_X=Mouse_X-Dx;
short Nouveau_Y=Mouse_Y-Dy;
short Ancien_X;
short Ancien_Y;
short width=Fenetre_Largeur*Menu_Facteur_X;
short height=Fenetre_Hauteur*Menu_Facteur_Y;
short a;
byte b;
byte *Buffer=NULL;
Effacer_curseur();
Ligne_horizontale_XOR(Nouveau_X,Nouveau_Y,width);
Ligne_verticale_XOR(Nouveau_X,Nouveau_Y+1,height-2);
Ligne_verticale_XOR(Nouveau_X+width-1,Nouveau_Y+1,height-2);
Ligne_horizontale_XOR(Nouveau_X,Nouveau_Y+height-1,width);
UpdateRect(Nouveau_X,Nouveau_Y,width,height);
Forme_curseur=FORME_CURSEUR_MULTIDIRECTIONNEL;
Afficher_curseur();
while (Mouse_K)
{
Ancien_X=Nouveau_X;
Ancien_Y=Nouveau_Y;
while(!Get_input() && Nouveau_X==Mouse_X-Dx && Nouveau_Y==Mouse_Y-Dy) Wait_VBL();
Nouveau_X=Mouse_X-Dx;
if (Nouveau_X<0)
{
Nouveau_X=0;
Dx = Mouse_X;
}
if (Nouveau_X>Largeur_ecran-width)
{
Nouveau_X=Largeur_ecran-width;
Dx = Mouse_X - Nouveau_X;
}
Nouveau_Y=Mouse_Y-Dy;
if (Nouveau_Y<0)
{
Nouveau_Y=0;
Dy = Mouse_Y;
}
if (Nouveau_Y>Hauteur_ecran-height)
{
Nouveau_Y=Hauteur_ecran-height;
Dy = Mouse_Y - Nouveau_Y;
}
if ((Nouveau_X!=Ancien_X) || (Nouveau_Y!=Ancien_Y))
{
Effacer_curseur();
Ligne_horizontale_XOR(Ancien_X,Ancien_Y,width);
Ligne_verticale_XOR(Ancien_X,Ancien_Y+1,height-2);
Ligne_verticale_XOR(Ancien_X+width-1,Ancien_Y+1,height-2);
Ligne_horizontale_XOR(Ancien_X,Ancien_Y+height-1,width);
Ligne_horizontale_XOR(Nouveau_X,Nouveau_Y,width);
Ligne_verticale_XOR(Nouveau_X,Nouveau_Y+1,height-2);
Ligne_verticale_XOR(Nouveau_X+width-1,Nouveau_Y+1,height-2);
Ligne_horizontale_XOR(Nouveau_X,Nouveau_Y+height-1,width);
Afficher_curseur();
UpdateRect(Ancien_X,Ancien_Y,width,height);
UpdateRect(Nouveau_X,Nouveau_Y,width,height);
}
}
Effacer_curseur();
Ligne_horizontale_XOR(Nouveau_X,Nouveau_Y,width);
Ligne_verticale_XOR(Nouveau_X,Nouveau_Y+1,height-2);
Ligne_verticale_XOR(Nouveau_X+width-1,Nouveau_Y+1,height-2);
Ligne_horizontale_XOR(Nouveau_X,Nouveau_Y+height-1,width);
if ((Nouveau_X!=Fenetre_Pos_X)
|| (Nouveau_Y!=Fenetre_Pos_Y))
{
a=Menu_Ordonnee;
Menu_Ordonnee=Menu_Ordonnee_avant_fenetre;
b=Menu_visible;
Menu_visible=Menu_visible_avant_fenetre;
//Afficher_ecran();
//Afficher_menu();
Menu_Ordonnee=a;
Menu_visible=b;
// Sauvegarde du contenu actuel de la fenêtre
Sauve_fond(&Buffer, Fenetre_Pos_X, Fenetre_Pos_Y, Fenetre_Largeur, Fenetre_Hauteur);
// Restore de ce que la fenêtre cachait
Restaure_fond(Fond_fenetre[Fenetre-1], Fenetre_Pos_X, Fenetre_Pos_Y, Fenetre_Largeur, Fenetre_Hauteur);
Fond_fenetre[Fenetre-1] = NULL;
// Sauvegarde de ce que la fenêtre remplace
Sauve_fond(&(Fond_fenetre[Fenetre-1]), Nouveau_X, Nouveau_Y, Fenetre_Largeur, Fenetre_Hauteur);
// Raffichage de la fenêtre
Restaure_fond(Buffer, Nouveau_X, Nouveau_Y, Fenetre_Largeur, Fenetre_Hauteur);
Buffer = NULL;
// Mise à jour du rectangle englobant
UpdateRect(
(Nouveau_X>Fenetre_Pos_X)?Fenetre_Pos_X:Nouveau_X,
(Nouveau_Y>Fenetre_Pos_Y)?Fenetre_Pos_Y:Nouveau_Y,
((Nouveau_X>Fenetre_Pos_X)?(Nouveau_X-Fenetre_Pos_X):(Fenetre_Pos_X-Nouveau_X)) + Fenetre_Largeur*Menu_Facteur_X,
((Nouveau_Y>Fenetre_Pos_Y)?(Nouveau_Y-Fenetre_Pos_Y):(Fenetre_Pos_Y-Nouveau_Y)) + Fenetre_Hauteur*Menu_Facteur_Y);
Fenetre_Pos_X=Nouveau_X;
Fenetre_Pos_Y=Nouveau_Y;
}
else
{
// Update pour effacer le rectangle XOR
UpdateRect(Fenetre_Pos_X, Fenetre_Pos_Y, Fenetre_Largeur*Menu_Facteur_X, Fenetre_Hauteur*Menu_Facteur_Y);
}
Forme_curseur=FORME_CURSEUR_FLECHE;
Afficher_curseur();
}
// Gestion des dropdown
short Fenetre_Dropdown_click(T_Bouton_dropdown *Bouton)
{
short Nb_choix;
short Indice_choix;
short Indice_selectionne;
short Ancien_Indice_selectionne;
short Hauteur_boite;
T_Dropdown_choix *Choix;
// Taille de l'ombre portée (en plus des dimensions normales)
#define OMBRE_DROITE 3
#define OMBRE_BAS 4
// Comptage des items pour calculer la taille
Nb_choix=0;
for (Choix=Bouton->Premier_choix; Choix!=NULL; Choix=Choix->Next)
{
Nb_choix++;
}
Hauteur_boite=3+Nb_choix*8+1;
Effacer_curseur();
Fenetre_Enfoncer_bouton_normal(Bouton->Pos_X,Bouton->Pos_Y,Bouton->Width,Bouton->Height);
Ouvrir_popup(
Fenetre_Pos_X+(Bouton->Pos_X)*Menu_Facteur_X,
Fenetre_Pos_Y+(Bouton->Pos_Y+Bouton->Height)*Menu_Facteur_Y,
Bouton->Largeur_choix+OMBRE_DROITE,
Hauteur_boite+OMBRE_BAS);
// Dessin de la boite
// Bord gauche
Block(Fenetre_Pos_X,Fenetre_Pos_Y,Menu_Facteur_X,Hauteur_boite*Menu_Facteur_Y,CM_Noir);
// Cadre fonce et blanc
Fenetre_Afficher_cadre_bombe(1,0,Bouton->Largeur_choix-1,Hauteur_boite);
// Ombre portée
if (OMBRE_BAS)
{
Block(Fenetre_Pos_X+OMBRE_DROITE*Menu_Facteur_X,
Fenetre_Pos_Y+Hauteur_boite*Menu_Facteur_Y,
Bouton->Largeur_choix*Menu_Facteur_X,
OMBRE_BAS*Menu_Facteur_Y,
CM_Noir);
Block(Fenetre_Pos_X,
Fenetre_Pos_Y+Hauteur_boite*Menu_Facteur_Y,
OMBRE_DROITE*Menu_Facteur_X,
Menu_Facteur_Y,
CM_Noir);
}
if (OMBRE_DROITE)
{
Block(Fenetre_Pos_X+Bouton->Largeur_choix*Menu_Facteur_X,
Fenetre_Pos_Y+OMBRE_BAS*Menu_Facteur_Y,
OMBRE_DROITE*Menu_Facteur_X,
(Hauteur_boite-OMBRE_BAS)*Menu_Facteur_Y,
CM_Noir);
Block(Fenetre_Pos_X+Bouton->Largeur_choix*Menu_Facteur_X,
Fenetre_Pos_Y,
Menu_Facteur_X,
OMBRE_BAS*Menu_Facteur_Y,
CM_Noir);
}
Indice_selectionne=-1;
while (1)
{
Ancien_Indice_selectionne = Indice_selectionne;
// Fenêtre grise
Block(Fenetre_Pos_X+2*Menu_Facteur_X,
Fenetre_Pos_Y+1*Menu_Facteur_Y,
(Bouton->Largeur_choix-3)*Menu_Facteur_X,(Hauteur_boite-2)*Menu_Facteur_Y,CM_Clair);
// Affichage des items
for(Choix=Bouton->Premier_choix,Indice_choix=0; Choix!=NULL; Choix=Choix->Next,Indice_choix++)
{
byte color_1;
byte color_2;
if (Indice_choix==Indice_selectionne)
{
color_1=CM_Blanc;
color_2=CM_Fonce;
Block(Fenetre_Pos_X+3*Menu_Facteur_X,
Fenetre_Pos_Y+((2+Indice_choix*8)*Menu_Facteur_Y),
(Bouton->Largeur_choix-5)*Menu_Facteur_X,(8)*Menu_Facteur_Y,CM_Fonce);
}
else
{
color_1=CM_Noir;
color_2=CM_Clair;
}
Print_dans_fenetre(3,2+Indice_choix*8,Choix->Label,color_1,color_2);
}
UpdateRect(Fenetre_Pos_X,Fenetre_Pos_Y,Fenetre_Largeur*Menu_Facteur_X,Fenetre_Hauteur*Menu_Facteur_Y);
Afficher_curseur();
do
{
// Attente
if(!Get_input())
Wait_VBL();
// Mise à jour du survol
Indice_selectionne=Fenetre_click_dans_zone(2,2,Bouton->Largeur_choix-2,Hauteur_boite-1)?
(((Mouse_Y-Fenetre_Pos_Y)/Menu_Facteur_Y-2)>>3) : -1;
} while (Mouse_K && Indice_selectionne==Ancien_Indice_selectionne);
if (!Mouse_K)
break;
Effacer_curseur();
}
Fermer_popup();
Fenetre_Desenfoncer_bouton_normal(Bouton->Pos_X,Bouton->Pos_Y,Bouton->Width,Bouton->Height);
Afficher_curseur();
if (Indice_selectionne>=0 && Indice_selectionne<Nb_choix)
{
for(Choix=Bouton->Premier_choix; Indice_selectionne; Choix=Choix->Next,Indice_selectionne--)
;
Fenetre_Attribut2=Choix->Number;
if (Bouton->Affiche_choix)
{
// Mettre à jour automatiquement le libellé de la dropdown
Print_dans_fenetre(Bouton->Pos_X+2,Bouton->Pos_Y+(Bouton->Height-7)/2,Choix->Label,CM_Noir,CM_Clair);
}
return Bouton->Number;
}
Fenetre_Attribut2=-1;
return 0;
}
// --- Fonction de clic sur un bouton a peu près ordinaire:
// Attend que l'on relache le bouton, et renvoie le numero du bouton si on
// est resté dessus, 0 si on a annulé en sortant du bouton.
short Fenetre_bouton_normal_click(word x_pos, word y_pos, word width, word height, short btn_number)
{
while(1)
{
Effacer_curseur();
Fenetre_Enfoncer_bouton_normal(x_pos,y_pos,width,height);
Afficher_curseur();
while (Fenetre_click_dans_zone(x_pos,y_pos,x_pos+width-1,y_pos+height-1))
{
if(!Get_input())
Wait_VBL();
if (!Mouse_K)
{
Effacer_curseur();
Fenetre_Desenfoncer_bouton_normal(x_pos,y_pos,width,height);
Afficher_curseur();
return btn_number;
}
}
Effacer_curseur();
Fenetre_Desenfoncer_bouton_normal(x_pos,y_pos,width,height);
Afficher_curseur();
while (!(Fenetre_click_dans_zone(x_pos,y_pos,x_pos+width-1,y_pos+height-1)))
{
if(!Get_input())
Wait_VBL();
if (!Mouse_K)
return 0;
}
}
}
// --- Renvoie le numéro du bouton clicke (-1:hors de la fenêtre, 0:aucun) ---
short Fenetre_Numero_bouton_clicke(void)
{
T_Bouton_normal * Temp1;
T_Bouton_palette * Temp2;
T_Bouton_scroller * Temp3;
T_Bouton_special * Temp4;
T_Bouton_dropdown * Temp5;
long Hauteur_maxi_jauge;
Fenetre_Attribut1=Mouse_K;
// Test du click sur les boutons normaux
for (Temp1=Fenetre_Liste_boutons_normal; Temp1; Temp1=Temp1->Next)
{
if (Fenetre_click_dans_zone(Temp1->Pos_X,Temp1->Pos_Y,Temp1->Pos_X+Temp1->Width-1,Temp1->Pos_Y+Temp1->Height-1))
{
if (Temp1->Repetable)
{
Effacer_curseur();
Fenetre_Enfoncer_bouton_normal(Temp1->Pos_X,Temp1->Pos_Y,Temp1->Width,Temp1->Height);
Afficher_curseur();
Tempo_jauge((Mouse_K==1)? Config.Valeur_tempo_jauge_gauche : Config.Valeur_tempo_jauge_droite);
Effacer_curseur();
Fenetre_Desenfoncer_bouton_normal(Temp1->Pos_X,Temp1->Pos_Y,Temp1->Width,Temp1->Height);
Afficher_curseur();
return Temp1->Number;
}
return Fenetre_bouton_normal_click(Temp1->Pos_X,Temp1->Pos_Y,Temp1->Width,Temp1->Height,Temp1->Number);
}
}
// Test du click sur les zones "palette"
for (Temp2=Fenetre_Liste_boutons_palette; Temp2; Temp2=Temp2->Next)
{
if (Fenetre_click_dans_zone(Temp2->Pos_X+5,Temp2->Pos_Y+3,Temp2->Pos_X+160,Temp2->Pos_Y+82))
{
// On stocke dans Attribut2 le numero de couleur cliqué
Fenetre_Attribut2 = (((Mouse_X-Fenetre_Pos_X)/Menu_Facteur_X)-(Temp2->Pos_X+2)) / 10 * 16 +
(((Mouse_Y-Fenetre_Pos_Y)/Menu_Facteur_Y)-(Temp2->Pos_Y+3)) / 5;
return Temp2->Number;
}
}
// Test du click sur les barres de défilement
for (Temp3=Fenetre_Liste_boutons_scroller; Temp3; Temp3=Temp3->Next)
{
if (Fenetre_click_dans_zone(Temp3->Pos_X,Temp3->Pos_Y,Temp3->Pos_X+10,Temp3->Pos_Y+Temp3->Height-1))
{
// Bouton flèche Haut
if (Fenetre_click_dans_zone(Temp3->Pos_X,Temp3->Pos_Y,Temp3->Pos_X+10,Temp3->Pos_Y+10))
{
Effacer_curseur();
Fenetre_Enfoncer_bouton_normal(Temp3->Pos_X,Temp3->Pos_Y,11,11);
if (Temp3->Position)
{
Temp3->Position--;
Fenetre_Attribut1=1;
Fenetre_Attribut2=Temp3->Position;
Fenetre_Dessiner_jauge(Temp3);
}
else
Fenetre_Attribut1=0;
Afficher_curseur();
Tempo_jauge((Mouse_K==1)? Config.Valeur_tempo_jauge_gauche : Config.Valeur_tempo_jauge_droite);
Effacer_curseur();
Fenetre_Desenfoncer_bouton_normal(Temp3->Pos_X,Temp3->Pos_Y,11,11);
Afficher_curseur();
}
else
// Bouton flèche Bas
if (Fenetre_click_dans_zone(Temp3->Pos_X,Temp3->Pos_Y+Temp3->Height-11,Temp3->Pos_X+10,Temp3->Pos_Y+Temp3->Height-1))
{
Effacer_curseur();
Fenetre_Enfoncer_bouton_normal(Temp3->Pos_X,Temp3->Pos_Y+Temp3->Height-11,11,11);
if (Temp3->Position+Temp3->Nb_visibles<Temp3->Nb_elements)
{
Temp3->Position++;
Fenetre_Attribut1=2;
Fenetre_Attribut2=Temp3->Position;
Fenetre_Dessiner_jauge(Temp3);
}
else
Fenetre_Attribut1=0;
Afficher_curseur();
Tempo_jauge((Mouse_K==1)? Config.Valeur_tempo_jauge_gauche : Config.Valeur_tempo_jauge_droite);
Effacer_curseur();
Fenetre_Desenfoncer_bouton_normal(Temp3->Pos_X,Temp3->Pos_Y+Temp3->Height-11,11,11);
Afficher_curseur();
}
else
// Jauge
if (Fenetre_click_dans_zone(Temp3->Pos_X,Temp3->Pos_Y+12,Temp3->Pos_X+10,Temp3->Pos_Y+Temp3->Height-13))
{
if (Temp3->Nb_elements>Temp3->Nb_visibles)
{
// S'il y a la place de faire scroller le curseur:
Hauteur_maxi_jauge=(Temp3->Height-24);
// Fenetre_Attribut2 reçoit la position dans la jauge correspondant au click
Fenetre_Attribut2 =(Mouse_Y-Fenetre_Pos_Y) / Menu_Facteur_Y;
Fenetre_Attribut2-=(Temp3->Pos_Y+12+((Temp3->Hauteur_curseur-1)>>1));
Fenetre_Attribut2*=(Temp3->Nb_elements-Temp3->Nb_visibles);
if (Fenetre_Attribut2<0)
Fenetre_Attribut2=0;
else
{
Fenetre_Attribut2 =Round_div(Fenetre_Attribut2,Hauteur_maxi_jauge-Temp3->Hauteur_curseur);
if (Fenetre_Attribut2+Temp3->Nb_visibles>Temp3->Nb_elements)
Fenetre_Attribut2=Temp3->Nb_elements-Temp3->Nb_visibles;
}
// Si le curseur de la jauge bouge:
if (Temp3->Position!=Fenetre_Attribut2)
{
Temp3->Position=Fenetre_Attribut2;
Fenetre_Attribut1=3;
Effacer_curseur();
Fenetre_Dessiner_jauge(Temp3);
Afficher_curseur();
}
else
// Si le curseur de la jauge ne bouge pas:
Fenetre_Attribut1=0;
}
else
// S'il n'y a pas la place de bouger le curseur de la jauge:
Fenetre_Attribut1=0;
}
else
// Le click se situe dans la zone de la jauge mais n'est sur aucune
// des 3 parties importantes de la jauge
Fenetre_Attribut1=0;
return (Fenetre_Attribut1)? Temp3->Number : 0;
}
}
// Test du click sur une zone spéciale
for (Temp4=Fenetre_Liste_boutons_special; Temp4; Temp4=Temp4->Next)
{
if (Fenetre_click_dans_zone(Temp4->Pos_X,Temp4->Pos_Y,Temp4->Pos_X+Temp4->Width-1,Temp4->Pos_Y+Temp4->Height-1))
return Temp4->Number;
}
// Test du click sur une dropdown
for (Temp5=Fenetre_Liste_boutons_dropdown; Temp5; Temp5=Temp5->Next)
{
if (Fenetre_click_dans_zone(Temp5->Pos_X,Temp5->Pos_Y,Temp5->Pos_X+Temp5->Width-1,Temp5->Pos_Y+Temp5->Height-1))
{
if (Mouse_K & Temp5->Bouton_actif)
return Fenetre_Dropdown_click(Temp5);
else
{
Fenetre_Attribut2=-1;
return Fenetre_bouton_normal_click(Temp5->Pos_X,Temp5->Pos_Y,Temp5->Width,Temp5->Height,Temp5->Number);
}
}
}
return 0;
}
short Fenetre_Numero_bouton_touche(void)
{
T_Bouton_normal * Temp;
if (Touche & MOD_SHIFT)
Fenetre_Attribut1=A_DROITE;
else
Fenetre_Attribut1=A_GAUCHE;
// On fait une première recherche
Temp=Fenetre_Liste_boutons_normal;
while (Temp!=NULL)
{
if (Temp->Raccourci==Touche)
{
Effacer_curseur();
Fenetre_Enfoncer_bouton_normal(Temp->Pos_X,Temp->Pos_Y,Temp->Width,Temp->Height);
Afficher_curseur();
Tempo_jauge(Config.Valeur_tempo_jauge_droite);
Effacer_curseur();
Fenetre_Desenfoncer_bouton_normal(Temp->Pos_X,Temp->Pos_Y,Temp->Width,Temp->Height);
Afficher_curseur();
return Temp->Number;
}
Temp=Temp->Next;
}
// Si la recherche n'a pas été fructueuse ET que l'utilisateur appuyait sur
// <Shift>, on regarde si un bouton ne pourrait pas réagir comme si <Shift>
// n'était pas appuyé.
if (Fenetre_Attribut1==A_DROITE)
{
Temp=Fenetre_Liste_boutons_normal;
while (Temp!=NULL)
{
if (Temp->Raccourci==(Touche&0x0FFF))
return Temp->Number;
Temp=Temp->Next;
}
}
return 0;
}
short Fenetre_Bouton_clicke(void)
{
short Bouton;
if(!Get_input())Wait_VBL();
// Gestion des clicks
if (Mouse_K)
{
if ((Mouse_X<Fenetre_Pos_X) || (Mouse_Y<Fenetre_Pos_Y)
|| (Mouse_X>=Fenetre_Pos_X+(Fenetre_Largeur*Menu_Facteur_X))
|| (Mouse_Y>=Fenetre_Pos_Y+(Fenetre_Hauteur*Menu_Facteur_Y)))
return -1;
else
{
if (Mouse_Y < Fenetre_Pos_Y+(12*Menu_Facteur_Y))
Deplacer_fenetre(Mouse_X-Fenetre_Pos_X,Mouse_Y-Fenetre_Pos_Y);
else
return Fenetre_Numero_bouton_clicke();
}
}
// Gestion des touches
if (Touche)
{
Bouton=Fenetre_Numero_bouton_touche();
if (Bouton)
{
Touche=0;
return Bouton;
}
}
return 0;
}
// Fonction qui sert à remapper les parties sauvegardées derriere les
// fenetres ouvertes. C'est utilisé par exemple par la fenetre de palette
// Qui remappe des couleurs, afin de propager les changements.
void Remappe_fond_fenetres(byte * Table_de_conversion, int Min_Y, int Max_Y)
{
int Indice_fenetre;
byte* EDI;
int dx,cx;
for (Indice_fenetre=0; Indice_fenetre<Fenetre; Indice_fenetre++)
{
EDI = Fond_fenetre[Indice_fenetre];
// Pour chaque ligne
for(dx=0; dx<Pile_Fenetre_Hauteur[Indice_fenetre]*Menu_Facteur_Y;dx++)
{
if (dx+Pile_Fenetre_Pos_Y[Indice_fenetre]>Max_Y)
return;
if (dx+Pile_Fenetre_Pos_Y[Indice_fenetre]<Min_Y)
{
EDI += Pile_Fenetre_Largeur[Indice_fenetre]*Menu_Facteur_X*Pixel_width;
}
else
// Pour chaque pixel
for(cx=Pile_Fenetre_Largeur[Indice_fenetre]*Menu_Facteur_X*Pixel_width;cx>0;cx--)
{
*EDI = Table_de_conversion[*EDI];
EDI ++;
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink