From 57fa46de8cd490ff776efe8cfc5da17fa7bc264d Mon Sep 17 00:00:00 2001 From: Adrien Destugues Date: Mon, 13 Aug 2007 18:41:50 +0000 Subject: [PATCH] Big cleanup, proper makefile git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@12 416bcca6-2ee7-4201-b75f-2eb2f807beb1 --- divers.c | 60 +- divers.h | 20 +- global.h | 280 +- graph.c | 11413 +++++++++++++++++++++++++------------------------- graph.h | 4 +- init.c | 92 +- linux.c | 5 + linux.h | 2 + loadsave.c | 584 +-- loadsave.h | 6 +- main.c | 116 +- makefile | 46 +- op_c.c | 2 +- pages.c | 278 +- readini.c | 120 +- saveini.c | 86 +- sdlscreen.c | 0 sdlscreen.h | 4 +- struct.h | 46 +- 19 files changed, 6588 insertions(+), 6576 deletions(-) create mode 100644 sdlscreen.c diff --git a/divers.c b/divers.c index d2405a26..027b8edd 100644 --- a/divers.c +++ b/divers.c @@ -12,13 +12,11 @@ word Palette_Compter_nb_couleurs_utilisees(dword* Tableau) word Nombre_Couleurs=0; int i; - - //Calcul du nombre de pixels dans l'image Nombre_De_Pixels=Principal_Hauteur_image*Principal_Largeur_image; - // On parcourt l'‚cran courant pour compter les utilisations des couleurs - for(i=0;i++;i>Nombre_De_Pixels) + // On parcourt l'écran courant pour compter les utilisations des couleurs + for(i=0;i>Nombre_De_Pixels;i++) { Couleur=*Pixel_Courant; //on lit la couleur dans l'écran @@ -28,32 +26,26 @@ word Palette_Compter_nb_couleurs_utilisees(dword* Tableau) Pixel_Courant++; } - //On va maintenant compter dans la table les couleurs utilis‚es: - - Couleur=0; //EDX - - do + //On va maintenant compter dans la table les couleurs utilisées: + Couleur=0; + do { - if (Tableau[Couleur]!=0) + if (Tableau[Couleur]!=0) Nombre_Couleurs++; - - Couleur++; - - }while (Couleur<256); + Couleur++; + }while(Couleur!=0); //On sort quand on a fait le tour (la var est sur 8 bits donc 255+1=0) return Nombre_Couleurs; } void Set_palette(T_Palette Palette) { - SDL_SetPalette(Ecran, SDL_LOGPAL|SDL_PHYSPAL, Palette, 0, 256); + puts("Set_Palette non implémenté!\n"); } void Attendre_fin_de_click(void) { - do - SDL_PumpEvents(); - while (SDL_GetMouseState(NULL, NULL)&SDL_BUTTON(0)); + puts("Attendre_fin_de_click non implémenté!\n"); } void Effacer_image_courante_Stencil(byte Couleur, byte * Pochoir) @@ -67,10 +59,10 @@ void Effacer_image_courante_Stencil(byte Couleur, byte * Pochoir) Nombre_De_Pixels=Principal_Hauteur_image*Principal_Largeur_image; - for(i=0;i++;i0 = … droite, Ellipse_Curseur_X<0 = … gauche) et … +// Indique si le pixel se trouvant à Ellipse_Curseur_X pixels +// (Ellipse_Curseur_X>0 = à droite, Ellipse_Curseur_X<0 = à gauche) et à // Ellipse_Curseur_Y pixels (Ellipse_Curseur_Y>0 = en bas, // Ellipse_Curseur_Y<0 = en haut) du centre se trouve dans l'ellipse en // cours. byte Pixel_dans_cercle(void); -// Indique si le pixel se trouvant … Cercle_Curseur_X pixels -// (Cercle_Curseur_X>0 = … droite, Cercle_Curseur_X<0 = … gauche) et … +// Indique si le pixel se trouvant à Cercle_Curseur_X pixels +// (Cercle_Curseur_X>0 = à droite, Cercle_Curseur_X<0 = à gauche) et à // Cercle_Curseur_Y pixels (Cercle_Curseur_Y>0 = en bas, // Cercle_Curseur_Y<0 = en haut) du centre se trouve dans le cercle en // cours. byte Bit(byte Octet, byte Rang); -// Extrait un bit d'un certain rang … partir d'un octet. +// Extrait un bit d'un certain rang à partir d'un octet. byte Couleur_ILBM_line(word Pos_X, word Vraie_taille_ligne); // Renvoie la couleur du pixel (ILBM) en Pos_X. diff --git a/global.h b/global.h index 3626651f..e738f72a 100644 --- a/global.h +++ b/global.h @@ -6,7 +6,7 @@ ////////////////////////////////////////////////////////////////////////////// // // -// Ce fichier contient les d‚claration des variables globales // +// Ce fichier contient les déclaration des variables globales // // // ////////////////////////////////////////////////////////////////////////////// @@ -59,11 +59,11 @@ GLOBAL struct S_Config byte Resolution_par_defaut; } Config; - // Tableau des touches sp‚ciales + // Tableau des touches spéciales GLOBAL word Config_Touche[NB_TOUCHES_SPECIALES]; -GLOBAL struct S_Mode_video +struct S_Mode_video { short Largeur; short Hauteur; @@ -71,7 +71,7 @@ GLOBAL struct S_Mode_video word Facteur_X; word Facteur_Y; char Ratio[5]; - signed char Refresh; // <0 => entrelac‚ + signed char Refresh; // <0 => entrelacé word Mode_VESA_de_base; void * Pointeur; byte Etat; // 0:Cool 1:OK ; 2:Bof ; 3:Naze ; si on rajoute +128 => incompatible @@ -81,16 +81,16 @@ GLOBAL struct S_Mode_video Mode_video[NB_MODES_VIDEO]; GLOBAL struct { - byte Granularite; // Facteur de gestion de la granularit‚ + byte Granularite; // Facteur de gestion de la granularité byte Code_fenetres; // Utilisation des fenˆtres: 0=AA 1=BB 2=AB 3=BA byte * WinFuncPtr; byte * Adresse_physique_LFB; // Si = 0 => Pas de LFB - dword Taille_LFB; // Taille de la m‚moire LFB + dword Taille_LFB; // Taille de la mémoire LFB } VESA_Mode_Infos[4]; - // Palette par d‚faut + // Palette par défaut GLOBAL T_Palette Palette_defaut; @@ -103,10 +103,10 @@ GLOBAL byte CM_Blanc; GLOBAL byte CM_Trans; GLOBAL struct Composantes Coul_menu_pref[4]; - // Etat des entr‚es + // Etat des entrées GLOBAL word Mouse_X; // Abscisse de la souris -GLOBAL word Mouse_Y; // Ordonn‚e de la souris +GLOBAL word Mouse_Y; // Ordonnée de la souris GLOBAL byte Mouse_K; // Etat des boutons de la souris GLOBAL word Touche; GLOBAL Uint8* Etat_Du_Clavier; // Scancode de la touche en cours et etat des touches de ctrl @@ -117,20 +117,20 @@ GLOBAL byte Mouse_Facteur_de_correction_Y; GLOBAL byte Autoriser_changement_de_couleur_pendant_operation; - // Donn‚es sur le curseur + // Données sur le curseur GLOBAL byte Forme_curseur; GLOBAL byte Forme_curseur_avant_fenetre; // Forme du curseur avant l'ouverture d'une fenˆtre GLOBAL byte Forcer_affichage_curseur; // Forcer l'affichage du curseur au prochain Get_input(); GLOBAL byte Cacher_curseur; -GLOBAL byte Curseur_dans_menu; // Bool‚en "Le curseur se trouve dans le menu" -GLOBAL byte Curseur_dans_menu_precedent; // Bool‚en "Le curseur se trouvait pr‚c‚demment dans le menu" -GLOBAL word Curseur_Decalage_X[NB_SPRITES_CURSEUR]; // Coordonn‚es X du point sensible de curseurs en sprite -GLOBAL word Curseur_Decalage_Y[NB_SPRITES_CURSEUR]; // Coordonn‚es Y du point sensible de curseurs en sprite +GLOBAL byte Curseur_dans_menu; // Booléen "Le curseur se trouve dans le menu" +GLOBAL byte Curseur_dans_menu_precedent; // Booléen "Le curseur se trouvait précédemment dans le menu" +GLOBAL word Curseur_Decalage_X[NB_SPRITES_CURSEUR]; // Coordonnées X du point sensible de curseurs en sprite +GLOBAL word Curseur_Decalage_Y[NB_SPRITES_CURSEUR]; // Coordonnées Y du point sensible de curseurs en sprite GLOBAL byte SPRITE_CURSEUR[NB_SPRITES_CURSEUR][HAUTEUR_SPRITE_CURSEUR][LARGEUR_SPRITE_CURSEUR]; // Dessins des sprites de curseur GLOBAL byte FOND_CURSEUR[HAUTEUR_SPRITE_CURSEUR][LARGEUR_SPRITE_CURSEUR]; // Contenu du dessous du curseur - // Donn‚es sur le pinceau + // Données sur le pinceau GLOBAL byte Pinceau_Forme; GLOBAL byte Pinceau_Forme_avant_fill; @@ -153,102 +153,102 @@ GLOBAL short Pinceau_Decalage_Y; // Commandes graphiques -GLOBAL fonction_afficheur Pixel; // Affiche un point … l'‚cran +GLOBAL fonction_afficheur Pixel; // Affiche un point … l'écran GLOBAL fonction_afficheur Pixel_dans_menu;// Affiche un point dans le menu (ou pas si le menu est invisible) -GLOBAL fonction_lecteur Lit_pixel; // Teste la couleur d'un pixel dans l'‚cran -GLOBAL fonction_effaceur Clear_screen; // Efface rapidement tout l'‚cran (en faisant attention de ne pas effacer le menu) -GLOBAL fonction_display Display_screen; // Affiche rapidement tout l'‚cran (en faisant attention de ne pas effacer le menu) -GLOBAL fonction_block Block; // Affiche rapidement un bloc … l'‚cran -GLOBAL fonction_afficheur Pixel_Preview_Normal; // Affiche un point de l'image … l'‚cran en mode normal (pas en mode loupe) -GLOBAL fonction_afficheur Pixel_Preview_Loupe; // Affiche un point de l'image … l'‚cran en mode loupe -GLOBAL fonction_afficheur Pixel_Preview; // Affiche un point de l'image … l'‚cran en fonction de l'‚tat du mode loupe +GLOBAL fonction_lecteur Lit_pixel; // Teste la couleur d'un pixel dans l'écran +GLOBAL fonction_effaceur Clear_screen; // Efface rapidement tout l'écran (en faisant attention de ne pas effacer le menu) +GLOBAL fonction_display Display_screen; // Affiche rapidement tout l'écran (en faisant attention de ne pas effacer le menu) +GLOBAL fonction_block Block; // Affiche rapidement un bloc … l'écran +GLOBAL fonction_afficheur Pixel_Preview_Normal; // Affiche un point de l'image … l'écran en mode normal (pas en mode loupe) +GLOBAL fonction_afficheur Pixel_Preview_Loupe; // Affiche un point de l'image … l'écran en mode loupe +GLOBAL fonction_afficheur Pixel_Preview; // Affiche un point de l'image … l'écran en fonction de l'état du mode loupe GLOBAL fonction_Ligne_XOR Ligne_horizontale_XOR;// Affiche une ligne horizontale en XOR (pour placer la loupe) GLOBAL fonction_Ligne_XOR Ligne_verticale_XOR; // Affiche une ligne verticale en XOR (pour placer la loupe) GLOBAL fonction_display_brush_Color Display_brush_Color; // Affiche une partie de la brosse en couleur GLOBAL fonction_display_brush_Mono Display_brush_Mono; // Affiche une partie de la brosse en monochrome -GLOBAL fonction_display_brush_Color Clear_brush; // Efface la partie de la brosse affich‚e … l'‚cran -GLOBAL fonction_remap Remap_screen; // Remappe une partie de l'‚cran avec les nouvelles couleurs du menu +GLOBAL fonction_display_brush_Color Clear_brush; // Efface la partie de la brosse affichée … l'écran +GLOBAL fonction_remap Remap_screen; // Remappe une partie de l'écran avec les nouvelles couleurs du menu GLOBAL fonction_procsline Afficher_ligne; // Afficher une ligne GLOBAL fonction_procsline Lire_ligne; // Afficher ou lire une ligne -GLOBAL fonction_display_zoom Display_zoomed_screen; // Affiche rapidement toute la partie zoom‚e … l'‚cran (en faisant attention de ne pas effacer le menu) +GLOBAL fonction_display_zoom Display_zoomed_screen; // Affiche rapidement toute la partie zoomée … l'écran (en faisant attention de ne pas effacer le menu) GLOBAL fonction_display_brush_Color_zoom Display_brush_Color_zoom; GLOBAL fonction_display_brush_Mono_zoom Display_brush_Mono_zoom; GLOBAL fonction_display_brush_Color_zoom Clear_brush_zoom; - // Donn‚es sur les dimensions de l'‚cran + // Données sur les dimensions de l'écran -GLOBAL int Resolution_actuelle; // R‚solution graphique courante -GLOBAL short Ecran_original_X; // |_ Dimensions de l'‚cran d'origine de -GLOBAL short Ecran_original_Y; // | l'image qui vient d'ˆtre charg‚e. -GLOBAL short Largeur_ecran; // Largeur de l'‚cran -GLOBAL short Hauteur_ecran; // Hauteur de l'‚cran +GLOBAL int Resolution_actuelle; // Résolution graphique courante +GLOBAL short Ecran_original_X; // |_ Dimensions de l'écran d'origine de +GLOBAL short Ecran_original_Y; // | l'image qui vient d'ˆtre chargée. +GLOBAL short Largeur_ecran; // Largeur de l'écran +GLOBAL short Hauteur_ecran; // Hauteur de l'écran GLOBAL short Limite_Haut; // | GLOBAL short Limite_Bas; // |_ Limites dans lesquelles -GLOBAL short Limite_Gauche; // | on peut ‚crire +GLOBAL short Limite_Gauche; // | on peut écrire GLOBAL short Limite_Droite; // | GLOBAL short Limite_visible_Bas; // |_ Derniers points visibles GLOBAL short Limite_visible_Droite; // | "… l'image" GLOBAL short Limite_Haut_Zoom; // | GLOBAL short Limite_Bas_Zoom; // |_ Limites dans lesquelles on peut -GLOBAL short Limite_Gauche_Zoom; // | ‚crire dans la partie zoom‚e +GLOBAL short Limite_Gauche_Zoom; // | écrire dans la partie zoomée GLOBAL short Limite_Droite_Zoom; // | GLOBAL short Limite_visible_Bas_Zoom; // |_ Derniers points visibles "… -GLOBAL short Limite_visible_Droite_Zoom; // | l'image" dans la partie zoom‚e +GLOBAL short Limite_visible_Droite_Zoom; // | l'image" dans la partie zoomée GLOBAL byte * Buffer_de_ligne_horizontale; // Buffer d'affichage de lignes - // Donn‚es sur l'image actuelle: + // Données sur l'image actuelle: GLOBAL byte * Principal_Ecran; // Ecran virtuel courant -GLOBAL T_Palette Principal_Palette; // Palette de l'‚cran en cours +GLOBAL T_Palette Principal_Palette; // Palette de l'écran en cours -GLOBAL byte Principal_Image_modifiee; // L'image courante a ‚t‚ modifi‚e -GLOBAL short Principal_Largeur_image; // Largeur de l'image dans laquelle l'utilisateur d‚sire travailler -GLOBAL short Principal_Hauteur_image; // Hauteur de l'image dans laquelle l'utilisateur d‚sire travailler -GLOBAL short Principal_Decalage_X; // D‚calage en X de l'‚cran par rapport au d‚but de l'image -GLOBAL short Principal_Decalage_Y; // D‚calage en Y de l'‚cran par rapport au d‚but de l'image +GLOBAL byte Principal_Image_modifiee; // L'image courante a été modifiée +GLOBAL short Principal_Largeur_image; // Largeur de l'image dans laquelle l'utilisateur désire travailler +GLOBAL short Principal_Hauteur_image; // Hauteur de l'image dans laquelle l'utilisateur désire travailler +GLOBAL short Principal_Decalage_X; // Décalage en X de l'écran par rapport au début de l'image +GLOBAL short Principal_Decalage_Y; // Décalage en Y de l'écran par rapport au début de l'image GLOBAL short Ancien_Principal_Decalage_X; GLOBAL short Ancien_Principal_Decalage_Y; GLOBAL char Principal_Repertoire_fichier[256]; // |_ Nom complet = GLOBAL char Principal_Nom_fichier[13]; // | Repertoire_fichier+"\"+Nom_fichier -GLOBAL byte Principal_Format_fichier; // Format auquel il faut lire et ‚crire le fichier +GLOBAL byte Principal_Format_fichier; // Format auquel il faut lire et écrire le fichier GLOBAL byte Principal_Format; // Format du fileselect -GLOBAL short Principal_File_list_Position; // D‚but de la partie affich‚e dans la liste de fichiers -GLOBAL short Principal_File_list_Decalage; // D‚calage de la barre de s‚lection dans le fileselector -GLOBAL char Principal_Repertoire_courant[256]; // R‚pertoire actuel sur disque +GLOBAL short Principal_File_list_Position; // Début de la partie affichée dans la liste de fichiers +GLOBAL short Principal_File_list_Decalage; // Décalage de la barre de sélection dans le fileselector +GLOBAL char Principal_Repertoire_courant[256]; // Répertoire actuel sur disque GLOBAL char Principal_Commentaire[TAILLE_COMMENTAIRE+1]; // Commentaire de l'image GLOBAL short Principal_Split; // Position en X du bord gauche du split de la loupe GLOBAL short Principal_X_Zoom; // (Menu_Facteur_X) + Position en X du bord droit du split de la loupe -GLOBAL float Principal_Proportion_split; // Proportion de la zone non-zoom‚e par rapport … l'‚cran +GLOBAL float Principal_Proportion_split; // Proportion de la zone non-zoomée par rapport … l'écran - // Donn‚es sur le brouillon: + // Données sur le brouillon: GLOBAL byte * Brouillon_Ecran; // Ecran virtuel brouillon -GLOBAL T_Palette Brouillon_Palette; // Palette de l'‚cran de brouillon +GLOBAL T_Palette Brouillon_Palette; // Palette de l'écran de brouillon -GLOBAL byte Brouillon_Image_modifiee; // Le brouillon a ‚t‚ modifi‚ -GLOBAL short Brouillon_Largeur_image; // Largeur du brouillon dans laquelle l'utilisateur d‚sire travailler -GLOBAL short Brouillon_Hauteur_image; // Hauteur du brouillon dans laquelle l'utilisateur d‚sire travailler -GLOBAL short Brouillon_Decalage_X; // D‚calage en X du brouillon par rapport au d‚but de l'image -GLOBAL short Brouillon_Decalage_Y; // D‚calage en Y du brouillon par rapport au d‚but de l'image +GLOBAL byte Brouillon_Image_modifiee; // Le brouillon a été modifié +GLOBAL short Brouillon_Largeur_image; // Largeur du brouillon dans laquelle l'utilisateur désire travailler +GLOBAL short Brouillon_Hauteur_image; // Hauteur du brouillon dans laquelle l'utilisateur désire travailler +GLOBAL short Brouillon_Decalage_X; // Décalage en X du brouillon par rapport au début de l'image +GLOBAL short Brouillon_Decalage_Y; // Décalage en Y du brouillon par rapport au début de l'image GLOBAL short Ancien_Brouillon_Decalage_X; GLOBAL short Ancien_Brouillon_Decalage_Y; GLOBAL char Brouillon_Repertoire_fichier[256]; // |_ Nom complet = GLOBAL char Brouillon_Nom_fichier[13]; // | Repertoire_fichier+"\"+Nom_fichier -GLOBAL byte Brouillon_Format_fichier; // Format auquel il faut lire et ‚crire le fichier +GLOBAL byte Brouillon_Format_fichier; // Format auquel il faut lire et écrire le fichier GLOBAL byte Brouillon_Format; // Format du fileselect -GLOBAL short Brouillon_File_list_Position; // D‚but de la partie affich‚e dans la liste de fichiers -GLOBAL short Brouillon_File_list_Decalage; // D‚calage de la barre de s‚lection dans le fileselector -GLOBAL char Brouillon_Repertoire_courant[256]; // R‚pertoire actuel sur disque +GLOBAL short Brouillon_File_list_Position; // Début de la partie affichée dans la liste de fichiers +GLOBAL short Brouillon_File_list_Decalage; // Décalage de la barre de sélection dans le fileselector +GLOBAL char Brouillon_Repertoire_courant[256]; // Répertoire actuel sur disque GLOBAL char Brouillon_Commentaire[TAILLE_COMMENTAIRE+1]; // Commentaire de l'image GLOBAL short Brouillon_Split; // Position en X du bord gauche du split de la loupe GLOBAL short Brouillon_X_Zoom; // (Menu_Facteur_X) + Position en X du bord droit du split de la loupe -GLOBAL float Brouillon_Proportion_split; // Proportion de la zone non-zoom‚e par rapport … l'‚cran +GLOBAL float Brouillon_Proportion_split; // Proportion de la zone non-zoomée par rapport … l'écran GLOBAL byte Brouillon_Loupe_Mode; // On est en mode loupe dans le brouillon GLOBAL word Brouillon_Loupe_Facteur; // Facteur de zoom dans le brouillon @@ -261,12 +261,12 @@ GLOBAL byte Masque_copie_couleurs[256]; // Tableau des couleurs // Sauvegarde de l'image: -GLOBAL byte * Ecran_backup; // Sauvegarde de l'‚cran virtuel courant +GLOBAL byte * Ecran_backup; // Sauvegarde de l'écran virtuel courant GLOBAL S_Liste_de_pages * Principal_Backups; // Liste des pages de backup de la page principale GLOBAL S_Liste_de_pages * Brouillon_Backups; // Liste des pages de backup de la page de brouillon - // Donn‚es sur la brosse: + // Données sur la brosse: GLOBAL byte * Brosse; // Sprite de la brosse GLOBAL word Brosse_Decalage_X; // Centre horizontal de la brosse @@ -277,7 +277,7 @@ GLOBAL word Brosse_Hauteur; // Hauteur de la brosse GLOBAL char Brosse_Repertoire_fichier[256]; // | GLOBAL char Brosse_Nom_fichier[13]; // | GLOBAL byte Brosse_Format_fichier; // | Infos sur le -GLOBAL byte Brosse_Format; // |_ s‚lecteur de +GLOBAL byte Brosse_Format; // |_ sélecteur de GLOBAL short Brosse_File_list_Position; // | fichiers de la GLOBAL short Brosse_File_list_Decalage; // | brosse. GLOBAL char Brosse_Repertoire_courant[256]; // | @@ -287,28 +287,28 @@ GLOBAL byte Brosse_Centre_rotation_defini; // | Infos sur le GLOBAL short Brosse_Centre_rotation_X; // |- centre de rotation GLOBAL short Brosse_Centre_rotation_Y; // | de la brosse - // Donn‚es sur le menu + // Données sur le menu -GLOBAL byte Menu_visible; // Le menu est actif … l'‚cran -GLOBAL word Menu_Ordonnee; // Ordonn‚e o— commence le menu -GLOBAL word Menu_Ordonnee_Texte; // Ordonn‚e o— commence le texte dans le menu +GLOBAL byte Menu_visible; // Le menu est actif … l'écran +GLOBAL word Menu_Ordonnee; // Ordonnée o— commence le menu +GLOBAL word Menu_Ordonnee_Texte; // Ordonnée o— commence le texte dans le menu GLOBAL word Menu_Facteur_X; // Facteur de grossissement du menu en X GLOBAL word Menu_Facteur_Y; // Facteur de grossissement du menu en Y GLOBAL word Menu_Taille_couleur; // Taille d'une couleur de la palette du menu - // Donn‚es sur la fenˆtre de menu + // Données sur la fenˆtre de menu GLOBAL byte Une_fenetre_est_ouverte; -GLOBAL word Fenetre_Pos_X; // Position du bord gauche de la fenˆtre dans l'‚cran -GLOBAL word Fenetre_Pos_Y; // Position du bord haut de la fenˆtre dans l'‚cran +GLOBAL word Fenetre_Pos_X; // Position du bord gauche de la fenˆtre dans l'écran +GLOBAL word Fenetre_Pos_Y; // Position du bord haut de la fenˆtre dans l'écran GLOBAL word Fenetre_Largeur; // Largeur de la fenˆtre GLOBAL word Fenetre_Hauteur; // Hauteur de la fenˆtre -GLOBAL byte Menu_visible_avant_fenetre; // Le menu ‚tait visible avant d'ouvir une fenˆtre -GLOBAL word Menu_Ordonnee_avant_fenetre; // Ordonn‚e du menu avant d'ouvrir une fenˆtre -GLOBAL byte Cacher_pinceau_avant_fenetre;// Le pinceau ‚tatit d‚j… cach‚ avant l'ouverture de la fenetre? +GLOBAL byte Menu_visible_avant_fenetre; // Le menu était visible avant d'ouvir une fenˆtre +GLOBAL word Menu_Ordonnee_avant_fenetre; // Ordonnée du menu avant d'ouvrir une fenˆtre +GLOBAL byte Cacher_pinceau_avant_fenetre;// Le pinceau étatit déj… caché avant l'ouverture de la fenetre? GLOBAL word Nb_boutons_fenetre; GLOBAL struct Fenetre_Bouton_normal * Fenetre_Liste_boutons_normal; @@ -321,33 +321,33 @@ GLOBAL int Fenetre_Attribut2; -// D‚finition des boutons //////////////////////////////////////////////////// +// Définition des boutons //////////////////////////////////////////////////// GLOBAL struct { // Informations sur l'aspect du bouton (graphisme): - word Decalage_X; // D‚calage par rapport … la gauche du menu - word Decalage_Y; // D‚calage par rapport au haut du menu + word Decalage_X; // Décalage par rapport … la gauche du menu + word Decalage_Y; // Décalage par rapport au haut du menu word Largeur; // Largeur du bouton word Hauteur; // Hauteur du bouton - byte Enfonce; // Le bouton est enfonc‚ + byte Enfonce; // Le bouton est enfoncé byte Forme; // Forme du bouton // Information sur les clicks de la souris: - fonction_action Gauche; // Action d‚clench‚e par un click gauche sur le bouton - fonction_action Droite; // Action d‚clench‚e par un click droit sur le bouton - word Raccourci_gauche; // Raccourci clavier ‚quivalent … un click gauche sur le bouton - word Raccourci_droite; // Raccourci clavier ‚quivalent … un click droit sur le bouton + fonction_action Gauche; // Action déclenchée par un click gauche sur le bouton + fonction_action Droite; // Action déclenchée par un click droit sur le bouton + word Raccourci_gauche; // Raccourci clavier équivalent … un click gauche sur le bouton + word Raccourci_droite; // Raccourci clavier équivalent … un click droit sur le bouton - // Informations sur le d‚senclenchement du bouton g‚r‚ par le moteur: - fonction_action Desenclencher; // Action appel‚e lors du d‚senclenchement du bouton + // Informations sur le désenclenchement du bouton géré par le moteur: + fonction_action Desenclencher; // Action appelée lors du désenclenchement du bouton byte Famille; // Ensemble de boutons auquel celui-ci appartient } Bouton[NB_BOUTONS]; -// Informations sur les diff‚rents modes de dessin +// Informations sur les différents modes de dessin GLOBAL fonction_effet Fonction_effet; @@ -357,8 +357,8 @@ GLOBAL byte Exclude_color[256]; // Couleurs // Mode smear: -GLOBAL byte Smear_Mode; // Le mode smear est enclench‚ -GLOBAL byte Smear_Debut; // On vient juste de commencer une op‚ration en Smear +GLOBAL byte Smear_Mode; // Le mode smear est enclenché +GLOBAL byte Smear_Debut; // On vient juste de commencer une opération en Smear GLOBAL byte * Smear_Brosse; // Sprite de la brosse de Smear GLOBAL word Smear_Brosse_Largeur; // Largeur de la brosse de Smear GLOBAL word Smear_Brosse_Hauteur; // Hauteur de la brosse de Smear @@ -367,24 +367,24 @@ GLOBAL short Smear_Min_X,Smear_Max_X,Smear_Min_Y,Smear_Max_Y; // Bornes de la Br // Mode shade: GLOBAL struct T_Shade Shade_Liste[8]; // Listes de shade -GLOBAL byte Shade_Actuel; // Num‚ro du shade en cours +GLOBAL byte Shade_Actuel; // Numéro du shade en cours GLOBAL byte * Shade_Table; // Table de conversion de shade en cours GLOBAL byte Shade_Table_gauche[256]; // Table de conversion de shade pour un clic gauche GLOBAL byte Shade_Table_droite[256]; // Table de conversion de shade pour un clic droit -GLOBAL byte Shade_Mode; // Le mode shade est enclench‚ +GLOBAL byte Shade_Mode; // Le mode shade est enclenché -GLOBAL byte Quick_shade_Mode; // Le mode quick-shade est enclench‚ +GLOBAL byte Quick_shade_Mode; // Le mode quick-shade est enclenché GLOBAL byte Quick_shade_Step; // Pas du mode quick-shade GLOBAL byte Quick_shade_Loop; // Normal / Loop / No sat. // Mode stencil: -GLOBAL byte Stencil_Mode; // Le mode stencil est enclench‚ -GLOBAL byte Stencil[256]; // Tableau des couleurs prot‚g‚es +GLOBAL byte Stencil_Mode; // Le mode stencil est enclenché +GLOBAL byte Stencil[256]; // Tableau des couleurs protégées // Mode grille: -GLOBAL byte Snap_Mode; // Le mode grille est enclench‚ +GLOBAL byte Snap_Mode; // Le mode grille est enclenché GLOBAL short Snap_Largeur; // Largeur entre 2 points de la grille GLOBAL short Snap_Hauteur; // Hauteur entre 2 points de la grille GLOBAL short Snap_Decalage_X; // Position en X du point le + … gauche @@ -392,34 +392,34 @@ GLOBAL short Snap_Decalage_Y; // Position en Y du point le + en haut // Mode trame: -GLOBAL byte Trame_Mode; // Le mode Trame est enclench‚ +GLOBAL byte Trame_Mode; // Le mode Trame est enclenché GLOBAL byte Trame[16][16]; // Sprite de la trame -GLOBAL word TRAME_PREDEFINIE[12][16]; // Trames pr‚s‚finies (compact‚es sur 16*16 bits) +GLOBAL word TRAME_PREDEFINIE[12][16]; // Trames préséfinies (compactées sur 16*16 bits) GLOBAL short Trame_Largeur; // Largeur de la trame GLOBAL short Trame_Hauteur; // Hauteur de la trame // Mode colorize: -GLOBAL byte Colorize_Mode; // Le mode Colorize est enclench‚ -GLOBAL byte Colorize_Opacite; // Intensit‚ du Colorize +GLOBAL byte Colorize_Mode; // Le mode Colorize est enclenché +GLOBAL byte Colorize_Opacite; // Intensité du Colorize GLOBAL byte Colorize_Mode_en_cours; // Le type de Colorize en cours (0-2) GLOBAL word Table_de_multiplication_par_Facteur_A[64]; GLOBAL word Table_de_multiplication_par_Facteur_B[64]; // Mode smooth: -GLOBAL byte Smooth_Mode; // Le mode Smooth est enclench‚ +GLOBAL byte Smooth_Mode; // Le mode Smooth est enclenché GLOBAL byte Smooth_Matrice[3][3]; // La matrice du Smooth actuel // Mode Tiling: -GLOBAL byte Tiling_Mode; // Le mode Tiling est enclench‚ -GLOBAL short Tiling_Decalage_X; // D‚calage du tiling en X -GLOBAL short Tiling_Decalage_Y; // D‚calage du tiling en Y +GLOBAL byte Tiling_Mode; // Le mode Tiling est enclenché +GLOBAL short Tiling_Decalage_X; // Décalage du tiling en X +GLOBAL short Tiling_Decalage_Y; // Décalage du tiling en Y // Mode Mask -GLOBAL byte Mask_Mode; // Le mode Masque est enclench‚ +GLOBAL byte Mask_Mode; // Le mode Masque est enclenché GLOBAL byte Mask[256]; // Tableau des couleurs constituant le masque // Mode loupe: @@ -439,7 +439,7 @@ GLOBAL word TABLE_ZOOM[NB_FACTEURS_DE_ZOOM][512]; extern word FACTEUR_ZOOM[NB_FACTEURS_DE_ZOOM]; #endif - // Donn‚es sur les ellipses et les cercles: + // Données sur les ellipses et les cercles: GLOBAL dword Table_des_carres[1025]; GLOBAL long Ellipse_Curseur_X; @@ -452,36 +452,36 @@ GLOBAL long Cercle_Curseur_X; GLOBAL long Cercle_Curseur_Y; GLOBAL long Cercle_Limite; - // Donn‚es sur les d‚grad‚s: + // Données sur les dégradés: -GLOBAL short Degrade_Borne_Inferieure; // Plus petite couleur englob‚e par le d‚grad‚ -GLOBAL short Degrade_Borne_Superieure; // Plus grande couleur englob‚e par le d‚grad‚ -GLOBAL int Degrade_Inverse; // Bool‚en "Le d‚grad‚ est en r‚alit‚ invers‚" +GLOBAL short Degrade_Borne_Inferieure; // Plus petite couleur englobée par le dégradé +GLOBAL short Degrade_Borne_Superieure; // Plus grande couleur englobée par le dégradé +GLOBAL int Degrade_Inverse; // Booléen "Le dégradé est en réalité inversé" GLOBAL long Degrade_Intervalle_bornes; // = Abs(Degrade_Borne_Inferieure-Degrade_Borne_Superieure)+1 -GLOBAL long Degrade_Intervalle_total; // Valeur maximum des indices pass‚s … la fonction de d‚grad‚ (!!! >0 !!!) -GLOBAL long Degrade_Melange_aleatoire; // Facteur de m‚lange (1-256+) du d‚grad‚ -GLOBAL fonction_degrade Traiter_degrade; // Fonction de traitement du d‚grad‚, varie selon la m‚thode choisie par l'utilisateur. +GLOBAL long Degrade_Intervalle_total; // Valeur maximum des indices passés … la fonction de dégradé (!!! >0 !!!) +GLOBAL long Degrade_Melange_aleatoire; // Facteur de mélange (1-256+) du dégradé +GLOBAL fonction_degrade Traiter_degrade; // Fonction de traitement du dégradé, varie selon la méthode choisie par l'utilisateur. GLOBAL fonction_afficheur Traiter_pixel_de_degrade; // Redirection de l'affichage -GLOBAL struct T_Degrade_Tableau Degrade_Tableau[16]; // Donn‚es de tous les d‚grad‚s -GLOBAL int Degrade_Courant; // Indice du tableau correspondant au d‚grad‚ courant +GLOBAL struct T_Degrade_Tableau Degrade_Tableau[16]; // Données de tous les dégradés +GLOBAL int Degrade_Courant; // Indice du tableau correspondant au dégradé courant - // Donn‚es sur le Spray: + // Données sur le Spray: GLOBAL byte Spray_Mode; // Mode Mono(1) ou Multicolore(0) GLOBAL short Spray_Size; // DiamŠtre du spray en pixels -GLOBAL byte Spray_Delay; // D‚lai en VBLs entre 2 "pschiitt" +GLOBAL byte Spray_Delay; // Délai en VBLs entre 2 "pschiitt" GLOBAL byte Spray_Mono_flow; // Nombre de pixels qui sortent en mˆme temps en mono GLOBAL byte Spray_Multi_flow[256]; // Idem pour chaque couleur - // Donn‚es diverses sur le programme: + // Données diverses sur le programme: GLOBAL byte Sortir_du_programme; -GLOBAL char Repertoire_du_programme[256]; // R‚pertoire dans lequel se trouve le programme -GLOBAL char Repertoire_initial[256]; // R‚pertoire … partir duquel … ‚t‚ lanc‚ le programme +GLOBAL char Repertoire_du_programme[256]; // Répertoire dans lequel se trouve le programme +GLOBAL char Repertoire_initial[256]; // Répertoire … partir duquel … été lancé le programme GLOBAL byte Fore_color; GLOBAL byte Back_color; GLOBAL byte Mode_de_dessin_en_cours; @@ -489,7 +489,7 @@ GLOBAL byte Courbe_en_cours; GLOBAL byte Ligne_en_cours; GLOBAL byte Couleur_debut_palette; GLOBAL byte Un_fichier_a_ete_passe_en_parametre; -GLOBAL byte Une_resolution_a_ete_passee_en_parametre; // utilis‚e uniquement si la variable pr‚c‚dente est … 1 +GLOBAL byte Une_resolution_a_ete_passee_en_parametre; // utilisée uniquement si la variable précédente est … 1 // Variables concernant l'OBJ DIVERS @@ -512,7 +512,7 @@ GLOBAL word MODE_X_Largeur_de_ligne; GLOBAL dword MODE_X_Valeur_initiale_de_esi; GLOBAL dword MODE_X_Valeur_initiale_de_edi; // Partie concernant le VESA: -GLOBAL byte Granularite; // Facteur de gestion de la granularit‚ de la carte +GLOBAL byte Granularite; // Facteur de gestion de la granularité de la carte GLOBAL byte VESA_Erreur; GLOBAL byte * VESA_WinFuncPtr; // Handler software de changement de banque GLOBAL word * VESA_Liste_des_modes; @@ -529,7 +529,7 @@ GLOBAL byte VESA_Version_Decimale; GLOBAL char VESA_Constructeur[TAILLE_NOM_CONSTRUCTEUR+1]; GLOBAL word VESA_Taille_memoire; - // Les diff‚rents sprites: + // Les différents sprites: GLOBAL byte BLOCK_MENU[HAUTEUR_MENU][LARGEUR_MENU]; GLOBAL byte SPRITE_MENU[NB_SPRITES_MENU][HAUTEUR_SPRITE_MENU][LARGEUR_SPRITE_MENU]; @@ -542,19 +542,19 @@ GLOBAL byte Fonte_fun [256*8*8]; GLOBAL byte Fonte_help [315][6][8]; GLOBAL byte * Fonte; - // Les donn‚es de l'aide: + // Les données de l'aide: GLOBAL struct Section_d_aide Table_d_aide[NB_SECTIONS_AIDE]; GLOBAL byte Section_d_aide_en_cours; // Indice de la table d'aide en cours de consultation -GLOBAL word Position_d_aide_en_cours; // Num‚ro de la ligne d'aide en cours de consultation +GLOBAL word Position_d_aide_en_cours; // Numéro de la ligne d'aide en cours de consultation - // Donn‚es sur les op‚rations + // Données sur les opérations -GLOBAL word Operation_avant_interruption; // Nø de l'op‚ration en cours avant l'utilisation d'une interruption -GLOBAL word Operation_en_cours; // Nø de l'op‚ration en cours -GLOBAL word Operation_Pile[TAILLE_PILE_OPERATIONS]; // Pile simplifi‚e +GLOBAL word Operation_avant_interruption; // Nø de l'opération en cours avant l'utilisation d'une interruption +GLOBAL word Operation_en_cours; // Nø de l'opération en cours +GLOBAL word Operation_Pile[TAILLE_PILE_OPERATIONS]; // Pile simplifiée GLOBAL byte Operation_Taille_pile; // Taille effective de la pile (0=vide) -GLOBAL byte Operation_dans_loupe; // Indique si l'op‚ration a commenc‚ dans la partie Zoom‚e ou non +GLOBAL byte Operation_dans_loupe; // Indique si l'opération a commencé dans la partie Zoomée ou non GLOBAL short Pipette_Couleur; GLOBAL short Pipette_X; @@ -568,8 +568,8 @@ GLOBAL short Pipette_Y; FORME_CURSEUR_CIBLE , // Dessin … la main discontinu FORME_CURSEUR_CIBLE , // Dessin … la main point par point FORME_CURSEUR_CIBLE , // Lignes - FORME_CURSEUR_CIBLE , // Lignes reli‚es - FORME_CURSEUR_CIBLE , // Lignes centr‚es + FORME_CURSEUR_CIBLE , // Lignes reliées + FORME_CURSEUR_CIBLE , // Lignes centrées FORME_CURSEUR_CIBLE_XOR , // Rectangle vide FORME_CURSEUR_CIBLE_XOR , // Rectangle plein FORME_CURSEUR_CIBLE , // Cercles vides @@ -580,7 +580,7 @@ GLOBAL short Pipette_Y; FORME_CURSEUR_CIBLE , // Remplacer FORME_CURSEUR_CIBLE_XOR , // Prise de brosse rectangulaire FORME_CURSEUR_CIBLE , // Prise d'une brosse multiforme - FORME_CURSEUR_CIBLE_PIPETTE , // R‚cup‚ration d'une couleur + FORME_CURSEUR_CIBLE_PIPETTE , // Récupération d'une couleur FORME_CURSEUR_RECTANGLE_XOR , // Positionnement de la fenˆtre de loupe FORME_CURSEUR_CIBLE , // Courbe … 3 points FORME_CURSEUR_CIBLE , // Courbe … 4 points @@ -590,8 +590,8 @@ GLOBAL short Pipette_Y; FORME_CURSEUR_CIBLE , // Polyfill FORME_CURSEUR_CIBLE , // Polyforme rempli FORME_CURSEUR_MULTIDIRECTIONNEL, // Scroll - FORME_CURSEUR_CIBLE , // Cercles d‚grad‚s - FORME_CURSEUR_CIBLE , // Ellipses d‚grad‚es + FORME_CURSEUR_CIBLE , // Cercles dégradés + FORME_CURSEUR_CIBLE , // Ellipses dégradées FORME_CURSEUR_ROTATE_XOR , // Faire tourner brosse FORME_CURSEUR_CIBLE_XOR , // Etirer brosse FORME_CURSEUR_CIBLE // Deformer brosse @@ -601,12 +601,12 @@ GLOBAL short Pipette_Y; #endif - // Proc‚dures … appeler: Op‚ration,Mouse_K,Etat de la pile + // Procédures … appeler: Opération,Mouse_K,Etat de la pile GLOBAL struct { - byte Effacer_curseur; // Bool‚en "il faut effacer le curseur pour l'op‚ra." - fonction_action Action; // Action appel‚e + byte Effacer_curseur; // Booléen "il faut effacer le curseur pour l'opéra." + fonction_action Action; // Action appelée } Operation[NB_OPERATIONS][3][TAILLE_PILE_OPERATIONS]; @@ -620,11 +620,11 @@ GLOBAL byte SPRITE_DRIVE[NB_SPRITES_DRIVES][HAUTEUR_SPRITE_DRIVE][LARGEUR_SPRITE // -- Section des informations sur les formats de fichiers ------------------ - // Comptage du nb d'‚l‚ments dans la liste: + // Comptage du nb d'éléments dans la liste: GLOBAL short Liste_Nb_elements; GLOBAL short Liste_Nb_fichiers; GLOBAL short Liste_Nb_repertoires; - // Tˆte de la liste chaŒn‚e: + // Tˆte de la liste chaŒnée: GLOBAL struct Element_de_liste_de_fileselect * Liste_du_fileselect; // ------------------- Inititialisation des formats connus ------------------- @@ -650,7 +650,7 @@ void Rien_du_tout(void); "PAL" // PAL }; - // Fonction … appeler pour v‚rifier la signature du fichier + // Fonction … appeler pour vérifier la signature du fichier fonction_action Format_Test[NB_FORMATS_LOAD]= { Test_PKM, // PKM @@ -701,7 +701,7 @@ void Rien_du_tout(void); Save_PAL // PAL }; - // indique si l'on doit consid‚rer que l'image n'est plus modifi‚e + // indique si l'on doit considérer que l'image n'est plus modifiée byte Format_Backup_done[NB_FORMATS_CONNUS]= { 1, // PKM @@ -743,9 +743,9 @@ void Rien_du_tout(void); extern byte Format_Commentaire[NB_FORMATS_CONNUS]; #endif -GLOBAL signed char Erreur_fichier; // 0: op‚ration I/O OK - // 1: Erreur dŠs le d‚but de l'op‚ration - // 2: Erreur durant l'op‚ration => donn‚es modifi‚es +GLOBAL signed char Erreur_fichier; // 0: opération I/O OK + // 1: Erreur dŠs le début de l'opération + // 2: Erreur durant l'opération => données modifiées //-1: Interruption du chargement d'une preview GLOBAL int Ligne_INI; diff --git a/graph.c b/graph.c index 3b666f27..9b5ffe50 100644 --- a/graph.c +++ b/graph.c @@ -1,7 +1,7 @@ -#include "sdlscreen.h" -#include "graph.h" +#include "sdlscreen.h" +#include "graph.h" #include "divers.h" -#include +#include #include #include @@ -11,875 +11,869 @@ #include "boutons.h" #include "pages.h" #include "global.h" - -// On d‚clare m‚chamment le prototype de Erreur pour ‚viter de faire un + +// On déclare méchamment le prototype de Erreur pour éviter de faire un // fichier "main.h": void Erreur(int Code); - -/* -byte Meilleure_couleur(byte R,byte V,byte B) -{ - short Coul; - int Delta_R,Delta_V,Delta_B; - int Dist; - int Best_dist=0x7FFFFFFF; - byte Best_color; - - for (Coul=0; Coul<256; Coul++) - { - if (!Exclude_color[Coul]) - { - Delta_R=(int)Principal_Palette[Coul].R-R; - Delta_V=(int)Principal_Palette[Coul].V-V; - Delta_B=(int)Principal_Palette[Coul].B-B; - - if (!(Dist=(Delta_R*Delta_R*30)+(Delta_V*Delta_V*59)+(Delta_B*Delta_B*11))) - return Coul; - - if (Dist>3)*Menu_Taille_couleur)*Menu_Facteur_X; - Debut_Y=Menu_Ordonnee_avant_fenetre+((2+((Couleur&7)<<2))*Menu_Facteur_Y); - Fin_X=Debut_X+Largeur; - Fin_Y=Debut_Y+Hauteur; - - // On affiche le bloc en entier si on peut, sinon on le d‚coupe autour - // de la fenˆtre. - if ( (Debut_Y>=Coin_Y) || (Fin_X<=Fenetre_Pos_X) || (Debut_X>=Coin_X) ) - Block(Debut_X,Debut_Y,Largeur,Hauteur,Vraie_couleur); - else - { - - if (Debut_X>=Fenetre_Pos_X) - { - if ( (Fin_X>Coin_X) || (Fin_Y>Coin_Y) ) - { - if ( (Fin_X>Coin_X) && (Fin_Y>Coin_Y) ) - { - Block(Coin_X,Debut_Y,Fin_X-Coin_X,Coin_Y-Debut_Y,Vraie_couleur); - Block(Debut_X,Coin_Y,Largeur,Fin_Y-Coin_Y,Vraie_couleur); - } - else - { - if (Fin_Y>Coin_Y) - Block(Debut_X,Coin_Y,Largeur,Fin_Y-Coin_Y,Vraie_couleur); - else - Block(Coin_X,Debut_Y,Fin_X-Coin_X,Hauteur,Vraie_couleur); - } - } - } - else - { - if (Fin_XCoin_Y) - { - Block(Debut_X,Debut_Y,Fenetre_Pos_X-Debut_X,Coin_Y-Debut_Y,Vraie_couleur); - Block(Debut_X,Coin_Y,Largeur,Fin_Y-Coin_Y,Vraie_couleur); - } - else - Block(Debut_X,Debut_Y,Fenetre_Pos_X-Debut_X,Hauteur,Vraie_couleur); - } - else - { - if (Fin_Y>Coin_Y) - { - Block(Debut_X,Debut_Y,Fenetre_Pos_X-Debut_X,Coin_Y-Debut_Y,Vraie_couleur); - Block(Coin_X,Debut_Y,Fin_X-Coin_X,Coin_Y-Debut_Y,Vraie_couleur); - Block(Debut_X,Coin_Y,Largeur,Fin_Y-Coin_Y,Vraie_couleur); - } - else - { - Block(Debut_X,Debut_Y,Fenetre_Pos_X-Debut_X,Hauteur,Vraie_couleur); - Block(Coin_X,Debut_Y,Fin_X-Coin_X,Hauteur,Vraie_couleur); - } - } - } - } - } - } -} - - -void Remapper_ecran_apres_changement_couleurs_menu(void) -{ - short Indice; - byte Table_de_conversion[256]; - short Temp,Temp2; - - if ( (CM_Clair!=Old_Clair) - || (CM_Fonce!=Old_Fonce) - || (CM_Blanc!=Old_Blanc) - || (CM_Noir !=Old_Noir ) - || (CM_Trans!=Old_Trans) ) - { - // Cr‚ation de la table de conversion - for (Indice=0; Indice<256; Indice++) - Table_de_conversion[Indice]=Indice; - - Table_de_conversion[Old_Noir ]=CM_Noir; - Table_de_conversion[Old_Fonce]=CM_Fonce; - Table_de_conversion[Old_Clair]=CM_Clair; - Table_de_conversion[Old_Blanc]=CM_Blanc; - - // Remappage de l'‚cran - - Temp=Fenetre_Hauteur*Menu_Facteur_Y; - - Remap_screen(Fenetre_Pos_X, Fenetre_Pos_Y, - Fenetre_Largeur*Menu_Facteur_X, - (Fenetre_Pos_Y+Temp>3)*Menu_Taille_couleur)*Menu_Facteur_X; + Debut_Y=Menu_Ordonnee_avant_fenetre+((2+((Couleur&7)<<2))*Menu_Facteur_Y); + Fin_X=Debut_X+Largeur; + Fin_Y=Debut_Y+Hauteur; + + // On affiche le bloc en entier si on peut, sinon on le découpe autour + // de la fenêtre. + if ( (Debut_Y>=Coin_Y) || (Fin_X<=Fenetre_Pos_X) || (Debut_X>=Coin_X) ) + Block(Debut_X,Debut_Y,Largeur,Hauteur,Vraie_couleur); + else + { + + if (Debut_X>=Fenetre_Pos_X) + { + if ( (Fin_X>Coin_X) || (Fin_Y>Coin_Y) ) + { + if ( (Fin_X>Coin_X) && (Fin_Y>Coin_Y) ) + { + Block(Coin_X,Debut_Y,Fin_X-Coin_X,Coin_Y-Debut_Y,Vraie_couleur); + Block(Debut_X,Coin_Y,Largeur,Fin_Y-Coin_Y,Vraie_couleur); + } + else + { + if (Fin_Y>Coin_Y) + Block(Debut_X,Coin_Y,Largeur,Fin_Y-Coin_Y,Vraie_couleur); + else + Block(Coin_X,Debut_Y,Fin_X-Coin_X,Hauteur,Vraie_couleur); + } + } + } + else + { + if (Fin_XCoin_Y) + { + Block(Debut_X,Debut_Y,Fenetre_Pos_X-Debut_X,Coin_Y-Debut_Y,Vraie_couleur); + Block(Debut_X,Coin_Y,Largeur,Fin_Y-Coin_Y,Vraie_couleur); + } + else + Block(Debut_X,Debut_Y,Fenetre_Pos_X-Debut_X,Hauteur,Vraie_couleur); + } + else + { + if (Fin_Y>Coin_Y) + { + Block(Debut_X,Debut_Y,Fenetre_Pos_X-Debut_X,Coin_Y-Debut_Y,Vraie_couleur); + Block(Coin_X,Debut_Y,Fin_X-Coin_X,Coin_Y-Debut_Y,Vraie_couleur); + Block(Debut_X,Coin_Y,Largeur,Fin_Y-Coin_Y,Vraie_couleur); + } + else + { + Block(Debut_X,Debut_Y,Fenetre_Pos_X-Debut_X,Hauteur,Vraie_couleur); + Block(Coin_X,Debut_Y,Fin_X-Coin_X,Hauteur,Vraie_couleur); + } + } + } + } + } + } +} + + +void Remapper_ecran_apres_changement_couleurs_menu(void) +{ + short Indice; + byte Table_de_conversion[256]; + short Temp/*,Temp2*/; + + if ( (CM_Clair!=Old_Clair) || (CM_Fonce!=Old_Fonce) || (CM_Blanc!=Old_Blanc) || (CM_Noir !=Old_Noir ) + || (CM_Trans!=Old_Trans) ) + { + // Création de la table de conversion + for (Indice=0; Indice<256; Indice++) + Table_de_conversion[Indice]=Indice; + + Table_de_conversion[Old_Noir ]=CM_Noir; + Table_de_conversion[Old_Fonce]=CM_Fonce; + Table_de_conversion[Old_Clair]=CM_Clair; + Table_de_conversion[Old_Blanc]=CM_Blanc; + + // Remappage de l'écran + + Temp=Fenetre_Hauteur*Menu_Facteur_Y; + + Remap_screen(Fenetre_Pos_X, Fenetre_Pos_Y, + Fenetre_Largeur*Menu_Facteur_X, + (Fenetre_Pos_Y+Temp255)) - Indice++; - - // On note la position de la premiŠre case de la s‚quence - Premier=Indice; - - // On recherche la position de la derniŠre case de la s‚quence - for (Dernier=Premier;Liste[Dernier+1]<256;Dernier++); - - // Pour toutes les cases non vides (et non inhib‚es) qui suivent - switch (Mode) - { - case MODE_SHADE_NORMAL : - for (;(Indice<512) && (Liste[Indice]<256);Indice++) - { // On met … jour les tables de conversion - Couleur=Liste[Indice]; - Table_inc[Couleur]=Liste[(Indice+Pas<=Dernier)?Indice+Pas:Dernier]; - Table_dec[Couleur]=Liste[(Indice-Pas>=Premier)?Indice-Pas:Premier]; - } - break; - case MODE_SHADE_BOUCLE : - Temp=1+Dernier-Premier; - for (;(Indice<512) && (Liste[Indice]<256);Indice++) - { // On met … jour les tables de conversion - Couleur=Liste[Indice]; - Table_inc[Couleur]=Liste[Premier+((Pas+Indice-Premier)%Temp)]; - Table_dec[Couleur]=Liste[Premier+(((Temp-Pas)+Indice-Premier)%Temp)]; - } - break; - default : // MODE_SHADE_NOSAT - for (;(Indice<512) && (Liste[Indice]<256);Indice++) - { // On met … jour les tables de conversion - Couleur=Liste[Indice]; - if (Indice+Pas<=Dernier) - Table_inc[Couleur]=Liste[Indice+Pas]; - if (Indice-Pas>=Premier) - Table_dec[Couleur]=Liste[Indice-Pas]; - } - } - } -} - - -// Transformer un nombre (entier naturel) en chaŒne -void Num2str(dword Nombre,char * Chaine,byte Taille) -{ - int Indice; - - for (Indice=Taille-1;Indice>=0;Indice--) - { - Chaine[Indice]=(Nombre%10)+'0'; - Nombre/=10; - if (Nombre==0) - for (Indice--;Indice>=0;Indice--) - Chaine[Indice]=' '; - } - Chaine[Taille]='\0'; -} - -// Transformer une chaŒne en un entier naturel (renvoie -1 si ch. invalide) -int Str2num(char * Chaine) -{ - int Valeur=0; - - for (;*Chaine;Chaine++) - { - if ( (*Chaine>='0') && (*Chaine<='9') ) - Valeur=(Valeur*10)+(*Chaine-'0'); - else - return -1; - } - return Valeur; -} - - -// Arrondir un nombre r‚el … la valeur entiŠre la plus proche -short Round(float Valeur) -{ - short Temp=Valeur; - - if (Valeur>=0) - { if ((Valeur-Temp)>= 0.5) Temp++; } - else - { if ((Valeur-Temp)<=-0.5) Temp--; } - - return Temp; -} - -// Arrondir le r‚sultat d'une division … la valeur entiŠre sup‚rieure -short Round_div_max(short Numerateur,short Diviseur) -{ - if (!(Numerateur % Diviseur)) - return (Numerateur/Diviseur); - else - return (Numerateur/Diviseur)+1; -} - - - -int Min(int A,int B) -{ - return (AB)?A:B; -} - - - - -void Transformer_point(short X, short Y, float cosA, float sinA, - short * Xr, short * Yr) -{ - *Xr=Round(((float)X*cosA)+((float)Y*sinA)); - *Yr=Round(((float)Y*cosA)-((float)X*sinA)); -} - - - -// -- Recadrer la partie non-zoom‚e de l'image par rapport … la partie zoom‚e -// lorsqu'on scrolle en mode Loupe -- -void Recadrer_ecran_par_rapport_au_zoom(void) -{ - // Centrage en X - if (Principal_Largeur_image>Principal_Split) - { - Principal_Decalage_X=Loupe_Decalage_X+(Loupe_Largeur>>1) - -(Principal_Split>>1); - if (Principal_Decalage_X<0) - Principal_Decalage_X=0; - else - if (Principal_Largeur_imageMenu_Ordonnee) - { - Principal_Decalage_Y=Loupe_Decalage_Y+(Loupe_Hauteur>>1) - -(Menu_Ordonnee>>1); - if (Principal_Decalage_Y<0) - Principal_Decalage_Y=0; - else - if (Principal_Hauteur_image>1)-X_theorique)/Loupe_Facteur)*Loupe_Facteur); - Principal_Split=Principal_X_Zoom-(Menu_Facteur_X*LARGEUR_BARRE_SPLIT); - - // Correction en cas de d‚bordement sur la gauche - while (Principal_Split*(Loupe_Facteur+1)=X_theorique) - { - Principal_Split-=Loupe_Facteur; - Principal_X_Zoom-=Loupe_Facteur; - } -} - - - -// -------------------- Calcul des information de la loupe ------------------- -void Calculer_donnees_loupe(void) -/* - AprŠs modification des donn‚es de la loupe, il faut recalculer les limites. -*/ -{ - Calculer_split(); - - Loupe_Largeur=(Largeur_ecran-Principal_X_Zoom)/Loupe_Facteur; - - Loupe_Hauteur=Menu_Ordonnee/Loupe_Facteur; - if (Menu_Ordonnee%Loupe_Facteur) - Loupe_Hauteur++; - - if (Loupe_Mode && Loupe_Decalage_X) - { - if (Principal_Largeur_image=Principal_Hauteur_image) - Limite_Bas=Principal_Hauteur_image-1; - else - Limite_Bas=Limite_visible_Bas; - - if (Limite_visible_Droite>=Principal_Largeur_image) - Limite_Droite=Principal_Largeur_image-1; - else - Limite_Droite=Limite_visible_Droite; - - // -- Calcul des limites de la partie zoom‚e de l'image -- - Limite_Haut_Zoom =Loupe_Decalage_Y; - Limite_Gauche_Zoom=Loupe_Decalage_X; - Limite_visible_Bas_Zoom =Limite_Haut_Zoom+Loupe_Hauteur-1; - Limite_visible_Droite_Zoom=Limite_Gauche_Zoom+Loupe_Largeur-1; - - if (Limite_visible_Bas_Zoom>=Principal_Hauteur_image) - Limite_Bas_Zoom=Principal_Hauteur_image-1; - else - Limite_Bas_Zoom=Limite_visible_Bas_Zoom; - - if (Limite_visible_Droite_Zoom>=Principal_Largeur_image) - Limite_Droite_Zoom=Principal_Largeur_image-1; - else - Limite_Droite_Zoom=Limite_visible_Droite_Zoom; - } - else - { - // -- Calcul des limites de la partie visible de l'image -- - Limite_Haut =Principal_Decalage_Y; - Limite_Gauche=Principal_Decalage_X; - Limite_visible_Bas =Limite_Haut+(Menu_visible?Menu_Ordonnee:Hauteur_ecran)-1; // A REVOIR POUR SIMPLIFICATION - Limite_visible_Droite=Limite_Gauche+Largeur_ecran-1; - - if (Limite_visible_Bas>=Principal_Hauteur_image) - Limite_Bas=Principal_Hauteur_image-1; - else - Limite_Bas=Limite_visible_Bas; - - if (Limite_visible_Droite>=Principal_Largeur_image) - Limite_Droite=Principal_Largeur_image-1; - else - Limite_Droite=Limite_visible_Droite; - } -} - - -// -- Calculer les coordonn‚es du pinceau en fonction du snap et de la loupe - -void Calculer_coordonnees_pinceau(void) -{ - if ((Loupe_Mode) && (Mouse_X>=Principal_X_Zoom)) - { - Pinceau_X=((Mouse_X-Principal_X_Zoom)/Loupe_Facteur)+Loupe_Decalage_X; - Pinceau_Y=(Mouse_Y/Loupe_Facteur)+Loupe_Decalage_Y; - } - else - { - Pinceau_X=Mouse_X+Principal_Decalage_X; - Pinceau_Y=Mouse_Y+Principal_Decalage_Y; - } - - if (Snap_Mode) - { - Pinceau_X=(((Pinceau_X+(Snap_Largeur>>1)-Snap_Decalage_X)/Snap_Largeur)*Snap_Largeur)+Snap_Decalage_X; - Pinceau_Y=(((Pinceau_Y+(Snap_Hauteur>>1)-Snap_Decalage_Y)/Snap_Hauteur)*Snap_Hauteur)+Snap_Decalage_Y; - } -} - - -// ------------ Changer le facteur de zoom et tout mettre … jour ------------- -void Changer_facteur_loupe(byte Indice_facteur) -{ - short Centre_X; - short Centre_Y; - - Centre_X=Loupe_Decalage_X+(Loupe_Largeur>>1); - Centre_Y=Loupe_Decalage_Y+(Loupe_Hauteur>>1); - - Loupe_Facteur=FACTEUR_ZOOM[Indice_facteur]; - Table_mul_facteur_zoom=TABLE_ZOOM[Indice_facteur]; - Calculer_donnees_loupe(); - - if (Loupe_Mode) - { - // Recalculer le d‚calage de la loupe - // Centrage "brut" de l‚cran par rapport … la loupe - Loupe_Decalage_X=Centre_X-(Loupe_Largeur>>1); - Loupe_Decalage_Y=Centre_Y-(Loupe_Hauteur>>1); - // Correction en cas de d‚bordement de l'image - if (Loupe_Decalage_X+Loupe_Largeur>Principal_Largeur_image) - Loupe_Decalage_X=Principal_Largeur_image-Loupe_Largeur; - if (Loupe_Decalage_Y+Loupe_Hauteur>Principal_Hauteur_image) - Loupe_Decalage_Y=Principal_Hauteur_image-Loupe_Hauteur; - if (Loupe_Decalage_X<0) - Loupe_Decalage_X=0; - if (Loupe_Decalage_Y<0) - Loupe_Decalage_Y=0; - - Recadrer_ecran_par_rapport_au_zoom(); - - Pixel_Preview=Pixel_Preview_Loupe; - } - else - Pixel_Preview=Pixel_Preview_Normal; - - Calculer_limites(); - Calculer_coordonnees_pinceau(); -} - - -// -- Affichage de la limite de l'image ------------------------------------- -void Afficher_limites_de_l_image(void) -{ - short Debut; - short Pos; - short Fin; - byte Droite_visible; - byte Bas_visible; - short Ancienne_Limite_Zoom; - - Droite_visible=Principal_Largeur_image<((Loupe_Mode)?Principal_Split:Largeur_ecran); - Bas_visible =Principal_Hauteur_imageMode_video[Numero].Facteur_Y) - && (Menu_Facteur_X==Menu_Facteur_Y) ) - Menu_Facteur_X++; - break; - default: // ne pas adapter - Menu_Facteur_X=1; - Menu_Facteur_Y=1; - } - - if (Buffer_de_ligne_horizontale) - free(Buffer_de_ligne_horizontale); - - Buffer_de_ligne_horizontale=(byte *)malloc((Largeur_ecran>Principal_Largeur_image)?Largeur_ecran:Principal_Largeur_image); - - switch (Mode_video[Numero].Mode) + return info.freeram; +} + + +// Transformer une liste de shade en deux tables de conversion +void Liste2tables(word * Liste,short Pas,byte Mode,byte * Table_inc,byte * Table_dec) +{ + int Indice; + int Premier; + int Dernier; + int Couleur; + int Temp; + + + // On initialise les deux tables de conversion en Identité + for (Indice=0;Indice<256;Indice++) + { + Table_inc[Indice]=Indice; + Table_dec[Indice]=Indice; + } + + // On s'apprête à examiner l'ensemble de la liste + for (Indice=0;Indice<512;Indice++) + { + // On recherche la première case de la liste non vide (et non inhibée) + while ((Indice<512) && (Liste[Indice]>255)) + Indice++; + + // On note la position de la première case de la séquence + Premier=Indice; + + // On recherche la position de la dernière case de la séquence + for (Dernier=Premier;Liste[Dernier+1]<256;Dernier++); + + // Pour toutes les cases non vides (et non inhibées) qui suivent + switch (Mode) + { + case MODE_SHADE_NORMAL : + for (;(Indice<512) && (Liste[Indice]<256);Indice++) + { // On met à jour les tables de conversion + Couleur=Liste[Indice]; + Table_inc[Couleur]=Liste[(Indice+Pas<=Dernier)?Indice+Pas:Dernier]; + Table_dec[Couleur]=Liste[(Indice-Pas>=Premier)?Indice-Pas:Premier]; + } + break; + case MODE_SHADE_BOUCLE : + Temp=1+Dernier-Premier; + for (;(Indice<512) && (Liste[Indice]<256);Indice++) + { // On met à jour les tables de conversion + Couleur=Liste[Indice]; + Table_inc[Couleur]=Liste[Premier+((Pas+Indice-Premier)%Temp)]; + Table_dec[Couleur]=Liste[Premier+(((Temp-Pas)+Indice-Premier)%Temp)]; + } + break; + default : // MODE_SHADE_NOSAT + for (;(Indice<512) && (Liste[Indice]<256);Indice++) + { // On met à jour les tables de conversion + Couleur=Liste[Indice]; + if (Indice+Pas<=Dernier) + Table_inc[Couleur]=Liste[Indice+Pas]; + if (Indice-Pas>=Premier) + Table_dec[Couleur]=Liste[Indice-Pas]; + } + } + } +} + + +// Transformer un nombre (entier naturel) en chaŒne +void Num2str(dword Nombre,char * Chaine,byte Taille) +{ + int Indice; + + for (Indice=Taille-1;Indice>=0;Indice--) + { + Chaine[Indice]=(Nombre%10)+'0'; + Nombre/=10; + if (Nombre==0) + for (Indice--;Indice>=0;Indice--) + Chaine[Indice]=' '; + } + Chaine[Taille]='\0'; +} + +// Transformer une chaŒne en un entier naturel (renvoie -1 si ch. invalide) +int Str2num(char * Chaine) +{ + int Valeur=0; + + for (;*Chaine;Chaine++) + { + if ( (*Chaine>='0') && (*Chaine<='9') ) + Valeur=(Valeur*10)+(*Chaine-'0'); + else + return -1; + } + return Valeur; +} + + +// Arrondir un nombre réel à la valeur entière la plus proche +short Round(float Valeur) +{ + short Temp=Valeur; + + if (Valeur>=0) + { if ((Valeur-Temp)>= 0.5) Temp++; } + else + { if ((Valeur-Temp)<=-0.5) Temp--; } + + return Temp; +} + +// Arrondir le résultat d'une division à la valeur entière supérieure +short Round_div_max(short Numerateur,short Diviseur) +{ + if (!(Numerateur % Diviseur)) + return (Numerateur/Diviseur); + else + return (Numerateur/Diviseur)+1; +} + + + +int Min(int A,int B) +{ + return (AB)?A:B; +} + + + + +void Transformer_point(short X, short Y, float cosA, float sinA, + short * Xr, short * Yr) +{ + *Xr=Round(((float)X*cosA)+((float)Y*sinA)); + *Yr=Round(((float)Y*cosA)-((float)X*sinA)); +} + + + +// -- Recadrer la partie non-zoomée de l'image par rapport à la partie zoomée +// lorsqu'on scrolle en mode Loupe -- +void Recadrer_ecran_par_rapport_au_zoom(void) +{ + // Centrage en X + if (Principal_Largeur_image>Principal_Split) + { + Principal_Decalage_X=Loupe_Decalage_X+(Loupe_Largeur>>1) + -(Principal_Split>>1); + if (Principal_Decalage_X<0) + Principal_Decalage_X=0; + else + if (Principal_Largeur_imageMenu_Ordonnee) + { + Principal_Decalage_Y=Loupe_Decalage_Y+(Loupe_Hauteur>>1) + -(Menu_Ordonnee>>1); + if (Principal_Decalage_Y<0) + Principal_Decalage_Y=0; + else + if (Principal_Hauteur_image>1)-X_theorique)/Loupe_Facteur)*Loupe_Facteur); + Principal_Split=Principal_X_Zoom-(Menu_Facteur_X*LARGEUR_BARRE_SPLIT); + + // Correction en cas de débordement sur la gauche + while (Principal_Split*(Loupe_Facteur+1)=X_theorique) + { + Principal_Split-=Loupe_Facteur; + Principal_X_Zoom-=Loupe_Facteur; + } +} + + + +// -------------------- Calcul des information de la loupe ------------------- +void Calculer_donnees_loupe(void) +/* + Après modification des données de la loupe, il faut recalculer les limites. +*/ +{ + Calculer_split(); + + Loupe_Largeur=(Largeur_ecran-Principal_X_Zoom)/Loupe_Facteur; + + Loupe_Hauteur=Menu_Ordonnee/Loupe_Facteur; + if (Menu_Ordonnee%Loupe_Facteur) + Loupe_Hauteur++; + + if (Loupe_Mode && Loupe_Decalage_X) + { + if (Principal_Largeur_image=Principal_Hauteur_image) + Limite_Bas=Principal_Hauteur_image-1; + else + Limite_Bas=Limite_visible_Bas; + + if (Limite_visible_Droite>=Principal_Largeur_image) + Limite_Droite=Principal_Largeur_image-1; + else + Limite_Droite=Limite_visible_Droite; + + // -- Calcul des limites de la partie zoomée de l'image -- + Limite_Haut_Zoom =Loupe_Decalage_Y; + Limite_Gauche_Zoom=Loupe_Decalage_X; + Limite_visible_Bas_Zoom =Limite_Haut_Zoom+Loupe_Hauteur-1; + Limite_visible_Droite_Zoom=Limite_Gauche_Zoom+Loupe_Largeur-1; + + if (Limite_visible_Bas_Zoom>=Principal_Hauteur_image) + Limite_Bas_Zoom=Principal_Hauteur_image-1; + else + Limite_Bas_Zoom=Limite_visible_Bas_Zoom; + + if (Limite_visible_Droite_Zoom>=Principal_Largeur_image) + Limite_Droite_Zoom=Principal_Largeur_image-1; + else + Limite_Droite_Zoom=Limite_visible_Droite_Zoom; + } + else + { + // -- Calcul des limites de la partie visible de l'image -- + Limite_Haut =Principal_Decalage_Y; + Limite_Gauche=Principal_Decalage_X; + Limite_visible_Bas =Limite_Haut+(Menu_visible?Menu_Ordonnee:Hauteur_ecran)-1; // A REVOIR POUR SIMPLIFICATION + Limite_visible_Droite=Limite_Gauche+Largeur_ecran-1; + + if (Limite_visible_Bas>=Principal_Hauteur_image) + Limite_Bas=Principal_Hauteur_image-1; + else + Limite_Bas=Limite_visible_Bas; + + if (Limite_visible_Droite>=Principal_Largeur_image) + Limite_Droite=Principal_Largeur_image-1; + else + Limite_Droite=Limite_visible_Droite; + } +} + + +// -- Calculer les coordonnées du pinceau en fonction du snap et de la loupe - +void Calculer_coordonnees_pinceau(void) +{ + if ((Loupe_Mode) && (Mouse_X>=Principal_X_Zoom)) + { + Pinceau_X=((Mouse_X-Principal_X_Zoom)/Loupe_Facteur)+Loupe_Decalage_X; + Pinceau_Y=(Mouse_Y/Loupe_Facteur)+Loupe_Decalage_Y; + } + else + { + Pinceau_X=Mouse_X+Principal_Decalage_X; + Pinceau_Y=Mouse_Y+Principal_Decalage_Y; + } + + if (Snap_Mode) + { + Pinceau_X=(((Pinceau_X+(Snap_Largeur>>1)-Snap_Decalage_X)/Snap_Largeur)*Snap_Largeur)+Snap_Decalage_X; + Pinceau_Y=(((Pinceau_Y+(Snap_Hauteur>>1)-Snap_Decalage_Y)/Snap_Hauteur)*Snap_Hauteur)+Snap_Decalage_Y; + } +} + + +// ------------ Changer le facteur de zoom et tout mettre à jour ------------- +void Changer_facteur_loupe(byte Indice_facteur) +{ + short Centre_X; + short Centre_Y; + + Centre_X=Loupe_Decalage_X+(Loupe_Largeur>>1); + Centre_Y=Loupe_Decalage_Y+(Loupe_Hauteur>>1); + + Loupe_Facteur=FACTEUR_ZOOM[Indice_facteur]; + Table_mul_facteur_zoom=TABLE_ZOOM[Indice_facteur]; + Calculer_donnees_loupe(); + + if (Loupe_Mode) + { + // Recalculer le décalage de la loupe + // Centrage "brut" de lécran par rapport à la loupe + Loupe_Decalage_X=Centre_X-(Loupe_Largeur>>1); + Loupe_Decalage_Y=Centre_Y-(Loupe_Hauteur>>1); + // Correction en cas de débordement de l'image + if (Loupe_Decalage_X+Loupe_Largeur>Principal_Largeur_image) + Loupe_Decalage_X=Principal_Largeur_image-Loupe_Largeur; + if (Loupe_Decalage_Y+Loupe_Hauteur>Principal_Hauteur_image) + Loupe_Decalage_Y=Principal_Hauteur_image-Loupe_Hauteur; + if (Loupe_Decalage_X<0) + Loupe_Decalage_X=0; + if (Loupe_Decalage_Y<0) + Loupe_Decalage_Y=0; + + Recadrer_ecran_par_rapport_au_zoom(); + + Pixel_Preview=Pixel_Preview_Loupe; + } + else + Pixel_Preview=Pixel_Preview_Normal; + + Calculer_limites(); + Calculer_coordonnees_pinceau(); +} + + +// -- Affichage de la limite de l'image ------------------------------------- +void Afficher_limites_de_l_image(void) +{ + short Debut; + short Pos; + short Fin; + byte Droite_visible; + byte Bas_visible; + short Ancienne_Limite_Zoom; + + Droite_visible=Principal_Largeur_image<((Loupe_Mode)?Principal_Split:Largeur_ecran); + Bas_visible =Principal_Hauteur_imageMode_video[Numero].Facteur_Y) + && (Menu_Facteur_X==Menu_Facteur_Y) ) + Menu_Facteur_X++; + break; + default: // ne pas adapter + Menu_Facteur_X=1; + Menu_Facteur_Y=1; + } + + if (Buffer_de_ligne_horizontale) + free(Buffer_de_ligne_horizontale); + + Buffer_de_ligne_horizontale=(byte *)malloc((Largeur_ecran>Principal_Largeur_image)?Largeur_ecran:Principal_Largeur_image); + + switch (Mode_video[Numero].Mode) { case MODE_SDL: Pixel= Pixel_SDL; @@ -903,4848 +897,4849 @@ void Initialiser_mode_video(int Numero) Clear_brush_zoom=Clear_brush_zoom_SDL; Set_Mode_SDL(); break; - - switch(Mode_video[Numero].Mode_VESA_de_base) - { - case 0x100 : Indice_VESA=0; // 640x400 - break; - case 0x101 : Indice_VESA=1; // 640x480 - break; - case 0x103 : Indice_VESA=2; // 800x600 - break; - default : Indice_VESA=3; // 1024x768 - } - - // On regarde si le mode supporte le LFB - if (VESA_Mode_Infos[Indice_VESA].Adresse_physique_LFB!=0) - { - // C'est le cas => on va s'en servir - - Set_VESA_mode(Mode_video[Numero].Mode_VESA_de_base | 0x4000); - Initialiser_le_LFB(VESA_Mode_Infos[Indice_VESA].Adresse_physique_LFB, - VESA_Mode_Infos[Indice_VESA].Taille_LFB); - if (Mode_X_Ptr!=NULL) - Retoucher_CRTC(); - } - else - { - // Ce n'est pas le cas, on continue comme si de rien n'‚tait - Granularite =VESA_Mode_Infos[Indice_VESA].Granularite; - VESA_WinFuncPtr=VESA_Mode_Infos[Indice_VESA].WinFuncPtr; - - Initialiser_mode_video_VESA(Mode_video[Numero].Mode_VESA_de_base); - if (Mode_X_Ptr!=NULL) - Retoucher_CRTC(); - } - } - Set_palette(Principal_Palette); - - Resolution_actuelle=Numero; - - Menu_Taille_couleur=((Largeur_ecran/Menu_Facteur_X)-(LARGEUR_MENU+2)) >> 3; - Menu_Ordonnee=Hauteur_ecran; - if (Menu_visible) - Menu_Ordonnee-=HAUTEUR_MENU*Menu_Facteur_Y; - Menu_Ordonnee_Texte=Hauteur_ecran-(Menu_Facteur_Y<<3); - Bouton[BOUTON_CHOIX_COL].Largeur=(Menu_Taille_couleur<<3)-1; - - Clip_mouse(); - Mouse_X = Largeur_ecran >> 1; - Mouse_Y = Hauteur_ecran >> 1; - Set_mouse_position(); - - Sensibilite_X=Config.Indice_Sensibilite_souris_X/Mode_video[Numero].Facteur_X; - Sensibilite_Y=Config.Indice_Sensibilite_souris_Y/Mode_video[Numero].Facteur_Y; - Sensibilite_X>>=Mouse_Facteur_de_correction_X; - Sensibilite_Y>>=Mouse_Facteur_de_correction_Y; - Sensibilite_souris(Sensibilite_X?Sensibilite_X:1,Sensibilite_Y?Sensibilite_Y:1); - - Brouillon_Decalage_X=0; // | Il faut penser … ‚viter les incoh‚rences - Brouillon_Decalage_Y=0; // |- de d‚calage du brouillon par rapport … - Brouillon_Loupe_Mode=0; // | la r‚solution. - } - - Pixel_Preview=Pixel_Preview_Normal; - - Principal_Decalage_X=0; // Il faut quand mˆme modifier ces valeurs … chaque - Principal_Decalage_Y=0; // fois car on n'est pas … l'abri d'une modification - // des dimensions de l'image. - Calculer_donnees_loupe(); - Calculer_limites(); - Calculer_coordonnees_pinceau(); -} - - -// -- Interface avec l'image, affect‚e par le facteur de grossissement ------- - - // fonction d'affichage "Pixel" utilis‚e pour les op‚rations d‚finitivement - // Ne doit … aucune condition ˆtre appel‚e en dehors de la partie visible - // de l'image dans l'‚cran (‡a pourrait ˆtre grave) -void Afficher_pixel(short X,short Y,byte Couleur) - // X & Y sont la position d'un point dans l'IMAGE - // Couleur est la couleur du point - // Le Stencil est g‚r‚. - // Les effets sont g‚r‚s par appel … Fonction_effet(). - // La Loupe est g‚r‚e par appel … Pixel_Preview(). -{ - if ( ( (!Trame_Mode) || (Effet_Trame(X,Y)) ) - && (!((Stencil_Mode) && (Stencil[Lit_pixel_dans_ecran_courant(X,Y)]))) - && (!((Mask_Mode) && (Mask[Lit_pixel_dans_ecran_brouillon(X,Y)]))) ) - { - Couleur=Fonction_effet(X,Y,Couleur); - Pixel_dans_ecran_courant(X,Y,Couleur); - Pixel_Preview(X,Y,Couleur); - } -} - - -// -- Interface avec le menu et les fenˆtres --------------------------------- - - // Affichage d'un pixel dans le menu (le menu doŒt ˆtre visible) - -void Pixel_dans_barre_d_outil(word X,word Y,byte Couleur) -{ - Block(X*Menu_Facteur_X,(Y*Menu_Facteur_Y)+Menu_Ordonnee,Menu_Facteur_X,Menu_Facteur_Y,Couleur); -} - - // Affichage d'un pixel dans la fenˆtre (la fenˆtre doŒt ˆtre visible) - -void Pixel_dans_fenetre(word X,word Y,byte Couleur) -{ - Block((X*Menu_Facteur_X)+Fenetre_Pos_X,(Y*Menu_Facteur_Y)+Fenetre_Pos_Y,Menu_Facteur_X,Menu_Facteur_Y,Couleur); -} - - -// -- Affichages de diff‚rents cƒdres dans une fenˆtre ----------------------- - - // -- Cadre g‚n‚ral avec couleurs paramŠtrables -- - -void Fenetre_Afficher_cadre_general(word Pos_X,word Pos_Y,word Largeur,word Hauteur, - byte Couleur_HG,byte Couleur_BD,byte Couleur_S,byte Couleur_CHG,byte Couleur_CBD) -// ParamŠtres de couleurs: -// Couleur_HG =Bords Haut et Gauche -// Couleur_BD =Bords Bas et Droite -// Couleur_S =Coins Haut-Droite et Bas-Gauche -// Couleur_CHG=Coin Haut-Gauche -// Couleur_CBD=Coin Bas-Droite -{ - // Bord haut (sans les extr‚mit‚s) - Block(Fenetre_Pos_X+((Pos_X+1)*Menu_Facteur_X), - Fenetre_Pos_Y+(Pos_Y*Menu_Facteur_Y), - (Largeur-2)*Menu_Facteur_X,Menu_Facteur_Y,Couleur_HG); - - // Bord bas (sans les extr‚mit‚s) - Block(Fenetre_Pos_X+((Pos_X+1)*Menu_Facteur_X), - Fenetre_Pos_Y+((Pos_Y+Hauteur-1)*Menu_Facteur_Y), - (Largeur-2)*Menu_Facteur_X,Menu_Facteur_Y,Couleur_BD); - - // Bord gauche (sans les extr‚mit‚s) - Block(Fenetre_Pos_X+(Pos_X*Menu_Facteur_X), - Fenetre_Pos_Y+((Pos_Y+1)*Menu_Facteur_Y), - Menu_Facteur_X,(Hauteur-2)*Menu_Facteur_Y,Couleur_HG); - - // Bord droite (sans les extr‚mit‚s) - Block(Fenetre_Pos_X+((Pos_X+Largeur-1)*Menu_Facteur_X), - Fenetre_Pos_Y+((Pos_Y+1)*Menu_Facteur_Y), - Menu_Facteur_X,(Hauteur-2)*Menu_Facteur_Y,Couleur_BD); - - // Coin haut gauche - Pixel_dans_fenetre(Pos_X,Pos_Y,Couleur_CHG); - // Coin haut droite - Pixel_dans_fenetre(Pos_X+Largeur-1,Pos_Y,Couleur_S); - // Coin bas droite - Pixel_dans_fenetre(Pos_X+Largeur-1,Pos_Y+Hauteur-1,Couleur_CBD); - // Coin bas gauche - Pixel_dans_fenetre(Pos_X,Pos_Y+Hauteur-1,Couleur_S); -} - - // -- Cadre dont tout le contour est d'une seule couleur -- - -void Fenetre_Afficher_cadre_mono(word Pos_X,word Pos_Y,word Largeur,word Hauteur,byte Couleur) -{ - Fenetre_Afficher_cadre_general(Pos_X,Pos_Y,Largeur,Hauteur,Couleur,Couleur,Couleur,Couleur,Couleur); -} - - // -- Cadre creux: fonc‚ en haut-gauche et clair en bas-droite -- - -void Fenetre_Afficher_cadre_creux(word Pos_X,word Pos_Y,word Largeur,word Hauteur) -{ - Fenetre_Afficher_cadre_general(Pos_X,Pos_Y,Largeur,Hauteur,CM_Fonce,CM_Blanc,CM_Clair,CM_Fonce,CM_Blanc); -} - - // -- Cadre bomb‚: clair en haut-gauche et fonc‚ en bas-droite -- - -void Fenetre_Afficher_cadre_bombe(word Pos_X,word Pos_Y,word Largeur,word Hauteur) -{ - Fenetre_Afficher_cadre_general(Pos_X,Pos_Y,Largeur,Hauteur,CM_Blanc,CM_Fonce,CM_Clair,CM_Blanc,CM_Fonce); -} - - // -- Cadre de s‚paration: un cadre bomb‚ dans un cadre creux (3D!!!) -- - -void Fenetre_Afficher_cadre(word Pos_X,word Pos_Y,word Largeur,word Hauteur) -{ - Fenetre_Afficher_cadre_creux(Pos_X,Pos_Y,Largeur,Hauteur); - Fenetre_Afficher_cadre_bombe(Pos_X+1,Pos_Y+1,Largeur-2,Hauteur-2); -} - - -//-- Affichages relatifs … la palette dans le menu --------------------------- - - // -- Affichage des couleurs courante (fore/back) de pinceau dans le menu -- - -void Afficher_foreback(void) -{ - if (Menu_visible) - { - Block((LARGEUR_MENU-17)*Menu_Facteur_X,Menu_Ordonnee+Menu_Facteur_Y,Menu_Facteur_X<<4,Menu_Facteur_Y*7,Back_color); - Block((LARGEUR_MENU-13)*Menu_Facteur_X,Menu_Ordonnee+(Menu_Facteur_Y<<1),Menu_Facteur_X<<3,Menu_Facteur_Y*5,Fore_color); - } -} - - // -- Tracer un cadre de couleur autour de la Fore_color dans le menu -- - -void Encadrer_couleur_menu(byte Couleur) -{ - word Debut_X,Debut_Y,Fin_X,Fin_Y; - word Indice; - - if ((Fore_color>=Couleur_debut_palette) && (Fore_color>3)*Menu_Taille_couleur)*Menu_Facteur_X; - Debut_Y=Menu_Ordonnee+((1+(((Fore_color-Couleur_debut_palette)&7)<<2))*Menu_Facteur_Y); - - Block(Debut_X,Debut_Y,(Menu_Taille_couleur+1)*Menu_Facteur_X,Menu_Facteur_Y,Couleur); - Block(Debut_X,Debut_Y+(Menu_Facteur_Y<<2),(Menu_Taille_couleur+1)*Menu_Facteur_X,Menu_Facteur_Y,Couleur); - - Block(Debut_X,Debut_Y+Menu_Facteur_Y,Menu_Facteur_X,Menu_Facteur_Y*3,Couleur); - Block(Debut_X+(Menu_Taille_couleur*Menu_Facteur_X),Debut_Y+Menu_Facteur_Y,Menu_Facteur_X,Menu_Facteur_Y*3,Couleur); - } - else - { - if (Couleur==CM_Noir) - { - Debut_X=(LARGEUR_MENU+1+((Fore_color-Couleur_debut_palette)>>3)*Menu_Taille_couleur)*Menu_Facteur_X; - Debut_Y=Menu_Ordonnee+((2+(((Fore_color-Couleur_debut_palette)&7)<<2))*Menu_Facteur_Y); - - Block(Debut_X,Debut_Y,Menu_Taille_couleur*Menu_Facteur_X, - Menu_Facteur_Y<<2,Fore_color); - } - else - { - Debut_X=LARGEUR_MENU+1+((Fore_color-Couleur_debut_palette)>>3)*Menu_Taille_couleur; - Debut_Y=2+(((Fore_color-Couleur_debut_palette)&7)<<2); - - Fin_X=Debut_X+Menu_Taille_couleur-1; - Fin_Y=Debut_Y+3; - - for (Indice=Debut_X; Indice<=Fin_X; Indice++) - Block(Indice*Menu_Facteur_X,Menu_Ordonnee+(Debut_Y*Menu_Facteur_Y), - Menu_Facteur_X,Menu_Facteur_Y, - ((Indice+Debut_Y)&1)?CM_Blanc:CM_Noir); - - for (Indice=Debut_Y+1; Indice>3)*Menu_Taille_couleur)*Menu_Facteur_X, - Menu_Ordonnee+((2+((Couleur&7)<<2))*Menu_Facteur_Y), - (Menu_Taille_couleur-1)*Menu_Facteur_X, - Menu_Facteur_Y*3, - Couleur_debut_palette+Couleur); - else - for (Couleur=0;Couleur<64;Couleur++) - Block((LARGEUR_MENU+1+(Couleur>>3)*Menu_Taille_couleur)*Menu_Facteur_X, - Menu_Ordonnee+((2+((Couleur&7)<<2))*Menu_Facteur_Y), - Menu_Taille_couleur*Menu_Facteur_X, - Menu_Facteur_Y<<2, - Couleur_debut_palette+Couleur); - - Encadrer_couleur_menu(CM_Blanc); - } -} - - // -- Recalculer l'origine de la palette dans le menu pour rendre la - // Fore_color visible -- - -void Recadrer_palette(void) -{ - byte Ancienne_couleur=Couleur_debut_palette; - - if (Fore_color=Couleur_debut_palette+64) - Couleur_debut_palette+=8; - } - if (Ancienne_couleur!=Couleur_debut_palette) - Afficher_palette_du_menu(); -} - - - // -- Afficher la barre de s‚paration entre les parties zoom‚es ou non en - // mode Loupe -- - -void Afficher_barre_de_split(void) -{ - // Partie grise du milieu - Block(Principal_Split+(Menu_Facteur_X<<1),Menu_Facteur_Y, - (LARGEUR_BARRE_SPLIT-4)*Menu_Facteur_X, - Menu_Ordonnee-(Menu_Facteur_Y<<1),CM_Clair); - - // Barre noire de gauche - Block(Principal_Split,0,Menu_Facteur_X,Menu_Ordonnee,CM_Noir); - - // Barre noire de droite - Block(Principal_X_Zoom-Menu_Facteur_X,0,Menu_Facteur_X,Menu_Ordonnee,CM_Noir); - - // Bord haut (blanc) - Block(Principal_Split+Menu_Facteur_X,0, - (LARGEUR_BARRE_SPLIT-3)*Menu_Facteur_X,Menu_Facteur_Y,CM_Blanc); - - // Bord gauche (blanc) - Block(Principal_Split+Menu_Facteur_X,Menu_Facteur_Y, - Menu_Facteur_X,(Menu_Ordonnee-(Menu_Facteur_Y<<1)),CM_Blanc); - - // Bord droite (gris fonc‚) - Block(Principal_X_Zoom-(Menu_Facteur_X<<1),Menu_Facteur_Y, - Menu_Facteur_X,(Menu_Ordonnee-(Menu_Facteur_Y<<1)),CM_Fonce); - - // Bord bas (gris fonc‚) - Block(Principal_Split+(Menu_Facteur_X<<1),Menu_Ordonnee-Menu_Facteur_Y, - (LARGEUR_BARRE_SPLIT-3)*Menu_Facteur_X,Menu_Facteur_Y,CM_Fonce); - - // Coin bas gauche - Block(Principal_Split+Menu_Facteur_X,Menu_Ordonnee-Menu_Facteur_Y, - Menu_Facteur_X,Menu_Facteur_Y,CM_Clair); - // Coin haut droite - Block(Principal_X_Zoom-(Menu_Facteur_X<<1),0, - Menu_Facteur_X,Menu_Facteur_Y,CM_Clair); -} - - // -- Afficher tout le menu -- - -void Afficher_menu(void) -{ - word Pos_X; - word Pos_Y; - char Chaine[4]; - - - if (Menu_visible) - { - // Affichage du sprite du menu - for (Pos_Y=0;Pos_Y=Principal_X_Zoom) )) - { - if ( (Operation_en_cours!=OPERATION_PIPETTE) - && (Operation_en_cours!=OPERATION_REMPLACER) ) - Print_dans_menu("X: Y: ",0); - else - { - Print_dans_menu("X: Y: ( )",0); - Num2str(Pipette_Couleur,Chaine,3); - Print_dans_menu(Chaine,20); - Print_general(170*Menu_Facteur_X,Menu_Ordonnee_Texte," ",0,Pipette_Couleur); - } - Print_coordonnees(); - } - Print_nom_fichier(); - } - } -} - - -// -- Affichage de texte ----------------------------------------------------- - - // -- Afficher une chaŒne n'importe o— … l'‚cran -- - -void Print_general(short X,short Y,char * Chaine,byte Couleur_texte,byte Couleur_fond) -{ - word Indice; - short Pos_X; - short Pos_Y; - char Caractere; - short Reel_X; - short Reel_Y; - short Largeur; - short Repeat_Menu_Facteur_X; - short Repeat_Menu_Facteur_Y; - - Reel_Y=Y; - Largeur=strlen(Chaine)*Menu_Facteur_X*8; - for (Pos_Y=0;Pos_Y<8;Pos_Y++) - { - Reel_X=0; // Position dans le buffer - for (Indice=0;Chaine[Indice]!='\0';Indice++) - { - Caractere=Chaine[Indice]; - for (Pos_X=0;Pos_X<8;Pos_X++) - for (Repeat_Menu_Facteur_X=0;Repeat_Menu_Facteur_X=0) && (Pinceau_Y>=0) - && (Pinceau_X=Debut) && (C<=Fin) && (Debut!=Fin)) - { - Largeur=1+Fin-Debut; - - if ( ((Mouse_K==A_GAUCHE) && Sens) || ((Mouse_K==A_DROITE) && (!Sens)) ) - C-=Quick_shade_Step%Largeur; - else - C+=Quick_shade_Step%Largeur; - - if (CFin) - switch (Quick_shade_Loop) - { - case MODE_SHADE_NORMAL : return Fin; - case MODE_SHADE_BOUCLE : return (C-Largeur); - default : return Couleur; - } - } - - return C; -} - - // -- Effet de Tiling -- - -byte Effet_Tiling(word X,word Y,byte Couleur) -{ - return Lit_pixel_dans_brosse((X+Brosse_Largeur-Tiling_Decalage_X)%Brosse_Largeur, - (Y+Brosse_Hauteur-Tiling_Decalage_Y)%Brosse_Hauteur); -} - - // -- Effet de Smooth -- - -byte Effet_Smooth(word X,word Y,byte Couleur) -{ - int R,V,B; - byte C; - int Poids,Poids_total; - byte X2=((X+1)(Limite_Droite+1)) - { - (*Largeur)=(Limite_Droite-(*X))+1; - } - - if ((*Y)(Limite_Bas+1)) - { - (*Hauteur)=(Limite_Bas-(*Y))+1; - } -} - - // -- Calcul de redimensionnement du pinceau pour ‚viter les d‚bordements - // de l'‚cran zoom‚ et de l'image -- - -void Calculer_dimensions_clipees_zoom(short * X,short * Y,short * Largeur,short * Hauteur) -{ - if ((*X)(Limite_Droite_Zoom+1)) - { - (*Largeur)=(Limite_Droite_Zoom-(*X))+1; - } - - if ((*Y)(Limite_Bas_Zoom+1)) - { - (*Hauteur)=(Limite_Bas_Zoom-(*Y))+1; - } -} - - - // -- Afficher le pinceau (de fa‡on d‚finitive ou non) -- - -void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview) - // X,Y: position du centre du pinceau - // Couleur: couleur … appliquer au pinceau - // Preview: "Il ne faut l'afficher qu'… l'‚cran" -{ - short Debut_X; // Position X (dans l'image) … partir de laquelle on affiche la brosse/pinceau - short Debut_Y; // Position Y (dans l'image) … partir de laquelle on affiche la brosse/pinceau - short Largeur; // Largeur dans l'‚cran selon laquelle on affiche la brosse/pinceau - short Hauteur; // Hauteur dans l'‚cran selon laquelle on affiche la brosse/pinceau - short Debut_Compteur_X; // Position X (dans la brosse/pinceau) … partir de laquelle on affiche la brosse/pinceau - short Debut_Compteur_Y; // Position Y (dans la brosse/pinceau) … partir de laquelle on affiche la brosse/pinceau - short Pos_X; // Position X (dans l'image) en cours d'affichage - short Pos_Y; // Position Y (dans l'image) en cours d'affichage - short Compteur_X; // Position X (dans la brosse/pinceau) en cours d'affichage - short Compteur_Y; // Position Y (dans la brosse/pinceau) en cours d'affichage - short Fin_Compteur_X; // Position X ou s'arrˆte l'affichade de la brosse/pinceau - short Fin_Compteur_Y; // Position Y ou s'arrˆte l'affichade de la brosse/pinceau - byte Couleur_temporaire; // Couleur de la brosse en cours d'affichage - int Position; - byte * Temp; - - if (!(Preview && Mouse_K)) - switch (Pinceau_Forme) - { - case FORME_PINCEAU_POINT : // !!! TOUJOURS EN PREVIEW !!! - if ( (Pinceau_X>=Limite_Gauche) - && (Pinceau_X<=Limite_Droite) - && (Pinceau_Y>=Limite_Haut) - && (Pinceau_Y<=Limite_Bas) ) - Pixel_Preview(Pinceau_X,Pinceau_Y,Couleur); - break; - case FORME_PINCEAU_BROSSE_COULEUR : // Brosse en couleur - Debut_X=X-Brosse_Decalage_X; - Debut_Y=Y-Brosse_Decalage_Y; - Largeur=Brosse_Largeur; - Hauteur=Brosse_Hauteur; - Calculer_dimensions_clipees(&Debut_X,&Debut_Y,&Largeur,&Hauteur); - Debut_Compteur_X=Debut_X-(X-Brosse_Decalage_X); - Debut_Compteur_Y=Debut_Y-(Y-Brosse_Decalage_Y); - Fin_Compteur_X=Debut_Compteur_X+Largeur; - Fin_Compteur_Y=Debut_Compteur_Y+Hauteur; - if (Preview) - { - if ( (Largeur>0) && (Hauteur>0) ) - Display_brush_Color(Debut_X-Principal_Decalage_X, - Debut_Y-Principal_Decalage_Y, - Debut_Compteur_X,Debut_Compteur_Y, - Largeur,Hauteur,Back_color, - Brosse_Largeur); - - if (Loupe_Mode) - { - Calculer_dimensions_clipees_zoom(&Debut_X,&Debut_Y,&Largeur,&Hauteur); - Debut_Compteur_X=Debut_X-(X-Brosse_Decalage_X); - Debut_Compteur_Y=Debut_Y-(Y-Brosse_Decalage_Y); - - if ( (Largeur>0) && (Hauteur>0) ) - { - // Corrections d–es au Zoom: - Debut_X=(Debut_X-Loupe_Decalage_X)*Loupe_Facteur; - Debut_Y=(Debut_Y-Loupe_Decalage_Y)*Loupe_Facteur; - Hauteur=Debut_Y+(Hauteur*Loupe_Facteur); - if (Hauteur>Menu_Ordonnee) - Hauteur=Menu_Ordonnee; - - Display_brush_Color_zoom(Principal_X_Zoom+Debut_X,Debut_Y, - Debut_Compteur_X,Debut_Compteur_Y, - Largeur,Hauteur,Back_color, - Brosse_Largeur, - Buffer_de_ligne_horizontale); - } - } - } - else - { - if ((Smear_Mode) && (Shade_Table==Shade_Table_gauche)) - { - if (Smear_Debut) - { - if ((Largeur>0) && (Hauteur>0)) - Copier_une_partie_d_image_dans_une_autre(Principal_Ecran, - Debut_X,Debut_Y, - Largeur,Hauteur, - Principal_Largeur_image, - Smear_Brosse, - Debut_Compteur_X, - Debut_Compteur_Y, - Smear_Brosse_Largeur); - Smear_Debut=0; - } - else - { - for (Pos_Y=Debut_Y,Compteur_Y=Debut_Compteur_Y;Compteur_Y=Smear_Min_Y) && (Compteur_X>=Smear_Min_X) ) - Afficher_pixel(Pos_X,Pos_Y,Smear_Brosse[Position]); - Smear_Brosse[Position]=Couleur_temporaire; - } - } - Smear_Min_X=Debut_Compteur_X; - Smear_Min_Y=Debut_Compteur_Y; - Smear_Max_X=Fin_Compteur_X; - Smear_Max_Y=Fin_Compteur_Y; - } - else - { - if (Shade_Table==Shade_Table_gauche) - for (Pos_Y=Debut_Y,Compteur_Y=Debut_Compteur_Y;Compteur_Y0) && (Hauteur>0) ) - Display_brush_Mono(Debut_X-Principal_Decalage_X, - Debut_Y-Principal_Decalage_Y, - Debut_Compteur_X,Debut_Compteur_Y, - Largeur,Hauteur, - Back_color,Fore_color, - Brosse_Largeur); - - if (Loupe_Mode) - { - Calculer_dimensions_clipees_zoom(&Debut_X,&Debut_Y,&Largeur,&Hauteur); - Debut_Compteur_X=Debut_X-(X-Brosse_Decalage_X); - Debut_Compteur_Y=Debut_Y-(Y-Brosse_Decalage_Y); - - if ( (Largeur>0) && (Hauteur>0) ) - { - // Corrections d–es au Zoom: - Debut_X=(Debut_X-Loupe_Decalage_X)*Loupe_Facteur; - Debut_Y=(Debut_Y-Loupe_Decalage_Y)*Loupe_Facteur; - Hauteur=Debut_Y+(Hauteur*Loupe_Facteur); - if (Hauteur>Menu_Ordonnee) - Hauteur=Menu_Ordonnee; - - Display_brush_Mono_zoom(Principal_X_Zoom+Debut_X,Debut_Y, - Debut_Compteur_X,Debut_Compteur_Y, - Largeur,Hauteur, - Back_color,Fore_color, - Brosse_Largeur, - Buffer_de_ligne_horizontale); - } - } - } - else - { - if ((Smear_Mode) && (Shade_Table==Shade_Table_gauche)) - { - if (Smear_Debut) - { - if ((Largeur>0) && (Hauteur>0)) - Copier_une_partie_d_image_dans_une_autre(Principal_Ecran, - Debut_X,Debut_Y, - Largeur,Hauteur, - Principal_Largeur_image, - Smear_Brosse, - Debut_Compteur_X, - Debut_Compteur_Y, - Smear_Brosse_Largeur); - Smear_Debut=0; - } - else - { - for (Pos_Y=Debut_Y,Compteur_Y=Debut_Compteur_Y;Compteur_Y=Smear_Min_Y) && (Compteur_X>=Smear_Min_X) ) - Afficher_pixel(Pos_X,Pos_Y,Smear_Brosse[Position]); - Smear_Brosse[Position]=Couleur_temporaire; - } - } - Smear_Min_X=Debut_Compteur_X; - Smear_Min_Y=Debut_Compteur_Y; - Smear_Max_X=Fin_Compteur_X; - Smear_Max_Y=Fin_Compteur_Y; - } - else - { - for (Pos_Y=Debut_Y,Compteur_Y=Debut_Compteur_Y;Compteur_Y0) && (Hauteur>0) ) - Display_brush_Mono(Debut_X-Principal_Decalage_X, - Debut_Y-Principal_Decalage_Y, - Debut_Compteur_X,Debut_Compteur_Y, - Largeur,Hauteur, - 0,Fore_color, - TAILLE_MAXI_PINCEAU); - - if (Loupe_Mode) - { - Calculer_dimensions_clipees_zoom(&Debut_X,&Debut_Y,&Largeur,&Hauteur); - Debut_Compteur_X=Debut_X-(X-Pinceau_Decalage_X); - Debut_Compteur_Y=Debut_Y-(Y-Pinceau_Decalage_Y); - - if ( (Largeur>0) && (Hauteur>0) ) - { - // Corrections d–es au Zoom: - Debut_X=(Debut_X-Loupe_Decalage_X)*Loupe_Facteur; - Debut_Y=(Debut_Y-Loupe_Decalage_Y)*Loupe_Facteur; - Hauteur=Debut_Y+(Hauteur*Loupe_Facteur); - if (Hauteur>Menu_Ordonnee) - Hauteur=Menu_Ordonnee; - - Display_brush_Mono_zoom(Principal_X_Zoom+Debut_X,Debut_Y, - Debut_Compteur_X,Debut_Compteur_Y, - Largeur,Hauteur, - 0,Fore_color, - TAILLE_MAXI_PINCEAU, - Buffer_de_ligne_horizontale); - } - } - - Brosse=Temp; - } - else - { - if ((Smear_Mode) && (Shade_Table==Shade_Table_gauche)) - { - if (Smear_Debut) - { - if ((Largeur>0) && (Hauteur>0)) - Copier_une_partie_d_image_dans_une_autre(Principal_Ecran, - Debut_X,Debut_Y, - Largeur,Hauteur, - Principal_Largeur_image, - Smear_Brosse, - Debut_Compteur_X, - Debut_Compteur_Y, - Smear_Brosse_Largeur); - Smear_Debut=0; - } - else - { - for (Pos_Y=Debut_Y,Compteur_Y=Debut_Compteur_Y;Compteur_Y=Smear_Min_Y) && (Compteur_X>=Smear_Min_X) ) - Afficher_pixel(Pos_X,Pos_Y,Smear_Brosse[Position]); - Smear_Brosse[Position]=Couleur_temporaire; - } - } - Smear_Min_X=Debut_Compteur_X; - Smear_Min_Y=Debut_Compteur_Y; - Smear_Max_X=Fin_Compteur_X; - Smear_Max_Y=Fin_Compteur_Y; - } - else - { - for (Pos_Y=Debut_Y,Compteur_Y=Debut_Compteur_Y;Compteur_Y=Limite_Gauche) - && (Pinceau_X<=Limite_Droite) - && (Pinceau_Y>=Limite_Haut) - && (Pinceau_Y<=Limite_Bas) ) - Pixel_Preview(Pinceau_X,Pinceau_Y,Lit_pixel_dans_ecran_courant(Pinceau_X,Pinceau_Y)); - break; - case FORME_PINCEAU_BROSSE_COULEUR : // Brosse en couleur - case FORME_PINCEAU_BROSSE_MONOCHROME : // Brosse monochrome - Debut_X=X-Brosse_Decalage_X; - Debut_Y=Y-Brosse_Decalage_Y; - Largeur=Brosse_Largeur; - Hauteur=Brosse_Hauteur; - Calculer_dimensions_clipees(&Debut_X,&Debut_Y,&Largeur,&Hauteur); - Debut_Compteur_X=Debut_X-(X-Brosse_Decalage_X); - Debut_Compteur_Y=Debut_Y-(Y-Brosse_Decalage_Y); - Fin_Compteur_X=Debut_Compteur_X+Largeur; - Fin_Compteur_Y=Debut_Compteur_Y+Hauteur; - - if ( (Largeur>0) && (Hauteur>0) ) - Clear_brush(Debut_X-Principal_Decalage_X, - Debut_Y-Principal_Decalage_Y, - Debut_Compteur_X,Debut_Compteur_Y, - Largeur,Hauteur,Back_color, - Principal_Largeur_image); - - if (Loupe_Mode) - { - Calculer_dimensions_clipees_zoom(&Debut_X,&Debut_Y,&Largeur,&Hauteur); - Debut_Compteur_X=Debut_X; - Debut_Compteur_Y=Debut_Y; - - if ( (Largeur>0) && (Hauteur>0) ) - { - // Corrections dues au Zoom: - Debut_X=(Debut_X-Loupe_Decalage_X)*Loupe_Facteur; - Debut_Y=(Debut_Y-Loupe_Decalage_Y)*Loupe_Facteur; - Hauteur=Debut_Y+(Hauteur*Loupe_Facteur); - if (Hauteur>Menu_Ordonnee) - Hauteur=Menu_Ordonnee; - - Clear_brush_zoom(Principal_X_Zoom+Debut_X,Debut_Y, - Debut_Compteur_X,Debut_Compteur_Y, - Largeur,Hauteur,Back_color, - Principal_Largeur_image, - Buffer_de_ligne_horizontale); - } - } - break; - default: // Pinceau - Debut_X=X-Pinceau_Decalage_X; - Debut_Y=Y-Pinceau_Decalage_Y; - Largeur=Pinceau_Largeur; - Hauteur=Pinceau_Hauteur; - Calculer_dimensions_clipees(&Debut_X,&Debut_Y,&Largeur,&Hauteur); - Debut_Compteur_X=Debut_X-(X-Pinceau_Decalage_X); - Debut_Compteur_Y=Debut_Y-(Y-Pinceau_Decalage_Y); - Fin_Compteur_X=Debut_Compteur_X+Largeur; - Fin_Compteur_Y=Debut_Compteur_Y+Hauteur; - - Temp=Brosse; - Brosse=Pinceau_Sprite; - - if ( (Largeur>0) && (Hauteur>0) ) - { - Clear_brush(Debut_X-Principal_Decalage_X, - Debut_Y-Principal_Decalage_Y, - Debut_Compteur_X,Debut_Compteur_Y, - Largeur,Hauteur,0, - Principal_Largeur_image); - } - - if (Loupe_Mode) - { - Calculer_dimensions_clipees_zoom(&Debut_X,&Debut_Y,&Largeur,&Hauteur); - Debut_Compteur_X=Debut_X; - Debut_Compteur_Y=Debut_Y; - - if ( (Largeur>0) && (Hauteur>0) ) - { - // Corrections dues au Zoom: - Debut_X=(Debut_X-Loupe_Decalage_X)*Loupe_Facteur; - Debut_Y=(Debut_Y-Loupe_Decalage_Y)*Loupe_Facteur; - Hauteur=Debut_Y+(Hauteur*Loupe_Facteur); - if (Hauteur>Menu_Ordonnee) - Hauteur=Menu_Ordonnee; - - Clear_brush_zoom(Principal_X_Zoom+Debut_X,Debut_Y, - Debut_Compteur_X,Debut_Compteur_Y, - Largeur,Hauteur,0, - Principal_Largeur_image, - Buffer_de_ligne_horizontale); - } - } - - Brosse=Temp; - break; - } -} - - -// -- Fonctions de manipulation du curseur ----------------------------------- - - - // -- Afficher une barre horizontale XOR zoom‚e - -void Ligne_horizontale_XOR_Zoom(short Pos_X, short Pos_Y, short Largeur) -{ - short Pos_X_reelle=Principal_X_Zoom+(Pos_X-Loupe_Decalage_X)*Loupe_Facteur; - short Pos_Y_reelle=(Pos_Y-Loupe_Decalage_Y)*Loupe_Facteur; - short Largeur_reelle=Largeur*Loupe_Facteur; - short Pos_Y_Fin=(Pos_Y_reelle+Loupe_Facteur=Principal_X_Zoom) ) ) - || (Une_fenetre_est_ouverte) || (Forme_curseur==FORME_CURSEUR_SABLIER) ) - Forme=Forme_curseur; - else - Forme=FORME_CURSEUR_FLECHE; - - switch(Forme) - { - case FORME_CURSEUR_CIBLE : - if (!Cacher_pinceau) - Afficher_pinceau(Pinceau_X,Pinceau_Y,Fore_color,1); - if (!Cacher_curseur) - { - if (Config.Curseur==1) - { - Debut_Y=(Mouse_Y<6)?6-Mouse_Y:0; - if (Debut_Y<4) - Ligne_verticale_XOR (Mouse_X,Mouse_Y+Debut_Y-6,4-Debut_Y); - - Debut_X=(Mouse_X<6)?(short)6-Mouse_X:0; - if (Debut_X<4) - Ligne_horizontale_XOR(Mouse_X+Debut_X-6,Mouse_Y,4-Debut_X); - - Fin_X=(Mouse_X+7>Largeur_ecran)?Mouse_X+7-Largeur_ecran:0; - if (Fin_X<4) - Ligne_horizontale_XOR(Mouse_X+3,Mouse_Y,4-Fin_X); - - Fin_Y=(Mouse_Y+7>Menu_Ordonnee/*Hauteur_ecran*/)?Mouse_Y+7-Menu_Ordonnee/*Hauteur_ecran*/:0; - if (Fin_Y<4) - Ligne_verticale_XOR (Mouse_X,Mouse_Y+3,4-Fin_Y); - } - else - { - Temp=(Config.Curseur)?FORME_CURSEUR_CIBLE_FINE:FORME_CURSEUR_CIBLE; - Debut_X=Mouse_X-Curseur_Decalage_X[Temp]; - Debut_Y=Mouse_Y-Curseur_Decalage_Y[Temp]; - - for (Pos_X=Debut_X,Compteur_X=0;Compteur_X<15;Pos_X++,Compteur_X++) - for (Pos_Y=Debut_Y,Compteur_Y=0;Compteur_Y<15;Pos_Y++,Compteur_Y++) - { - Couleur=SPRITE_CURSEUR[Temp][Compteur_Y][Compteur_X]; - if ( (Pos_X>=0) && (Pos_X=0) && (Pos_YLargeur_ecran)?Mouse_X+6-Largeur_ecran:0; - if (Fin_X<3) - Ligne_horizontale_XOR(Mouse_X+3,Mouse_Y,3-Fin_X); - - Fin_Y=(Mouse_Y+6>Menu_Ordonnee/*Hauteur_ecran*/)?Mouse_Y+6-Menu_Ordonnee/*Hauteur_ecran*/:0; - if (Fin_Y<3) - Ligne_verticale_XOR (Mouse_X,Mouse_Y+3,3-Fin_Y); - - // Petites barres aux extr‚mit‚s - - Debut_X=(!Mouse_X); - Debut_Y=(!Mouse_Y); - Fin_X=(Mouse_X>=Largeur_ecran-1); - Fin_Y=(Mouse_Y>=Menu_Ordonnee-1); - - if (Mouse_Y>5) - Ligne_horizontale_XOR(Debut_X+Mouse_X-1,Mouse_Y-6,3-(Debut_X+Fin_X)); - - if (Mouse_X>5) - Ligne_verticale_XOR (Mouse_X-6,Debut_Y+Mouse_Y-1,3-(Debut_Y+Fin_Y)); - - if (Mouse_X=0) && (Pos_X=0) && (Pos_Y=0) && (Pos_Y>=0) ) - { - FOND_CURSEUR[Compteur_Y][Compteur_X]=Lit_pixel(Pos_X,Pos_Y); - if (Couleur!=CM_Trans) - Pixel(Pos_X,Pos_Y,Couleur); - } - } - break; - case FORME_CURSEUR_CIBLE_XOR : - Pos_X=Pinceau_X-Principal_Decalage_X; - Pos_Y=Pinceau_Y-Principal_Decalage_Y; - - Compteur_X=(Loupe_Mode)?Principal_Split:Largeur_ecran; // Largeur de la barre XOR - if ((Pos_Y=Limite_Haut)) - Ligne_horizontale_XOR(0,Pinceau_Y-Principal_Decalage_Y,Compteur_X); - - if ((Pos_X=Limite_Gauche)) - Ligne_verticale_XOR(Pinceau_X-Principal_Decalage_X,0,Menu_Ordonnee); - - if (Loupe_Mode) - { - if ((Pinceau_Y>=Limite_Haut_Zoom) && (Pinceau_Y<=Limite_visible_Bas_Zoom)) - Ligne_horizontale_XOR_Zoom(Limite_Gauche_Zoom,Pinceau_Y,Loupe_Largeur); - if ((Pinceau_X>=Limite_Gauche_Zoom) && (Pinceau_X<=Limite_visible_Droite_Zoom)) - Ligne_verticale_XOR_Zoom(Pinceau_X,Limite_Haut_Zoom,Loupe_Hauteur); - } - break; - case FORME_CURSEUR_RECTANGLE_XOR : - // !!! Cette forme ne peut pas ˆtre utilis‚e en mode Loupe !!! - Debut_X=Mouse_X-(Loupe_Largeur>>1); - Debut_Y=Mouse_Y-(Loupe_Hauteur>>1); - if (Debut_X+Loupe_Largeur>=Limite_Droite-Principal_Decalage_X) - Debut_X=Limite_Droite-Loupe_Largeur-Principal_Decalage_X+1; - if (Debut_Y+Loupe_Hauteur>=Limite_Bas-Principal_Decalage_Y) - Debut_Y=Limite_Bas-Loupe_Hauteur-Principal_Decalage_Y+1; - if (Debut_X<0) - Debut_X=0; - if (Debut_Y<0) - Debut_Y=0; - Fin_X=Debut_X+Loupe_Largeur-1; - Fin_Y=Debut_Y+Loupe_Hauteur-1; - - Ligne_horizontale_XOR(Debut_X,Debut_Y,Loupe_Largeur); - Ligne_verticale_XOR(Debut_X,Debut_Y+1,Loupe_Hauteur-2); - Ligne_verticale_XOR( Fin_X,Debut_Y+1,Loupe_Hauteur-2); - Ligne_horizontale_XOR(Debut_X, Fin_Y,Loupe_Largeur); - - Debut_X=(Mouse_X-3); - Debut_Y=(Mouse_Y-3); - Fin_X =(Mouse_X+4); - Fin_Y =(Mouse_Y+4); - if (Debut_X<0) - Debut_X=0; - if (Debut_Y<0) - Debut_Y=0; - if (Fin_X>Largeur_ecran) - Fin_X=Largeur_ecran; - if (Fin_Y>Menu_Ordonnee) - Fin_Y=Menu_Ordonnee; - - Ligne_horizontale_XOR(Debut_X,Mouse_Y,Fin_X-Debut_X); - Ligne_verticale_XOR (Mouse_X,Debut_Y,Fin_Y-Debut_Y); - break; - default: //case FORME_CURSEUR_ROTATE_XOR : - Debut_X=1-(Brosse_Largeur>>1); - Debut_Y=1-(Brosse_Hauteur>>1); - Fin_X=Debut_X+Brosse_Largeur-1; - Fin_Y=Debut_Y+Brosse_Hauteur-1; - - if (Brosse_Centre_rotation_defini) - { - if ( (Brosse_Centre_rotation_X==Pinceau_X) - && (Brosse_Centre_rotation_Y==Pinceau_Y) ) - { - cosA=1.0; - sinA=0.0; - } - else - { - Pos_X=Pinceau_X-Brosse_Centre_rotation_X; - Pos_Y=Pinceau_Y-Brosse_Centre_rotation_Y; - cosA=(float)Pos_X/sqrt((Pos_X*Pos_X)+(Pos_Y*Pos_Y)); - sinA=sin(acos(cosA)); - if (Pos_Y>0) sinA=-sinA; - } - - Transformer_point(Debut_X,Debut_Y, cosA,sinA, &X1,&Y1); - Transformer_point(Fin_X ,Debut_Y, cosA,sinA, &X2,&Y2); - Transformer_point(Debut_X,Fin_Y , cosA,sinA, &X3,&Y3); - Transformer_point(Fin_X ,Fin_Y , cosA,sinA, &X4,&Y4); - - X1+=Brosse_Centre_rotation_X; - Y1+=Brosse_Centre_rotation_Y; - X2+=Brosse_Centre_rotation_X; - Y2+=Brosse_Centre_rotation_Y; - X3+=Brosse_Centre_rotation_X; - Y3+=Brosse_Centre_rotation_Y; - X4+=Brosse_Centre_rotation_X; - Y4+=Brosse_Centre_rotation_Y; - Pixel_figure_Preview_xor(Brosse_Centre_rotation_X,Brosse_Centre_rotation_Y,0); - Tracer_ligne_Preview_xor(Brosse_Centre_rotation_X,Brosse_Centre_rotation_Y,Pinceau_X,Pinceau_Y,0); - } - else - { - X1=X3=1-Brosse_Largeur; - Y1=Y2=Debut_Y; - X2=X4=Pinceau_X; - Y3=Y4=Fin_Y; - - X1+=Pinceau_X; - Y1+=Pinceau_Y; - Y2+=Pinceau_Y; - X3+=Pinceau_X; - Y3+=Pinceau_Y; - Y4+=Pinceau_Y; - Pixel_figure_Preview_xor(Pinceau_X-Fin_X,Pinceau_Y,0); - Tracer_ligne_Preview_xor(Pinceau_X-Fin_X,Pinceau_Y,Pinceau_X,Pinceau_Y,0); - } - - Tracer_ligne_Preview_xor(X1,Y1,X2,Y2,0); - Tracer_ligne_Preview_xor(X2,Y2,X4,Y4,0); - Tracer_ligne_Preview_xor(X4,Y4,X3,Y3,0); - Tracer_ligne_Preview_xor(X3,Y3,X1,Y1,0); - } -} - - // -- Effacer le curseur -- - -void Effacer_curseur(void) -{ - byte Forme; - short Debut_X; - short Debut_Y; - short Fin_X; - short Fin_Y; - short Pos_X; - short Pos_Y; - short Compteur_X; - short Compteur_Y; - short Fin_Compteur_X; // Position X ou s'arrˆte l'affichage de la brosse/pinceau - short Fin_Compteur_Y; // Position Y ou s'arrˆte l'affichage de la brosse/pinceau - int Temp; - byte Couleur; - float cosA,sinA; - short X1,Y1,X2,Y2,X3,Y3,X4,Y4; - - if ( ( (Mouse_Y=Principal_X_Zoom) ) ) - || (Une_fenetre_est_ouverte) || (Forme_curseur==FORME_CURSEUR_SABLIER) ) - Forme=Forme_curseur; - else - Forme=FORME_CURSEUR_FLECHE; - - switch(Forme) - { - case FORME_CURSEUR_CIBLE : - if (!Cacher_curseur) - { - if (Config.Curseur==1) - { - Debut_Y=(Mouse_Y<6)?6-Mouse_Y:0; - if (Debut_Y<4) - Ligne_verticale_XOR (Mouse_X,Mouse_Y+Debut_Y-6,4-Debut_Y); - - Debut_X=(Mouse_X<6)?(short)6-Mouse_X:0; - if (Debut_X<4) - Ligne_horizontale_XOR(Mouse_X+Debut_X-6,Mouse_Y,4-Debut_X); - - Fin_X=(Mouse_X+7>Largeur_ecran)?Mouse_X+7-Largeur_ecran:0; - if (Fin_X<4) - Ligne_horizontale_XOR(Mouse_X+3,Mouse_Y,4-Fin_X); - - Fin_Y=(Mouse_Y+7>Menu_Ordonnee/*Hauteur_ecran*/)?Mouse_Y+7-Menu_Ordonnee/*Hauteur_ecran*/:0; - if (Fin_Y<4) - Ligne_verticale_XOR (Mouse_X,Mouse_Y+3,4-Fin_Y); - } - else - { - Temp=(Config.Curseur)?FORME_CURSEUR_CIBLE_FINE:FORME_CURSEUR_CIBLE; - Debut_X=Mouse_X-Curseur_Decalage_X[Temp]; - Debut_Y=Mouse_Y-Curseur_Decalage_Y[Temp]; - - for (Pos_X=Debut_X,Compteur_X=0;Compteur_X<15;Pos_X++,Compteur_X++) - for (Pos_Y=Debut_Y,Compteur_Y=0;Compteur_Y<15;Pos_Y++,Compteur_Y++) - if ( (Pos_X>=0) && (Pos_X=0) && (Pos_YLargeur_ecran)?Mouse_X+6-Largeur_ecran:0; - if (Fin_X<3) - Ligne_horizontale_XOR(Mouse_X+3,Mouse_Y,3-Fin_X); - - Fin_Y=(Mouse_Y+6>Menu_Ordonnee/*Hauteur_ecran*/)?Mouse_Y+6-Menu_Ordonnee/*Hauteur_ecran*/:0; - if (Fin_Y<3) - Ligne_verticale_XOR (Mouse_X,Mouse_Y+3,3-Fin_Y); - - // Petites barres aux extr‚mit‚s - - Debut_X=(!Mouse_X); - Debut_Y=(!Mouse_Y); - Fin_X=(Mouse_X>=Largeur_ecran-1); - Fin_Y=(Mouse_Y>=Menu_Ordonnee-1); - - if (Mouse_Y>5) - Ligne_horizontale_XOR(Debut_X+Mouse_X-1,Mouse_Y-6,3-(Debut_X+Fin_X)); - - if (Mouse_X>5) - Ligne_verticale_XOR (Mouse_X-6,Debut_Y+Mouse_Y-1,3-(Debut_Y+Fin_Y)); - - if (Mouse_X=0) && (Pos_X=0) && (Pos_Y=0) && (Pos_Y>=0) ) - Pixel(Pos_X,Pos_Y,FOND_CURSEUR[Compteur_Y][Compteur_X]); - break; - case FORME_CURSEUR_CIBLE_XOR : - Pos_X=Pinceau_X-Principal_Decalage_X; - Pos_Y=Pinceau_Y-Principal_Decalage_Y; - - Compteur_X=(Loupe_Mode)?Principal_Split:Largeur_ecran; // Largeur de la barre XOR - if ((Pos_Y=Limite_Haut)) - Ligne_horizontale_XOR(0,Pinceau_Y-Principal_Decalage_Y,Compteur_X); - - if ((Pos_X=Limite_Gauche)) - Ligne_verticale_XOR(Pinceau_X-Principal_Decalage_X,0,Menu_Ordonnee); - - if (Loupe_Mode) - { - if ((Pinceau_Y>=Limite_Haut_Zoom) && (Pinceau_Y<=Limite_visible_Bas_Zoom)) - Ligne_horizontale_XOR_Zoom(Limite_Gauche_Zoom,Pinceau_Y,Loupe_Largeur); - if ((Pinceau_X>=Limite_Gauche_Zoom) && (Pinceau_X<=Limite_visible_Droite_Zoom)) - Ligne_verticale_XOR_Zoom(Pinceau_X,Limite_Haut_Zoom,Loupe_Hauteur); - } - break; - case FORME_CURSEUR_RECTANGLE_XOR : - // !!! Cette forme ne peut pas ˆtre utilis‚e en mode Loupe !!! - Debut_X=Mouse_X-(Loupe_Largeur>>1); - Debut_Y=Mouse_Y-(Loupe_Hauteur>>1); - if (Debut_X+Loupe_Largeur>=Limite_Droite-Principal_Decalage_X) - Debut_X=Limite_Droite-Loupe_Largeur-Principal_Decalage_X+1; - if (Debut_Y+Loupe_Hauteur>=Limite_Bas-Principal_Decalage_Y) - Debut_Y=Limite_Bas-Loupe_Hauteur-Principal_Decalage_Y+1; - if (Debut_X<0) - Debut_X=0; - if (Debut_Y<0) - Debut_Y=0; - Fin_X=Debut_X+Loupe_Largeur-1; - Fin_Y=Debut_Y+Loupe_Hauteur-1; - - Ligne_horizontale_XOR(Debut_X,Debut_Y,Loupe_Largeur); - Ligne_verticale_XOR(Debut_X,Debut_Y+1,Loupe_Hauteur-2); - Ligne_verticale_XOR( Fin_X,Debut_Y+1,Loupe_Hauteur-2); - Ligne_horizontale_XOR(Debut_X, Fin_Y,Loupe_Largeur); - - Debut_X=(Mouse_X-3); - Debut_Y=(Mouse_Y-3); - Fin_X =(Mouse_X+4); - Fin_Y =(Mouse_Y+4); - if (Debut_X<0) - Debut_X=0; - if (Debut_Y<0) - Debut_Y=0; - if (Fin_X>Largeur_ecran) - Fin_X=Largeur_ecran; - if (Fin_Y>Menu_Ordonnee) - Fin_Y=Menu_Ordonnee; - - Ligne_horizontale_XOR(Debut_X,Mouse_Y,Fin_X-Debut_X); - Ligne_verticale_XOR (Mouse_X,Debut_Y,Fin_Y-Debut_Y); - break; - default: //case FORME_CURSEUR_ROTATE_XOR : - Debut_X=1-(Brosse_Largeur>>1); - Debut_Y=1-(Brosse_Hauteur>>1); - Fin_X=Debut_X+Brosse_Largeur-1; - Fin_Y=Debut_Y+Brosse_Hauteur-1; - - if (Brosse_Centre_rotation_defini) - { - if ( (Brosse_Centre_rotation_X==Pinceau_X) - && (Brosse_Centre_rotation_Y==Pinceau_Y) ) - { - cosA=1.0; - sinA=0.0; - } - else - { - Pos_X=Pinceau_X-Brosse_Centre_rotation_X; - Pos_Y=Pinceau_Y-Brosse_Centre_rotation_Y; - cosA=(float)Pos_X/sqrt((Pos_X*Pos_X)+(Pos_Y*Pos_Y)); - sinA=sin(acos(cosA)); - if (Pos_Y>0) sinA=-sinA; - } - - Transformer_point(Debut_X,Debut_Y, cosA,sinA, &X1,&Y1); - Transformer_point(Fin_X ,Debut_Y, cosA,sinA, &X2,&Y2); - Transformer_point(Debut_X,Fin_Y , cosA,sinA, &X3,&Y3); - Transformer_point(Fin_X ,Fin_Y , cosA,sinA, &X4,&Y4); - - X1+=Brosse_Centre_rotation_X; - Y1+=Brosse_Centre_rotation_Y; - X2+=Brosse_Centre_rotation_X; - Y2+=Brosse_Centre_rotation_Y; - X3+=Brosse_Centre_rotation_X; - Y3+=Brosse_Centre_rotation_Y; - X4+=Brosse_Centre_rotation_X; - Y4+=Brosse_Centre_rotation_Y; - Pixel_figure_Preview_xor(Brosse_Centre_rotation_X,Brosse_Centre_rotation_Y,0); - Tracer_ligne_Preview_xor(Brosse_Centre_rotation_X,Brosse_Centre_rotation_Y,Pinceau_X,Pinceau_Y,0); - } - else - { - X1=X3=1-Brosse_Largeur; - Y1=Y2=Debut_Y; - X2=X4=Pinceau_X; - Y3=Y4=Fin_Y; - - X1+=Pinceau_X; - Y1+=Pinceau_Y; - Y2+=Pinceau_Y; - X3+=Pinceau_X; - Y3+=Pinceau_Y; - Y4+=Pinceau_Y; - Pixel_figure_Preview_xor(Pinceau_X-Fin_X,Pinceau_Y,0); - Tracer_ligne_Preview_xor(Pinceau_X-Fin_X,Pinceau_Y,Pinceau_X,Pinceau_Y,0); - } - - Tracer_ligne_Preview_xor(X1,Y1,X2,Y2,0); - Tracer_ligne_Preview_xor(X2,Y2,X4,Y4,0); - Tracer_ligne_Preview_xor(X4,Y4,X3,Y3,0); - Tracer_ligne_Preview_xor(X3,Y3,X1,Y1,0); - } -} - - - -//---- Fenˆtre demandant de confirmer une action et renvoyant la r‚ponse ----- -byte Demande_de_confirmation(char * Message) -{ - short Bouton_clicke; - word Largeur_de_la_fenetre; - - Largeur_de_la_fenetre=(strlen(Message)<<3)+20; - - if (Largeur_de_la_fenetre<120) - Largeur_de_la_fenetre=120; - - Ouvrir_fenetre(Largeur_de_la_fenetre,60,"Confirmation"); - - Print_dans_fenetre((Largeur_de_la_fenetre>>1)-(strlen(Message)<<2),20,Message,CM_Noir,CM_Clair); - - Fenetre_Definir_bouton_normal((Largeur_de_la_fenetre/3)-20 ,37,40,14,"Yes",1,1,0x0015); // 1 - Fenetre_Definir_bouton_normal(((Largeur_de_la_fenetre<<1)/3)-20,37,40,14,"No" ,1,1,0x0031); // 2 - - Afficher_curseur(); - - do - { - Bouton_clicke=Fenetre_Bouton_clicke(); - if (Touche==0x001C) Bouton_clicke=1; - if (Touche==0x0001) Bouton_clicke=2; - } - while (Bouton_clicke<=0); - - Fermer_fenetre(); - Afficher_curseur(); - - return (Bouton_clicke==1)? 1 : 0; -} - - - -//---- Fenˆtre avertissant de quelque chose et attendant un click sur OK ----- -void Warning_message(char * Message) -{ - short Bouton_clicke; - word Largeur_de_la_fenetre; - - Largeur_de_la_fenetre=(strlen(Message)<<3)+20; - if (Largeur_de_la_fenetre<120) - Largeur_de_la_fenetre=120; - - Ouvrir_fenetre(Largeur_de_la_fenetre,60,"Warning!"); - - Print_dans_fenetre((Largeur_de_la_fenetre>>1)-(strlen(Message)<<2),20,Message,CM_Noir,CM_Clair); - Fenetre_Definir_bouton_normal((Largeur_de_la_fenetre>>1)-20 ,37,40,14,"OK",1,1,0x001C); // 1 - Afficher_curseur(); - - do - Bouton_clicke=Fenetre_Bouton_clicke(); - while ((Bouton_clicke<=0) && (Touche!=0x0001) && (Touche!=0x0018)); - - Fermer_fenetre(); - Afficher_curseur(); -} - - - -// -- Fonction diverses d'affichage ------------------------------------------ - - // -- Reafficher toute l'image (en prenant en compte le facteur de zoom) -- - -void Afficher_ecran(void) -{ - word Largeur; - word Hauteur; - - // ---/\/\/\ Partie non zoom‚e: /\/\/\--- - if (Loupe_Mode) - { - if (Principal_Largeur_image … 64 lignes fct(Menu_Facteur) - word Nb_couleurs =(Debut_block<=Fin_block)?Fin_block-Debut_block+1:Debut_block-Fin_block+1; - word Ligne_en_cours=(Debut_block<=Fin_block)?0:Total_lignes-1; - - word Debut_X =Fenetre_Pos_X+(Menu_Facteur_X*Pos_X); - word Largeur_ligne =Menu_Facteur_X<<4; // <=> … 16 pixels fct(Menu_Facteur) - - word Debut_Y =Fenetre_Pos_Y+(Menu_Facteur_Y*Pos_Y); - word Fin_Y =Debut_Y+Total_lignes; - word Indice; - - if (Debut_block>Fin_block) - { - Indice=Debut_block; - Debut_block=Fin_block; - Fin_block=Indice; - } - - for (Indice=Debut_Y;IndiceFin_X) - { - Temporaire=Debut_X; - Debut_X =Fin_X; - Fin_X =Temporaire; - } - if (Debut_Y>Fin_Y) - { - Temporaire=Debut_Y; - Debut_Y =Fin_Y; - Fin_Y =Temporaire; - } - - // On ne capture la nouvelle brosse que si elle est au moins partiellement - // dans l'image: - - if ((Debut_XPrincipal_Largeur_image) - Nouvelle_Brosse_Largeur=Principal_Largeur_image-Debut_X; - if (Debut_Y+Nouvelle_Brosse_Hauteur>Principal_Hauteur_image) - Nouvelle_Brosse_Hauteur=Principal_Hauteur_image-Debut_Y; - - if ( (((long)Brosse_Hauteur)*Brosse_Largeur) != - (((long)Nouvelle_Brosse_Hauteur)*Nouvelle_Brosse_Largeur) ) - { - free(Brosse); - Brosse=(byte *)malloc(((long)Nouvelle_Brosse_Hauteur)*Nouvelle_Brosse_Largeur); - if (!Brosse) - { - Erreur(0); - - Brosse=(byte *)malloc(1*1); - Nouvelle_Brosse_Hauteur=Nouvelle_Brosse_Largeur=1; - *Brosse=Fore_color; - } - } - Brosse_Largeur=Nouvelle_Brosse_Largeur; - Brosse_Hauteur=Nouvelle_Brosse_Hauteur; - - free(Smear_Brosse); - Smear_Brosse_Largeur=(Brosse_Largeur>TAILLE_MAXI_PINCEAU)?Brosse_Largeur:TAILLE_MAXI_PINCEAU; - Smear_Brosse_Hauteur=(Brosse_Hauteur>TAILLE_MAXI_PINCEAU)?Brosse_Hauteur:TAILLE_MAXI_PINCEAU; - Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Hauteur)*Smear_Brosse_Largeur); - - if (!Smear_Brosse) // On ne peut mˆme pas allouer la brosse du smear! - { - Erreur(0); - - free(Brosse); - Brosse=(byte *)malloc(1*1); - Brosse_Hauteur=1; - Brosse_Largeur=1; - - Smear_Brosse=(byte *)malloc(TAILLE_MAXI_PINCEAU*TAILLE_MAXI_PINCEAU); - Smear_Brosse_Hauteur=TAILLE_MAXI_PINCEAU; - Smear_Brosse_Largeur=TAILLE_MAXI_PINCEAU; - } - - Copier_image_dans_brosse(Debut_X,Debut_Y,Brosse_Largeur,Brosse_Hauteur,Principal_Largeur_image); - - // On regarde s'il faut effacer quelque chose: - if (Effacement) - { - for (Pos_Y=Debut_Y;Pos_Y>1); - Brosse_Decalage_Y=(Brosse_Hauteur>>1); - } -} - - -void Rotate_90_deg() -{ - short Temporaire; - byte * Nouvelle_Brosse; - - Nouvelle_Brosse=(byte *)malloc(((long)Brosse_Hauteur)*Brosse_Largeur); - if (Nouvelle_Brosse) - { - Rotate_90_deg_LOWLEVEL(Brosse,Nouvelle_Brosse); - free(Brosse); - Brosse=Nouvelle_Brosse; - - Temporaire=Brosse_Largeur; - Brosse_Largeur=Brosse_Hauteur; - Brosse_Hauteur=Temporaire; - - Temporaire=Smear_Brosse_Largeur; - Smear_Brosse_Largeur=Smear_Brosse_Hauteur; - Smear_Brosse_Hauteur=Temporaire; - - // On centre la prise sur la brosse - Brosse_Decalage_X=(Brosse_Largeur>>1); - Brosse_Decalage_Y=(Brosse_Hauteur>>1); - } - else - Erreur(0); -} - - -void Remap_brosse(void) -{ - short Pos_X; // Variable de balayage de la brosse - short Pos_Y; // Variable de balayage de la brosse - byte Utilisee[256]; // Tableau de bool‚ens "La couleur est utilis‚e" - int Couleur; - - - // On commence par initialiser le tableau de bool‚ens … faux - for (Couleur=0;Couleur<=255;Couleur++) - Utilisee[Couleur]=0; - - // On calcule la table d'utilisation des couleurs - for (Pos_Y=0;Pos_Y>1); - Brosse_Decalage_Y=(Brosse_Hauteur>>1); - - free(Temporaire); // Lib‚ration de l'ancienne brosse - - // R‚allocation d'un buffer de Smear - free(Smear_Brosse); - Smear_Brosse_Largeur=(Brosse_Largeur>TAILLE_MAXI_PINCEAU)?Brosse_Largeur:TAILLE_MAXI_PINCEAU; - Smear_Brosse_Hauteur=(Brosse_Hauteur>TAILLE_MAXI_PINCEAU)?Brosse_Hauteur:TAILLE_MAXI_PINCEAU; - Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Largeur)*Smear_Brosse_Hauteur); - } - else - Erreur(0); // Pas assez de m‚moire! -} - - -void Nibble_brush(void) -{ - long Pos,Pos_X,Pos_Y; - byte Etat; - byte * Nouvelle_brosse; - byte * Temporaire; - word Largeur; - word Hauteur; - - if ( (Brosse_Largeur>2) && (Brosse_Hauteur>2) ) - { - Largeur=Brosse_Largeur-2; - Hauteur=Brosse_Hauteur-2; - Nouvelle_brosse=(byte *)malloc(((long)Largeur)*Hauteur); - - if (Nouvelle_brosse) - { - // On copie la brosse courante dans la nouvelle - Copier_une_partie_d_image_dans_une_autre(Brosse, // Source - 1, - 1, - Largeur, - Hauteur, - Brosse_Largeur, - Nouvelle_brosse, // Destination - 0, - 0, - Largeur); - - // On intervertit la nouvelle et l'ancienne brosse: - Temporaire=Brosse; - Brosse=Nouvelle_brosse; - Brosse_Largeur-=2; - Brosse_Hauteur-=2; - Largeur+=2; - Hauteur+=2; - - // 1er balayage (horizontal) - for (Pos_Y=0; Pos_Y0) - Pixel_dans_brosse(Pos_X-1,Pos_Y,Back_color); - Etat=0; - } - } - else - { - if (!Etat) - { - Pixel_dans_brosse(Pos_X,Pos_Y,Back_color); - Etat=1; - } - } - } - // Cas du dernier pixel … droite de la ligne - if (Temporaire[((Pos_Y+1)*Largeur)+Pos_X+1]==Back_color) - Pixel_dans_brosse(Pos_X-1,Pos_Y,Back_color); - } - - // 2Šme balayage (vertical) - for (Pos_X=0; Pos_X0) - Pixel_dans_brosse(Pos_X,Pos_Y-1,Back_color); - Etat=0; - } - } - else - { - if (!Etat) - { - Pixel_dans_brosse(Pos_X,Pos_Y,Back_color); - Etat=1; - } - } - } - // Cas du dernier pixel en bas de la colonne - if (Temporaire[((Pos_Y+1)*Largeur)+Pos_X+1]==Back_color) - Pixel_dans_brosse(Pos_X,Pos_Y-1,Back_color); - } - - // On recentre la prise sur la brosse - Brosse_Decalage_X=(Brosse_Largeur>>1); - Brosse_Decalage_Y=(Brosse_Hauteur>>1); - - free(Temporaire); // Lib‚ration de l'ancienne brosse - - // R‚allocation d'un buffer de Smear - free(Smear_Brosse); - Smear_Brosse_Largeur=(Brosse_Largeur>TAILLE_MAXI_PINCEAU)?Brosse_Largeur:TAILLE_MAXI_PINCEAU; - Smear_Brosse_Hauteur=(Brosse_Hauteur>TAILLE_MAXI_PINCEAU)?Brosse_Hauteur:TAILLE_MAXI_PINCEAU; - Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Largeur)*Smear_Brosse_Hauteur); - } - else - Erreur(0); // Pas assez de m‚moire! - } -} - - -#include "pages.c" - - -////////////////////////////////////////////////////////////////////////////// -////////////////////////////// GESTION DU FILLER ///////////////////////////// -////////////////////////////////////////////////////////////////////////////// - - -void Fill(short * Limite_atteinte_Haut , short * Limite_atteinte_Bas, - short * Limite_atteinte_Gauche, short * Limite_atteinte_Droite) -// -// Cette fonction fait un remplissage classique d'une zone d‚limit‚e de -// l'image. Les limites employ‚es sont Limite_Haut, Limite_Bas, Limite_Gauche -// et Limite_Droite. Le point de d‚part du remplissage est Pinceau_X,Pinceau_Y -// et s'effectue en th‚orie sur la couleur 1 et emploie la couleur 2 pour le -// remplissage. Ces restrictions sont d–es … l'utilisation qu'on en fait dans -// la fonction principale "Remplir", qui se charge de faire une gestion de -// tous les effets. -// Cette fonction ne doit pas ˆtre directement appel‚e. -// -{ - short Pos_X; // Abscisse de balayage du segment, utilis‚e lors de l'"affichage" - short Ligne; // Ordonn‚e de la ligne en cours de traitement - short Debut_X; // Abscisse de d‚part du segment trait‚ - short Fin_X; // Abscisse de fin du segment trait‚ - int Modifs_effectuees; // Bool‚en "On a fait une modif dans le dernier passage" - int Propagation_possible; // Bool‚en "On peut propager la couleur dans le segment" - short Limite_courante_Bas; // Intervalle vertical restreint - short Limite_courante_Haut; - int Ligne_modifiee; // Bool‚en "On a fait une modif dans la ligne" - - Modifs_effectuees=1; - Limite_courante_Haut=Pinceau_Y; - Limite_courante_Bas =Min(Pinceau_Y+1,Limite_Bas); - *Limite_atteinte_Gauche=Pinceau_X; - *Limite_atteinte_Droite=Pinceau_X+1; - Pixel_dans_ecran_courant(Pinceau_X,Pinceau_Y,2); - - while (Modifs_effectuees) - { - Modifs_effectuees=0; - - for (Ligne=Limite_courante_Haut;Ligne<=Limite_courante_Bas;Ligne++) - { - Ligne_modifiee=0; - // On va traiter le cas de la ligne nø Ligne. - - // On commence le traitement … la gauche de l'‚cran - Debut_X=Limite_Gauche; - - // Pour chaque segment de couleur 1 que peut contenir la ligne - while (Debut_X<=Limite_Droite) - { - // On cherche son d‚but - for (;(Debut_X<=Limite_Droite) && - (Lit_pixel_dans_ecran_courant(Debut_X,Ligne)!=1);Debut_X++); - - if (Debut_X<=Limite_Droite) - { - // Un segment de couleur 1 existe et commence … la position Debut_X. - // On va donc en chercher la fin. - for (Fin_X=Debut_X+1;(Fin_X<=Limite_Droite) && - (Lit_pixel_dans_ecran_courant(Fin_X,Ligne)==1);Fin_X++); - - // On sait qu'il existe un segment de couleur 1 qui commence en - // Debut_X et qui se termine en Fin_X-1. - - // On va maintenant regarder si une couleur sur la p‚riph‚rie - // permet de colorier ce segment avec la couleur 2. - - Propagation_possible=( - // Test de la pr‚sence d'un point … gauche du segment - ((Debut_X>Limite_Gauche) && - (Lit_pixel_dans_ecran_courant(Debut_X-1,Ligne)==2)) || - // Test de la pr‚sence d'un point … droite du segment - ((Fin_X-1Limite_Haut)) - for (Pos_X=Debut_X;Pos_X*Limite_atteinte_Droite) - *Limite_atteinte_Droite=Fin_X; - // On remplit le segment de Debut_X … Fin_X-1. - for (Pos_X=Debut_X;Pos_XLimite_Haut) - Limite_courante_Haut--; - - for (Ligne=Limite_courante_Bas;Ligne>=Limite_courante_Haut;Ligne--) - { - Ligne_modifiee=0; - // On va traiter le cas de la ligne nø Ligne. - - // On commence le traitement … la gauche de l'‚cran - Debut_X=Limite_Gauche; - - // Pour chaque segment de couleur 1 que peut contenir la ligne - while (Debut_X<=Limite_Droite) - { - // On cherche son d‚but - for (;(Debut_X<=Limite_Droite) && - (Lit_pixel_dans_ecran_courant(Debut_X,Ligne)!=1);Debut_X++); - - if (Debut_X<=Limite_Droite) - { - // Un segment de couleur 1 existe et commence … la position Debut_X. - // On va donc en chercher la fin. - for (Fin_X=Debut_X+1;(Fin_X<=Limite_Droite) && - (Lit_pixel_dans_ecran_courant(Fin_X,Ligne)==1);Fin_X++); - - // On sait qu'il existe un segment de couleur 1 qui commence en - // Debut_X et qui se termine en Fin_X-1. - - // On va maintenant regarder si une couleur sur la p‚riph‚rie - // permet de colorier ce segment avec la couleur 2. - - Propagation_possible=( - // Test de la pr‚sence d'un point … gauche du segment - ((Debut_X>Limite_Gauche) && - (Lit_pixel_dans_ecran_courant(Debut_X-1,Ligne)==2)) || - // Test de la pr‚sence d'un point … droite du segment - ((Fin_X-1*Limite_atteinte_Droite) - *Limite_atteinte_Droite=Fin_X; - // On remplit le segment de Debut_X … Fin_X-1. - for (Pos_X=Debut_X;Pos_XLimite_Haut) ) - Limite_courante_Haut--; // On monte cette limite vers le haut - } - } - - *Limite_atteinte_Haut=Limite_courante_Haut; - *Limite_atteinte_Bas =Limite_courante_Bas; - (*Limite_atteinte_Droite)--; -} // Fin de la routine de remplissage "Fill" - - -void Remplir(byte Couleur_de_remplissage) -// -// Cette fonction fait un remplissage qui gŠre tous les effets. Elle fait -// appel … "Fill()". -// -{ - byte Forme_curseur_avant_remplissage; - byte * FX_Feedback_Ecran_avant_remplissage; - short Pos_X,Pos_Y; - short Limite_atteinte_Haut ,Limite_atteinte_Bas; - short Limite_atteinte_Gauche,Limite_atteinte_Droite; - byte Table_de_remplacement[256]; - - - // Avant toute chose, on v‚rifie que l'on n'est pas en train de remplir - // en dehors de l'image: - - if ( (Pinceau_X>=Limite_Gauche) && - (Pinceau_X<=Limite_Droite) && - (Pinceau_Y>=Limite_Haut) && - (Pinceau_Y<=Limite_Bas) ) - { - // On suppose que le curseur est d‚j… cach‚. - // Effacer_curseur(); - - // On va faire patienter l'utilisateur en lui affichant un joli petit - // sablier: - Forme_curseur_avant_remplissage=Forme_curseur; - Forme_curseur=FORME_CURSEUR_SABLIER; - Afficher_curseur(); - - // On commence par effectuer un backup de l'image. - Backup(); - - // On fait attention au Feedback qui DOIT se faire avec le backup. - FX_Feedback_Ecran_avant_remplissage=FX_Feedback_Ecran; - FX_Feedback_Ecran=Ecran_backup; - - // On va maintenant "‚purer" la zone visible de l'image: - memset(Table_de_remplacement,0,256); - Table_de_remplacement[Lit_pixel_dans_ecran_courant(Pinceau_X,Pinceau_Y)]=1; - Remplacer_toutes_les_couleurs_dans_limites(Table_de_remplacement); - - // On fait maintenant un remplissage classique de la couleur 1 avec la 2 - Fill(&Limite_atteinte_Haut ,&Limite_atteinte_Bas, - &Limite_atteinte_Gauche,&Limite_atteinte_Droite); - - // On s'apprˆte … faire des op‚rations qui n‚cessitent un affichage. Il - // faut donc retirer de l'‚cran le curseur: - Effacer_curseur(); - Forme_curseur=Forme_curseur_avant_remplissage; - - // Il va maintenant falloir qu'on "turn" ce gros caca "into" un truc qui - // ressemble un peu plus … ce … quoi l'utilisateur peut s'attendre. - if (Limite_atteinte_Haut>Limite_Haut) - Copier_une_partie_d_image_dans_une_autre(Ecran_backup, - Limite_Gauche,Limite_Haut, - (Limite_Droite-Limite_Gauche)+1, - Limite_atteinte_Haut-Limite_Haut, - Principal_Largeur_image,Principal_Ecran, - Limite_Gauche,Limite_Haut,Principal_Largeur_image); - if (Limite_atteinte_BasLimite_Gauche) - Copier_une_partie_d_image_dans_une_autre(Ecran_backup, - Limite_Gauche,Limite_atteinte_Haut, - Limite_atteinte_Gauche-Limite_Gauche, - (Limite_atteinte_Bas-Limite_atteinte_Haut)+1, - Principal_Largeur_image,Principal_Ecran, - Limite_Gauche,Limite_atteinte_Haut,Principal_Largeur_image); - if (Limite_atteinte_Droite=Limite_Gauche) && - (Pos_X<=Limite_Droite) && - (Pos_Y>=Limite_Haut) && - (Pos_Y<=Limite_Bas) ) - Pixel_Preview(Pos_X,Pos_Y,Couleur); - } - - // Affichage d'un point pour une preview en xor - void Pixel_figure_Preview_xor(short Pos_X,short Pos_Y,byte Couleur) - { - if ( (Pos_X>=Limite_Gauche) && - (Pos_X<=Limite_Droite) && - (Pos_Y>=Limite_Haut) && - (Pos_Y<=Limite_Bas) ) - Pixel_Preview(Pos_X,Pos_Y,~Lit_pixel(Pos_X-Principal_Decalage_X, - Pos_Y-Principal_Decalage_Y)); - } - - // Effacement d'un point de preview - void Pixel_figure_Effacer_preview(short Pos_X,short Pos_Y,byte Couleur) - { - if ( (Pos_X>=Limite_Gauche) && - (Pos_X<=Limite_Droite) && - (Pos_Y>=Limite_Haut) && - (Pos_Y<=Limite_Bas) ) - Pixel_Preview(Pos_X,Pos_Y,Lit_pixel_dans_ecran_courant(Pos_X,Pos_Y)); - } - - // Affichage d'un point dans la brosse - void Pixel_figure_Dans_brosse(short Pos_X,short Pos_Y,byte Couleur) - { - Pos_X-=Brosse_Decalage_X; - Pos_Y-=Brosse_Decalage_Y; - if ( (Pos_X>=0) && - (Pos_X=0) && - (Pos_YLimite_Bas) - Fin_Y=Limite_Bas; - if (Debut_XLimite_Droite) - Fin_X=Limite_Droite; - - // Affichage du cercle - for (Pos_Y=Debut_Y,Cercle_Curseur_Y=(long)Debut_Y-Centre_Y;Pos_Y<=Fin_Y;Pos_Y++,Cercle_Curseur_Y++) - for (Pos_X=Debut_X,Cercle_Curseur_X=(long)Debut_X-Centre_X;Pos_X<=Fin_X;Pos_X++,Cercle_Curseur_X++) - if (Pixel_dans_cercle()) - Afficher_pixel(Pos_X,Pos_Y,Couleur); -} - - - // -- Tracer g‚n‚ral d'une ellipse vide ----------------------------------- - -void Tracer_ellipse_vide_General(short Centre_X,short Centre_Y,short Rayon_horizontal,short Rayon_vertical,byte Couleur) -{ - short Debut_X; - short Debut_Y; - short Pos_X; - short Pos_Y; - - Debut_X=Centre_X-Rayon_horizontal; - Debut_Y=Centre_Y-Rayon_vertical; - - // Calcul des limites de l'ellipse - Ellipse_Calculer_limites(Rayon_horizontal+1,Rayon_vertical+1); - - // Affichage des extremit‚es de l'ellipse sur chaque quart de l'ellipse: - for (Pos_Y=Debut_Y,Ellipse_Curseur_Y=-Rayon_vertical;Pos_YLimite_Bas) - Fin_Y=Limite_Bas; - if (Debut_XLimite_Droite) - Fin_X=Limite_Droite; - - // Affichage de l'ellipse - for (Pos_Y=Debut_Y,Ellipse_Curseur_Y=Debut_Y-Centre_Y;Pos_Y<=Fin_Y;Pos_Y++,Ellipse_Curseur_Y++) - for (Pos_X=Debut_X,Ellipse_Curseur_X=Debut_X-Centre_X;Pos_X<=Fin_X;Pos_X++,Ellipse_Curseur_X++) - if (Pixel_dans_ellipse()) - Afficher_pixel(Pos_X,Pos_Y,Couleur); -} - - - // -- Tracer g‚n‚ral d'une ligne ------------------------------------------ - -void Tracer_ligne_General(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y, byte Couleur) -{ - short Pos_X,Pos_Y; - short Incr_X,Incr_Y; - short i,Cumul; - short Delta_X,Delta_Y; - - - Pos_X=Debut_X; - Pos_Y=Debut_Y; - - if (Debut_XDelta_X) - { - Cumul=Delta_Y>>1; - for (i=1; i=Delta_Y) - { - Cumul-=Delta_Y; - Pos_X+=Incr_X; - } - Pixel_figure(Pos_X,Pos_Y,Couleur); - } - } - else - { - Cumul=Delta_X>>1; - for (i=1; i=Delta_X) - { - Cumul-=Delta_X; - Pos_Y+=Incr_Y; - } - Pixel_figure(Pos_X,Pos_Y,Couleur); - } - } - - if ( (Debut_X!=Fin_X) || (Debut_Y!=Fin_Y) ) - Pixel_figure(Fin_X,Fin_Y,Couleur); -} - - // -- Tracer d‚finitif d'une ligne -- - -void Tracer_ligne_Definitif(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y, byte Couleur) -{ - Pixel_figure=Pixel_figure_Definitif; - Tracer_ligne_General(Debut_X,Debut_Y,Fin_X,Fin_Y,Couleur); -} - - // -- Tracer la preview d'une ligne -- - -void Tracer_ligne_Preview(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y,byte Couleur) -{ - Pixel_figure=Pixel_figure_Preview; - Tracer_ligne_General(Debut_X,Debut_Y,Fin_X,Fin_Y,Couleur); -} - - // -- Tracer la preview d'une ligne en xor -- - -void Tracer_ligne_Preview_xor(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y,byte Couleur) -{ - Pixel_figure=Pixel_figure_Preview_xor; - Tracer_ligne_General(Debut_X,Debut_Y,Fin_X,Fin_Y,Couleur); -} - - // -- Effacer la preview d'une ligne -- - -void Effacer_ligne_Preview(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y) -{ - Pixel_figure=Pixel_figure_Effacer_preview; - Tracer_ligne_General(Debut_X,Debut_Y,Fin_X,Fin_Y,0); -} - - - // -- Tracer un rectangle vide -- - -void Tracer_rectangle_vide(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y,byte Couleur) -{ - short Tempo; - short Pos_X; - short Pos_Y; - - - // On v‚rifie que les bornes soient dans le bon sens: - if (Debut_X>Fin_X) - { - Tempo=Debut_X; - Debut_X=Fin_X; - Fin_X=Tempo; - } - if (Debut_Y>Fin_Y) - { - Tempo=Debut_Y; - Debut_Y=Fin_Y; - Fin_Y=Tempo; - } - - // On trace le rectangle: - - for (Pos_X=Debut_X;Pos_X<=Fin_X;Pos_X++) - Afficher_pinceau(Pos_X,Debut_Y,Couleur,0); - - for (Pos_Y=Debut_Y+1;Pos_YFin_X) - { - Tempo=Debut_X; - Debut_X=Fin_X; - Fin_X=Tempo; - } - if (Debut_Y>Fin_Y) - { - Tempo=Debut_Y; - Debut_Y=Fin_Y; - Fin_Y=Tempo; - } - - // Correction en cas de d‚passement des limites de l'image - if (Fin_X>Limite_Droite) - Fin_X=Limite_Droite; - if (Fin_Y>Limite_Bas) - Fin_Y=Limite_Bas; - - // On trace le rectangle: - for (Pos_Y=Debut_Y;Pos_Y<=Fin_Y;Pos_Y++) - for (Pos_X=Debut_X;Pos_X<=Fin_X;Pos_X++) - Afficher_pixel(Pos_X,Pos_Y,Couleur); -} - - - - - // -- Tracer une courbe de B‚zier -- - -void Tracer_courbe_General(short X1, short Y1, - short X2, short Y2, - short X3, short Y3, - short X4, short Y4, - byte Couleur) -{ - float Delta,T,T2,T3; - short X,Y,Old_X,Old_Y; - word i; - int CX[4]; - int CY[4]; - - // Calcul des vecteurs de coefficients - CX[0]= - X1 + 3*X2 - 3*X3 + X4; - CX[1]= + 3*X1 - 6*X2 + 3*X3; - CX[2]= - 3*X1 + 3*X2; - CX[3]= + X1; - CY[0]= - Y1 + 3*Y2 - 3*Y3 + Y4; - CY[1]= + 3*Y1 - 6*Y2 + 3*Y3; - CY[2]= - 3*Y1 + 3*Y2; - CY[3]= + Y1; - - // Tra‡age de la courbe - Old_X=X1; - Old_Y=Y1; - Pixel_figure(Old_X,Old_Y,Couleur); - Delta=0.05; // 1.0/20 - T=0; - for (i=1; i<=20; i++) - { - T=T+Delta; T2=T*T; T3=T2*T; - X=Round(T3*CX[0] + T2*CX[1] + T*CX[2] + CX[3]); - Y=Round(T3*CY[0] + T2*CY[1] + T*CY[2] + CY[3]); - Tracer_ligne_General(Old_X,Old_Y,X,Y,Couleur); - Old_X=X; - Old_Y=Y; - } -} - - // -- Tracer une courbe de B‚zier d‚finitivement -- - -void Tracer_courbe_Definitif(short X1, short Y1, - short X2, short Y2, - short X3, short Y3, - short X4, short Y4, - byte Couleur) -{ - Pixel_figure=Pixel_figure_Definitif; - Tracer_courbe_General(X1,Y1,X2,Y2,X3,Y3,X4,Y4,Couleur); -} - - // -- Tracer la preview d'une courbe de B‚zier -- - -void Tracer_courbe_Preview(short X1, short Y1, - short X2, short Y2, - short X3, short Y3, - short X4, short Y4, - byte Couleur) -{ - Pixel_figure=Pixel_figure_Preview; - Tracer_courbe_General(X1,Y1,X2,Y2,X3,Y3,X4,Y4,Couleur); -} - - // -- Effacer la preview d'une courbe de B‚zier -- - -void Effacer_courbe_Preview(short X1, short Y1, - short X2, short Y2, - short X3, short Y3, - short X4, short Y4, - byte Couleur) -{ - Pixel_figure=Pixel_figure_Effacer_preview; - Tracer_courbe_General(X1,Y1,X2,Y2,X3,Y3,X4,Y4,Couleur); -} - - - - - // -- Spray : un petit coup de Pschiitt! -- - -void Aerographe(short Bouton_clicke) -{ - short Pos_X,Pos_Y; - short Rayon=Spray_Size>>1; - long Rayon_au_carre=(long)Rayon*Rayon; - short Indice,Count; - byte Indice_couleur; - byte Sens; - - - Effacer_curseur(); - - if (Spray_Mode) - { - for (Count=1; Count<=Spray_Mono_flow; Count++) - { - Pos_X=(rand()%Spray_Size)-Rayon; - Pos_Y=(rand()%Spray_Size)-Rayon; - if ( (Pos_X*Pos_X)+(Pos_Y*Pos_Y) <= Rayon_au_carre ) - { - Pos_X+=Pinceau_X; - Pos_Y+=Pinceau_Y; - if (Bouton_clicke==1) - Afficher_pinceau(Pos_X,Pos_Y,Fore_color,0); - else - Afficher_pinceau(Pos_X,Pos_Y,Back_color,0); - } - } - } - else - { - // On essaye de se balader dans la table des flux de fa‡on … ce que ce - // ne soit pas toujours la derniŠre couleur qui soit affich‚e en dernier - // Pour ‡a, on part d'une couleur au pif dans une direction al‚atoire. - Sens=rand()&1; - for (Indice=0,Indice_couleur=rand()/*%256*/; Indice<256; Indice++) - { - for (Count=1; Count<=Spray_Multi_flow[Indice_couleur]; Count++) - { - Pos_X=(rand()%Spray_Size)-Rayon; - Pos_Y=(rand()%Spray_Size)-Rayon; - if ( (Pos_X*Pos_X)+(Pos_Y*Pos_Y) <= Rayon_au_carre ) - { - Pos_X+=Pinceau_X; - Pos_Y+=Pinceau_Y; - if (Bouton_clicke==A_GAUCHE) - Afficher_pinceau(Pos_X,Pos_Y,Indice_couleur,0); - else - Afficher_pinceau(Pos_X,Pos_Y,Back_color,0); - } - } - if (Sens) - Indice_couleur++; - else - Indice_couleur--; - } - } - - Afficher_curseur(); - - for (Count=1; Count<=Spray_Delay; Count++) - Wait_VBL(); -} - - - - ////////////////////////////////////////////////////////////////////////// - ////////////////////////// GESTION DES DEGRADES ////////////////////////// - ////////////////////////////////////////////////////////////////////////// - - - // -- Gestion d'un d‚grad‚ de base (le plus moche) -- - -void Degrade_de_base(long Indice,short Pos_X,short Pos_Y) -{ - long Position; - - // On fait un premier calcul partiel - Position=(Indice*Degrade_Intervalle_bornes); - - // On gŠre un d‚placement au hasard - Position+=(Degrade_Intervalle_total*(rand()%Degrade_Melange_aleatoire)) >>6; - Position-=(Degrade_Intervalle_total*Degrade_Melange_aleatoire) >>7; - - Position/=Degrade_Intervalle_total; - - // On va v‚rifier que nos petites idioties n'ont pas ‚ject‚ la valeur hors - // des valeurs autoris‚es par le d‚grad‚ d‚fini par l'utilisateur. - - if (Position<0) - Position=0; - else if (Position>=Degrade_Intervalle_bornes) - Position=Degrade_Intervalle_bornes-1; - - // On ramŠne ensuite la position dans le d‚grad‚ vers un num‚ro de couleur - if (Degrade_Inverse) - Traiter_pixel_de_degrade(Pos_X,Pos_Y,Degrade_Borne_Superieure-Position); - else - Traiter_pixel_de_degrade(Pos_X,Pos_Y,Degrade_Borne_Inferieure+Position); -} - - - // -- Gestion d'un d‚grad‚ par trames simples -- - -void Degrade_de_trames_simples(long Indice,short Pos_X,short Pos_Y) -{ - long Position_dans_degrade; - long Position_dans_segment; - - // - // But de l'op‚ration: en plus de calculer la position de base (d‚sign‚e - // dans cette proc‚dure par "Position_dans_degrade", on calcule la position - // de l'indice dans le sch‚ma suivant: - // - // Ú Les indices qui traŒnent de ce c“t‚ du segment se voient subir - // ³ une incr‚mentation conditionnelle … leur position dans l'‚cran. - // v - // ÃÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄúúú ú ú - // ^ - // ÀÄ Les indices qui traŒnent de ce c“t‚ du segment se voient subir une - // d‚cr‚mentation conditionnelle … leur position dans l'‚cran. - - // On fait d'abord un premier calcul partiel - Position_dans_degrade=(Indice*Degrade_Intervalle_bornes); - - // On gŠre un d‚placement au hasard... - Position_dans_degrade+=(Degrade_Intervalle_total*(rand()%Degrade_Melange_aleatoire)) >>6; - Position_dans_degrade-=(Degrade_Intervalle_total*Degrade_Melange_aleatoire) >>7; - - if (Position_dans_degrade<0) - Position_dans_degrade=0; - - // ... qui nous permet de calculer la position dans le segment - Position_dans_segment=((Position_dans_degrade<<2)/Degrade_Intervalle_total)&3; - - // On peut ensuite terminer le calcul de l'indice dans le d‚grad‚ - Position_dans_degrade/=Degrade_Intervalle_total; - - // On va pouvoir discuter de la valeur de Position_dans_degrade en fonction - // de la position dans l'‚cran et de la Position_dans_segment. - - switch (Position_dans_segment) - { - case 0 : // On est sur la gauche du segment - if (((Pos_X+Pos_Y)&1)==0) - Position_dans_degrade--; - break; - - // On n'a pas … traiter les cas 1 et 2 car ils repr‚sentent des valeurs - // suffisament au centre du segment pour ne pas avoir … subir la trame - - case 3 : // On est sur la droite du segment - if (((Pos_X+Pos_Y)&1)!=0) // Note: on doit faire le test inverse au cas gauche pour synchroniser les 2 c“t‚s de la trame. - Position_dans_degrade++; - } - - // On va v‚rifier que nos petites idioties n'ont pas ‚ject‚ la valeur hors - // des valeurs autoris‚es par le d‚grad‚ d‚fini par l'utilisateur. - - if (Position_dans_degrade<0) - Position_dans_degrade=0; - else if (Position_dans_degrade>=Degrade_Intervalle_bornes) - Position_dans_degrade=Degrade_Intervalle_bornes-1; - - // On ramŠne ensuite la position dans le d‚grad‚ vers un num‚ro de couleur - if (Degrade_Inverse) - Position_dans_degrade=Degrade_Borne_Superieure-Position_dans_degrade; - else - Position_dans_degrade=Degrade_Borne_Inferieure+Position_dans_degrade; - - Traiter_pixel_de_degrade(Pos_X,Pos_Y,Position_dans_degrade); -} - - - // -- Gestion d'un d‚grad‚ par trames ‚tendues -- - -void Degrade_de_trames_etendues(long Indice,short Pos_X,short Pos_Y) -{ - long Position_dans_degrade; - long Position_dans_segment; - - // - // But de l'op‚ration: en plus de calculer la position de base (d‚sign‚e - // dans cette proc‚dure par "Position_dans_degrade", on calcule la position - // de l'indice dans le sch‚ma suivant: - // - // Ú Les indices qui traŒnent de ce c“t‚ du segment se voient subir - // ³ une incr‚mentation conditionnelle … leur position dans l'‚cran. - // v - // ÃÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄúúú ú ú - // ^ - // ÀÄ Les indices qui traŒnent de ce c“t‚ du segment se voient subir une - // d‚cr‚mentation conditionnelle … leur position dans l'‚cran. - - // On fait d'abord un premier calcul partiel - Position_dans_degrade=(Indice*Degrade_Intervalle_bornes); - - // On gŠre un d‚placement au hasard - Position_dans_degrade+=(Degrade_Intervalle_total*(rand()%Degrade_Melange_aleatoire)) >>6; - Position_dans_degrade-=(Degrade_Intervalle_total*Degrade_Melange_aleatoire) >>7; - - if (Position_dans_degrade<0) - Position_dans_degrade=0; - - // Qui nous permet de calculer la position dans le segment - Position_dans_segment=((Position_dans_degrade<<3)/Degrade_Intervalle_total)&7; - - // On peut ensuite terminer le calcul de l'indice dans le d‚grad‚ - Position_dans_degrade/=Degrade_Intervalle_total; - - // On va pouvoir discuter de la valeur de Position_dans_degrade en fonction - // de la position dans l'‚cran et de la Position_dans_segment. - - switch (Position_dans_segment) - { - case 0 : // On est sur l'extrˆme gauche du segment - if (((Pos_X+Pos_Y)&1)==0) - Position_dans_degrade--; - break; - - case 1 : // On est sur la gauche du segment - case 2 : // On est sur la gauche du segment - if (((Pos_X & 1)==0) && ((Pos_Y & 1)==0)) - Position_dans_degrade--; - break; - - // On n'a pas … traiter les cas 3 et 4 car ils repr‚sentent des valeurs - // suffisament au centre du segment pour ne pas avoir … subir la trame - - case 5 : // On est sur la droite du segment - case 6 : // On est sur la droite du segment - if (((Pos_X & 1)==0) && ((Pos_Y & 1)!=0)) - Position_dans_degrade++; - break; - - case 7 : // On est sur l'extreme droite du segment - if (((Pos_X+Pos_Y)&1)!=0) // Note: on doit faire le test inverse au cas gauche pour synchroniser les 2 c“t‚s de la trame. - Position_dans_degrade++; - } - - // On va v‚rifier que nos petites idioties n'ont pas ‚ject‚ la valeur hors - // des valeurs autoris‚es par le d‚grad‚ d‚fini par l'utilisateur. - - if (Position_dans_degrade<0) - Position_dans_degrade=0; - else if (Position_dans_degrade>=Degrade_Intervalle_bornes) - Position_dans_degrade=Degrade_Intervalle_bornes-1; - - // On ramŠne ensuite la position dans le d‚grad‚ vers un num‚ro de couleur - if (Degrade_Inverse) - Position_dans_degrade=Degrade_Borne_Superieure-Position_dans_degrade; - else - Position_dans_degrade=Degrade_Borne_Inferieure+Position_dans_degrade; - - Traiter_pixel_de_degrade(Pos_X,Pos_Y,Position_dans_degrade); -} - - - - - - - - // -- Tracer un cercle degrad‚ (une sphŠre) -- - -void Tracer_cercle_degrade(short Centre_X,short Centre_Y,short Rayon,short Eclairage_X,short Eclairage_Y) -{ - long Debut_X; - long Debut_Y; - long Pos_X; - long Pos_Y; - long Fin_X; - long Fin_Y; - long Distance_X; // Distance (au carr‚) sur les X du point en cours au centre d'‚clairage - long Distance_Y; // Distance (au carr‚) sur les Y du point en cours au centre d'‚clairage - - Debut_X=Centre_X-Rayon; - Debut_Y=Centre_Y-Rayon; - Fin_X=Centre_X+Rayon; - Fin_Y=Centre_Y+Rayon; - - // Correction des bornes d'aprŠs les limites - if (Debut_YLimite_Bas) - Fin_Y=Limite_Bas; - if (Debut_XLimite_Droite) - Fin_X=Limite_Droite; - - Degrade_Intervalle_total=Cercle_Limite+ - ((Centre_X-Eclairage_X)*(Centre_X-Eclairage_X))+ - ((Centre_Y-Eclairage_Y)*(Centre_Y-Eclairage_Y))+ - (2L*Rayon*sqrt( - ((Centre_X-Eclairage_X)*(Centre_X-Eclairage_X))+ - ((Centre_Y-Eclairage_Y)*(Centre_Y-Eclairage_Y)))); - - if (Degrade_Intervalle_total==0) - Degrade_Intervalle_total=1; - - // Affichage du cercle - for (Pos_Y=Debut_Y,Cercle_Curseur_Y=(long)Debut_Y-Centre_Y;Pos_Y<=Fin_Y;Pos_Y++,Cercle_Curseur_Y++) - { - Distance_Y =(Pos_Y-Eclairage_Y); - Distance_Y*=Distance_Y; - for (Pos_X=Debut_X,Cercle_Curseur_X=(long)Debut_X-Centre_X;Pos_X<=Fin_X;Pos_X++,Cercle_Curseur_X++) - if (Pixel_dans_cercle()) - { - Distance_X =(Pos_X-Eclairage_X); - Distance_X*=Distance_X; - Traiter_degrade(Distance_X+Distance_Y,Pos_X,Pos_Y); - } - } -} - - - // -- Tracer une ellipse degrad‚e -- - -void Tracer_ellipse_degradee(short Centre_X,short Centre_Y,short Rayon_horizontal,short Rayon_vertical,short Eclairage_X,short Eclairage_Y) -{ - long Debut_X; - long Debut_Y; - long Pos_X; - long Pos_Y; - long Fin_X; - long Fin_Y; - long Distance_X; // Distance (au carr‚) sur les X du point en cours au centre d'‚clairage - long Distance_Y; // Distance (au carr‚) sur les Y du point en cours au centre d'‚clairage - - - Debut_X=Centre_X-Rayon_horizontal; - Debut_Y=Centre_Y-Rayon_vertical; - Fin_X=Centre_X+Rayon_horizontal; - Fin_Y=Centre_Y+Rayon_vertical; - - // Calcul des limites de l'ellipse - Ellipse_Calculer_limites(Rayon_horizontal+1,Rayon_vertical+1); - - // On calcule la distance maximale: - Degrade_Intervalle_total=(Rayon_horizontal*Rayon_horizontal)+ - (Rayon_vertical*Rayon_vertical)+ - ((Centre_X-Eclairage_X)*(Centre_X-Eclairage_X))+ - ((Centre_Y-Eclairage_Y)*(Centre_Y-Eclairage_Y))+ - (2L - *sqrt( - (Rayon_horizontal*Rayon_horizontal)+ - (Rayon_vertical *Rayon_vertical )) - *sqrt( - ((Centre_X-Eclairage_X)*(Centre_X-Eclairage_X))+ - ((Centre_Y-Eclairage_Y)*(Centre_Y-Eclairage_Y)))); - - if (Degrade_Intervalle_total==0) - Degrade_Intervalle_total=1; - - // Correction des bornes d'aprŠs les limites - if (Debut_YLimite_Bas) - Fin_Y=Limite_Bas; - if (Debut_XLimite_Droite) - Fin_X=Limite_Droite; - - // Affichage de l'ellipse - for (Pos_Y=Debut_Y,Ellipse_Curseur_Y=Debut_Y-Centre_Y;Pos_Y<=Fin_Y;Pos_Y++,Ellipse_Curseur_Y++) - { - Distance_Y =(Pos_Y-Eclairage_Y); - Distance_Y*=Distance_Y; - for (Pos_X=Debut_X,Ellipse_Curseur_X=Debut_X-Centre_X;Pos_X<=Fin_X;Pos_X++,Ellipse_Curseur_X++) - if (Pixel_dans_ellipse()) - { - Distance_X =(Pos_X-Eclairage_X); - Distance_X*=Distance_X; - Traiter_degrade(Distance_X+Distance_Y,Pos_X,Pos_Y); - } - } -} - - - - - - - - // -- Tracer un polyg“ne plein -- - -typedef struct POLYGON_EDGE /* an active edge */ -{ - short top; /* top y position */ - short bottom; /* bottom y position */ - float x, dx; /* floating point x position and gradient */ - float w; /* width of line segment */ - struct POLYGON_EDGE *prev; /* doubly linked list */ - struct POLYGON_EDGE *next; -} POLYGON_EDGE; - - - -/* fill_edge_structure: - * Polygon helper function: initialises an edge structure for the 2d - * rasteriser. - */ -void fill_edge_structure(POLYGON_EDGE *edge, short *i1, short *i2) -{ - short *it; - - if (i2[1] < i1[1]) - { - it = i1; - i1 = i2; - i2 = it; - } - - edge->top = i1[1]; - edge->bottom = i2[1] - 1; - edge->dx = ((float) i2[0] - (float) i1[0]) / ((float) i2[1] - (float) i1[1]); - edge->x = i1[0] + 0.4999999; - edge->prev = NULL; - edge->next = NULL; - - if (edge->dx+1 < 0.0) - edge->x += edge->dx+1; - - if (edge->dx >= 0.0) - edge->w = edge->dx; - else - edge->w = -(edge->dx); - - if (edge->w-1.0<0.0) - edge->w = 0.0; - else - edge->w = edge->w-1; -} - - - -/* add_edge: - * Adds an edge structure to a linked list, returning the new head pointer. - */ -POLYGON_EDGE * add_edge(POLYGON_EDGE *list, POLYGON_EDGE *edge, int sort_by_x) -{ - POLYGON_EDGE *pos = list; - POLYGON_EDGE *prev = NULL; - - if (sort_by_x) - { - while ( (pos) && ((pos->x+((pos->w+pos->dx)/2)) < (edge->x+((edge->w+edge->dx)/2))) ) - { - prev = pos; - pos = pos->next; - } - } - else - { - while ((pos) && (pos->top < edge->top)) - { - prev = pos; - pos = pos->next; - } - } - - edge->next = pos; - edge->prev = prev; - - if (pos) - pos->prev = edge; - - if (prev) - { - prev->next = edge; - return list; - } - else - return edge; -} - - - -/* remove_edge: - * Removes an edge structure from a list, returning the new head pointer. - */ -POLYGON_EDGE * remove_edge(POLYGON_EDGE *list, POLYGON_EDGE *edge) -{ - if (edge->next) - edge->next->prev = edge->prev; - - if (edge->prev) - { - edge->prev->next = edge->next; - return list; - } - else - return edge->next; -} - - - -/* polygon: - * Draws a filled polygon with an arbitrary number of corners. Pass the - * number of vertices, then an array containing a series of x, y points - * (a total of vertices*2 values). - */ -void Polyfill_General(int Vertices, short * Points, int Color) -{ - short c; - short top = 0x7FFF; - short bottom = 0; - short *i1, *i2; - short Pos_X,Fin_X; - POLYGON_EDGE *edge, *next_edge, *initial_edge; - POLYGON_EDGE *active_edges = NULL; - POLYGON_EDGE *inactive_edges = NULL; - - - /* allocate some space and fill the edge table */ - initial_edge=edge=(POLYGON_EDGE *) malloc(sizeof(POLYGON_EDGE) * Vertices); - - i1 = Points; - i2 = Points + ((Vertices-1)<<1); - - for (c=0; cbottom >= edge->top) - { - if (edge->top < top) - top = edge->top; - - if (edge->bottom > bottom) - bottom = edge->bottom; - - inactive_edges = add_edge(inactive_edges, edge, 0); - edge++; - } - } - i2 = i1; - i1 += 2; - } - - /* for each scanline in the polygon... */ - for (c=top; c<=bottom; c++) - { - /* check for newly active edges */ - edge = inactive_edges; - while ((edge) && (edge->top == c)) - { - next_edge = edge->next; - inactive_edges = remove_edge(inactive_edges, edge); - active_edges = add_edge(active_edges, edge, 1); - edge = next_edge; - } - - /* draw horizontal line segments */ - if ((c>=Limite_Haut) && (c<=Limite_Bas)) - { - edge = active_edges; - while ((edge) && (edge->next)) - { - Pos_X=/*Round*/(edge->x); - Fin_X=/*Round*/(edge->next->x+edge->next->w); - if (Pos_XLimite_Droite) - Fin_X=Limite_Droite; - for (; Pos_X<=Fin_X; Pos_X++) - Pixel_figure(Pos_X,c,Color); - edge = edge->next->next; - } - } - - /* update edges, sorting and removing dead ones */ - edge = active_edges; - while (edge) - { - next_edge = edge->next; - if (c >= edge->bottom) - active_edges = remove_edge(active_edges, edge); - else - { - edge->x += edge->dx; - while ((edge->prev) && ( (edge->x+(edge->w/2)) < (edge->prev->x+(edge->prev->w/2))) ) - { - if (edge->next) - edge->next->prev = edge->prev; - edge->prev->next = edge->next; - edge->next = edge->prev; - edge->prev = edge->prev->prev; - edge->next->prev = edge; - if (edge->prev) - edge->prev->next = edge; - else - active_edges = edge; - } - } - edge = next_edge; - } - } - - free(initial_edge); -} - - -void Polyfill(int Vertices, short * Points, int Color) -{ - Pixel_figure=Afficher_pixel; - Polyfill_General(Vertices,Points,Color); -} - - - -void Capturer_brosse_au_lasso(int Vertices, short * Points,short Effacement) -{ - short Debut_X=Limite_Droite+1; - short Debut_Y=Limite_Bas+1; - short Fin_X=Limite_Gauche-1; - short Fin_Y=Limite_Haut-1; - short Temporaire; - short Pos_X; - short Pos_Y; - word Nouvelle_Brosse_Largeur; - word Nouvelle_Brosse_Hauteur; - - - // On recherche les bornes de la brosse: - for (Temporaire=0; TemporaireFin_X) - Fin_X=Pos_X; - if (Pos_YFin_Y) - Fin_Y=Pos_Y; - } - - // On clippe ces bornes … l'‚cran: - if (Debut_XLimite_Droite) - Fin_X=Limite_Droite; - if (Debut_YLimite_Bas) - Fin_Y=Limite_Bas; - - // On ne capture la nouvelle brosse que si elle est au moins partiellement - // dans l'image: - - if ((Debut_XTAILLE_MAXI_PINCEAU)?Brosse_Largeur:TAILLE_MAXI_PINCEAU; - Smear_Brosse_Hauteur=(Brosse_Hauteur>TAILLE_MAXI_PINCEAU)?Brosse_Hauteur:TAILLE_MAXI_PINCEAU; - Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Hauteur)*Smear_Brosse_Largeur); - - if (!Smear_Brosse) // On ne peut mˆme pas allouer la brosse du smear! - { - Erreur(0); - - free(Brosse); - Brosse=(byte *)malloc(1*1); - Brosse_Hauteur=1; - Brosse_Largeur=1; - - Smear_Brosse=(byte *)malloc(TAILLE_MAXI_PINCEAU*TAILLE_MAXI_PINCEAU); - Smear_Brosse_Hauteur=TAILLE_MAXI_PINCEAU; - Smear_Brosse_Largeur=TAILLE_MAXI_PINCEAU; - } - - Brosse_Decalage_X=Debut_X; - Brosse_Decalage_Y=Debut_Y; - Pixel_figure=Pixel_figure_Dans_brosse; - - memset(Brosse,Back_color,(long)Brosse_Largeur*Brosse_Hauteur); - Polyfill_General(Vertices,Points,~Back_color); - - // On retrace les bordures du lasso: - for (Temporaire=1; Temporaire>1); - Brosse_Decalage_Y=(Brosse_Hauteur>>1); - } -} - - - -//------------ Remplacement de la couleur point‚e par une autre -------------- - -void Remplacer(byte Nouvelle_couleur) -{ - byte Ancienne_couleur; - - if ((Pinceau_X=0) - Pos_X_initial = 0; // Pas d'inversion en X de la brosse - else - Pos_X_initial = (Brosse_Largeur<<16)-1; // Inversion en X de la brosse - - free(Smear_Brosse); // On libŠre un peu de m‚moire - - if (New_Brosse=(byte *)malloc(New_Brosse_Largeur*New_Brosse_Hauteur)) - { - Offset=0; - - // Calcul de la valeur initiale de Pos_Y: - if (Dy>=0) - Pos_Y_dans_brosse=0; // Pas d'inversion en Y de la brosse - else - Pos_Y_dans_brosse=(Brosse_Hauteur<<16)-1; // Inversion en Y de la brosse - - // Pour chaque ligne - for (Ligne=0;Ligne>16,Pos_Y_dans_brosse>>16); - // On passe … la colonne de brosse suivante: - Pos_X_dans_brosse+=Delta_X_dans_brosse; - // On passe au pixel suivant de la nouvelle brosse: - Offset++; - } - - // On passe … la ligne de brosse suivante: - Pos_Y_dans_brosse+=Delta_Y_dans_brosse; - } - - free(Brosse); - Brosse=New_Brosse; - - Brosse_Largeur=New_Brosse_Largeur; - Brosse_Hauteur=New_Brosse_Hauteur; - - Smear_Brosse_Largeur=(Brosse_Largeur>TAILLE_MAXI_PINCEAU)?Brosse_Largeur:TAILLE_MAXI_PINCEAU; - Smear_Brosse_Hauteur=(Brosse_Hauteur>TAILLE_MAXI_PINCEAU)?Brosse_Hauteur:TAILLE_MAXI_PINCEAU; - Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Hauteur)*Smear_Brosse_Largeur); - - if (!Smear_Brosse) // On ne peut mˆme pas allouer la brosse du smear! - { - Erreur(0); - - free(Brosse); - Brosse=(byte *)malloc(1*1); - Brosse_Hauteur=1; - Brosse_Largeur=1; - - Smear_Brosse=(byte *)malloc(TAILLE_MAXI_PINCEAU*TAILLE_MAXI_PINCEAU); - Smear_Brosse_Hauteur=TAILLE_MAXI_PINCEAU; - Smear_Brosse_Largeur=TAILLE_MAXI_PINCEAU; - } - - Brosse_Decalage_X=(Brosse_Largeur>>1); - Brosse_Decalage_Y=(Brosse_Hauteur>>1); - } - else - { - // Ici la lib‚ration de m‚moire n'a pas suffit donc on remet dans l'‚tat - // o— c'etait avant. On a juste … r‚allouer la Smear_Brosse car il y a - // normalement la place pour elle puisque rien d'autre n'a pu ˆtre allou‚ - // entre temps. - Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Hauteur)*Smear_Brosse_Largeur); - Erreur(0); - } -} - - - -void Etirer_brosse_preview(short X1, short Y1, short X2, short Y2) -{ - int Pos_X_src,Pos_Y_src; - int Pos_X_src_Initiale,Pos_Y_src_Initiale; - int Delta_X,Delta_Y; - int Pos_X_dest,Pos_Y_dest; - int Pos_X_dest_Initiale,Pos_Y_dest_Initiale; - int Pos_X_dest_Finale,Pos_Y_dest_Finale; - int Largeur_dest,Hauteur_dest; - byte Couleur; - - - // 1er calcul des positions destination extremes: - Pos_X_dest_Initiale=Min(X1,X2); - Pos_Y_dest_Initiale=Min(Y1,Y2); - Pos_X_dest_Finale =Max(X1,X2); - Pos_Y_dest_Finale =Max(Y1,Y2); - - // Calcul des dimensions de la destination: - Largeur_dest=Pos_X_dest_Finale-Pos_X_dest_Initiale+1; - Hauteur_dest=Pos_Y_dest_Finale-Pos_Y_dest_Initiale+1; - - // Calcul des vecteurs d'incr‚mentation : - Delta_X=(Brosse_Largeur<<16)/Largeur_dest; - Delta_Y=(Brosse_Hauteur<<16)/Hauteur_dest; - - // 1er calcul de la position X initiale dans la source: - Pos_X_src_Initiale=(Brosse_Largeur<<16)* - (Max(Pos_X_dest_Initiale,Limite_Gauche)- - Pos_X_dest_Initiale)/Largeur_dest; - // Calcul du clip de la destination: - Pos_X_dest_Initiale=Max(Pos_X_dest_Initiale,Limite_Gauche); - Pos_X_dest_Finale =Min(Pos_X_dest_Finale ,Limite_visible_Droite); - // On discute selon l'inversion en X - if (X1>X2) - { - // Inversion -> Inversion du signe de Delta_X - Delta_X=-Delta_X; - Pos_X_src_Initiale=(Brosse_Largeur<<16)-1-Pos_X_src_Initiale; - } - - // 1er calcul de la position Y initiale dans la source: - Pos_Y_src_Initiale=(Brosse_Hauteur<<16)* - (Max(Pos_Y_dest_Initiale,Limite_Haut)- - Pos_Y_dest_Initiale)/Hauteur_dest; - // Calcul du clip de la destination: - Pos_Y_dest_Initiale=Max(Pos_Y_dest_Initiale,Limite_Haut); - Pos_Y_dest_Finale =Min(Pos_Y_dest_Finale ,Limite_visible_Bas); - // On discute selon l'inversion en Y - if (Y1>Y2) - { - // Inversion -> Inversion du signe de Delta_Y - Delta_Y=-Delta_Y; - Pos_Y_src_Initiale=(Brosse_Hauteur<<16)-1-Pos_Y_src_Initiale; - } - - // Pour chaque ligne : - Pos_Y_src=Pos_Y_src_Initiale; - for (Pos_Y_dest=Pos_Y_dest_Initiale;Pos_Y_dest<=Pos_Y_dest_Finale;Pos_Y_dest++) - { - // Pour chaque colonne: - Pos_X_src=Pos_X_src_Initiale; - for (Pos_X_dest=Pos_X_dest_Initiale;Pos_X_dest<=Pos_X_dest_Finale;Pos_X_dest++) - { - Couleur=Lit_pixel_dans_brosse(Pos_X_src>>16,Pos_Y_src>>16); - if (Couleur!=Back_color) - Pixel_Preview(Pos_X_dest,Pos_Y_dest,Couleur); - - Pos_X_src+=Delta_X; - } - - Pos_Y_src+=Delta_Y; - } -} - - - -//------------------------- Rotation de la brosse --------------------------- - -#define INDEFINI (-1.0e20F) -float * ScanY_Xt[2]; -float * ScanY_Yt[2]; -float * ScanY_X[2]; - - -void Interpoler_texture(int Debut_X,int Debut_Y,int Xt1,int Yt1, - int Fin_X ,int Fin_Y ,int Xt2,int Yt2,int Hauteur) -{ - int Pos_X,Pos_Y; - int Incr_X,Incr_Y; - int i,Cumul; - int Delta_X,Delta_Y; - int Delta_Xt=Xt2-Xt1; - int Delta_Yt=Yt2-Yt1; - int Delta_X2=Fin_X-Debut_X; - int Delta_Y2=Fin_Y-Debut_Y; - float Xt,Yt; - - - Pos_X=Debut_X; - Pos_Y=Debut_Y; - - if (Debut_XDelta_Y) - { - Cumul=Delta_X>>1; - for (i=0; i<=Delta_X; i++) - { - if (Cumul>=Delta_X) - { - Cumul-=Delta_X; - Pos_Y+=Incr_Y; - } - - if ((Pos_Y>=0) && (Pos_Y=ScanY_X[0][Pos_Y]) - { - if ((ScanY_X[1][Pos_Y]==INDEFINI) // Droit non d‚fini - || (Pos_X>ScanY_X[1][Pos_Y])) - { - ScanY_X[1][Pos_Y]=Pos_X; - ScanY_Xt[1][Pos_Y]=Xt; - ScanY_Yt[1][Pos_Y]=Yt; - } - } - else - { - if (ScanY_X[1][Pos_Y]==INDEFINI) // Droit non d‚fini - { - ScanY_X[1][Pos_Y]=ScanY_X[0][Pos_Y]; - ScanY_Xt[1][Pos_Y]=ScanY_Xt[0][Pos_Y]; - ScanY_Yt[1][Pos_Y]=ScanY_Yt[0][Pos_Y]; - ScanY_X[0][Pos_Y]=Pos_X; - ScanY_Xt[0][Pos_Y]=Xt; - ScanY_Yt[0][Pos_Y]=Yt; - } - else - { - ScanY_X[0][Pos_Y]=Pos_X; - ScanY_Xt[0][Pos_Y]=Xt; - ScanY_Yt[0][Pos_Y]=Yt; - } - } - } - } - Pos_X+=Incr_X; - Cumul+=Delta_Y; - } - } - else - { - Cumul=Delta_Y>>1; - for (i=0; i<=Delta_Y; i++) - { - if (Cumul>=Delta_Y) - { - Cumul-=Delta_Y; - Pos_X+=Incr_X; - } - - if ((Pos_Y>=0) && (Pos_Y=ScanY_X[0][Pos_Y]) - { - if ((ScanY_X[1][Pos_Y]==INDEFINI) // Droit non d‚fini - || (Pos_X>ScanY_X[1][Pos_Y])) - { - ScanY_X[1][Pos_Y]=Pos_X; - ScanY_Xt[1][Pos_Y]=Xt; - ScanY_Yt[1][Pos_Y]=Yt; - } - } - else - { - if (ScanY_X[1][Pos_Y]==INDEFINI) // Droit non d‚fini - { - ScanY_X[1][Pos_Y]=ScanY_X[0][Pos_Y]; - ScanY_Xt[1][Pos_Y]=ScanY_Xt[0][Pos_Y]; - ScanY_Yt[1][Pos_Y]=ScanY_Yt[0][Pos_Y]; - ScanY_X[0][Pos_Y]=Pos_X; - ScanY_Xt[0][Pos_Y]=Xt; - ScanY_Yt[0][Pos_Y]=Yt; - } - else - { - ScanY_X[0][Pos_Y]=Pos_X; - ScanY_Xt[0][Pos_Y]=Xt; - ScanY_Yt[0][Pos_Y]=Yt; - } - } - } - } - Pos_Y+=Incr_Y; - Cumul+=Delta_X; - } - } -} - - - -void Calculer_quad_texture(int X1,int Y1,int Xt1,int Yt1, - int X2,int Y2,int Xt2,int Yt2, - int X3,int Y3,int Xt3,int Yt3, - int X4,int Y4,int Xt4,int Yt4, - byte * Buffer, int Largeur, int Hauteur) -{ - int Xmin,Xmax,Ymin,Ymax; - int X,Y,Xt,Yt; - int Debut_X,Fin_X,Largeur_ligne; - float Temp; - byte Couleur; - - Xmin=Min(Min(X1,X2),Min(X3,X4)); - Ymin=Min(Min(Y1,Y2),Min(Y3,Y4)); - - ScanY_Xt[0]=(float *)malloc(Hauteur*sizeof(float)); - ScanY_Xt[1]=(float *)malloc(Hauteur*sizeof(float)); - ScanY_Yt[0]=(float *)malloc(Hauteur*sizeof(float)); - ScanY_Yt[1]=(float *)malloc(Hauteur*sizeof(float)); - ScanY_X[0] =(float *)malloc(Hauteur*sizeof(float)); - ScanY_X[1] =(float *)malloc(Hauteur*sizeof(float)); - - // Remplir avec des valeurs ‚gales … INDEFINI. - for (Y=0; Y>1); - Debut_Y=1-(Brosse_Hauteur>>1); - Fin_X=Debut_X+Brosse_Largeur-1; - Fin_Y=Debut_Y+Brosse_Hauteur-1; - - Transformer_point(Debut_X,Debut_Y, cosA,sinA, &X1,&Y1); - Transformer_point(Fin_X ,Debut_Y, cosA,sinA, &X2,&Y2); - Transformer_point(Debut_X,Fin_Y , cosA,sinA, &X3,&Y3); - Transformer_point(Fin_X ,Fin_Y , cosA,sinA, &X4,&Y4); - - // Calcul des nouvelles dimensions de la brosse: - Xmin=Min(Min((int)X1,(int)X2),Min((int)X3,(int)X4)); - Xmax=Max(Max((int)X1,(int)X2),Max((int)X3,(int)X4)); - Ymin=Min(Min((int)Y1,(int)Y2),Min((int)Y3,(int)Y4)); - Ymax=Max(Max((int)Y1,(int)Y2),Max((int)Y3,(int)Y4)); - - New_Brosse_Largeur=Xmax+1-Xmin; - New_Brosse_Hauteur=Ymax+1-Ymin; - - free(Smear_Brosse); // On libŠre un peu de m‚moire - - if (New_Brosse=(byte *)malloc(New_Brosse_Largeur*New_Brosse_Hauteur)) - { - // Et maintenant on calcule la nouvelle brosse tourn‚e. - Calculer_quad_texture(X1,Y1, 0, 0, - X2,Y2,Brosse_Largeur-1, 0, - X3,Y3, 0,Brosse_Hauteur-1, - X4,Y4,Brosse_Largeur-1,Brosse_Hauteur-1, - New_Brosse,New_Brosse_Largeur,New_Brosse_Hauteur); - - free(Brosse); - Brosse=New_Brosse; - - Brosse_Largeur=New_Brosse_Largeur; - Brosse_Hauteur=New_Brosse_Hauteur; - - Smear_Brosse_Largeur=(Brosse_Largeur>TAILLE_MAXI_PINCEAU)?Brosse_Largeur:TAILLE_MAXI_PINCEAU; - Smear_Brosse_Hauteur=(Brosse_Hauteur>TAILLE_MAXI_PINCEAU)?Brosse_Hauteur:TAILLE_MAXI_PINCEAU; - Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Hauteur)*Smear_Brosse_Largeur); - - if (!Smear_Brosse) // On ne peut mˆme pas allouer la brosse du smear! - { - Erreur(0); - - free(Brosse); - Brosse=(byte *)malloc(1*1); - Brosse_Hauteur=1; - Brosse_Largeur=1; - - Smear_Brosse=(byte *)malloc(TAILLE_MAXI_PINCEAU*TAILLE_MAXI_PINCEAU); - Smear_Brosse_Hauteur=TAILLE_MAXI_PINCEAU; - Smear_Brosse_Largeur=TAILLE_MAXI_PINCEAU; - } - - Brosse_Decalage_X=(Brosse_Largeur>>1); - Brosse_Decalage_Y=(Brosse_Hauteur>>1); - } - else - { - // Ici la lib‚ration de m‚moire n'a pas suffit donc on remet dans l'‚tat - // o— c'etait avant. On a juste … r‚allouer la Smear_Brosse car il y a - // normalement la place pour elle puisque rien d'autre n'a pu ˆtre allou‚ - // entre temps. - Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Hauteur)*Smear_Brosse_Largeur); - Erreur(0); - } -} - - - -void Dessiner_quad_texture_preview(int X1,int Y1,int Xt1,int Yt1, - int X2,int Y2,int Xt2,int Yt2, - int X3,int Y3,int Xt3,int Yt3, - int X4,int Y4,int Xt4,int Yt4) -{ - int Xmin,Xmax,Ymin,Ymax; - int X,Y,Xt,Yt; - int Y_,Ymin_; - int Debut_X,Fin_X,Largeur,Hauteur; - float Temp; - byte Couleur; - - Xmin=Min(Min(X1,X2),Min(X3,X4)); - Xmax=Max(Max(X1,X2),Max(X3,X4)); - Ymin=Min(Min(Y1,Y2),Min(Y3,Y4)); - Ymax=Max(Max(Y1,Y2),Max(Y3,Y4)); - Hauteur=1+Ymax-Ymin; - - ScanY_Xt[0]=(float *)malloc(Hauteur*sizeof(float)); - ScanY_Xt[1]=(float *)malloc(Hauteur*sizeof(float)); - ScanY_Yt[0]=(float *)malloc(Hauteur*sizeof(float)); - ScanY_Yt[1]=(float *)malloc(Hauteur*sizeof(float)); - ScanY_X[0] =(float *)malloc(Hauteur*sizeof(float)); - ScanY_X[1] =(float *)malloc(Hauteur*sizeof(float)); - - // Remplir avec des valeurs ‚gales … INDEFINI. - for (Y=0; YLimite_Bas) Ymax=Limite_Bas; - - for (Y_=Ymin; Y_<=Ymax; Y_++) - { - Y=Y_-Ymin_; - Debut_X=Round(ScanY_X[0][Y]); - Fin_X =Round(ScanY_X[1][Y]); - - Largeur=1+Fin_X-Debut_X; - - if (Debut_XLimite_Droite) Fin_X=Limite_Droite; - - for (X=Debut_X; X<=Fin_X; X++) - { - Temp=(float)(0.5+(float)X-ScanY_X[0][Y])/(float)Largeur; - Xt=Round((float)(ScanY_Xt[0][Y])+(Temp*(ScanY_Xt[1][Y]-ScanY_Xt[0][Y]))); - Yt=Round((float)(ScanY_Yt[0][Y])+(Temp*(ScanY_Yt[1][Y]-ScanY_Yt[0][Y]))); - - Couleur=Lit_pixel_dans_brosse(Xt,Yt); - if (Couleur!=Back_color) - Pixel_Preview(X,Y_,Couleur); - } - } - - free(ScanY_Xt[0]); - free(ScanY_Xt[1]); - free(ScanY_Yt[0]); - free(ScanY_Yt[1]); - free(ScanY_X[0]); - free(ScanY_X[1]); -} - - -void Tourner_brosse_preview(float Angle) -{ - short X1,Y1,X2,Y2,X3,Y3,X4,Y4; - int Debut_X,Fin_X,Debut_Y,Fin_Y; - float cosA=cos(Angle); - float sinA=sin(Angle); - - // Calcul des coordonn‚es des 4 coins: - // 1 2 - // 3 4 - - Debut_X=1-(Brosse_Largeur>>1); - Debut_Y=1-(Brosse_Hauteur>>1); - Fin_X=Debut_X+Brosse_Largeur-1; - Fin_Y=Debut_Y+Brosse_Hauteur-1; - - Transformer_point(Debut_X,Debut_Y, cosA,sinA, &X1,&Y1); - Transformer_point(Fin_X ,Debut_Y, cosA,sinA, &X2,&Y2); - Transformer_point(Debut_X,Fin_Y , cosA,sinA, &X3,&Y3); - Transformer_point(Fin_X ,Fin_Y , cosA,sinA, &X4,&Y4); - - X1+=Brosse_Centre_rotation_X; - Y1+=Brosse_Centre_rotation_Y; - X2+=Brosse_Centre_rotation_X; - Y2+=Brosse_Centre_rotation_Y; - X3+=Brosse_Centre_rotation_X; - Y3+=Brosse_Centre_rotation_Y; - X4+=Brosse_Centre_rotation_X; - Y4+=Brosse_Centre_rotation_Y; - - // Et maintenant on dessine la brosse tourn‚e. - Dessiner_quad_texture_preview(X1,Y1, 0, 0, - X2,Y2,Brosse_Largeur-1, 0, - X3,Y3, 0,Brosse_Hauteur-1, - X4,Y4,Brosse_Largeur-1,Brosse_Hauteur-1); -} +/* + switch(Mode_video[Numero].Mode_VESA_de_base) + { + case 0x100 : Indice_VESA=0; // 640x400 + break; + case 0x101 : Indice_VESA=1; // 640x480 + break; + case 0x103 : Indice_VESA=2; // 800x600 + break; + default : Indice_VESA=3; // 1024x768 + } + + // On regarde si le mode supporte le LFB + if (VESA_Mode_Infos[Indice_VESA].Adresse_physique_LFB!=0) + { + // C'est le cas => on va s'en servir + + Set_VESA_mode(Mode_video[Numero].Mode_VESA_de_base | 0x4000); + Initialiser_le_LFB(VESA_Mode_Infos[Indice_VESA].Adresse_physique_LFB, + VESA_Mode_Infos[Indice_VESA].Taille_LFB); + if (Mode_X_Ptr!=NULL) + Retoucher_CRTC(); + } + else + { + // Ce n'est pas le cas, on continue comme si de rien n'était + Granularite =VESA_Mode_Infos[Indice_VESA].Granularite; + VESA_WinFuncPtr=VESA_Mode_Infos[Indice_VESA].WinFuncPtr; + + Initialiser_mode_video_VESA(Mode_video[Numero].Mode_VESA_de_base); + if (Mode_X_Ptr!=NULL) + Retoucher_CRTC(); + } +*/ + } + Set_palette(Principal_Palette); + + Resolution_actuelle=Numero; + + Menu_Taille_couleur=((Largeur_ecran/Menu_Facteur_X)-(LARGEUR_MENU+2)) >> 3; + Menu_Ordonnee=Hauteur_ecran; + if (Menu_visible) + Menu_Ordonnee-=HAUTEUR_MENU*Menu_Facteur_Y; + Menu_Ordonnee_Texte=Hauteur_ecran-(Menu_Facteur_Y<<3); + Bouton[BOUTON_CHOIX_COL].Largeur=(Menu_Taille_couleur<<3)-1; + + Clip_mouse(); + Mouse_X = Largeur_ecran >> 1; + Mouse_Y = Hauteur_ecran >> 1; + Set_mouse_position(); + + Sensibilite_X=Config.Indice_Sensibilite_souris_X/Mode_video[Numero].Facteur_X; + Sensibilite_Y=Config.Indice_Sensibilite_souris_Y/Mode_video[Numero].Facteur_Y; + Sensibilite_X>>=Mouse_Facteur_de_correction_X; + Sensibilite_Y>>=Mouse_Facteur_de_correction_Y; + Sensibilite_souris(Sensibilite_X?Sensibilite_X:1,Sensibilite_Y?Sensibilite_Y:1); + + Brouillon_Decalage_X=0; // | Il faut penser à éviter les incohérences + Brouillon_Decalage_Y=0; // |- de décalage du brouillon par rapport à + Brouillon_Loupe_Mode=0; // | la résolution. + } + + Pixel_Preview=Pixel_Preview_Normal; + + Principal_Decalage_X=0; // Il faut quand même modifier ces valeurs à chaque + Principal_Decalage_Y=0; // fois car on n'est pas à l'abri d'une modification + // des dimensions de l'image. + Calculer_donnees_loupe(); + Calculer_limites(); + Calculer_coordonnees_pinceau(); +} + + +// -- Interface avec l'image, affectée par le facteur de grossissement ------- + + // fonction d'affichage "Pixel" utilisée pour les opérations définitivement + // Ne doit à aucune condition être appelée en dehors de la partie visible + // de l'image dans l'écran (‡a pourrait être grave) +void Afficher_pixel(short X,short Y,byte Couleur) + // X & Y sont la position d'un point dans l'IMAGE + // Couleur est la couleur du point + // Le Stencil est géré. + // Les effets sont gérés par appel à Fonction_effet(). + // La Loupe est gérée par appel à Pixel_Preview(). +{ + if ( ( (!Trame_Mode) || (Effet_Trame(X,Y)) ) + && (!((Stencil_Mode) && (Stencil[Lit_pixel_dans_ecran_courant(X,Y)]))) + && (!((Mask_Mode) && (Mask[Lit_pixel_dans_ecran_brouillon(X,Y)]))) ) + { + Couleur=Fonction_effet(X,Y,Couleur); + Pixel_dans_ecran_courant(X,Y,Couleur); + Pixel_Preview(X,Y,Couleur); + } +} + + +// -- Interface avec le menu et les fenêtres --------------------------------- + + // Affichage d'un pixel dans le menu (le menu doŒt être visible) + +void Pixel_dans_barre_d_outil(word X,word Y,byte Couleur) +{ + Block(X*Menu_Facteur_X,(Y*Menu_Facteur_Y)+Menu_Ordonnee,Menu_Facteur_X,Menu_Facteur_Y,Couleur); +} + + // Affichage d'un pixel dans la fenêtre (la fenêtre doŒt être visible) + +void Pixel_dans_fenetre(word X,word Y,byte Couleur) +{ + Block((X*Menu_Facteur_X)+Fenetre_Pos_X,(Y*Menu_Facteur_Y)+Fenetre_Pos_Y,Menu_Facteur_X,Menu_Facteur_Y,Couleur); +} + + +// -- Affichages de différents cƒdres dans une fenêtre ----------------------- + + // -- Cadre général avec couleurs paramètrables -- + +void Fenetre_Afficher_cadre_general(word Pos_X,word Pos_Y,word Largeur,word Hauteur, + byte Couleur_HG,byte Couleur_BD,byte Couleur_S,byte Couleur_CHG,byte Couleur_CBD) +// Paramètres de couleurs: +// Couleur_HG =Bords Haut et Gauche +// Couleur_BD =Bords Bas et Droite +// Couleur_S =Coins Haut-Droite et Bas-Gauche +// Couleur_CHG=Coin Haut-Gauche +// Couleur_CBD=Coin Bas-Droite +{ + // Bord haut (sans les extrémités) + Block(Fenetre_Pos_X+((Pos_X+1)*Menu_Facteur_X), + Fenetre_Pos_Y+(Pos_Y*Menu_Facteur_Y), + (Largeur-2)*Menu_Facteur_X,Menu_Facteur_Y,Couleur_HG); + + // Bord bas (sans les extrémités) + Block(Fenetre_Pos_X+((Pos_X+1)*Menu_Facteur_X), + Fenetre_Pos_Y+((Pos_Y+Hauteur-1)*Menu_Facteur_Y), + (Largeur-2)*Menu_Facteur_X,Menu_Facteur_Y,Couleur_BD); + + // Bord gauche (sans les extrémités) + Block(Fenetre_Pos_X+(Pos_X*Menu_Facteur_X), + Fenetre_Pos_Y+((Pos_Y+1)*Menu_Facteur_Y), + Menu_Facteur_X,(Hauteur-2)*Menu_Facteur_Y,Couleur_HG); + + // Bord droite (sans les extrémités) + Block(Fenetre_Pos_X+((Pos_X+Largeur-1)*Menu_Facteur_X), + Fenetre_Pos_Y+((Pos_Y+1)*Menu_Facteur_Y), + Menu_Facteur_X,(Hauteur-2)*Menu_Facteur_Y,Couleur_BD); + + // Coin haut gauche + Pixel_dans_fenetre(Pos_X,Pos_Y,Couleur_CHG); + // Coin haut droite + Pixel_dans_fenetre(Pos_X+Largeur-1,Pos_Y,Couleur_S); + // Coin bas droite + Pixel_dans_fenetre(Pos_X+Largeur-1,Pos_Y+Hauteur-1,Couleur_CBD); + // Coin bas gauche + Pixel_dans_fenetre(Pos_X,Pos_Y+Hauteur-1,Couleur_S); +} + + // -- Cadre dont tout le contour est d'une seule couleur -- + +void Fenetre_Afficher_cadre_mono(word Pos_X,word Pos_Y,word Largeur,word Hauteur,byte Couleur) +{ + Fenetre_Afficher_cadre_general(Pos_X,Pos_Y,Largeur,Hauteur,Couleur,Couleur,Couleur,Couleur,Couleur); +} + + // -- Cadre creux: foncé en haut-gauche et clair en bas-droite -- + +void Fenetre_Afficher_cadre_creux(word Pos_X,word Pos_Y,word Largeur,word Hauteur) +{ + Fenetre_Afficher_cadre_general(Pos_X,Pos_Y,Largeur,Hauteur,CM_Fonce,CM_Blanc,CM_Clair,CM_Fonce,CM_Blanc); +} + + // -- Cadre bombé: clair en haut-gauche et foncé en bas-droite -- + +void Fenetre_Afficher_cadre_bombe(word Pos_X,word Pos_Y,word Largeur,word Hauteur) +{ + Fenetre_Afficher_cadre_general(Pos_X,Pos_Y,Largeur,Hauteur,CM_Blanc,CM_Fonce,CM_Clair,CM_Blanc,CM_Fonce); +} + + // -- Cadre de séparation: un cadre bombé dans un cadre creux (3D!!!) -- + +void Fenetre_Afficher_cadre(word Pos_X,word Pos_Y,word Largeur,word Hauteur) +{ + Fenetre_Afficher_cadre_creux(Pos_X,Pos_Y,Largeur,Hauteur); + Fenetre_Afficher_cadre_bombe(Pos_X+1,Pos_Y+1,Largeur-2,Hauteur-2); +} + + +//-- Affichages relatifs à la palette dans le menu --------------------------- + + // -- Affichage des couleurs courante (fore/back) de pinceau dans le menu -- + +void Afficher_foreback(void) +{ + if (Menu_visible) + { + Block((LARGEUR_MENU-17)*Menu_Facteur_X,Menu_Ordonnee+Menu_Facteur_Y,Menu_Facteur_X<<4,Menu_Facteur_Y*7,Back_color); + Block((LARGEUR_MENU-13)*Menu_Facteur_X,Menu_Ordonnee+(Menu_Facteur_Y<<1),Menu_Facteur_X<<3,Menu_Facteur_Y*5,Fore_color); + } +} + + // -- Tracer un cadre de couleur autour de la Fore_color dans le menu -- + +void Encadrer_couleur_menu(byte Couleur) +{ + word Debut_X,Debut_Y,Fin_X,Fin_Y; + word Indice; + + if ((Fore_color>=Couleur_debut_palette) && (Fore_color>3)*Menu_Taille_couleur)*Menu_Facteur_X; + Debut_Y=Menu_Ordonnee+((1+(((Fore_color-Couleur_debut_palette)&7)<<2))*Menu_Facteur_Y); + + Block(Debut_X,Debut_Y,(Menu_Taille_couleur+1)*Menu_Facteur_X,Menu_Facteur_Y,Couleur); + Block(Debut_X,Debut_Y+(Menu_Facteur_Y<<2),(Menu_Taille_couleur+1)*Menu_Facteur_X,Menu_Facteur_Y,Couleur); + + Block(Debut_X,Debut_Y+Menu_Facteur_Y,Menu_Facteur_X,Menu_Facteur_Y*3,Couleur); + Block(Debut_X+(Menu_Taille_couleur*Menu_Facteur_X),Debut_Y+Menu_Facteur_Y,Menu_Facteur_X,Menu_Facteur_Y*3,Couleur); + } + else + { + if (Couleur==CM_Noir) + { + Debut_X=(LARGEUR_MENU+1+((Fore_color-Couleur_debut_palette)>>3)*Menu_Taille_couleur)*Menu_Facteur_X; + Debut_Y=Menu_Ordonnee+((2+(((Fore_color-Couleur_debut_palette)&7)<<2))*Menu_Facteur_Y); + + Block(Debut_X,Debut_Y,Menu_Taille_couleur*Menu_Facteur_X, + Menu_Facteur_Y<<2,Fore_color); + } + else + { + Debut_X=LARGEUR_MENU+1+((Fore_color-Couleur_debut_palette)>>3)*Menu_Taille_couleur; + Debut_Y=2+(((Fore_color-Couleur_debut_palette)&7)<<2); + + Fin_X=Debut_X+Menu_Taille_couleur-1; + Fin_Y=Debut_Y+3; + + for (Indice=Debut_X; Indice<=Fin_X; Indice++) + Block(Indice*Menu_Facteur_X,Menu_Ordonnee+(Debut_Y*Menu_Facteur_Y), + Menu_Facteur_X,Menu_Facteur_Y, + ((Indice+Debut_Y)&1)?CM_Blanc:CM_Noir); + + for (Indice=Debut_Y+1; Indice>3)*Menu_Taille_couleur)*Menu_Facteur_X, + Menu_Ordonnee+((2+((Couleur&7)<<2))*Menu_Facteur_Y), + (Menu_Taille_couleur-1)*Menu_Facteur_X, + Menu_Facteur_Y*3, + Couleur_debut_palette+Couleur); + else + for (Couleur=0;Couleur<64;Couleur++) + Block((LARGEUR_MENU+1+(Couleur>>3)*Menu_Taille_couleur)*Menu_Facteur_X, + Menu_Ordonnee+((2+((Couleur&7)<<2))*Menu_Facteur_Y), + Menu_Taille_couleur*Menu_Facteur_X, + Menu_Facteur_Y<<2, + Couleur_debut_palette+Couleur); + + Encadrer_couleur_menu(CM_Blanc); + } +} + + // -- Recalculer l'origine de la palette dans le menu pour rendre la + // Fore_color visible -- + +void Recadrer_palette(void) +{ + byte Ancienne_couleur=Couleur_debut_palette; + + if (Fore_color=Couleur_debut_palette+64) + Couleur_debut_palette+=8; + } + if (Ancienne_couleur!=Couleur_debut_palette) + Afficher_palette_du_menu(); +} + + + // -- Afficher la barre de séparation entre les parties zoomées ou non en + // mode Loupe -- + +void Afficher_barre_de_split(void) +{ + // Partie grise du milieu + Block(Principal_Split+(Menu_Facteur_X<<1),Menu_Facteur_Y, + (LARGEUR_BARRE_SPLIT-4)*Menu_Facteur_X, + Menu_Ordonnee-(Menu_Facteur_Y<<1),CM_Clair); + + // Barre noire de gauche + Block(Principal_Split,0,Menu_Facteur_X,Menu_Ordonnee,CM_Noir); + + // Barre noire de droite + Block(Principal_X_Zoom-Menu_Facteur_X,0,Menu_Facteur_X,Menu_Ordonnee,CM_Noir); + + // Bord haut (blanc) + Block(Principal_Split+Menu_Facteur_X,0, + (LARGEUR_BARRE_SPLIT-3)*Menu_Facteur_X,Menu_Facteur_Y,CM_Blanc); + + // Bord gauche (blanc) + Block(Principal_Split+Menu_Facteur_X,Menu_Facteur_Y, + Menu_Facteur_X,(Menu_Ordonnee-(Menu_Facteur_Y<<1)),CM_Blanc); + + // Bord droite (gris foncé) + Block(Principal_X_Zoom-(Menu_Facteur_X<<1),Menu_Facteur_Y, + Menu_Facteur_X,(Menu_Ordonnee-(Menu_Facteur_Y<<1)),CM_Fonce); + + // Bord bas (gris foncé) + Block(Principal_Split+(Menu_Facteur_X<<1),Menu_Ordonnee-Menu_Facteur_Y, + (LARGEUR_BARRE_SPLIT-3)*Menu_Facteur_X,Menu_Facteur_Y,CM_Fonce); + + // Coin bas gauche + Block(Principal_Split+Menu_Facteur_X,Menu_Ordonnee-Menu_Facteur_Y, + Menu_Facteur_X,Menu_Facteur_Y,CM_Clair); + // Coin haut droite + Block(Principal_X_Zoom-(Menu_Facteur_X<<1),0, + Menu_Facteur_X,Menu_Facteur_Y,CM_Clair); +} + + // -- Afficher tout le menu -- + +void Afficher_menu(void) +{ + word Pos_X; + word Pos_Y; + char Chaine[4]; + + + if (Menu_visible) + { + // Affichage du sprite du menu + for (Pos_Y=0;Pos_Y=Principal_X_Zoom) )) + { + if ( (Operation_en_cours!=OPERATION_PIPETTE) + && (Operation_en_cours!=OPERATION_REMPLACER) ) + Print_dans_menu("X: Y: ",0); + else + { + Print_dans_menu("X: Y: ( )",0); + Num2str(Pipette_Couleur,Chaine,3); + Print_dans_menu(Chaine,20); + Print_general(170*Menu_Facteur_X,Menu_Ordonnee_Texte," ",0,Pipette_Couleur); + } + Print_coordonnees(); + } + Print_nom_fichier(); + } + } +} + + +// -- Affichage de texte ----------------------------------------------------- + + // -- Afficher une chaŒne n'importe o— à l'écran -- + +void Print_general(short X,short Y,char * Chaine,byte Couleur_texte,byte Couleur_fond) +{ + word Indice; + short Pos_X; + short Pos_Y; + char Caractere; + short Reel_X; + short Reel_Y; + short Largeur; + short Repeat_Menu_Facteur_X; + short Repeat_Menu_Facteur_Y; + + Reel_Y=Y; + Largeur=strlen(Chaine)*Menu_Facteur_X*8; + for (Pos_Y=0;Pos_Y<8;Pos_Y++) + { + Reel_X=0; // Position dans le buffer + for (Indice=0;Chaine[Indice]!='\0';Indice++) + { + Caractere=Chaine[Indice]; + for (Pos_X=0;Pos_X<8;Pos_X++) + for (Repeat_Menu_Facteur_X=0;Repeat_Menu_Facteur_X=0) && (Pinceau_Y>=0) + && (Pinceau_X=Debut) && (C<=Fin) && (Debut!=Fin)) + { + Largeur=1+Fin-Debut; + + if ( ((Mouse_K==A_GAUCHE) && Sens) || ((Mouse_K==A_DROITE) && (!Sens)) ) + C-=Quick_shade_Step%Largeur; + else + C+=Quick_shade_Step%Largeur; + + if (CFin) + switch (Quick_shade_Loop) + { + case MODE_SHADE_NORMAL : return Fin; + case MODE_SHADE_BOUCLE : return (C-Largeur); + default : return Couleur; + } + } + + return C; +} + + // -- Effet de Tiling -- + +byte Effet_Tiling(word X,word Y,byte Couleur) +{ + return Lit_pixel_dans_brosse((X+Brosse_Largeur-Tiling_Decalage_X)%Brosse_Largeur, + (Y+Brosse_Hauteur-Tiling_Decalage_Y)%Brosse_Hauteur); +} + + // -- Effet de Smooth -- + +byte Effet_Smooth(word X,word Y,byte Couleur) +{ + int R,V,B; + byte C; + int Poids,Poids_total; + byte X2=((X+1)(Limite_Droite+1)) + { + (*Largeur)=(Limite_Droite-(*X))+1; + } + + if ((*Y)(Limite_Bas+1)) + { + (*Hauteur)=(Limite_Bas-(*Y))+1; + } +} + + // -- Calcul de redimensionnement du pinceau pour éviter les débordements + // de l'écran zoomé et de l'image -- + +void Calculer_dimensions_clipees_zoom(short * X,short * Y,short * Largeur,short * Hauteur) +{ + if ((*X)(Limite_Droite_Zoom+1)) + { + (*Largeur)=(Limite_Droite_Zoom-(*X))+1; + } + + if ((*Y)(Limite_Bas_Zoom+1)) + { + (*Hauteur)=(Limite_Bas_Zoom-(*Y))+1; + } +} + + + // -- Afficher le pinceau (de façon définitive ou non) -- + +void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview) + // X,Y: position du centre du pinceau + // Couleur: couleur à appliquer au pinceau + // Preview: "Il ne faut l'afficher qu'… l'écran" +{ + short Debut_X; // Position X (dans l'image) à partir de laquelle on affiche la brosse/pinceau + short Debut_Y; // Position Y (dans l'image) à partir de laquelle on affiche la brosse/pinceau + short Largeur; // Largeur dans l'écran selon laquelle on affiche la brosse/pinceau + short Hauteur; // Hauteur dans l'écran selon laquelle on affiche la brosse/pinceau + short Debut_Compteur_X; // Position X (dans la brosse/pinceau) à partir de laquelle on affiche la brosse/pinceau + short Debut_Compteur_Y; // Position Y (dans la brosse/pinceau) à partir de laquelle on affiche la brosse/pinceau + short Pos_X; // Position X (dans l'image) en cours d'affichage + short Pos_Y; // Position Y (dans l'image) en cours d'affichage + short Compteur_X; // Position X (dans la brosse/pinceau) en cours d'affichage + short Compteur_Y; // Position Y (dans la brosse/pinceau) en cours d'affichage + short Fin_Compteur_X; // Position X ou s'arrête l'affichade de la brosse/pinceau + short Fin_Compteur_Y; // Position Y ou s'arrête l'affichade de la brosse/pinceau + byte Couleur_temporaire; // Couleur de la brosse en cours d'affichage + int Position; + byte * Temp; + + if (!(Preview && Mouse_K)) + switch (Pinceau_Forme) + { + case FORME_PINCEAU_POINT : // !!! TOUJOURS EN PREVIEW !!! + if ( (Pinceau_X>=Limite_Gauche) + && (Pinceau_X<=Limite_Droite) + && (Pinceau_Y>=Limite_Haut) + && (Pinceau_Y<=Limite_Bas) ) + Pixel_Preview(Pinceau_X,Pinceau_Y,Couleur); + break; + case FORME_PINCEAU_BROSSE_COULEUR : // Brosse en couleur + Debut_X=X-Brosse_Decalage_X; + Debut_Y=Y-Brosse_Decalage_Y; + Largeur=Brosse_Largeur; + Hauteur=Brosse_Hauteur; + Calculer_dimensions_clipees(&Debut_X,&Debut_Y,&Largeur,&Hauteur); + Debut_Compteur_X=Debut_X-(X-Brosse_Decalage_X); + Debut_Compteur_Y=Debut_Y-(Y-Brosse_Decalage_Y); + Fin_Compteur_X=Debut_Compteur_X+Largeur; + Fin_Compteur_Y=Debut_Compteur_Y+Hauteur; + if (Preview) + { + if ( (Largeur>0) && (Hauteur>0) ) + Display_brush_Color(Debut_X-Principal_Decalage_X, + Debut_Y-Principal_Decalage_Y, + Debut_Compteur_X,Debut_Compteur_Y, + Largeur,Hauteur,Back_color, + Brosse_Largeur); + + if (Loupe_Mode) + { + Calculer_dimensions_clipees_zoom(&Debut_X,&Debut_Y,&Largeur,&Hauteur); + Debut_Compteur_X=Debut_X-(X-Brosse_Decalage_X); + Debut_Compteur_Y=Debut_Y-(Y-Brosse_Decalage_Y); + + if ( (Largeur>0) && (Hauteur>0) ) + { + // Corrections d–es au Zoom: + Debut_X=(Debut_X-Loupe_Decalage_X)*Loupe_Facteur; + Debut_Y=(Debut_Y-Loupe_Decalage_Y)*Loupe_Facteur; + Hauteur=Debut_Y+(Hauteur*Loupe_Facteur); + if (Hauteur>Menu_Ordonnee) + Hauteur=Menu_Ordonnee; + + Display_brush_Color_zoom(Principal_X_Zoom+Debut_X,Debut_Y, + Debut_Compteur_X,Debut_Compteur_Y, + Largeur,Hauteur,Back_color, + Brosse_Largeur, + Buffer_de_ligne_horizontale); + } + } + } + else + { + if ((Smear_Mode) && (Shade_Table==Shade_Table_gauche)) + { + if (Smear_Debut) + { + if ((Largeur>0) && (Hauteur>0)) + Copier_une_partie_d_image_dans_une_autre(Principal_Ecran, + Debut_X,Debut_Y, + Largeur,Hauteur, + Principal_Largeur_image, + Smear_Brosse, + Debut_Compteur_X, + Debut_Compteur_Y, + Smear_Brosse_Largeur); + Smear_Debut=0; + } + else + { + for (Pos_Y=Debut_Y,Compteur_Y=Debut_Compteur_Y;Compteur_Y=Smear_Min_Y) && (Compteur_X>=Smear_Min_X) ) + Afficher_pixel(Pos_X,Pos_Y,Smear_Brosse[Position]); + Smear_Brosse[Position]=Couleur_temporaire; + } + } + Smear_Min_X=Debut_Compteur_X; + Smear_Min_Y=Debut_Compteur_Y; + Smear_Max_X=Fin_Compteur_X; + Smear_Max_Y=Fin_Compteur_Y; + } + else + { + if (Shade_Table==Shade_Table_gauche) + for (Pos_Y=Debut_Y,Compteur_Y=Debut_Compteur_Y;Compteur_Y0) && (Hauteur>0) ) + Display_brush_Mono(Debut_X-Principal_Decalage_X, + Debut_Y-Principal_Decalage_Y, + Debut_Compteur_X,Debut_Compteur_Y, + Largeur,Hauteur, + Back_color,Fore_color, + Brosse_Largeur); + + if (Loupe_Mode) + { + Calculer_dimensions_clipees_zoom(&Debut_X,&Debut_Y,&Largeur,&Hauteur); + Debut_Compteur_X=Debut_X-(X-Brosse_Decalage_X); + Debut_Compteur_Y=Debut_Y-(Y-Brosse_Decalage_Y); + + if ( (Largeur>0) && (Hauteur>0) ) + { + // Corrections d–es au Zoom: + Debut_X=(Debut_X-Loupe_Decalage_X)*Loupe_Facteur; + Debut_Y=(Debut_Y-Loupe_Decalage_Y)*Loupe_Facteur; + Hauteur=Debut_Y+(Hauteur*Loupe_Facteur); + if (Hauteur>Menu_Ordonnee) + Hauteur=Menu_Ordonnee; + + Display_brush_Mono_zoom(Principal_X_Zoom+Debut_X,Debut_Y, + Debut_Compteur_X,Debut_Compteur_Y, + Largeur,Hauteur, + Back_color,Fore_color, + Brosse_Largeur, + Buffer_de_ligne_horizontale); + } + } + } + else + { + if ((Smear_Mode) && (Shade_Table==Shade_Table_gauche)) + { + if (Smear_Debut) + { + if ((Largeur>0) && (Hauteur>0)) + Copier_une_partie_d_image_dans_une_autre(Principal_Ecran, + Debut_X,Debut_Y, + Largeur,Hauteur, + Principal_Largeur_image, + Smear_Brosse, + Debut_Compteur_X, + Debut_Compteur_Y, + Smear_Brosse_Largeur); + Smear_Debut=0; + } + else + { + for (Pos_Y=Debut_Y,Compteur_Y=Debut_Compteur_Y;Compteur_Y=Smear_Min_Y) && (Compteur_X>=Smear_Min_X) ) + Afficher_pixel(Pos_X,Pos_Y,Smear_Brosse[Position]); + Smear_Brosse[Position]=Couleur_temporaire; + } + } + Smear_Min_X=Debut_Compteur_X; + Smear_Min_Y=Debut_Compteur_Y; + Smear_Max_X=Fin_Compteur_X; + Smear_Max_Y=Fin_Compteur_Y; + } + else + { + for (Pos_Y=Debut_Y,Compteur_Y=Debut_Compteur_Y;Compteur_Y0) && (Hauteur>0) ) + Display_brush_Mono(Debut_X-Principal_Decalage_X, + Debut_Y-Principal_Decalage_Y, + Debut_Compteur_X,Debut_Compteur_Y, + Largeur,Hauteur, + 0,Fore_color, + TAILLE_MAXI_PINCEAU); + + if (Loupe_Mode) + { + Calculer_dimensions_clipees_zoom(&Debut_X,&Debut_Y,&Largeur,&Hauteur); + Debut_Compteur_X=Debut_X-(X-Pinceau_Decalage_X); + Debut_Compteur_Y=Debut_Y-(Y-Pinceau_Decalage_Y); + + if ( (Largeur>0) && (Hauteur>0) ) + { + // Corrections d–es au Zoom: + Debut_X=(Debut_X-Loupe_Decalage_X)*Loupe_Facteur; + Debut_Y=(Debut_Y-Loupe_Decalage_Y)*Loupe_Facteur; + Hauteur=Debut_Y+(Hauteur*Loupe_Facteur); + if (Hauteur>Menu_Ordonnee) + Hauteur=Menu_Ordonnee; + + Display_brush_Mono_zoom(Principal_X_Zoom+Debut_X,Debut_Y, + Debut_Compteur_X,Debut_Compteur_Y, + Largeur,Hauteur, + 0,Fore_color, + TAILLE_MAXI_PINCEAU, + Buffer_de_ligne_horizontale); + } + } + + Brosse=Temp; + } + else + { + if ((Smear_Mode) && (Shade_Table==Shade_Table_gauche)) + { + if (Smear_Debut) + { + if ((Largeur>0) && (Hauteur>0)) + Copier_une_partie_d_image_dans_une_autre(Principal_Ecran, + Debut_X,Debut_Y, + Largeur,Hauteur, + Principal_Largeur_image, + Smear_Brosse, + Debut_Compteur_X, + Debut_Compteur_Y, + Smear_Brosse_Largeur); + Smear_Debut=0; + } + else + { + for (Pos_Y=Debut_Y,Compteur_Y=Debut_Compteur_Y;Compteur_Y=Smear_Min_Y) && (Compteur_X>=Smear_Min_X) ) + Afficher_pixel(Pos_X,Pos_Y,Smear_Brosse[Position]); + Smear_Brosse[Position]=Couleur_temporaire; + } + } + Smear_Min_X=Debut_Compteur_X; + Smear_Min_Y=Debut_Compteur_Y; + Smear_Max_X=Fin_Compteur_X; + Smear_Max_Y=Fin_Compteur_Y; + } + else + { + for (Pos_Y=Debut_Y,Compteur_Y=Debut_Compteur_Y;Compteur_Y=Limite_Gauche) + && (Pinceau_X<=Limite_Droite) + && (Pinceau_Y>=Limite_Haut) + && (Pinceau_Y<=Limite_Bas) ) + Pixel_Preview(Pinceau_X,Pinceau_Y,Lit_pixel_dans_ecran_courant(Pinceau_X,Pinceau_Y)); + break; + case FORME_PINCEAU_BROSSE_COULEUR : // Brosse en couleur + case FORME_PINCEAU_BROSSE_MONOCHROME : // Brosse monochrome + Debut_X=X-Brosse_Decalage_X; + Debut_Y=Y-Brosse_Decalage_Y; + Largeur=Brosse_Largeur; + Hauteur=Brosse_Hauteur; + Calculer_dimensions_clipees(&Debut_X,&Debut_Y,&Largeur,&Hauteur); + Debut_Compteur_X=Debut_X-(X-Brosse_Decalage_X); + Debut_Compteur_Y=Debut_Y-(Y-Brosse_Decalage_Y); + Fin_Compteur_X=Debut_Compteur_X+Largeur; + Fin_Compteur_Y=Debut_Compteur_Y+Hauteur; + + if ( (Largeur>0) && (Hauteur>0) ) + Clear_brush(Debut_X-Principal_Decalage_X, + Debut_Y-Principal_Decalage_Y, + Debut_Compteur_X,Debut_Compteur_Y, + Largeur,Hauteur,Back_color, + Principal_Largeur_image); + + if (Loupe_Mode) + { + Calculer_dimensions_clipees_zoom(&Debut_X,&Debut_Y,&Largeur,&Hauteur); + Debut_Compteur_X=Debut_X; + Debut_Compteur_Y=Debut_Y; + + if ( (Largeur>0) && (Hauteur>0) ) + { + // Corrections dues au Zoom: + Debut_X=(Debut_X-Loupe_Decalage_X)*Loupe_Facteur; + Debut_Y=(Debut_Y-Loupe_Decalage_Y)*Loupe_Facteur; + Hauteur=Debut_Y+(Hauteur*Loupe_Facteur); + if (Hauteur>Menu_Ordonnee) + Hauteur=Menu_Ordonnee; + + Clear_brush_zoom(Principal_X_Zoom+Debut_X,Debut_Y, + Debut_Compteur_X,Debut_Compteur_Y, + Largeur,Hauteur,Back_color, + Principal_Largeur_image, + Buffer_de_ligne_horizontale); + } + } + break; + default: // Pinceau + Debut_X=X-Pinceau_Decalage_X; + Debut_Y=Y-Pinceau_Decalage_Y; + Largeur=Pinceau_Largeur; + Hauteur=Pinceau_Hauteur; + Calculer_dimensions_clipees(&Debut_X,&Debut_Y,&Largeur,&Hauteur); + Debut_Compteur_X=Debut_X-(X-Pinceau_Decalage_X); + Debut_Compteur_Y=Debut_Y-(Y-Pinceau_Decalage_Y); + Fin_Compteur_X=Debut_Compteur_X+Largeur; + Fin_Compteur_Y=Debut_Compteur_Y+Hauteur; + + Temp=Brosse; + Brosse=Pinceau_Sprite; + + if ( (Largeur>0) && (Hauteur>0) ) + { + Clear_brush(Debut_X-Principal_Decalage_X, + Debut_Y-Principal_Decalage_Y, + Debut_Compteur_X,Debut_Compteur_Y, + Largeur,Hauteur,0, + Principal_Largeur_image); + } + + if (Loupe_Mode) + { + Calculer_dimensions_clipees_zoom(&Debut_X,&Debut_Y,&Largeur,&Hauteur); + Debut_Compteur_X=Debut_X; + Debut_Compteur_Y=Debut_Y; + + if ( (Largeur>0) && (Hauteur>0) ) + { + // Corrections dues au Zoom: + Debut_X=(Debut_X-Loupe_Decalage_X)*Loupe_Facteur; + Debut_Y=(Debut_Y-Loupe_Decalage_Y)*Loupe_Facteur; + Hauteur=Debut_Y+(Hauteur*Loupe_Facteur); + if (Hauteur>Menu_Ordonnee) + Hauteur=Menu_Ordonnee; + + Clear_brush_zoom(Principal_X_Zoom+Debut_X,Debut_Y, + Debut_Compteur_X,Debut_Compteur_Y, + Largeur,Hauteur,0, + Principal_Largeur_image, + Buffer_de_ligne_horizontale); + } + } + + Brosse=Temp; + break; + } +} + + +// -- Fonctions de manipulation du curseur ----------------------------------- + + + // -- Afficher une barre horizontale XOR zoomée + +void Ligne_horizontale_XOR_Zoom(short Pos_X, short Pos_Y, short Largeur) +{ + short Pos_X_reelle=Principal_X_Zoom+(Pos_X-Loupe_Decalage_X)*Loupe_Facteur; + short Pos_Y_reelle=(Pos_Y-Loupe_Decalage_Y)*Loupe_Facteur; + short Largeur_reelle=Largeur*Loupe_Facteur; + short Pos_Y_Fin=(Pos_Y_reelle+Loupe_Facteur=Principal_X_Zoom) ) ) + || (Une_fenetre_est_ouverte) || (Forme_curseur==FORME_CURSEUR_SABLIER) ) + Forme=Forme_curseur; + else + Forme=FORME_CURSEUR_FLECHE; + + switch(Forme) + { + case FORME_CURSEUR_CIBLE : + if (!Cacher_pinceau) + Afficher_pinceau(Pinceau_X,Pinceau_Y,Fore_color,1); + if (!Cacher_curseur) + { + if (Config.Curseur==1) + { + Debut_Y=(Mouse_Y<6)?6-Mouse_Y:0; + if (Debut_Y<4) + Ligne_verticale_XOR (Mouse_X,Mouse_Y+Debut_Y-6,4-Debut_Y); + + Debut_X=(Mouse_X<6)?(short)6-Mouse_X:0; + if (Debut_X<4) + Ligne_horizontale_XOR(Mouse_X+Debut_X-6,Mouse_Y,4-Debut_X); + + Fin_X=(Mouse_X+7>Largeur_ecran)?Mouse_X+7-Largeur_ecran:0; + if (Fin_X<4) + Ligne_horizontale_XOR(Mouse_X+3,Mouse_Y,4-Fin_X); + + Fin_Y=(Mouse_Y+7>Menu_Ordonnee/*Hauteur_ecran*/)?Mouse_Y+7-Menu_Ordonnee/*Hauteur_ecran*/:0; + if (Fin_Y<4) + Ligne_verticale_XOR (Mouse_X,Mouse_Y+3,4-Fin_Y); + } + else + { + Temp=(Config.Curseur)?FORME_CURSEUR_CIBLE_FINE:FORME_CURSEUR_CIBLE; + Debut_X=Mouse_X-Curseur_Decalage_X[Temp]; + Debut_Y=Mouse_Y-Curseur_Decalage_Y[Temp]; + + for (Pos_X=Debut_X,Compteur_X=0;Compteur_X<15;Pos_X++,Compteur_X++) + for (Pos_Y=Debut_Y,Compteur_Y=0;Compteur_Y<15;Pos_Y++,Compteur_Y++) + { + Couleur=SPRITE_CURSEUR[Temp][Compteur_Y][Compteur_X]; + if ( (Pos_X>=0) && (Pos_X=0) && (Pos_YLargeur_ecran)?Mouse_X+6-Largeur_ecran:0; + if (Fin_X<3) + Ligne_horizontale_XOR(Mouse_X+3,Mouse_Y,3-Fin_X); + + Fin_Y=(Mouse_Y+6>Menu_Ordonnee/*Hauteur_ecran*/)?Mouse_Y+6-Menu_Ordonnee/*Hauteur_ecran*/:0; + if (Fin_Y<3) + Ligne_verticale_XOR (Mouse_X,Mouse_Y+3,3-Fin_Y); + + // Petites barres aux extrémités + + Debut_X=(!Mouse_X); + Debut_Y=(!Mouse_Y); + Fin_X=(Mouse_X>=Largeur_ecran-1); + Fin_Y=(Mouse_Y>=Menu_Ordonnee-1); + + if (Mouse_Y>5) + Ligne_horizontale_XOR(Debut_X+Mouse_X-1,Mouse_Y-6,3-(Debut_X+Fin_X)); + + if (Mouse_X>5) + Ligne_verticale_XOR (Mouse_X-6,Debut_Y+Mouse_Y-1,3-(Debut_Y+Fin_Y)); + + if (Mouse_X=0) && (Pos_X=0) && (Pos_Y=0) && (Pos_Y>=0) ) + { + FOND_CURSEUR[Compteur_Y][Compteur_X]=Lit_pixel(Pos_X,Pos_Y); + if (Couleur!=CM_Trans) + Pixel(Pos_X,Pos_Y,Couleur); + } + } + break; + case FORME_CURSEUR_CIBLE_XOR : + Pos_X=Pinceau_X-Principal_Decalage_X; + Pos_Y=Pinceau_Y-Principal_Decalage_Y; + + Compteur_X=(Loupe_Mode)?Principal_Split:Largeur_ecran; // Largeur de la barre XOR + if ((Pos_Y=Limite_Haut)) + Ligne_horizontale_XOR(0,Pinceau_Y-Principal_Decalage_Y,Compteur_X); + + if ((Pos_X=Limite_Gauche)) + Ligne_verticale_XOR(Pinceau_X-Principal_Decalage_X,0,Menu_Ordonnee); + + if (Loupe_Mode) + { + if ((Pinceau_Y>=Limite_Haut_Zoom) && (Pinceau_Y<=Limite_visible_Bas_Zoom)) + Ligne_horizontale_XOR_Zoom(Limite_Gauche_Zoom,Pinceau_Y,Loupe_Largeur); + if ((Pinceau_X>=Limite_Gauche_Zoom) && (Pinceau_X<=Limite_visible_Droite_Zoom)) + Ligne_verticale_XOR_Zoom(Pinceau_X,Limite_Haut_Zoom,Loupe_Hauteur); + } + break; + case FORME_CURSEUR_RECTANGLE_XOR : + // !!! Cette forme ne peut pas être utilisée en mode Loupe !!! + Debut_X=Mouse_X-(Loupe_Largeur>>1); + Debut_Y=Mouse_Y-(Loupe_Hauteur>>1); + if (Debut_X+Loupe_Largeur>=Limite_Droite-Principal_Decalage_X) + Debut_X=Limite_Droite-Loupe_Largeur-Principal_Decalage_X+1; + if (Debut_Y+Loupe_Hauteur>=Limite_Bas-Principal_Decalage_Y) + Debut_Y=Limite_Bas-Loupe_Hauteur-Principal_Decalage_Y+1; + if (Debut_X<0) + Debut_X=0; + if (Debut_Y<0) + Debut_Y=0; + Fin_X=Debut_X+Loupe_Largeur-1; + Fin_Y=Debut_Y+Loupe_Hauteur-1; + + Ligne_horizontale_XOR(Debut_X,Debut_Y,Loupe_Largeur); + Ligne_verticale_XOR(Debut_X,Debut_Y+1,Loupe_Hauteur-2); + Ligne_verticale_XOR( Fin_X,Debut_Y+1,Loupe_Hauteur-2); + Ligne_horizontale_XOR(Debut_X, Fin_Y,Loupe_Largeur); + + Debut_X=(Mouse_X-3); + Debut_Y=(Mouse_Y-3); + Fin_X =(Mouse_X+4); + Fin_Y =(Mouse_Y+4); + if (Debut_X<0) + Debut_X=0; + if (Debut_Y<0) + Debut_Y=0; + if (Fin_X>Largeur_ecran) + Fin_X=Largeur_ecran; + if (Fin_Y>Menu_Ordonnee) + Fin_Y=Menu_Ordonnee; + + Ligne_horizontale_XOR(Debut_X,Mouse_Y,Fin_X-Debut_X); + Ligne_verticale_XOR (Mouse_X,Debut_Y,Fin_Y-Debut_Y); + break; + default: //case FORME_CURSEUR_ROTATE_XOR : + Debut_X=1-(Brosse_Largeur>>1); + Debut_Y=1-(Brosse_Hauteur>>1); + Fin_X=Debut_X+Brosse_Largeur-1; + Fin_Y=Debut_Y+Brosse_Hauteur-1; + + if (Brosse_Centre_rotation_defini) + { + if ( (Brosse_Centre_rotation_X==Pinceau_X) + && (Brosse_Centre_rotation_Y==Pinceau_Y) ) + { + cosA=1.0; + sinA=0.0; + } + else + { + Pos_X=Pinceau_X-Brosse_Centre_rotation_X; + Pos_Y=Pinceau_Y-Brosse_Centre_rotation_Y; + cosA=(float)Pos_X/sqrt((Pos_X*Pos_X)+(Pos_Y*Pos_Y)); + sinA=sin(acos(cosA)); + if (Pos_Y>0) sinA=-sinA; + } + + Transformer_point(Debut_X,Debut_Y, cosA,sinA, &X1,&Y1); + Transformer_point(Fin_X ,Debut_Y, cosA,sinA, &X2,&Y2); + Transformer_point(Debut_X,Fin_Y , cosA,sinA, &X3,&Y3); + Transformer_point(Fin_X ,Fin_Y , cosA,sinA, &X4,&Y4); + + X1+=Brosse_Centre_rotation_X; + Y1+=Brosse_Centre_rotation_Y; + X2+=Brosse_Centre_rotation_X; + Y2+=Brosse_Centre_rotation_Y; + X3+=Brosse_Centre_rotation_X; + Y3+=Brosse_Centre_rotation_Y; + X4+=Brosse_Centre_rotation_X; + Y4+=Brosse_Centre_rotation_Y; + Pixel_figure_Preview_xor(Brosse_Centre_rotation_X,Brosse_Centre_rotation_Y,0); + Tracer_ligne_Preview_xor(Brosse_Centre_rotation_X,Brosse_Centre_rotation_Y,Pinceau_X,Pinceau_Y,0); + } + else + { + X1=X3=1-Brosse_Largeur; + Y1=Y2=Debut_Y; + X2=X4=Pinceau_X; + Y3=Y4=Fin_Y; + + X1+=Pinceau_X; + Y1+=Pinceau_Y; + Y2+=Pinceau_Y; + X3+=Pinceau_X; + Y3+=Pinceau_Y; + Y4+=Pinceau_Y; + Pixel_figure_Preview_xor(Pinceau_X-Fin_X,Pinceau_Y,0); + Tracer_ligne_Preview_xor(Pinceau_X-Fin_X,Pinceau_Y,Pinceau_X,Pinceau_Y,0); + } + + Tracer_ligne_Preview_xor(X1,Y1,X2,Y2,0); + Tracer_ligne_Preview_xor(X2,Y2,X4,Y4,0); + Tracer_ligne_Preview_xor(X4,Y4,X3,Y3,0); + Tracer_ligne_Preview_xor(X3,Y3,X1,Y1,0); + } +} + + // -- Effacer le curseur -- + +void Effacer_curseur(void) +{ + byte Forme; + short Debut_X; + short Debut_Y; + short Fin_X; + short Fin_Y; + short Pos_X; + short Pos_Y; + short Compteur_X; + short Compteur_Y; + //short Fin_Compteur_X; // Position X ou s'arrête l'affichage de la brosse/pinceau + //short Fin_Compteur_Y; // Position Y ou s'arrête l'affichage de la brosse/pinceau + int Temp; + //byte Couleur; + float cosA,sinA; + short X1,Y1,X2,Y2,X3,Y3,X4,Y4; + + if ( ( (Mouse_Y=Principal_X_Zoom) ) ) + || (Une_fenetre_est_ouverte) || (Forme_curseur==FORME_CURSEUR_SABLIER) ) + Forme=Forme_curseur; + else + Forme=FORME_CURSEUR_FLECHE; + + switch(Forme) + { + case FORME_CURSEUR_CIBLE : + if (!Cacher_curseur) + { + if (Config.Curseur==1) + { + Debut_Y=(Mouse_Y<6)?6-Mouse_Y:0; + if (Debut_Y<4) + Ligne_verticale_XOR (Mouse_X,Mouse_Y+Debut_Y-6,4-Debut_Y); + + Debut_X=(Mouse_X<6)?(short)6-Mouse_X:0; + if (Debut_X<4) + Ligne_horizontale_XOR(Mouse_X+Debut_X-6,Mouse_Y,4-Debut_X); + + Fin_X=(Mouse_X+7>Largeur_ecran)?Mouse_X+7-Largeur_ecran:0; + if (Fin_X<4) + Ligne_horizontale_XOR(Mouse_X+3,Mouse_Y,4-Fin_X); + + Fin_Y=(Mouse_Y+7>Menu_Ordonnee/*Hauteur_ecran*/)?Mouse_Y+7-Menu_Ordonnee/*Hauteur_ecran*/:0; + if (Fin_Y<4) + Ligne_verticale_XOR (Mouse_X,Mouse_Y+3,4-Fin_Y); + } + else + { + Temp=(Config.Curseur)?FORME_CURSEUR_CIBLE_FINE:FORME_CURSEUR_CIBLE; + Debut_X=Mouse_X-Curseur_Decalage_X[Temp]; + Debut_Y=Mouse_Y-Curseur_Decalage_Y[Temp]; + + for (Pos_X=Debut_X,Compteur_X=0;Compteur_X<15;Pos_X++,Compteur_X++) + for (Pos_Y=Debut_Y,Compteur_Y=0;Compteur_Y<15;Pos_Y++,Compteur_Y++) + if ( (Pos_X>=0) && (Pos_X=0) && (Pos_YLargeur_ecran)?Mouse_X+6-Largeur_ecran:0; + if (Fin_X<3) + Ligne_horizontale_XOR(Mouse_X+3,Mouse_Y,3-Fin_X); + + Fin_Y=(Mouse_Y+6>Menu_Ordonnee/*Hauteur_ecran*/)?Mouse_Y+6-Menu_Ordonnee/*Hauteur_ecran*/:0; + if (Fin_Y<3) + Ligne_verticale_XOR (Mouse_X,Mouse_Y+3,3-Fin_Y); + + // Petites barres aux extrémités + + Debut_X=(!Mouse_X); + Debut_Y=(!Mouse_Y); + Fin_X=(Mouse_X>=Largeur_ecran-1); + Fin_Y=(Mouse_Y>=Menu_Ordonnee-1); + + if (Mouse_Y>5) + Ligne_horizontale_XOR(Debut_X+Mouse_X-1,Mouse_Y-6,3-(Debut_X+Fin_X)); + + if (Mouse_X>5) + Ligne_verticale_XOR (Mouse_X-6,Debut_Y+Mouse_Y-1,3-(Debut_Y+Fin_Y)); + + if (Mouse_X=0) && (Pos_X=0) && (Pos_Y=0) && (Pos_Y>=0) ) + Pixel(Pos_X,Pos_Y,FOND_CURSEUR[Compteur_Y][Compteur_X]); + break; + case FORME_CURSEUR_CIBLE_XOR : + Pos_X=Pinceau_X-Principal_Decalage_X; + Pos_Y=Pinceau_Y-Principal_Decalage_Y; + + Compteur_X=(Loupe_Mode)?Principal_Split:Largeur_ecran; // Largeur de la barre XOR + if ((Pos_Y=Limite_Haut)) + Ligne_horizontale_XOR(0,Pinceau_Y-Principal_Decalage_Y,Compteur_X); + + if ((Pos_X=Limite_Gauche)) + Ligne_verticale_XOR(Pinceau_X-Principal_Decalage_X,0,Menu_Ordonnee); + + if (Loupe_Mode) + { + if ((Pinceau_Y>=Limite_Haut_Zoom) && (Pinceau_Y<=Limite_visible_Bas_Zoom)) + Ligne_horizontale_XOR_Zoom(Limite_Gauche_Zoom,Pinceau_Y,Loupe_Largeur); + if ((Pinceau_X>=Limite_Gauche_Zoom) && (Pinceau_X<=Limite_visible_Droite_Zoom)) + Ligne_verticale_XOR_Zoom(Pinceau_X,Limite_Haut_Zoom,Loupe_Hauteur); + } + break; + case FORME_CURSEUR_RECTANGLE_XOR : + // !!! Cette forme ne peut pas être utilisée en mode Loupe !!! + Debut_X=Mouse_X-(Loupe_Largeur>>1); + Debut_Y=Mouse_Y-(Loupe_Hauteur>>1); + if (Debut_X+Loupe_Largeur>=Limite_Droite-Principal_Decalage_X) + Debut_X=Limite_Droite-Loupe_Largeur-Principal_Decalage_X+1; + if (Debut_Y+Loupe_Hauteur>=Limite_Bas-Principal_Decalage_Y) + Debut_Y=Limite_Bas-Loupe_Hauteur-Principal_Decalage_Y+1; + if (Debut_X<0) + Debut_X=0; + if (Debut_Y<0) + Debut_Y=0; + Fin_X=Debut_X+Loupe_Largeur-1; + Fin_Y=Debut_Y+Loupe_Hauteur-1; + + Ligne_horizontale_XOR(Debut_X,Debut_Y,Loupe_Largeur); + Ligne_verticale_XOR(Debut_X,Debut_Y+1,Loupe_Hauteur-2); + Ligne_verticale_XOR( Fin_X,Debut_Y+1,Loupe_Hauteur-2); + Ligne_horizontale_XOR(Debut_X, Fin_Y,Loupe_Largeur); + + Debut_X=(Mouse_X-3); + Debut_Y=(Mouse_Y-3); + Fin_X =(Mouse_X+4); + Fin_Y =(Mouse_Y+4); + if (Debut_X<0) + Debut_X=0; + if (Debut_Y<0) + Debut_Y=0; + if (Fin_X>Largeur_ecran) + Fin_X=Largeur_ecran; + if (Fin_Y>Menu_Ordonnee) + Fin_Y=Menu_Ordonnee; + + Ligne_horizontale_XOR(Debut_X,Mouse_Y,Fin_X-Debut_X); + Ligne_verticale_XOR (Mouse_X,Debut_Y,Fin_Y-Debut_Y); + break; + default: //case FORME_CURSEUR_ROTATE_XOR : + Debut_X=1-(Brosse_Largeur>>1); + Debut_Y=1-(Brosse_Hauteur>>1); + Fin_X=Debut_X+Brosse_Largeur-1; + Fin_Y=Debut_Y+Brosse_Hauteur-1; + + if (Brosse_Centre_rotation_defini) + { + if ( (Brosse_Centre_rotation_X==Pinceau_X) + && (Brosse_Centre_rotation_Y==Pinceau_Y) ) + { + cosA=1.0; + sinA=0.0; + } + else + { + Pos_X=Pinceau_X-Brosse_Centre_rotation_X; + Pos_Y=Pinceau_Y-Brosse_Centre_rotation_Y; + cosA=(float)Pos_X/sqrt((Pos_X*Pos_X)+(Pos_Y*Pos_Y)); + sinA=sin(acos(cosA)); + if (Pos_Y>0) sinA=-sinA; + } + + Transformer_point(Debut_X,Debut_Y, cosA,sinA, &X1,&Y1); + Transformer_point(Fin_X ,Debut_Y, cosA,sinA, &X2,&Y2); + Transformer_point(Debut_X,Fin_Y , cosA,sinA, &X3,&Y3); + Transformer_point(Fin_X ,Fin_Y , cosA,sinA, &X4,&Y4); + + X1+=Brosse_Centre_rotation_X; + Y1+=Brosse_Centre_rotation_Y; + X2+=Brosse_Centre_rotation_X; + Y2+=Brosse_Centre_rotation_Y; + X3+=Brosse_Centre_rotation_X; + Y3+=Brosse_Centre_rotation_Y; + X4+=Brosse_Centre_rotation_X; + Y4+=Brosse_Centre_rotation_Y; + Pixel_figure_Preview_xor(Brosse_Centre_rotation_X,Brosse_Centre_rotation_Y,0); + Tracer_ligne_Preview_xor(Brosse_Centre_rotation_X,Brosse_Centre_rotation_Y,Pinceau_X,Pinceau_Y,0); + } + else + { + X1=X3=1-Brosse_Largeur; + Y1=Y2=Debut_Y; + X2=X4=Pinceau_X; + Y3=Y4=Fin_Y; + + X1+=Pinceau_X; + Y1+=Pinceau_Y; + Y2+=Pinceau_Y; + X3+=Pinceau_X; + Y3+=Pinceau_Y; + Y4+=Pinceau_Y; + Pixel_figure_Preview_xor(Pinceau_X-Fin_X,Pinceau_Y,0); + Tracer_ligne_Preview_xor(Pinceau_X-Fin_X,Pinceau_Y,Pinceau_X,Pinceau_Y,0); + } + + Tracer_ligne_Preview_xor(X1,Y1,X2,Y2,0); + Tracer_ligne_Preview_xor(X2,Y2,X4,Y4,0); + Tracer_ligne_Preview_xor(X4,Y4,X3,Y3,0); + Tracer_ligne_Preview_xor(X3,Y3,X1,Y1,0); + } +} + + + +//---- Fenêtre demandant de confirmer une action et renvoyant la réponse ----- +byte Demande_de_confirmation(char * Message) +{ + short Bouton_clicke; + word Largeur_de_la_fenetre; + + Largeur_de_la_fenetre=(strlen(Message)<<3)+20; + + if (Largeur_de_la_fenetre<120) + Largeur_de_la_fenetre=120; + + Ouvrir_fenetre(Largeur_de_la_fenetre,60,"Confirmation"); + + Print_dans_fenetre((Largeur_de_la_fenetre>>1)-(strlen(Message)<<2),20,Message,CM_Noir,CM_Clair); + + Fenetre_Definir_bouton_normal((Largeur_de_la_fenetre/3)-20 ,37,40,14,"Yes",1,1,0x0015); // 1 + Fenetre_Definir_bouton_normal(((Largeur_de_la_fenetre<<1)/3)-20,37,40,14,"No" ,1,1,0x0031); // 2 + + Afficher_curseur(); + + do + { + Bouton_clicke=Fenetre_Bouton_clicke(); + if (Touche==0x001C) Bouton_clicke=1; + if (Touche==0x0001) Bouton_clicke=2; + } + while (Bouton_clicke<=0); + + Fermer_fenetre(); + Afficher_curseur(); + + return (Bouton_clicke==1)? 1 : 0; +} + + + +//---- Fenêtre avertissant de quelque chose et attendant un click sur OK ----- +void Warning_message(char * Message) +{ + short Bouton_clicke; + word Largeur_de_la_fenetre; + + Largeur_de_la_fenetre=(strlen(Message)<<3)+20; + if (Largeur_de_la_fenetre<120) + Largeur_de_la_fenetre=120; + + Ouvrir_fenetre(Largeur_de_la_fenetre,60,"Warning!"); + + Print_dans_fenetre((Largeur_de_la_fenetre>>1)-(strlen(Message)<<2),20,Message,CM_Noir,CM_Clair); + Fenetre_Definir_bouton_normal((Largeur_de_la_fenetre>>1)-20 ,37,40,14,"OK",1,1,0x001C); // 1 + Afficher_curseur(); + + do + Bouton_clicke=Fenetre_Bouton_clicke(); + while ((Bouton_clicke<=0) && (Touche!=0x0001) && (Touche!=0x0018)); + + Fermer_fenetre(); + Afficher_curseur(); +} + + + +// -- Fonction diverses d'affichage ------------------------------------------ + + // -- Reafficher toute l'image (en prenant en compte le facteur de zoom) -- + +void Afficher_ecran(void) +{ + word Largeur; + word Hauteur; + + // ---/\/\/\ Partie non zoomée: /\/\/\--- + if (Loupe_Mode) + { + if (Principal_Largeur_image à 64 lignes fct(Menu_Facteur) + word Nb_couleurs =(Debut_block<=Fin_block)?Fin_block-Debut_block+1:Debut_block-Fin_block+1; + word Ligne_en_cours=(Debut_block<=Fin_block)?0:Total_lignes-1; + + word Debut_X =Fenetre_Pos_X+(Menu_Facteur_X*Pos_X); + word Largeur_ligne =Menu_Facteur_X<<4; // <=> à 16 pixels fct(Menu_Facteur) + + word Debut_Y =Fenetre_Pos_Y+(Menu_Facteur_Y*Pos_Y); + word Fin_Y =Debut_Y+Total_lignes; + word Indice; + + if (Debut_block>Fin_block) + { + Indice=Debut_block; + Debut_block=Fin_block; + Fin_block=Indice; + } + + for (Indice=Debut_Y;IndiceFin_X) + { + Temporaire=Debut_X; + Debut_X =Fin_X; + Fin_X =Temporaire; + } + if (Debut_Y>Fin_Y) + { + Temporaire=Debut_Y; + Debut_Y =Fin_Y; + Fin_Y =Temporaire; + } + + // On ne capture la nouvelle brosse que si elle est au moins partiellement + // dans l'image: + + if ((Debut_XPrincipal_Largeur_image) + Nouvelle_Brosse_Largeur=Principal_Largeur_image-Debut_X; + if (Debut_Y+Nouvelle_Brosse_Hauteur>Principal_Hauteur_image) + Nouvelle_Brosse_Hauteur=Principal_Hauteur_image-Debut_Y; + + if ( (((long)Brosse_Hauteur)*Brosse_Largeur) != + (((long)Nouvelle_Brosse_Hauteur)*Nouvelle_Brosse_Largeur) ) + { + free(Brosse); + Brosse=(byte *)malloc(((long)Nouvelle_Brosse_Hauteur)*Nouvelle_Brosse_Largeur); + if (!Brosse) + { + Erreur(0); + + Brosse=(byte *)malloc(1*1); + Nouvelle_Brosse_Hauteur=Nouvelle_Brosse_Largeur=1; + *Brosse=Fore_color; + } + } + Brosse_Largeur=Nouvelle_Brosse_Largeur; + Brosse_Hauteur=Nouvelle_Brosse_Hauteur; + + free(Smear_Brosse); + Smear_Brosse_Largeur=(Brosse_Largeur>TAILLE_MAXI_PINCEAU)?Brosse_Largeur:TAILLE_MAXI_PINCEAU; + Smear_Brosse_Hauteur=(Brosse_Hauteur>TAILLE_MAXI_PINCEAU)?Brosse_Hauteur:TAILLE_MAXI_PINCEAU; + Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Hauteur)*Smear_Brosse_Largeur); + + if (!Smear_Brosse) // On ne peut même pas allouer la brosse du smear! + { + Erreur(0); + + free(Brosse); + Brosse=(byte *)malloc(1*1); + Brosse_Hauteur=1; + Brosse_Largeur=1; + + Smear_Brosse=(byte *)malloc(TAILLE_MAXI_PINCEAU*TAILLE_MAXI_PINCEAU); + Smear_Brosse_Hauteur=TAILLE_MAXI_PINCEAU; + Smear_Brosse_Largeur=TAILLE_MAXI_PINCEAU; + } + + Copier_image_dans_brosse(Debut_X,Debut_Y,Brosse_Largeur,Brosse_Hauteur,Principal_Largeur_image); + + // On regarde s'il faut effacer quelque chose: + if (Effacement) + { + for (Pos_Y=Debut_Y;Pos_Y>1); + Brosse_Decalage_Y=(Brosse_Hauteur>>1); + } +} + + +void Rotate_90_deg() +{ + short Temporaire; + byte * Nouvelle_Brosse; + + Nouvelle_Brosse=(byte *)malloc(((long)Brosse_Hauteur)*Brosse_Largeur); + if (Nouvelle_Brosse) + { + Rotate_90_deg_LOWLEVEL(Brosse,Nouvelle_Brosse); + free(Brosse); + Brosse=Nouvelle_Brosse; + + Temporaire=Brosse_Largeur; + Brosse_Largeur=Brosse_Hauteur; + Brosse_Hauteur=Temporaire; + + Temporaire=Smear_Brosse_Largeur; + Smear_Brosse_Largeur=Smear_Brosse_Hauteur; + Smear_Brosse_Hauteur=Temporaire; + + // On centre la prise sur la brosse + Brosse_Decalage_X=(Brosse_Largeur>>1); + Brosse_Decalage_Y=(Brosse_Hauteur>>1); + } + else + Erreur(0); +} + + +void Remap_brosse(void) +{ + short Pos_X; // Variable de balayage de la brosse + short Pos_Y; // Variable de balayage de la brosse + byte Utilisee[256]; // Tableau de booléens "La couleur est utilisée" + int Couleur; + + + // On commence par initialiser le tableau de booléens à faux + for (Couleur=0;Couleur<=255;Couleur++) + Utilisee[Couleur]=0; + + // On calcule la table d'utilisation des couleurs + for (Pos_Y=0;Pos_Y>1); + Brosse_Decalage_Y=(Brosse_Hauteur>>1); + + free(Temporaire); // Libération de l'ancienne brosse + + // Réallocation d'un buffer de Smear + free(Smear_Brosse); + Smear_Brosse_Largeur=(Brosse_Largeur>TAILLE_MAXI_PINCEAU)?Brosse_Largeur:TAILLE_MAXI_PINCEAU; + Smear_Brosse_Hauteur=(Brosse_Hauteur>TAILLE_MAXI_PINCEAU)?Brosse_Hauteur:TAILLE_MAXI_PINCEAU; + Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Largeur)*Smear_Brosse_Hauteur); + } + else + Erreur(0); // Pas assez de mémoire! +} + + +void Nibble_brush(void) +{ + long /*Pos,*/Pos_X,Pos_Y; + byte Etat; + byte * Nouvelle_brosse; + byte * Temporaire; + word Largeur; + word Hauteur; + + if ( (Brosse_Largeur>2) && (Brosse_Hauteur>2) ) + { + Largeur=Brosse_Largeur-2; + Hauteur=Brosse_Hauteur-2; + Nouvelle_brosse=(byte *)malloc(((long)Largeur)*Hauteur); + + if (Nouvelle_brosse) + { + // On copie la brosse courante dans la nouvelle + Copier_une_partie_d_image_dans_une_autre(Brosse, // Source + 1, + 1, + Largeur, + Hauteur, + Brosse_Largeur, + Nouvelle_brosse, // Destination + 0, + 0, + Largeur); + + // On intervertit la nouvelle et l'ancienne brosse: + Temporaire=Brosse; + Brosse=Nouvelle_brosse; + Brosse_Largeur-=2; + Brosse_Hauteur-=2; + Largeur+=2; + Hauteur+=2; + + // 1er balayage (horizontal) + for (Pos_Y=0; Pos_Y0) + Pixel_dans_brosse(Pos_X-1,Pos_Y,Back_color); + Etat=0; + } + } + else + { + if (!Etat) + { + Pixel_dans_brosse(Pos_X,Pos_Y,Back_color); + Etat=1; + } + } + } + // Cas du dernier pixel à droite de la ligne + if (Temporaire[((Pos_Y+1)*Largeur)+Pos_X+1]==Back_color) + Pixel_dans_brosse(Pos_X-1,Pos_Y,Back_color); + } + + // 2ème balayage (vertical) + for (Pos_X=0; Pos_X0) + Pixel_dans_brosse(Pos_X,Pos_Y-1,Back_color); + Etat=0; + } + } + else + { + if (!Etat) + { + Pixel_dans_brosse(Pos_X,Pos_Y,Back_color); + Etat=1; + } + } + } + // Cas du dernier pixel en bas de la colonne + if (Temporaire[((Pos_Y+1)*Largeur)+Pos_X+1]==Back_color) + Pixel_dans_brosse(Pos_X,Pos_Y-1,Back_color); + } + + // On recentre la prise sur la brosse + Brosse_Decalage_X=(Brosse_Largeur>>1); + Brosse_Decalage_Y=(Brosse_Hauteur>>1); + + free(Temporaire); // Libération de l'ancienne brosse + + // Réallocation d'un buffer de Smear + free(Smear_Brosse); + Smear_Brosse_Largeur=(Brosse_Largeur>TAILLE_MAXI_PINCEAU)?Brosse_Largeur:TAILLE_MAXI_PINCEAU; + Smear_Brosse_Hauteur=(Brosse_Hauteur>TAILLE_MAXI_PINCEAU)?Brosse_Hauteur:TAILLE_MAXI_PINCEAU; + Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Largeur)*Smear_Brosse_Hauteur); + } + else + Erreur(0); // Pas assez de mémoire! + } +} + + +#include "pages.c" + + +////////////////////////////////////////////////////////////////////////////// +////////////////////////////// GESTION DU FILLER ///////////////////////////// +////////////////////////////////////////////////////////////////////////////// + + +void Fill(short * Limite_atteinte_Haut , short * Limite_atteinte_Bas, + short * Limite_atteinte_Gauche, short * Limite_atteinte_Droite) +// +// Cette fonction fait un remplissage classique d'une zone délimitée de +// l'image. Les limites employées sont Limite_Haut, Limite_Bas, Limite_Gauche +// et Limite_Droite. Le point de départ du remplissage est Pinceau_X,Pinceau_Y +// et s'effectue en théorie sur la couleur 1 et emploie la couleur 2 pour le +// remplissage. Ces restrictions sont d–es à l'utilisation qu'on en fait dans +// la fonction principale "Remplir", qui se charge de faire une gestion de +// tous les effets. +// Cette fonction ne doit pas être directement appelée. +// +{ + short Pos_X; // Abscisse de balayage du segment, utilisée lors de l'"affichage" + short Ligne; // Ordonnée de la ligne en cours de traitement + short Debut_X; // Abscisse de départ du segment traité + short Fin_X; // Abscisse de fin du segment traité + int Modifs_effectuees; // Booléen "On a fait une modif dans le dernier passage" + int Propagation_possible; // Booléen "On peut propager la couleur dans le segment" + short Limite_courante_Bas; // Intervalle vertical restreint + short Limite_courante_Haut; + int Ligne_modifiee; // Booléen "On a fait une modif dans la ligne" + + Modifs_effectuees=1; + Limite_courante_Haut=Pinceau_Y; + Limite_courante_Bas =Min(Pinceau_Y+1,Limite_Bas); + *Limite_atteinte_Gauche=Pinceau_X; + *Limite_atteinte_Droite=Pinceau_X+1; + Pixel_dans_ecran_courant(Pinceau_X,Pinceau_Y,2); + + while (Modifs_effectuees) + { + Modifs_effectuees=0; + + for (Ligne=Limite_courante_Haut;Ligne<=Limite_courante_Bas;Ligne++) + { + Ligne_modifiee=0; + // On va traiter le cas de la ligne nø Ligne. + + // On commence le traitement à la gauche de l'écran + Debut_X=Limite_Gauche; + + // Pour chaque segment de couleur 1 que peut contenir la ligne + while (Debut_X<=Limite_Droite) + { + // On cherche son début + for (;(Debut_X<=Limite_Droite) && + (Lit_pixel_dans_ecran_courant(Debut_X,Ligne)!=1);Debut_X++); + + if (Debut_X<=Limite_Droite) + { + // Un segment de couleur 1 existe et commence à la position Debut_X. + // On va donc en chercher la fin. + for (Fin_X=Debut_X+1;(Fin_X<=Limite_Droite) && + (Lit_pixel_dans_ecran_courant(Fin_X,Ligne)==1);Fin_X++); + + // On sait qu'il existe un segment de couleur 1 qui commence en + // Debut_X et qui se termine en Fin_X-1. + + // On va maintenant regarder si une couleur sur la périphérie + // permet de colorier ce segment avec la couleur 2. + + Propagation_possible=( + // Test de la présence d'un point à gauche du segment + ((Debut_X>Limite_Gauche) && + (Lit_pixel_dans_ecran_courant(Debut_X-1,Ligne)==2)) || + // Test de la présence d'un point à droite du segment + ((Fin_X-1Limite_Haut)) + for (Pos_X=Debut_X;Pos_X*Limite_atteinte_Droite) + *Limite_atteinte_Droite=Fin_X; + // On remplit le segment de Debut_X à Fin_X-1. + for (Pos_X=Debut_X;Pos_XLimite_Haut) + Limite_courante_Haut--; + + for (Ligne=Limite_courante_Bas;Ligne>=Limite_courante_Haut;Ligne--) + { + Ligne_modifiee=0; + // On va traiter le cas de la ligne nø Ligne. + + // On commence le traitement à la gauche de l'écran + Debut_X=Limite_Gauche; + + // Pour chaque segment de couleur 1 que peut contenir la ligne + while (Debut_X<=Limite_Droite) + { + // On cherche son début + for (;(Debut_X<=Limite_Droite) && + (Lit_pixel_dans_ecran_courant(Debut_X,Ligne)!=1);Debut_X++); + + if (Debut_X<=Limite_Droite) + { + // Un segment de couleur 1 existe et commence à la position Debut_X. + // On va donc en chercher la fin. + for (Fin_X=Debut_X+1;(Fin_X<=Limite_Droite) && + (Lit_pixel_dans_ecran_courant(Fin_X,Ligne)==1);Fin_X++); + + // On sait qu'il existe un segment de couleur 1 qui commence en + // Debut_X et qui se termine en Fin_X-1. + + // On va maintenant regarder si une couleur sur la périphérie + // permet de colorier ce segment avec la couleur 2. + + Propagation_possible=( + // Test de la présence d'un point à gauche du segment + ((Debut_X>Limite_Gauche) && + (Lit_pixel_dans_ecran_courant(Debut_X-1,Ligne)==2)) || + // Test de la présence d'un point à droite du segment + ((Fin_X-1*Limite_atteinte_Droite) + *Limite_atteinte_Droite=Fin_X; + // On remplit le segment de Debut_X à Fin_X-1. + for (Pos_X=Debut_X;Pos_XLimite_Haut) ) + Limite_courante_Haut--; // On monte cette limite vers le haut + } + } + + *Limite_atteinte_Haut=Limite_courante_Haut; + *Limite_atteinte_Bas =Limite_courante_Bas; + (*Limite_atteinte_Droite)--; +} // Fin de la routine de remplissage "Fill" + + +void Remplir(byte Couleur_de_remplissage) +// +// Cette fonction fait un remplissage qui gère tous les effets. Elle fait +// appel à "Fill()". +// +{ + byte Forme_curseur_avant_remplissage; + byte * FX_Feedback_Ecran_avant_remplissage; + short Pos_X,Pos_Y; + short Limite_atteinte_Haut ,Limite_atteinte_Bas; + short Limite_atteinte_Gauche,Limite_atteinte_Droite; + byte Table_de_remplacement[256]; + + + // Avant toute chose, on vérifie que l'on n'est pas en train de remplir + // en dehors de l'image: + + if ( (Pinceau_X>=Limite_Gauche) && + (Pinceau_X<=Limite_Droite) && + (Pinceau_Y>=Limite_Haut) && + (Pinceau_Y<=Limite_Bas) ) + { + // On suppose que le curseur est déjà caché. + // Effacer_curseur(); + + // On va faire patienter l'utilisateur en lui affichant un joli petit + // sablier: + Forme_curseur_avant_remplissage=Forme_curseur; + Forme_curseur=FORME_CURSEUR_SABLIER; + Afficher_curseur(); + + // On commence par effectuer un backup de l'image. + Backup(); + + // On fait attention au Feedback qui DOIT se faire avec le backup. + FX_Feedback_Ecran_avant_remplissage=FX_Feedback_Ecran; + FX_Feedback_Ecran=Ecran_backup; + + // On va maintenant "épurer" la zone visible de l'image: + memset(Table_de_remplacement,0,256); + Table_de_remplacement[Lit_pixel_dans_ecran_courant(Pinceau_X,Pinceau_Y)]=1; + Remplacer_toutes_les_couleurs_dans_limites(Table_de_remplacement); + + // On fait maintenant un remplissage classique de la couleur 1 avec la 2 + Fill(&Limite_atteinte_Haut ,&Limite_atteinte_Bas, + &Limite_atteinte_Gauche,&Limite_atteinte_Droite); + + // On s'apprête à faire des opérations qui nécessitent un affichage. Il + // faut donc retirer de l'écran le curseur: + Effacer_curseur(); + Forme_curseur=Forme_curseur_avant_remplissage; + + // Il va maintenant falloir qu'on "turn" ce gros caca "into" un truc qui + // ressemble un peu plus à ce à quoi l'utilisateur peut s'attendre. + if (Limite_atteinte_Haut>Limite_Haut) + Copier_une_partie_d_image_dans_une_autre(Ecran_backup, + Limite_Gauche,Limite_Haut, + (Limite_Droite-Limite_Gauche)+1, + Limite_atteinte_Haut-Limite_Haut, + Principal_Largeur_image,Principal_Ecran, + Limite_Gauche,Limite_Haut,Principal_Largeur_image); + if (Limite_atteinte_BasLimite_Gauche) + Copier_une_partie_d_image_dans_une_autre(Ecran_backup, + Limite_Gauche,Limite_atteinte_Haut, + Limite_atteinte_Gauche-Limite_Gauche, + (Limite_atteinte_Bas-Limite_atteinte_Haut)+1, + Principal_Largeur_image,Principal_Ecran, + Limite_Gauche,Limite_atteinte_Haut,Principal_Largeur_image); + if (Limite_atteinte_Droite=Limite_Gauche) && + (Pos_X<=Limite_Droite) && + (Pos_Y>=Limite_Haut) && + (Pos_Y<=Limite_Bas) ) + Pixel_Preview(Pos_X,Pos_Y,Couleur); + } + + // Affichage d'un point pour une preview en xor + void Pixel_figure_Preview_xor(short Pos_X,short Pos_Y,byte Couleur) + { + if ( (Pos_X>=Limite_Gauche) && + (Pos_X<=Limite_Droite) && + (Pos_Y>=Limite_Haut) && + (Pos_Y<=Limite_Bas) ) + Pixel_Preview(Pos_X,Pos_Y,~Lit_pixel(Pos_X-Principal_Decalage_X, + Pos_Y-Principal_Decalage_Y)); + } + + // Effacement d'un point de preview + void Pixel_figure_Effacer_preview(short Pos_X,short Pos_Y,byte Couleur) + { + if ( (Pos_X>=Limite_Gauche) && + (Pos_X<=Limite_Droite) && + (Pos_Y>=Limite_Haut) && + (Pos_Y<=Limite_Bas) ) + Pixel_Preview(Pos_X,Pos_Y,Lit_pixel_dans_ecran_courant(Pos_X,Pos_Y)); + } + + // Affichage d'un point dans la brosse + void Pixel_figure_Dans_brosse(short Pos_X,short Pos_Y,byte Couleur) + { + Pos_X-=Brosse_Decalage_X; + Pos_Y-=Brosse_Decalage_Y; + if ( (Pos_X>=0) && + (Pos_X=0) && + (Pos_YLimite_Bas) + Fin_Y=Limite_Bas; + if (Debut_XLimite_Droite) + Fin_X=Limite_Droite; + + // Affichage du cercle + for (Pos_Y=Debut_Y,Cercle_Curseur_Y=(long)Debut_Y-Centre_Y;Pos_Y<=Fin_Y;Pos_Y++,Cercle_Curseur_Y++) + for (Pos_X=Debut_X,Cercle_Curseur_X=(long)Debut_X-Centre_X;Pos_X<=Fin_X;Pos_X++,Cercle_Curseur_X++) + if (Pixel_dans_cercle()) + Afficher_pixel(Pos_X,Pos_Y,Couleur); +} + + + // -- Tracer général d'une ellipse vide ----------------------------------- + +void Tracer_ellipse_vide_General(short Centre_X,short Centre_Y,short Rayon_horizontal,short Rayon_vertical,byte Couleur) +{ + short Debut_X; + short Debut_Y; + short Pos_X; + short Pos_Y; + + Debut_X=Centre_X-Rayon_horizontal; + Debut_Y=Centre_Y-Rayon_vertical; + + // Calcul des limites de l'ellipse + Ellipse_Calculer_limites(Rayon_horizontal+1,Rayon_vertical+1); + + // Affichage des extremitées de l'ellipse sur chaque quart de l'ellipse: + for (Pos_Y=Debut_Y,Ellipse_Curseur_Y=-Rayon_vertical;Pos_YLimite_Bas) + Fin_Y=Limite_Bas; + if (Debut_XLimite_Droite) + Fin_X=Limite_Droite; + + // Affichage de l'ellipse + for (Pos_Y=Debut_Y,Ellipse_Curseur_Y=Debut_Y-Centre_Y;Pos_Y<=Fin_Y;Pos_Y++,Ellipse_Curseur_Y++) + for (Pos_X=Debut_X,Ellipse_Curseur_X=Debut_X-Centre_X;Pos_X<=Fin_X;Pos_X++,Ellipse_Curseur_X++) + if (Pixel_dans_ellipse()) + Afficher_pixel(Pos_X,Pos_Y,Couleur); +} + + + // -- Tracer général d'une ligne ------------------------------------------ + +void Tracer_ligne_General(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y, byte Couleur) +{ + short Pos_X,Pos_Y; + short Incr_X,Incr_Y; + short i,Cumul; + short Delta_X,Delta_Y; + + + Pos_X=Debut_X; + Pos_Y=Debut_Y; + + if (Debut_XDelta_X) + { + Cumul=Delta_Y>>1; + for (i=1; i=Delta_Y) + { + Cumul-=Delta_Y; + Pos_X+=Incr_X; + } + Pixel_figure(Pos_X,Pos_Y,Couleur); + } + } + else + { + Cumul=Delta_X>>1; + for (i=1; i=Delta_X) + { + Cumul-=Delta_X; + Pos_Y+=Incr_Y; + } + Pixel_figure(Pos_X,Pos_Y,Couleur); + } + } + + if ( (Debut_X!=Fin_X) || (Debut_Y!=Fin_Y) ) + Pixel_figure(Fin_X,Fin_Y,Couleur); +} + + // -- Tracer définitif d'une ligne -- + +void Tracer_ligne_Definitif(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y, byte Couleur) +{ + Pixel_figure=Pixel_figure_Definitif; + Tracer_ligne_General(Debut_X,Debut_Y,Fin_X,Fin_Y,Couleur); +} + + // -- Tracer la preview d'une ligne -- + +void Tracer_ligne_Preview(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y,byte Couleur) +{ + Pixel_figure=Pixel_figure_Preview; + Tracer_ligne_General(Debut_X,Debut_Y,Fin_X,Fin_Y,Couleur); +} + + // -- Tracer la preview d'une ligne en xor -- + +void Tracer_ligne_Preview_xor(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y,byte Couleur) +{ + Pixel_figure=Pixel_figure_Preview_xor; + Tracer_ligne_General(Debut_X,Debut_Y,Fin_X,Fin_Y,Couleur); +} + + // -- Effacer la preview d'une ligne -- + +void Effacer_ligne_Preview(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y) +{ + Pixel_figure=Pixel_figure_Effacer_preview; + Tracer_ligne_General(Debut_X,Debut_Y,Fin_X,Fin_Y,0); +} + + + // -- Tracer un rectangle vide -- + +void Tracer_rectangle_vide(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y,byte Couleur) +{ + short Tempo; + short Pos_X; + short Pos_Y; + + + // On vérifie que les bornes soient dans le bon sens: + if (Debut_X>Fin_X) + { + Tempo=Debut_X; + Debut_X=Fin_X; + Fin_X=Tempo; + } + if (Debut_Y>Fin_Y) + { + Tempo=Debut_Y; + Debut_Y=Fin_Y; + Fin_Y=Tempo; + } + + // On trace le rectangle: + + for (Pos_X=Debut_X;Pos_X<=Fin_X;Pos_X++) + Afficher_pinceau(Pos_X,Debut_Y,Couleur,0); + + for (Pos_Y=Debut_Y+1;Pos_YFin_X) + { + Tempo=Debut_X; + Debut_X=Fin_X; + Fin_X=Tempo; + } + if (Debut_Y>Fin_Y) + { + Tempo=Debut_Y; + Debut_Y=Fin_Y; + Fin_Y=Tempo; + } + + // Correction en cas de dépassement des limites de l'image + if (Fin_X>Limite_Droite) + Fin_X=Limite_Droite; + if (Fin_Y>Limite_Bas) + Fin_Y=Limite_Bas; + + // On trace le rectangle: + for (Pos_Y=Debut_Y;Pos_Y<=Fin_Y;Pos_Y++) + for (Pos_X=Debut_X;Pos_X<=Fin_X;Pos_X++) + Afficher_pixel(Pos_X,Pos_Y,Couleur); +} + + + + + // -- Tracer une courbe de Bézier -- + +void Tracer_courbe_General(short X1, short Y1, + short X2, short Y2, + short X3, short Y3, + short X4, short Y4, + byte Couleur) +{ + float Delta,T,T2,T3; + short X,Y,Old_X,Old_Y; + word i; + int CX[4]; + int CY[4]; + + // Calcul des vecteurs de coefficients + CX[0]= - X1 + 3*X2 - 3*X3 + X4; + CX[1]= + 3*X1 - 6*X2 + 3*X3; + CX[2]= - 3*X1 + 3*X2; + CX[3]= + X1; + CY[0]= - Y1 + 3*Y2 - 3*Y3 + Y4; + CY[1]= + 3*Y1 - 6*Y2 + 3*Y3; + CY[2]= - 3*Y1 + 3*Y2; + CY[3]= + Y1; + + // Traçage de la courbe + Old_X=X1; + Old_Y=Y1; + Pixel_figure(Old_X,Old_Y,Couleur); + Delta=0.05; // 1.0/20 + T=0; + for (i=1; i<=20; i++) + { + T=T+Delta; T2=T*T; T3=T2*T; + X=Round(T3*CX[0] + T2*CX[1] + T*CX[2] + CX[3]); + Y=Round(T3*CY[0] + T2*CY[1] + T*CY[2] + CY[3]); + Tracer_ligne_General(Old_X,Old_Y,X,Y,Couleur); + Old_X=X; + Old_Y=Y; + } +} + + // -- Tracer une courbe de Bézier définitivement -- + +void Tracer_courbe_Definitif(short X1, short Y1, + short X2, short Y2, + short X3, short Y3, + short X4, short Y4, + byte Couleur) +{ + Pixel_figure=Pixel_figure_Definitif; + Tracer_courbe_General(X1,Y1,X2,Y2,X3,Y3,X4,Y4,Couleur); +} + + // -- Tracer la preview d'une courbe de Bézier -- + +void Tracer_courbe_Preview(short X1, short Y1, + short X2, short Y2, + short X3, short Y3, + short X4, short Y4, + byte Couleur) +{ + Pixel_figure=Pixel_figure_Preview; + Tracer_courbe_General(X1,Y1,X2,Y2,X3,Y3,X4,Y4,Couleur); +} + + // -- Effacer la preview d'une courbe de Bézier -- + +void Effacer_courbe_Preview(short X1, short Y1, + short X2, short Y2, + short X3, short Y3, + short X4, short Y4, + byte Couleur) +{ + Pixel_figure=Pixel_figure_Effacer_preview; + Tracer_courbe_General(X1,Y1,X2,Y2,X3,Y3,X4,Y4,Couleur); +} + + + + + // -- Spray : un petit coup de Pschiitt! -- + +void Aerographe(short Bouton_clicke) +{ + short Pos_X,Pos_Y; + short Rayon=Spray_Size>>1; + long Rayon_au_carre=(long)Rayon*Rayon; + short Indice,Count; + byte Indice_couleur; + byte Sens; + + + Effacer_curseur(); + + if (Spray_Mode) + { + for (Count=1; Count<=Spray_Mono_flow; Count++) + { + Pos_X=(rand()%Spray_Size)-Rayon; + Pos_Y=(rand()%Spray_Size)-Rayon; + if ( (Pos_X*Pos_X)+(Pos_Y*Pos_Y) <= Rayon_au_carre ) + { + Pos_X+=Pinceau_X; + Pos_Y+=Pinceau_Y; + if (Bouton_clicke==1) + Afficher_pinceau(Pos_X,Pos_Y,Fore_color,0); + else + Afficher_pinceau(Pos_X,Pos_Y,Back_color,0); + } + } + } + else + { + // On essaye de se balader dans la table des flux de façon à ce que ce + // ne soit pas toujours la dernière couleur qui soit affichée en dernier + // Pour ça, on part d'une couleur au pif dans une direction aléatoire. + Sens=rand()&1; + for (Indice=0,Indice_couleur=rand()/*%256*/; Indice<256; Indice++) + { + for (Count=1; Count<=Spray_Multi_flow[Indice_couleur]; Count++) + { + Pos_X=(rand()%Spray_Size)-Rayon; + Pos_Y=(rand()%Spray_Size)-Rayon; + if ( (Pos_X*Pos_X)+(Pos_Y*Pos_Y) <= Rayon_au_carre ) + { + Pos_X+=Pinceau_X; + Pos_Y+=Pinceau_Y; + if (Bouton_clicke==A_GAUCHE) + Afficher_pinceau(Pos_X,Pos_Y,Indice_couleur,0); + else + Afficher_pinceau(Pos_X,Pos_Y,Back_color,0); + } + } + if (Sens) + Indice_couleur++; + else + Indice_couleur--; + } + } + + Afficher_curseur(); + + for (Count=1; Count<=Spray_Delay; Count++) + Wait_VBL(); +} + + + + ////////////////////////////////////////////////////////////////////////// + ////////////////////////// GESTION DES DEGRADES ////////////////////////// + ////////////////////////////////////////////////////////////////////////// + + + // -- Gestion d'un dégradé de base (le plus moche) -- + +void Degrade_de_base(long Indice,short Pos_X,short Pos_Y) +{ + long Position; + + // On fait un premier calcul partiel + Position=(Indice*Degrade_Intervalle_bornes); + + // On gère un déplacement au hasard + Position+=(Degrade_Intervalle_total*(rand()%Degrade_Melange_aleatoire)) >>6; + Position-=(Degrade_Intervalle_total*Degrade_Melange_aleatoire) >>7; + + Position/=Degrade_Intervalle_total; + + // On va vérifier que nos petites idioties n'ont pas éjecté la valeur hors + // des valeurs autorisées par le dégradé défini par l'utilisateur. + + if (Position<0) + Position=0; + else if (Position>=Degrade_Intervalle_bornes) + Position=Degrade_Intervalle_bornes-1; + + // On ramène ensuite la position dans le dégradé vers un numéro de couleur + if (Degrade_Inverse) + Traiter_pixel_de_degrade(Pos_X,Pos_Y,Degrade_Borne_Superieure-Position); + else + Traiter_pixel_de_degrade(Pos_X,Pos_Y,Degrade_Borne_Inferieure+Position); +} + + + // -- Gestion d'un dégradé par trames simples -- + +void Degrade_de_trames_simples(long Indice,short Pos_X,short Pos_Y) +{ + long Position_dans_degrade; + long Position_dans_segment; + + // + // But de l'opération: en plus de calculer la position de base (désignée + // dans cette procédure par "Position_dans_degrade", on calcule la position + // de l'indice dans le schéma suivant: + // + // Ú Les indices qui traŒnent de ce c“té du segment se voient subir + // ³ une incrémentation conditionnelle à leur position dans l'écran. + // v + // ÃÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄúúú ú ú + // ^ + // ÀÄ Les indices qui traŒnent de ce c“té du segment se voient subir une + // décrémentation conditionnelle à leur position dans l'écran. + + // On fait d'abord un premier calcul partiel + Position_dans_degrade=(Indice*Degrade_Intervalle_bornes); + + // On gère un déplacement au hasard... + Position_dans_degrade+=(Degrade_Intervalle_total*(rand()%Degrade_Melange_aleatoire)) >>6; + Position_dans_degrade-=(Degrade_Intervalle_total*Degrade_Melange_aleatoire) >>7; + + if (Position_dans_degrade<0) + Position_dans_degrade=0; + + // ... qui nous permet de calculer la position dans le segment + Position_dans_segment=((Position_dans_degrade<<2)/Degrade_Intervalle_total)&3; + + // On peut ensuite terminer le calcul de l'indice dans le dégradé + Position_dans_degrade/=Degrade_Intervalle_total; + + // On va pouvoir discuter de la valeur de Position_dans_degrade en fonction + // de la position dans l'écran et de la Position_dans_segment. + + switch (Position_dans_segment) + { + case 0 : // On est sur la gauche du segment + if (((Pos_X+Pos_Y)&1)==0) + Position_dans_degrade--; + break; + + // On n'a pas à traiter les cas 1 et 2 car ils représentent des valeurs + // suffisament au centre du segment pour ne pas avoir à subir la trame + + case 3 : // On est sur la droite du segment + if (((Pos_X+Pos_Y)&1)!=0) // Note: on doit faire le test inverse au cas gauche pour synchroniser les 2 c“tés de la trame. + Position_dans_degrade++; + } + + // On va vérifier que nos petites idioties n'ont pas éjecté la valeur hors + // des valeurs autorisées par le dégradé défini par l'utilisateur. + + if (Position_dans_degrade<0) + Position_dans_degrade=0; + else if (Position_dans_degrade>=Degrade_Intervalle_bornes) + Position_dans_degrade=Degrade_Intervalle_bornes-1; + + // On ramène ensuite la position dans le dégradé vers un numéro de couleur + if (Degrade_Inverse) + Position_dans_degrade=Degrade_Borne_Superieure-Position_dans_degrade; + else + Position_dans_degrade=Degrade_Borne_Inferieure+Position_dans_degrade; + + Traiter_pixel_de_degrade(Pos_X,Pos_Y,Position_dans_degrade); +} + + + // -- Gestion d'un dégradé par trames étendues -- + +void Degrade_de_trames_etendues(long Indice,short Pos_X,short Pos_Y) +{ + long Position_dans_degrade; + long Position_dans_segment; + + // + // But de l'opération: en plus de calculer la position de base (désignée + // dans cette procédure par "Position_dans_degrade", on calcule la position + // de l'indice dans le schéma suivant: + // + // Ú Les indices qui traŒnent de ce c“té du segment se voient subir + // ³ une incrémentation conditionnelle à leur position dans l'écran. + // v + // ÃÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄúúú ú ú + // ^ + // ÀÄ Les indices qui traŒnent de ce c“té du segment se voient subir une + // décrémentation conditionnelle à leur position dans l'écran. + + // On fait d'abord un premier calcul partiel + Position_dans_degrade=(Indice*Degrade_Intervalle_bornes); + + // On gère un déplacement au hasard + Position_dans_degrade+=(Degrade_Intervalle_total*(rand()%Degrade_Melange_aleatoire)) >>6; + Position_dans_degrade-=(Degrade_Intervalle_total*Degrade_Melange_aleatoire) >>7; + + if (Position_dans_degrade<0) + Position_dans_degrade=0; + + // Qui nous permet de calculer la position dans le segment + Position_dans_segment=((Position_dans_degrade<<3)/Degrade_Intervalle_total)&7; + + // On peut ensuite terminer le calcul de l'indice dans le dégradé + Position_dans_degrade/=Degrade_Intervalle_total; + + // On va pouvoir discuter de la valeur de Position_dans_degrade en fonction + // de la position dans l'écran et de la Position_dans_segment. + + switch (Position_dans_segment) + { + case 0 : // On est sur l'extrême gauche du segment + if (((Pos_X+Pos_Y)&1)==0) + Position_dans_degrade--; + break; + + case 1 : // On est sur la gauche du segment + case 2 : // On est sur la gauche du segment + if (((Pos_X & 1)==0) && ((Pos_Y & 1)==0)) + Position_dans_degrade--; + break; + + // On n'a pas à traiter les cas 3 et 4 car ils représentent des valeurs + // suffisament au centre du segment pour ne pas avoir à subir la trame + + case 5 : // On est sur la droite du segment + case 6 : // On est sur la droite du segment + if (((Pos_X & 1)==0) && ((Pos_Y & 1)!=0)) + Position_dans_degrade++; + break; + + case 7 : // On est sur l'extreme droite du segment + if (((Pos_X+Pos_Y)&1)!=0) // Note: on doit faire le test inverse au cas gauche pour synchroniser les 2 c“tés de la trame. + Position_dans_degrade++; + } + + // On va vérifier que nos petites idioties n'ont pas éjecté la valeur hors + // des valeurs autorisées par le dégradé défini par l'utilisateur. + + if (Position_dans_degrade<0) + Position_dans_degrade=0; + else if (Position_dans_degrade>=Degrade_Intervalle_bornes) + Position_dans_degrade=Degrade_Intervalle_bornes-1; + + // On ramène ensuite la position dans le dégradé vers un numéro de couleur + if (Degrade_Inverse) + Position_dans_degrade=Degrade_Borne_Superieure-Position_dans_degrade; + else + Position_dans_degrade=Degrade_Borne_Inferieure+Position_dans_degrade; + + Traiter_pixel_de_degrade(Pos_X,Pos_Y,Position_dans_degrade); +} + + + + + + + + // -- Tracer un cercle degradé (une sphère) -- + +void Tracer_cercle_degrade(short Centre_X,short Centre_Y,short Rayon,short Eclairage_X,short Eclairage_Y) +{ + long Debut_X; + long Debut_Y; + long Pos_X; + long Pos_Y; + long Fin_X; + long Fin_Y; + long Distance_X; // Distance (au carré) sur les X du point en cours au centre d'éclairage + long Distance_Y; // Distance (au carré) sur les Y du point en cours au centre d'éclairage + + Debut_X=Centre_X-Rayon; + Debut_Y=Centre_Y-Rayon; + Fin_X=Centre_X+Rayon; + Fin_Y=Centre_Y+Rayon; + + // Correction des bornes d'après les limites + if (Debut_YLimite_Bas) + Fin_Y=Limite_Bas; + if (Debut_XLimite_Droite) + Fin_X=Limite_Droite; + + Degrade_Intervalle_total=Cercle_Limite+ + ((Centre_X-Eclairage_X)*(Centre_X-Eclairage_X))+ + ((Centre_Y-Eclairage_Y)*(Centre_Y-Eclairage_Y))+ + (2L*Rayon*sqrt( + ((Centre_X-Eclairage_X)*(Centre_X-Eclairage_X))+ + ((Centre_Y-Eclairage_Y)*(Centre_Y-Eclairage_Y)))); + + if (Degrade_Intervalle_total==0) + Degrade_Intervalle_total=1; + + // Affichage du cercle + for (Pos_Y=Debut_Y,Cercle_Curseur_Y=(long)Debut_Y-Centre_Y;Pos_Y<=Fin_Y;Pos_Y++,Cercle_Curseur_Y++) + { + Distance_Y =(Pos_Y-Eclairage_Y); + Distance_Y*=Distance_Y; + for (Pos_X=Debut_X,Cercle_Curseur_X=(long)Debut_X-Centre_X;Pos_X<=Fin_X;Pos_X++,Cercle_Curseur_X++) + if (Pixel_dans_cercle()) + { + Distance_X =(Pos_X-Eclairage_X); + Distance_X*=Distance_X; + Traiter_degrade(Distance_X+Distance_Y,Pos_X,Pos_Y); + } + } +} + + + // -- Tracer une ellipse degradée -- + +void Tracer_ellipse_degradee(short Centre_X,short Centre_Y,short Rayon_horizontal,short Rayon_vertical,short Eclairage_X,short Eclairage_Y) +{ + long Debut_X; + long Debut_Y; + long Pos_X; + long Pos_Y; + long Fin_X; + long Fin_Y; + long Distance_X; // Distance (au carré) sur les X du point en cours au centre d'éclairage + long Distance_Y; // Distance (au carré) sur les Y du point en cours au centre d'éclairage + + + Debut_X=Centre_X-Rayon_horizontal; + Debut_Y=Centre_Y-Rayon_vertical; + Fin_X=Centre_X+Rayon_horizontal; + Fin_Y=Centre_Y+Rayon_vertical; + + // Calcul des limites de l'ellipse + Ellipse_Calculer_limites(Rayon_horizontal+1,Rayon_vertical+1); + + // On calcule la distance maximale: + Degrade_Intervalle_total=(Rayon_horizontal*Rayon_horizontal)+ + (Rayon_vertical*Rayon_vertical)+ + ((Centre_X-Eclairage_X)*(Centre_X-Eclairage_X))+ + ((Centre_Y-Eclairage_Y)*(Centre_Y-Eclairage_Y))+ + (2L + *sqrt( + (Rayon_horizontal*Rayon_horizontal)+ + (Rayon_vertical *Rayon_vertical )) + *sqrt( + ((Centre_X-Eclairage_X)*(Centre_X-Eclairage_X))+ + ((Centre_Y-Eclairage_Y)*(Centre_Y-Eclairage_Y)))); + + if (Degrade_Intervalle_total==0) + Degrade_Intervalle_total=1; + + // Correction des bornes d'après les limites + if (Debut_YLimite_Bas) + Fin_Y=Limite_Bas; + if (Debut_XLimite_Droite) + Fin_X=Limite_Droite; + + // Affichage de l'ellipse + for (Pos_Y=Debut_Y,Ellipse_Curseur_Y=Debut_Y-Centre_Y;Pos_Y<=Fin_Y;Pos_Y++,Ellipse_Curseur_Y++) + { + Distance_Y =(Pos_Y-Eclairage_Y); + Distance_Y*=Distance_Y; + for (Pos_X=Debut_X,Ellipse_Curseur_X=Debut_X-Centre_X;Pos_X<=Fin_X;Pos_X++,Ellipse_Curseur_X++) + if (Pixel_dans_ellipse()) + { + Distance_X =(Pos_X-Eclairage_X); + Distance_X*=Distance_X; + Traiter_degrade(Distance_X+Distance_Y,Pos_X,Pos_Y); + } + } +} + + + + + + + + // -- Tracer un polyg“ne plein -- + +typedef struct POLYGON_EDGE /* an active edge */ +{ + short top; /* top y position */ + short bottom; /* bottom y position */ + float x, dx; /* floating point x position and gradient */ + float w; /* width of line segment */ + struct POLYGON_EDGE *prev; /* doubly linked list */ + struct POLYGON_EDGE *next; +} POLYGON_EDGE; + + + +/* fill_edge_structure: + * Polygon helper function: initialises an edge structure for the 2d + * rasteriser. + */ +void fill_edge_structure(POLYGON_EDGE *edge, short *i1, short *i2) +{ + short *it; + + if (i2[1] < i1[1]) + { + it = i1; + i1 = i2; + i2 = it; + } + + edge->top = i1[1]; + edge->bottom = i2[1] - 1; + edge->dx = ((float) i2[0] - (float) i1[0]) / ((float) i2[1] - (float) i1[1]); + edge->x = i1[0] + 0.4999999; + edge->prev = NULL; + edge->next = NULL; + + if (edge->dx+1 < 0.0) + edge->x += edge->dx+1; + + if (edge->dx >= 0.0) + edge->w = edge->dx; + else + edge->w = -(edge->dx); + + if (edge->w-1.0<0.0) + edge->w = 0.0; + else + edge->w = edge->w-1; +} + + + +/* add_edge: + * Adds an edge structure to a linked list, returning the new head pointer. + */ +POLYGON_EDGE * add_edge(POLYGON_EDGE *list, POLYGON_EDGE *edge, int sort_by_x) +{ + POLYGON_EDGE *pos = list; + POLYGON_EDGE *prev = NULL; + + if (sort_by_x) + { + while ( (pos) && ((pos->x+((pos->w+pos->dx)/2)) < (edge->x+((edge->w+edge->dx)/2))) ) + { + prev = pos; + pos = pos->next; + } + } + else + { + while ((pos) && (pos->top < edge->top)) + { + prev = pos; + pos = pos->next; + } + } + + edge->next = pos; + edge->prev = prev; + + if (pos) + pos->prev = edge; + + if (prev) + { + prev->next = edge; + return list; + } + else + return edge; +} + + + +/* remove_edge: + * Removes an edge structure from a list, returning the new head pointer. + */ +POLYGON_EDGE * remove_edge(POLYGON_EDGE *list, POLYGON_EDGE *edge) +{ + if (edge->next) + edge->next->prev = edge->prev; + + if (edge->prev) + { + edge->prev->next = edge->next; + return list; + } + else + return edge->next; +} + + + +/* polygon: + * Draws a filled polygon with an arbitrary number of corners. Pass the + * number of vertices, then an array containing a series of x, y points + * (a total of vertices*2 values). + */ +void Polyfill_General(int Vertices, short * Points, int Color) +{ + short c; + short top = 0x7FFF; + short bottom = 0; + short *i1, *i2; + short Pos_X,Fin_X; + POLYGON_EDGE *edge, *next_edge, *initial_edge; + POLYGON_EDGE *active_edges = NULL; + POLYGON_EDGE *inactive_edges = NULL; + + + /* allocate some space and fill the edge table */ + initial_edge=edge=(POLYGON_EDGE *) malloc(sizeof(POLYGON_EDGE) * Vertices); + + i1 = Points; + i2 = Points + ((Vertices-1)<<1); + + for (c=0; cbottom >= edge->top) + { + if (edge->top < top) + top = edge->top; + + if (edge->bottom > bottom) + bottom = edge->bottom; + + inactive_edges = add_edge(inactive_edges, edge, 0); + edge++; + } + } + i2 = i1; + i1 += 2; + } + + /* for each scanline in the polygon... */ + for (c=top; c<=bottom; c++) + { + /* check for newly active edges */ + edge = inactive_edges; + while ((edge) && (edge->top == c)) + { + next_edge = edge->next; + inactive_edges = remove_edge(inactive_edges, edge); + active_edges = add_edge(active_edges, edge, 1); + edge = next_edge; + } + + /* draw horizontal line segments */ + if ((c>=Limite_Haut) && (c<=Limite_Bas)) + { + edge = active_edges; + while ((edge) && (edge->next)) + { + Pos_X=/*Round*/(edge->x); + Fin_X=/*Round*/(edge->next->x+edge->next->w); + if (Pos_XLimite_Droite) + Fin_X=Limite_Droite; + for (; Pos_X<=Fin_X; Pos_X++) + Pixel_figure(Pos_X,c,Color); + edge = edge->next->next; + } + } + + /* update edges, sorting and removing dead ones */ + edge = active_edges; + while (edge) + { + next_edge = edge->next; + if (c >= edge->bottom) + active_edges = remove_edge(active_edges, edge); + else + { + edge->x += edge->dx; + while ((edge->prev) && ( (edge->x+(edge->w/2)) < (edge->prev->x+(edge->prev->w/2))) ) + { + if (edge->next) + edge->next->prev = edge->prev; + edge->prev->next = edge->next; + edge->next = edge->prev; + edge->prev = edge->prev->prev; + edge->next->prev = edge; + if (edge->prev) + edge->prev->next = edge; + else + active_edges = edge; + } + } + edge = next_edge; + } + } + + free(initial_edge); +} + + +void Polyfill(int Vertices, short * Points, int Color) +{ + Pixel_figure=Afficher_pixel; + Polyfill_General(Vertices,Points,Color); +} + + + +void Capturer_brosse_au_lasso(int Vertices, short * Points,short Effacement) +{ + short Debut_X=Limite_Droite+1; + short Debut_Y=Limite_Bas+1; + short Fin_X=Limite_Gauche-1; + short Fin_Y=Limite_Haut-1; + short Temporaire; + short Pos_X; + short Pos_Y; + word Nouvelle_Brosse_Largeur; + word Nouvelle_Brosse_Hauteur; + + + // On recherche les bornes de la brosse: + for (Temporaire=0; TemporaireFin_X) + Fin_X=Pos_X; + if (Pos_YFin_Y) + Fin_Y=Pos_Y; + } + + // On clippe ces bornes à l'écran: + if (Debut_XLimite_Droite) + Fin_X=Limite_Droite; + if (Debut_YLimite_Bas) + Fin_Y=Limite_Bas; + + // On ne capture la nouvelle brosse que si elle est au moins partiellement + // dans l'image: + + if ((Debut_XTAILLE_MAXI_PINCEAU)?Brosse_Largeur:TAILLE_MAXI_PINCEAU; + Smear_Brosse_Hauteur=(Brosse_Hauteur>TAILLE_MAXI_PINCEAU)?Brosse_Hauteur:TAILLE_MAXI_PINCEAU; + Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Hauteur)*Smear_Brosse_Largeur); + + if (!Smear_Brosse) // On ne peut même pas allouer la brosse du smear! + { + Erreur(0); + + free(Brosse); + Brosse=(byte *)malloc(1*1); + Brosse_Hauteur=1; + Brosse_Largeur=1; + + Smear_Brosse=(byte *)malloc(TAILLE_MAXI_PINCEAU*TAILLE_MAXI_PINCEAU); + Smear_Brosse_Hauteur=TAILLE_MAXI_PINCEAU; + Smear_Brosse_Largeur=TAILLE_MAXI_PINCEAU; + } + + Brosse_Decalage_X=Debut_X; + Brosse_Decalage_Y=Debut_Y; + Pixel_figure=Pixel_figure_Dans_brosse; + + memset(Brosse,Back_color,(long)Brosse_Largeur*Brosse_Hauteur); + Polyfill_General(Vertices,Points,~Back_color); + + // On retrace les bordures du lasso: + for (Temporaire=1; Temporaire>1); + Brosse_Decalage_Y=(Brosse_Hauteur>>1); + } +} + + + +//------------ Remplacement de la couleur pointée par une autre -------------- + +void Remplacer(byte Nouvelle_couleur) +{ + byte Ancienne_couleur; + + if ((Pinceau_X=0) + Pos_X_initial = 0; // Pas d'inversion en X de la brosse + else + Pos_X_initial = (Brosse_Largeur<<16)-1; // Inversion en X de la brosse + + free(Smear_Brosse); // On libère un peu de mémoire + + if ((New_Brosse=((byte *)malloc(New_Brosse_Largeur*New_Brosse_Hauteur)))) + { + Offset=0; + + // Calcul de la valeur initiale de Pos_Y: + if (Dy>=0) + Pos_Y_dans_brosse=0; // Pas d'inversion en Y de la brosse + else + Pos_Y_dans_brosse=(Brosse_Hauteur<<16)-1; // Inversion en Y de la brosse + + // Pour chaque ligne + for (Ligne=0;Ligne>16,Pos_Y_dans_brosse>>16); + // On passe à la colonne de brosse suivante: + Pos_X_dans_brosse+=Delta_X_dans_brosse; + // On passe au pixel suivant de la nouvelle brosse: + Offset++; + } + + // On passe à la ligne de brosse suivante: + Pos_Y_dans_brosse+=Delta_Y_dans_brosse; + } + + free(Brosse); + Brosse=New_Brosse; + + Brosse_Largeur=New_Brosse_Largeur; + Brosse_Hauteur=New_Brosse_Hauteur; + + Smear_Brosse_Largeur=(Brosse_Largeur>TAILLE_MAXI_PINCEAU)?Brosse_Largeur:TAILLE_MAXI_PINCEAU; + Smear_Brosse_Hauteur=(Brosse_Hauteur>TAILLE_MAXI_PINCEAU)?Brosse_Hauteur:TAILLE_MAXI_PINCEAU; + Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Hauteur)*Smear_Brosse_Largeur); + + if (!Smear_Brosse) // On ne peut même pas allouer la brosse du smear! + { + Erreur(0); + + free(Brosse); + Brosse=(byte *)malloc(1*1); + Brosse_Hauteur=1; + Brosse_Largeur=1; + + Smear_Brosse=(byte *)malloc(TAILLE_MAXI_PINCEAU*TAILLE_MAXI_PINCEAU); + Smear_Brosse_Hauteur=TAILLE_MAXI_PINCEAU; + Smear_Brosse_Largeur=TAILLE_MAXI_PINCEAU; + } + + Brosse_Decalage_X=(Brosse_Largeur>>1); + Brosse_Decalage_Y=(Brosse_Hauteur>>1); + } + else + { + // Ici la libération de mémoire n'a pas suffit donc on remet dans l'état + // o— c'etait avant. On a juste à réallouer la Smear_Brosse car il y a + // normalement la place pour elle puisque rien d'autre n'a pu être alloué + // entre temps. + Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Hauteur)*Smear_Brosse_Largeur); + Erreur(0); + } +} + + + +void Etirer_brosse_preview(short X1, short Y1, short X2, short Y2) +{ + int Pos_X_src,Pos_Y_src; + int Pos_X_src_Initiale,Pos_Y_src_Initiale; + int Delta_X,Delta_Y; + int Pos_X_dest,Pos_Y_dest; + int Pos_X_dest_Initiale,Pos_Y_dest_Initiale; + int Pos_X_dest_Finale,Pos_Y_dest_Finale; + int Largeur_dest,Hauteur_dest; + byte Couleur; + + + // 1er calcul des positions destination extremes: + Pos_X_dest_Initiale=Min(X1,X2); + Pos_Y_dest_Initiale=Min(Y1,Y2); + Pos_X_dest_Finale =Max(X1,X2); + Pos_Y_dest_Finale =Max(Y1,Y2); + + // Calcul des dimensions de la destination: + Largeur_dest=Pos_X_dest_Finale-Pos_X_dest_Initiale+1; + Hauteur_dest=Pos_Y_dest_Finale-Pos_Y_dest_Initiale+1; + + // Calcul des vecteurs d'incrémentation : + Delta_X=(Brosse_Largeur<<16)/Largeur_dest; + Delta_Y=(Brosse_Hauteur<<16)/Hauteur_dest; + + // 1er calcul de la position X initiale dans la source: + Pos_X_src_Initiale=(Brosse_Largeur<<16)* + (Max(Pos_X_dest_Initiale,Limite_Gauche)- + Pos_X_dest_Initiale)/Largeur_dest; + // Calcul du clip de la destination: + Pos_X_dest_Initiale=Max(Pos_X_dest_Initiale,Limite_Gauche); + Pos_X_dest_Finale =Min(Pos_X_dest_Finale ,Limite_visible_Droite); + // On discute selon l'inversion en X + if (X1>X2) + { + // Inversion -> Inversion du signe de Delta_X + Delta_X=-Delta_X; + Pos_X_src_Initiale=(Brosse_Largeur<<16)-1-Pos_X_src_Initiale; + } + + // 1er calcul de la position Y initiale dans la source: + Pos_Y_src_Initiale=(Brosse_Hauteur<<16)* + (Max(Pos_Y_dest_Initiale,Limite_Haut)- + Pos_Y_dest_Initiale)/Hauteur_dest; + // Calcul du clip de la destination: + Pos_Y_dest_Initiale=Max(Pos_Y_dest_Initiale,Limite_Haut); + Pos_Y_dest_Finale =Min(Pos_Y_dest_Finale ,Limite_visible_Bas); + // On discute selon l'inversion en Y + if (Y1>Y2) + { + // Inversion -> Inversion du signe de Delta_Y + Delta_Y=-Delta_Y; + Pos_Y_src_Initiale=(Brosse_Hauteur<<16)-1-Pos_Y_src_Initiale; + } + + // Pour chaque ligne : + Pos_Y_src=Pos_Y_src_Initiale; + for (Pos_Y_dest=Pos_Y_dest_Initiale;Pos_Y_dest<=Pos_Y_dest_Finale;Pos_Y_dest++) + { + // Pour chaque colonne: + Pos_X_src=Pos_X_src_Initiale; + for (Pos_X_dest=Pos_X_dest_Initiale;Pos_X_dest<=Pos_X_dest_Finale;Pos_X_dest++) + { + Couleur=Lit_pixel_dans_brosse(Pos_X_src>>16,Pos_Y_src>>16); + if (Couleur!=Back_color) + Pixel_Preview(Pos_X_dest,Pos_Y_dest,Couleur); + + Pos_X_src+=Delta_X; + } + + Pos_Y_src+=Delta_Y; + } +} + + + +//------------------------- Rotation de la brosse --------------------------- + +#define INDEFINI (-1.0e20F) +float * ScanY_Xt[2]; +float * ScanY_Yt[2]; +float * ScanY_X[2]; + + +void Interpoler_texture(int Debut_X,int Debut_Y,int Xt1,int Yt1, + int Fin_X ,int Fin_Y ,int Xt2,int Yt2,int Hauteur) +{ + int Pos_X,Pos_Y; + int Incr_X,Incr_Y; + int i,Cumul; + int Delta_X,Delta_Y; + int Delta_Xt=Xt2-Xt1; + int Delta_Yt=Yt2-Yt1; + int Delta_X2=Fin_X-Debut_X; + int Delta_Y2=Fin_Y-Debut_Y; + float Xt,Yt; + + + Pos_X=Debut_X; + Pos_Y=Debut_Y; + + if (Debut_XDelta_Y) + { + Cumul=Delta_X>>1; + for (i=0; i<=Delta_X; i++) + { + if (Cumul>=Delta_X) + { + Cumul-=Delta_X; + Pos_Y+=Incr_Y; + } + + if ((Pos_Y>=0) && (Pos_Y=ScanY_X[0][Pos_Y]) + { + if ((ScanY_X[1][Pos_Y]==INDEFINI) // Droit non défini + || (Pos_X>ScanY_X[1][Pos_Y])) + { + ScanY_X[1][Pos_Y]=Pos_X; + ScanY_Xt[1][Pos_Y]=Xt; + ScanY_Yt[1][Pos_Y]=Yt; + } + } + else + { + if (ScanY_X[1][Pos_Y]==INDEFINI) // Droit non défini + { + ScanY_X[1][Pos_Y]=ScanY_X[0][Pos_Y]; + ScanY_Xt[1][Pos_Y]=ScanY_Xt[0][Pos_Y]; + ScanY_Yt[1][Pos_Y]=ScanY_Yt[0][Pos_Y]; + ScanY_X[0][Pos_Y]=Pos_X; + ScanY_Xt[0][Pos_Y]=Xt; + ScanY_Yt[0][Pos_Y]=Yt; + } + else + { + ScanY_X[0][Pos_Y]=Pos_X; + ScanY_Xt[0][Pos_Y]=Xt; + ScanY_Yt[0][Pos_Y]=Yt; + } + } + } + } + Pos_X+=Incr_X; + Cumul+=Delta_Y; + } + } + else + { + Cumul=Delta_Y>>1; + for (i=0; i<=Delta_Y; i++) + { + if (Cumul>=Delta_Y) + { + Cumul-=Delta_Y; + Pos_X+=Incr_X; + } + + if ((Pos_Y>=0) && (Pos_Y=ScanY_X[0][Pos_Y]) + { + if ((ScanY_X[1][Pos_Y]==INDEFINI) // Droit non défini + || (Pos_X>ScanY_X[1][Pos_Y])) + { + ScanY_X[1][Pos_Y]=Pos_X; + ScanY_Xt[1][Pos_Y]=Xt; + ScanY_Yt[1][Pos_Y]=Yt; + } + } + else + { + if (ScanY_X[1][Pos_Y]==INDEFINI) // Droit non défini + { + ScanY_X[1][Pos_Y]=ScanY_X[0][Pos_Y]; + ScanY_Xt[1][Pos_Y]=ScanY_Xt[0][Pos_Y]; + ScanY_Yt[1][Pos_Y]=ScanY_Yt[0][Pos_Y]; + ScanY_X[0][Pos_Y]=Pos_X; + ScanY_Xt[0][Pos_Y]=Xt; + ScanY_Yt[0][Pos_Y]=Yt; + } + else + { + ScanY_X[0][Pos_Y]=Pos_X; + ScanY_Xt[0][Pos_Y]=Xt; + ScanY_Yt[0][Pos_Y]=Yt; + } + } + } + } + Pos_Y+=Incr_Y; + Cumul+=Delta_X; + } + } +} + + + +void Calculer_quad_texture(int X1,int Y1,int Xt1,int Yt1, + int X2,int Y2,int Xt2,int Yt2, + int X3,int Y3,int Xt3,int Yt3, + int X4,int Y4,int Xt4,int Yt4, + byte * Buffer, int Largeur, int Hauteur) +{ + int Xmin,/*Xmax,*/Ymin/*,Ymax*/; + int X,Y,Xt,Yt; + int Debut_X,Fin_X,Largeur_ligne; + float Temp; + //byte Couleur; + + Xmin=Min(Min(X1,X2),Min(X3,X4)); + Ymin=Min(Min(Y1,Y2),Min(Y3,Y4)); + + ScanY_Xt[0]=(float *)malloc(Hauteur*sizeof(float)); + ScanY_Xt[1]=(float *)malloc(Hauteur*sizeof(float)); + ScanY_Yt[0]=(float *)malloc(Hauteur*sizeof(float)); + ScanY_Yt[1]=(float *)malloc(Hauteur*sizeof(float)); + ScanY_X[0] =(float *)malloc(Hauteur*sizeof(float)); + ScanY_X[1] =(float *)malloc(Hauteur*sizeof(float)); + + // Remplir avec des valeurs égales à INDEFINI. + for (Y=0; Y>1); + Debut_Y=1-(Brosse_Hauteur>>1); + Fin_X=Debut_X+Brosse_Largeur-1; + Fin_Y=Debut_Y+Brosse_Hauteur-1; + + Transformer_point(Debut_X,Debut_Y, cosA,sinA, &X1,&Y1); + Transformer_point(Fin_X ,Debut_Y, cosA,sinA, &X2,&Y2); + Transformer_point(Debut_X,Fin_Y , cosA,sinA, &X3,&Y3); + Transformer_point(Fin_X ,Fin_Y , cosA,sinA, &X4,&Y4); + + // Calcul des nouvelles dimensions de la brosse: + Xmin=Min(Min((int)X1,(int)X2),Min((int)X3,(int)X4)); + Xmax=Max(Max((int)X1,(int)X2),Max((int)X3,(int)X4)); + Ymin=Min(Min((int)Y1,(int)Y2),Min((int)Y3,(int)Y4)); + Ymax=Max(Max((int)Y1,(int)Y2),Max((int)Y3,(int)Y4)); + + New_Brosse_Largeur=Xmax+1-Xmin; + New_Brosse_Hauteur=Ymax+1-Ymin; + + free(Smear_Brosse); // On libère un peu de mémoire + + if ((New_Brosse=((byte *)malloc(New_Brosse_Largeur*New_Brosse_Hauteur)))) + { + // Et maintenant on calcule la nouvelle brosse tournée. + Calculer_quad_texture(X1,Y1, 0, 0, + X2,Y2,Brosse_Largeur-1, 0, + X3,Y3, 0,Brosse_Hauteur-1, + X4,Y4,Brosse_Largeur-1,Brosse_Hauteur-1, + New_Brosse,New_Brosse_Largeur,New_Brosse_Hauteur); + + free(Brosse); + Brosse=New_Brosse; + + Brosse_Largeur=New_Brosse_Largeur; + Brosse_Hauteur=New_Brosse_Hauteur; + + Smear_Brosse_Largeur=(Brosse_Largeur>TAILLE_MAXI_PINCEAU)?Brosse_Largeur:TAILLE_MAXI_PINCEAU; + Smear_Brosse_Hauteur=(Brosse_Hauteur>TAILLE_MAXI_PINCEAU)?Brosse_Hauteur:TAILLE_MAXI_PINCEAU; + Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Hauteur)*Smear_Brosse_Largeur); + + if (!Smear_Brosse) // On ne peut même pas allouer la brosse du smear! + { + Erreur(0); + + free(Brosse); + Brosse=(byte *)malloc(1*1); + Brosse_Hauteur=1; + Brosse_Largeur=1; + + Smear_Brosse=(byte *)malloc(TAILLE_MAXI_PINCEAU*TAILLE_MAXI_PINCEAU); + Smear_Brosse_Hauteur=TAILLE_MAXI_PINCEAU; + Smear_Brosse_Largeur=TAILLE_MAXI_PINCEAU; + } + + Brosse_Decalage_X=(Brosse_Largeur>>1); + Brosse_Decalage_Y=(Brosse_Hauteur>>1); + } + else + { + // Ici la libération de mémoire n'a pas suffit donc on remet dans l'état + // o— c'etait avant. On a juste à réallouer la Smear_Brosse car il y a + // normalement la place pour elle puisque rien d'autre n'a pu être alloué + // entre temps. + Smear_Brosse=(byte *)malloc(((long)Smear_Brosse_Hauteur)*Smear_Brosse_Largeur); + Erreur(0); + } +} + + + +void Dessiner_quad_texture_preview(int X1,int Y1,int Xt1,int Yt1, + int X2,int Y2,int Xt2,int Yt2, + int X3,int Y3,int Xt3,int Yt3, + int X4,int Y4,int Xt4,int Yt4) +{ + int Xmin,Xmax,Ymin,Ymax; + int X,Y,Xt,Yt; + int Y_,Ymin_; + int Debut_X,Fin_X,Largeur,Hauteur; + float Temp; + byte Couleur; + + Xmin=Min(Min(X1,X2),Min(X3,X4)); + Xmax=Max(Max(X1,X2),Max(X3,X4)); + Ymin=Min(Min(Y1,Y2),Min(Y3,Y4)); + Ymax=Max(Max(Y1,Y2),Max(Y3,Y4)); + Hauteur=1+Ymax-Ymin; + + ScanY_Xt[0]=(float *)malloc(Hauteur*sizeof(float)); + ScanY_Xt[1]=(float *)malloc(Hauteur*sizeof(float)); + ScanY_Yt[0]=(float *)malloc(Hauteur*sizeof(float)); + ScanY_Yt[1]=(float *)malloc(Hauteur*sizeof(float)); + ScanY_X[0] =(float *)malloc(Hauteur*sizeof(float)); + ScanY_X[1] =(float *)malloc(Hauteur*sizeof(float)); + + // Remplir avec des valeurs égales à INDEFINI. + for (Y=0; YLimite_Bas) Ymax=Limite_Bas; + + for (Y_=Ymin; Y_<=Ymax; Y_++) + { + Y=Y_-Ymin_; + Debut_X=Round(ScanY_X[0][Y]); + Fin_X =Round(ScanY_X[1][Y]); + + Largeur=1+Fin_X-Debut_X; + + if (Debut_XLimite_Droite) Fin_X=Limite_Droite; + + for (X=Debut_X; X<=Fin_X; X++) + { + Temp=(float)(0.5+(float)X-ScanY_X[0][Y])/(float)Largeur; + Xt=Round((float)(ScanY_Xt[0][Y])+(Temp*(ScanY_Xt[1][Y]-ScanY_Xt[0][Y]))); + Yt=Round((float)(ScanY_Yt[0][Y])+(Temp*(ScanY_Yt[1][Y]-ScanY_Yt[0][Y]))); + + Couleur=Lit_pixel_dans_brosse(Xt,Yt); + if (Couleur!=Back_color) + Pixel_Preview(X,Y_,Couleur); + } + } + + free(ScanY_Xt[0]); + free(ScanY_Xt[1]); + free(ScanY_Yt[0]); + free(ScanY_Yt[1]); + free(ScanY_X[0]); + free(ScanY_X[1]); +} + + +void Tourner_brosse_preview(float Angle) +{ + short X1,Y1,X2,Y2,X3,Y3,X4,Y4; + int Debut_X,Fin_X,Debut_Y,Fin_Y; + float cosA=cos(Angle); + float sinA=sin(Angle); + + // Calcul des coordonnées des 4 coins: + // 1 2 + // 3 4 + + Debut_X=1-(Brosse_Largeur>>1); + Debut_Y=1-(Brosse_Hauteur>>1); + Fin_X=Debut_X+Brosse_Largeur-1; + Fin_Y=Debut_Y+Brosse_Hauteur-1; + + Transformer_point(Debut_X,Debut_Y, cosA,sinA, &X1,&Y1); + Transformer_point(Fin_X ,Debut_Y, cosA,sinA, &X2,&Y2); + Transformer_point(Debut_X,Fin_Y , cosA,sinA, &X3,&Y3); + Transformer_point(Fin_X ,Fin_Y , cosA,sinA, &X4,&Y4); + + X1+=Brosse_Centre_rotation_X; + Y1+=Brosse_Centre_rotation_Y; + X2+=Brosse_Centre_rotation_X; + Y2+=Brosse_Centre_rotation_Y; + X3+=Brosse_Centre_rotation_X; + Y3+=Brosse_Centre_rotation_Y; + X4+=Brosse_Centre_rotation_X; + Y4+=Brosse_Centre_rotation_Y; + + // Et maintenant on dessine la brosse tournée. + Dessiner_quad_texture_preview(X1,Y1, 0, 0, + X2,Y2,Brosse_Largeur-1, 0, + X3,Y3, 0,Brosse_Hauteur-1, + X4,Y4,Brosse_Largeur-1,Brosse_Hauteur-1); +} diff --git a/graph.h b/graph.h index 1d7ec5bc..a9bba218 100644 --- a/graph.h +++ b/graph.h @@ -1,3 +1,5 @@ +#include "global.h" + //byte Meilleure_couleur(byte Rouge, byte Vert, byte Bleu); void Remapper_ecran_apres_changement_couleurs_menu(void); @@ -52,7 +54,7 @@ byte Effet_Smooth(word X,word Y,byte Couleur); void Afficher_foreback(void); -void Afficher_pixel(short X,short Y,byte Couleur); +void Afficher_pixel(word X,word Y,byte Couleur); void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview); void Effacer_pinceau(short X,short Y); diff --git a/init.c b/init.c index 89f5dce9..40a4691b 100644 --- a/init.c +++ b/init.c @@ -20,11 +20,11 @@ #include #include "divers.h" -// On d‚clare m‚chamment le prototype de Erreur pour ‚viter de faire un +// On déclare méchamment le prototype de Erreur pour éviter de faire un // fichier "main.h": void Erreur(int Code); -// Chercher le r‚pertoire contenant GFX2.EXE +// Chercher le répertoire contenant GFX2.EXE void Chercher_repertoire_du_programme(char * Chaine) { int Position; @@ -81,8 +81,8 @@ void Rechercher_drives(void) byte Lecteur; byte Nb_lecteurs_disquettes; byte Lecteur_de_disquettes; - byte Type_de_lecteur; - char Bidon[256]; + byte Type_de_lecteur=42; + //char Bidon[256]; Nb_drives=0; Nb_lecteurs_disquettes=(Type_de_lecteur_de_disquette(0)>0)+(Type_de_lecteur_de_disquette(1)>0); @@ -106,7 +106,7 @@ void Rechercher_drives(void) { if (Disk_map(2)==Disk_map(1)) { - // Il n'y a pas de lecteur ‚mul‚ par un SUBST + // Il n'y a pas de lecteur émulé par un SUBST Lecteur_de_disquettes=Disk_map(1)-1; for (Lecteur=0; Lecteur<=1; Lecteur++) { @@ -125,7 +125,7 @@ void Rechercher_drives(void) } else { - // Il y a un lecteur ‚mul‚ par un SUBST + // Il y a un lecteur émulé par un SUBST Lecteur_de_disquettes=Disk_map(1)-1; // On cherche d'abord sur quel lecteur le lecteur physique est dispo @@ -144,24 +144,24 @@ void Rechercher_drives(void) } } - // On d‚clare les trucs maintenant + // On déclare les trucs maintenant if (Lecteur_de_disquettes==0) { - // Situation : On a un lecteur A: qui est r‚el et un lecteur B: ‚mul‚ + // Situation : On a un lecteur A: qui est réel et un lecteur B: émulé Ajouter_lecteur(0,Type_de_lecteur); Ajouter_lecteur(1,DRIVE_NETWORK); } else { - // Situation : On a un lecteur A: qui est r‚el et un lecteur B: ‚mul‚ + // Situation : On a un lecteur A: qui est réel et un lecteur B: émulé Ajouter_lecteur(0,DRIVE_NETWORK); Ajouter_lecteur(1,Type_de_lecteur); } } } else - // Il n'y a pas de lecteur de D7 physique, mais on v‚rifie s'il n'y en a - // pas qui seraient ‚mul‚s par SUBST + // Il n'y a pas de lecteur de D7 physique, mais on vérifie s'il n'y en a + // pas qui seraient émulés par SUBST for (Lecteur=0; Lecteur<=1; Lecteur++) { switch (Freespace(Lecteur+1)) @@ -173,8 +173,8 @@ void Rechercher_drives(void) } } - // Test de la pr‚sence d'autres lecteurs (HDD, CD, R‚seau) - // On les met tous en r‚seau avant de tester leur vrai type. + // Test de la présence d'autres lecteurs (HDD, CD, Réseau) + // On les met tous en réseau avant de tester leur vrai type. for (Lecteur=2; Lecteur<=25; Lecteur++) { if (Disque_dur_present(Lecteur-2)) @@ -190,7 +190,7 @@ void Rechercher_drives(void) } -// Fonction de d‚cryptage +// Fonction de décryptage #define DECRYPT_TAILLE_CLE 14 byte Decrypt_compteur=0; @@ -206,7 +206,7 @@ void Rechercher_drives(void) return Temp; } -// D‚cryptage d'une donn‚e +// Décryptage d'une donnée void Decrypte(byte * Donnee,int Taille) { @@ -228,7 +228,7 @@ void Charger_DAT(void) byte Pos_Y; word Mot_temporaire; - struct stat* Informations_Fichier; + struct stat* Informations_Fichier=NULL; strcpy(Nom_du_fichier,Repertoire_du_programme); @@ -248,7 +248,7 @@ void Charger_DAT(void) if (read(Handle,BLOCK_MENU,LARGEUR_MENU*HAUTEUR_MENU)!=LARGEUR_MENU*HAUTEUR_MENU) Erreur(ERREUR_DAT_CORROMPU); - Decrypte(BLOCK_MENU,LARGEUR_MENU*HAUTEUR_MENU); + Decrypte((byte *)BLOCK_MENU,LARGEUR_MENU*HAUTEUR_MENU); if (read(Handle,SPRITE_EFFET,LARGEUR_SPRITE_MENU*HAUTEUR_SPRITE_MENU*NB_SPRITES_EFFETS)!= LARGEUR_SPRITE_MENU*HAUTEUR_SPRITE_MENU*NB_SPRITES_EFFETS) @@ -311,12 +311,12 @@ void Charger_DAT(void) Fonte=Fonte_systeme; - // Lecture de la fonte 6x8: (sp‚ciale aide) + // Lecture de la fonte 6x8: (spéciale aide) if (read(Handle,Fonte_help,(315*6*8))!=(315*6*8)) Erreur(ERREUR_DAT_CORROMPU); Decrypte((byte*)Fonte_help,(315*6*8)); - // Lecture des diff‚rentes sections de l'aide: + // Lecture des différentes sections de l'aide: // Pour chaque section "Indice" de l'aide: for (Indice=0;Indice #include -#include "boutons.h" +#include "boutons.h" + +#include "linux.h" -// On d‚clare m‚chamment le prototype de Erreur pour ‚viter de faire un +// On déclare méchamment le prototype de Erreur pour éviter de faire un // fichier "main.h": void Erreur(int Code); -// Chargement des pixels dans l'‚cran principal -void Pixel_Chargement_dans_ecran_courant(short Pos_X,short Pos_Y,byte Couleur) +// Chargement des pixels dans l'écran principal +void Pixel_Chargement_dans_ecran_courant(word Pos_X,word Pos_Y,byte Couleur) { - if ((Pos_X>=0) && (Pos_Y>=0)) + //if ((Pos_X>=0) && (Pos_Y>=0)) //Toujours vrai ? if ((Pos_X=0) && (Pos_Y>=0)) + //if ((Pos_X>=0) && (Pos_Y>=0)) if ((Pos_X>5)<<3; @@ -121,7 +123,7 @@ void Palette_fake_24b(T_Palette Palette) } } -// Suppl‚ment … faire lors de l'initialisation d'une preview dans le cas +// Supplément à faire lors de l'initialisation d'une preview dans le cas // d'une image 24b void Initialiser_preview_24b(int Largeur,int Hauteur) { @@ -153,10 +155,10 @@ void Initialiser_preview_24b(int Largeur,int Hauteur) if (Pixel_de_chargement==Pixel_Chargement_dans_ecran_courant) Erreur_fichier=1; // 1 => On n'a pas perdu l'image courante else - Erreur_fichier=3; // 3 => Chargement de brosse ‚chou‚ + Erreur_fichier=3; // 3 => Chargement de brosse échoué } else - Image_24b=1; // On a un buffer … traiter en fin de chargement + Image_24b=1; // On a un buffer à traiter en fin de chargement } } @@ -165,10 +167,10 @@ void Initialiser_preview_24b(int Largeur,int Hauteur) void Initialiser_preview(short Largeur,short Hauteur,long Taille,int Format) // -// Cette proc‚dure doit ˆtre appel‚e par les routines de chargement +// Cette procédure doit ˆtre appelée par les routines de chargement // d'images. -// Elle doit ˆtre appel‚e entre le moment o— l'on connait la dimension de -// l'image (dimension r‚elle, pas dimension tronqu‚e) et l'affichage du +// Elle doit ˆtre appelée entre le moment o— l'on connait la dimension de +// l'image (dimension réelle, pas dimension tronquée) et l'affichage du // premier point. // { @@ -180,9 +182,9 @@ void Initialiser_preview(short Largeur,short Hauteur,long Taille,int Format) if (Pixel_de_chargement==Pixel_Chargement_dans_preview) { - // Pr‚paration du chargement d'une preview: + // Préparation du chargement d'une preview: - // Affichage des donn‚es "Image size:" + // Affichage des données "Image size:" if ((Largeur<10000) && (Hauteur<10000)) { Num2str(Largeur,Chaine,4); @@ -223,14 +225,14 @@ void Initialiser_preview(short Largeur,short Hauteur,long Taille,int Format) Print_dans_fenetre( 83,74,Format_Extension[Format-1],CM_Noir,CM_Clair); } - // On efface le commentaire pr‚c‚dent + // On efface le commentaire précédent Block(Fenetre_Pos_X+46*Menu_Facteur_X,Fenetre_Pos_Y+176*Menu_Facteur_Y, Menu_Facteur_X<<8,Menu_Facteur_Y<<3,CM_Clair); // Affichage du commentaire if (Format_Commentaire[Format-1]) Print_dans_fenetre(46,176,Principal_Commentaire,CM_Noir,CM_Clair); - // Calculs des donn‚es n‚cessaires … l'affichage de la preview: + // Calculs des données nécessaires à l'affichage de la preview: Preview_Facteur_X=Round_div_max(Largeur,122*Menu_Facteur_X); Preview_Facteur_Y=Round_div_max(Hauteur, 82*Menu_Facteur_Y); @@ -257,7 +259,7 @@ void Initialiser_preview(short Largeur,short Hauteur,long Taille,int Format) { if (Backup_avec_nouvelles_dimensions(0,Largeur,Hauteur)) { - // La nouvelle page a pu ˆtre allou‚e, elle est pour l'instant pleine + // La nouvelle page a pu ˆtre allouée, elle est pour l'instant pleine // de 0s. Elle fait Principal_Largeur_image de large. // Normalement tout va bien, tout est sous contr“le... } @@ -354,7 +356,7 @@ void Nom_fichier_complet(char * Nom_du_fichier, byte Sauve_Colorix) ///////////////////////////////////////////////////////////////////////////// -// Gestion des lectures et ‚critures // +// Gestion des lectures et écritures // ///////////////////////////////////////////////////////////////////////////// byte * Tampon_lecture; @@ -430,12 +432,12 @@ void /*__interrupt __near*/ Nouveau_handler_clavier(void) } -// -------- Modifier la valeur du code d'erreur d'accŠs … un fichier -------- -// On n'est pas oblig‚ d'utiliser cette fonction … chaque fois mais il est +// -------- Modifier la valeur du code d'erreur d'accŠs à un fichier -------- +// On n'est pas obligé d'utiliser cette fonction à chaque fois mais il est // important de l'utiliser dans les cas du type: // if (!Erreur_fichier) *** else Erreur_fichier=***; // En fait, dans le cas o— l'on modifie Erreur_fichier alors qu'elle contient -// dŠj… un code d'erreur. +// dŠjà un code d'erreur. void Modif_Erreur_fichier(int Nouvelle_valeur) { if (Erreur_fichier>=0) @@ -447,10 +449,10 @@ void Modif_Erreur_fichier(int Nouvelle_valeur) void Charger_image(byte Image) { int Indice; // Indice de balayage des formats - int Format; // Format du fichier … charger + int Format; // Format du fichier à charger - // On place par d‚faut Erreur_fichier … vrai au cas o— on ne sache pas + // On place par défaut Erreur_fichier à vrai au cas o— on ne sache pas // charger le format du fichier: Erreur_fichier=1; @@ -458,14 +460,14 @@ void Charger_image(byte Image) { Format_Test[Principal_Format-1](); if (!Erreur_fichier) - // Si dans le s‚lecteur il y a un format valide on le prend tout de suite + // Si dans le sélecteur il y a un format valide on le prend tout de suite Format=Principal_Format-1; } if (Erreur_fichier) { - // Sinon, on va devoir scanner les diff‚rents formats qu'on connait pour - // savoir … quel format est le fichier: + // Sinon, on va devoir scanner les différents formats qu'on connait pour + // savoir à quel format est le fichier: for (Indice=0;IndicePages); } } } else - // Sinon, l'appelant sera au courant de l'‚chec grƒce … Erreur_fichier; - // et si on s'apprˆtait … faire un chargement d‚finitif de l'image (pas + // Sinon, l'appelant sera au courant de l'échec grƒce à Erreur_fichier; + // et si on s'apprˆtait à faire un chargement définitif de l'image (pas // une preview), alors on flash l'utilisateur. if (Pixel_de_chargement!=Pixel_Chargement_dans_preview) Erreur(0); @@ -571,7 +573,7 @@ void Charger_image(byte Image) // -- Sauver n'importe quel type connu de fichier d'image (ou palette) ------ void Sauver_image(byte Image) { - // On place par d‚faut Erreur_fichier … vrai au cas o— on ne sache pas + // On place par défaut Erreur_fichier à vrai au cas o— on ne sache pas // sauver le format du fichier: (Est-ce vraiment utile??? Je ne crois pas!) Erreur_fichier=1; @@ -627,7 +629,7 @@ void Load_PAL(void) { int Handle; // Handle du fichier char Nom_du_fichier[256]; // Nom complet du fichier - long Taille_du_fichier; // Taille du fichier + //long Taille_du_fichier; // Taille du fichier Nom_fichier_complet(Nom_du_fichier,0); @@ -655,7 +657,7 @@ void Load_PAL(void) close(Handle); } else - // Si on n'a pas r‚ussi … ouvrir le fichier, alors il y a eu une erreur + // Si on n'a pas réussi à ouvrir le fichier, alors il y a eu une erreur Erreur_fichier=1; } @@ -665,7 +667,7 @@ void Save_PAL(void) { int Fichier; // Handle du fichier char Nom_du_fichier[256]; // Nom complet du fichier - long Taille_du_fichier; // Taille du fichier + //long Taille_du_fichier; // Taille du fichier Nom_fichier_complet(Nom_du_fichier,0); @@ -685,15 +687,15 @@ void Save_PAL(void) else // Ecriture correcte => Fermeture normale du fichier close(Fichier); } - else // Si on n'a pas r‚ussi … ouvrir le fichier, alors il y a eu une erreur + else // Si on n'a pas réussi à ouvrir le fichier, alors il y a eu une erreur { Erreur_fichier=1; close(Fichier); remove(Nom_du_fichier); - // On se fout du r‚sultat de l'op‚ration car si ‡a - // renvoie 0 c'est que le fichier avait ‚t‚ partiel- - // -lement ‚crit, sinon pas du tout. Or dans tous les - // cas ‡a revient au mˆme pour nous: Sauvegarde rat‚e! + // On se fout du résultat de l'opération car si ‡a + // renvoie 0 c'est que le fichier avait été partiel- + // -lement écrit, sinon pas du tout. Or dans tous les + // cas ‡a revient au mˆme pour nous: Sauvegarde ratée! } } @@ -729,7 +731,7 @@ void Test_IMG(void) Handle=open(Nom_du_fichier,O_RDONLY); if (Handle!=-1) { - // Lecture et v‚rification de la signature + // Lecture et vérification de la signature if ((read(Handle,&IMG_Header,sizeof(struct Header)))==sizeof(struct Header)) { if ( (!memcmp(IMG_Header.Filler1,Signature,6)) @@ -779,10 +781,10 @@ void Load_IMG(void) if (Erreur_fichier==0) { // On commence par passer la palette en 256 comme ‡a, si la nouvelle - // palette a moins de 256 coul, la pr‚c‚dente ne souffrira pas d'un - // assombrissement pr‚judiciable. + // palette a moins de 256 coul, la précédente ne souffrira pas d'un + // assombrissement préjudiciable. Palette_64_to_256(Principal_Palette); - // On peut maintenant transf‚rer la nouvelle palette + // On peut maintenant transférer la nouvelle palette memcpy(Principal_Palette,IMG_Header.Palette,sizeof(T_Palette)); Palette_256_to_64(Principal_Palette); Set_palette(Principal_Palette); @@ -865,7 +867,7 @@ void Save_IMG(void) if (Erreur_fichier) remove(Nom_du_fichier); } - else // Erreur d'‚criture (disque plein ou prot‚g‚) + else // Erreur d'écriture (disque plein ou protégé) { close(Fichier); remove(Nom_du_fichier); @@ -896,7 +898,7 @@ void Test_PKM(void) struct Header { char Ident[3]; // ChaŒne "PKM" } - byte Methode; // M‚thode de compression: + byte Methode; // Méthode de compression: // 0 = compression en ligne (c)KM // autres = inconnues pour le moment byte Recon1; // Octet de reconnaissance sur 1 octet } @@ -920,9 +922,9 @@ void Test_PKM(void) // Lecture du header du fichier if (read(Fichier,&Head,sizeof(struct Header))==sizeof(struct Header)) { - // On regarde s'il y a la signature PKM suivie de la m‚thode 0. - // La constante "PKM" ‚tant un chaŒne, elle se termine toujours par 0. - // Donc pas la peine de s'emm...er … regarder si la m‚thode est … 0. + // On regarde s'il y a la signature PKM suivie de la méthode 0. + // La constante "PKM" étant un chaŒne, elle se termine toujours par 0. + // Donc pas la peine de s'emm...er à regarder si la méthode est à 0. if ( (!memcmp(&Head,"PKM",4)) && Head.Largeur && Head.Hauteur) Erreur_fichier=0; } @@ -939,7 +941,7 @@ void Load_PKM(void) struct Header { char Ident[3]; // ChaŒne "PKM" } - byte Methode; // M‚thode de compression: + byte Methode; // Méthode de compression: // 0 = compression en ligne (c)KM // autres = inconnues pour le moment byte Recon1; // Octet de reconnaissance sur 1 octet } @@ -1011,7 +1013,7 @@ void Load_PKM(void) Erreur_fichier=2; break; - case 1 : // Dimensions de l'‚cran d'origine + case 1 : // Dimensions de l'écran d'origine if (read(Fichier,&Octet,1)==1) { if (Octet==4) @@ -1081,7 +1083,7 @@ void Load_PKM(void) Compteur_de_pixels=0; Taille_pack=(Informations_Fichier->st_size)-sizeof(struct Header)-Head.Jump; - // Boucle de d‚compression: + // Boucle de décompression: while ( (Compteur_de_pixelsst_size; - // On avance dans le fichier (pas besoin de tester ce qui l'a d‚j… ‚t‚) + // On avance dans le fichier (pas besoin de tester ce qui l'a déjà été) read(LBM_Fichier,Section,4); Lire_long(); read(LBM_Fichier,Format,4); - if (!Wait_for("BMHD")) + if (!Wait_for((byte *)"BMHD")) Erreur_fichier=1; Lire_long(); @@ -1661,7 +1663,7 @@ void Load_LBM(void) if ( (read(LBM_Fichier,&Header,sizeof(struct Header_LBM))==sizeof(struct Header_LBM)) && Header.Width && Header.Height) { - if ( (Header.Bit_planes) && (Wait_for("CMAP")) ) + if ( (Header.Bit_planes) && (Wait_for((byte *)"CMAP")) ) { Nb_couleurs=Lire_long()/3; @@ -1669,15 +1671,15 @@ void Load_LBM(void) { if ((Nb_couleurs==32) && (Header.Bit_planes==6)) { // Ce n'est pas une image HAM mais une image 64 coul. - Image_HAM=1; // Sauv‚e en 32 coul. => il faut copier les 32 coul. + Image_HAM=1; // Sauvée en 32 coul. => il faut copier les 32 coul. } // sur les 32 suivantes et assombrir ces derniŠres. else { if ((Header.Bit_planes==6) || (Header.Bit_planes==8)) Image_HAM=Header.Bit_planes; else - // Erreur_fichier=1; /* C'est cens‚ ˆtre incorrect mais j'ai */ - Image_HAM=0; /* trouv‚ un fichier comme ‡a, alors... */ + // Erreur_fichier=1; /* C'est censé ˆtre incorrect mais j'ai */ + Image_HAM=0; /* trouvé un fichier comme ‡a, alors... */ } } else @@ -1693,8 +1695,8 @@ void Load_LBM(void) Back_color=Header.Transp_col; // On commence par passer la palette en 256 comme ‡a, si la nouvelle - // palette a moins de 256 coul, la pr‚c‚dente ne souffrira pas d'un - // assombrissement pr‚judiciable. + // palette a moins de 256 coul, la précédente ne souffrira pas d'un + // assombrissement préjudiciable. if (Config.Clear_palette) memset(Principal_Palette,0,sizeof(T_Palette)); else @@ -1713,7 +1715,7 @@ void Load_LBM(void) if (read(LBM_Fichier,&Octet,1)==1) Erreur_fichier=2; - if ( (Wait_for("BODY")) && (!Erreur_fichier) ) + if ( (Wait_for((byte *)"BODY")) && (!Erreur_fichier) ) { Taille_image=Lire_long(); swab((char *)&Header.Width ,(char *)&Principal_Largeur_image,2); @@ -1740,7 +1742,7 @@ void Load_LBM(void) } if (!Header.Compression) - { // non compress‚ + { // non compressé LBM_Buffer=(byte *)malloc(Taille_ligne); for (Pos_Y=0; ((Pos_Yst_size) & 1) { Ecrire_long((Informations_Fichier->st_size)-7); @@ -2106,7 +2108,7 @@ void Test_BMP(void) long Taille_1; // =Taille du fichier word Reserv_1; // =0 word Reserv_2; // =0 - long Decalage; // Nb octets avant les donn‚es bitmap + long Decalage; // Nb octets avant les données bitmap long Taille_2; // =40 long Largeur; @@ -2147,7 +2149,7 @@ void Load_BMP(void) long Taille_1; // =Taille du fichier word Reserv_1; // =0 word Reserv_2; // =0 - long Decalage; // Nb octets avant les donn‚es bitmap + long Decalage; // Nb octets avant les données bitmap long Taille_2; // =40 long Largeur; @@ -2206,13 +2208,13 @@ void Load_BMP(void) if (read(Fichier,Palette_locale,Nb_Couleurs<<2)==(Nb_Couleurs<<2)) { // On commence par passer la palette en 256 comme ‡a, si la nouvelle - // palette a moins de 256 coul, la pr‚c‚dente ne souffrira pas d'un - // assombrissement pr‚judiciable. + // palette a moins de 256 coul, la précédente ne souffrira pas d'un + // assombrissement préjudiciable. if (Config.Clear_palette) memset(Principal_Palette,0,sizeof(T_Palette)); else Palette_64_to_256(Principal_Palette); - // On peut maintenant transf‚rer la nouvelle palette + // On peut maintenant transférer la nouvelle palette for (Indice=0; Indice Clear tables word Valeur_Eof; // Valeur <=> Fin d'image @@ -2728,14 +2730,14 @@ void Load_GIF(void) ( (memcmp(Signature,"GIF87a",6)==0) || (memcmp(Signature,"GIF89a",6)==0) ) ) { - // Allocation de m‚moire pour les tables & piles de traitement: + // Allocation de mémoire pour les tables & piles de traitement: Alphabet_Pile =(word *)malloc(4096*sizeof(word)); Alphabet_Prefixe=(word *)malloc(4096*sizeof(word)); Alphabet_Suffixe=(word *)malloc(4096*sizeof(word)); if (read(GIF_Fichier,&LSDB,sizeof(struct Type_LSDB))==sizeof(struct Type_LSDB)) { - // Lecture du Logical Screen Descriptor Block r‚ussie: + // Lecture du Logical Screen Descriptor Block réussie: Ecran_original_X=LSDB.Largeur; Ecran_original_Y=LSDB.Hauteur; @@ -2758,8 +2760,8 @@ void Load_GIF(void) // Palette globale dispo: // On commence par passer la palette en 256 comme ‡a, si la - // nouvelle palette a moins de 256 coul, la pr‚c‚dente ne souffrira - // pas d'un assombrissement pr‚judiciable. + // nouvelle palette a moins de 256 coul, la précédente ne souffrira + // pas d'un assombrissement préjudiciable. if (Config.Clear_palette) memset(Principal_Palette,0,sizeof(T_Palette)); else @@ -2771,7 +2773,7 @@ void Load_GIF(void) read(GIF_Fichier,Principal_Palette,Nb_couleurs*3); else { - // Palette tri‚e par composantes: + // Palette triée par composantes: for (Indice_de_couleur=0;Indice_de_couleur0xFFF) { - // R‚intialisation de la table: + // Réintialisation de la table: GIF_Set_code(256); Alphabet_Free=258; GIF_Nb_bits =9; @@ -3242,21 +3244,21 @@ void Save_GIF(void) if (!Erreur_fichier) { - // On ‚crit le code dans le fichier + // On écrit le code dans le fichier GIF_Set_code(Chaine_en_cours); // DerniŠre portion d'image // Cette derniŠre portion ne devrait pas poser de problŠmes - // du c“t‚ GIF_Nb_bits puisque pour que GIF_Nb_bits change de + // du c“té GIF_Nb_bits puisque pour que GIF_Nb_bits change de // valeur, il faudrait que la table de chaŒne soit remplie or // c'est impossible puisqu'on traite une chaŒne qui se trouve - // d‚j… dans la table, et qu'elle n'a rien d'in‚dit. Donc on - // ne devrait pas avoir … changer de taille, mais je laisse + // déjà dans la table, et qu'elle n'a rien d'inédit. Donc on + // ne devrait pas avoir à changer de taille, mais je laisse // quand mˆme en remarque tout ‡a, au cas o— il subsisterait // des problŠmes dans certains cas exceptionnels. // - // Note: de toutes fa‡ons, ces lignes en commentaires ont ‚t‚s - // ‚crites par copier/coller du temps o— la sauvegarde du - // GIF d‚connait. Il y a donc fort … parier qu'elles ne + // Note: de toutes fa‡ons, ces lignes en commentaires ont étés + // écrites par copier/coller du temps o— la sauvegarde du + // GIF déconnait. Il y a donc fort à parier qu'elles ne // sont pas correctes. /* @@ -3267,7 +3269,7 @@ void Save_GIF(void) // On balargue un Clear Code GIF_Set_code(256); - // On r‚initialise les donn‚es LZW + // On réinitialise les données LZW Alphabet_Free=258; GIF_Nb_bits =9; Alphabet_Max =511; @@ -3282,35 +3284,35 @@ void Save_GIF(void) GIF_Set_code(257); // Code de Fin d'image if (GIF_Rest_bits!=0) - GIF_Set_code(0); // Code bidon permettant de s'assurer que tous les bits du dernier code aient bien ‚t‚s inscris dans le buffer GIF - GIF_Vider_le_buffer(); // On envoie les derniŠres donn‚es du buffer GIF dans le buffer KM - Close_ecriture(GIF_Fichier); // On envoie les derniŠres donn‚es du buffer KM dans le fichier + GIF_Set_code(0); // Code bidon permettant de s'assurer que tous les bits du dernier code aient bien étés inscris dans le buffer GIF + GIF_Vider_le_buffer(); // On envoie les derniŠres données du buffer GIF dans le buffer KM + Close_ecriture(GIF_Fichier); // On envoie les derniŠres données du buffer KM dans le fichier - Chaine_en_cours=0x3B00; // On ‚crit un GIF TERMINATOR, exig‚ par SVGA et SEA. + Chaine_en_cours=0x3B00; // On écrit un GIF TERMINATOR, exigé par SVGA et SEA. if (write(GIF_Fichier,&Chaine_en_cours,sizeof(Chaine_en_cours))!=sizeof(Chaine_en_cours)) Erreur_fichier=1; } - } // On a pu ‚crire l'IDB + } // On a pu écrire l'IDB else Erreur_fichier=1; - } // On a pu ‚crire la palette + } // On a pu écrire la palette else Erreur_fichier=1; Palette_256_to_64(Principal_Palette); - } // On a pu ‚crire le LSDB + } // On a pu écrire le LSDB else Erreur_fichier=1; - // Lib‚ration de la m‚moire utilis‚e par les tables + // Libération de la mémoire utilisée par les tables free(Alphabet_Soeur); free(Alphabet_Fille); free(Alphabet_Suffixe); free(Alphabet_Prefixe); - } // On a pu ‚crire la signature du fichier + } // On a pu écrire la signature du fichier else Erreur_fichier=1; @@ -3318,7 +3320,7 @@ void Save_GIF(void) if (Erreur_fichier) remove(Nom_du_fichier); - } // On a pu ouvrir le fichier en ‚criture + } // On a pu ouvrir le fichier en écriture else Erreur_fichier=1; } @@ -3345,21 +3347,21 @@ void Test_PCX(void) { byte Manufacturer; // |_ Il font chier ces cons! Ils auraient pu byte Version; // | mettre une vraie signature significative! - byte Compression; // L'image est-elle compress‚e? + byte Compression; // L'image est-elle compressée? byte Depth; // Nombre de bits pour coder un pixel (inutile puisqu'on se sert de Plane) word X_min; // |_ Coin haut-gauche | - word Y_min; // | de l'image |_ (Cr‚tin!) + word Y_min; // | de l'image |_ (Crétin!) word X_max; // |_ Coin bas-droit | word Y_max; // | de l'image | - word X_dpi; // |_ Densit‚ de |_ (Presque inutile parce que + word X_dpi; // |_ Densité de |_ (Presque inutile parce que word Y_dpi; // | l'image | aucun moniteur n'est pareil!) - byte Palette_16c[48]; // Palette 16 coul (inutile pour 256c) (d‚bile!) + byte Palette_16c[48]; // Palette 16 coul (inutile pour 256c) (débile!) byte Reserved; // Ca me plait ‡a aussi! byte Plane; // 4 => 16c , 1 => 256c word Bytes_per_plane_line;// Doit toujours ˆtre pair - word Palette_info; // 1 => Couleur , 2 => Gris (ignor‚ … partir de la version 4) + word Palette_info; // 1 => Couleur , 2 => Gris (ignoré à partir de la version 4) word Screen_X; // |_ Dimensions de - word Screen_Y; // | l'‚cran d'origine + word Screen_Y; // | l'écran d'origine byte Filler[54]; // Ca... J'adore! } Header; // Je hais ce header! @@ -3372,7 +3374,7 @@ void Test_PCX(void) if (read(Fichier,&Header,sizeof(struct PCX_Header))==sizeof(struct PCX_Header)) { // Vu que ce header a une signature de merde et peu significative, il - // va falloir que je teste diff‚rentes petites valeurs dont je connais + // va falloir que je teste différentes petites valeurs dont je connais // l'intervalle. Grrr! if ( (Header.Manufacturer!=10) || (Header.Compression>1) @@ -3393,7 +3395,7 @@ void Test_PCX(void) // -- Lire un fichier au format PCX ----------------------------------------- - // -- Afficher une ligne PCX cod‚e sur 1 seul plan avec moins de 256 c. -- + // -- Afficher une ligne PCX codée sur 1 seul plan avec moins de 256 c. -- void Draw_PCX_line(short Pos_Y, short Vraie_taille_ligne, byte Depth) { short Pos_X; @@ -3417,25 +3419,25 @@ void Load_PCX(void) { byte Manufacturer; // |_ Il font chier ces cons! Ils auraient pu byte Version; // | mettre une vraie signature! - byte Compression; // L'image est-elle compress‚e? + byte Compression; // L'image est-elle compressée? byte Depth; // Nombre de bits pour coder un pixel (inutile puisqu'on se sert de Plane) word X_min; // |_ Coin haut-gauche | - word Y_min; // | de l'image |_ (Cr‚tin!) + word Y_min; // | de l'image |_ (Crétin!) word X_max; // |_ Coin bas-droit | word Y_max; // | de l'image | - word X_dpi; // |_ Densit‚ de |_ (Presque inutile parce que + word X_dpi; // |_ Densité de |_ (Presque inutile parce que word Y_dpi; // | l'image | aucun moniteur n'est pareil!) - byte Palette_16c[48]; // Palette 16 coul (inutile pour 256c) (d‚bile!) + byte Palette_16c[48]; // Palette 16 coul (inutile pour 256c) (débile!) byte Reserved; // Ca me plait ‡a aussi! byte Plane; // 4 => 16c , 1 => 256c , ... word Bytes_per_plane_line;// Doit toujours ˆtre pair - word Palette_info; // 1 => Couleur , 2 => Gris (ignor‚ … partir de la version 4) + word Palette_info; // 1 => Couleur , 2 => Gris (ignoré à partir de la version 4) word Screen_X; // |_ Dimensions de - word Screen_Y; // | l'‚cran d'origine + word Screen_Y; // | l'écran d'origine byte Filler[54]; // Ca... J'adore! } Header; // Je hais ce header! short Taille_ligne; - short Vraie_taille_ligne; // Largeur de l'image corrig‚e + short Vraie_taille_ligne; // Largeur de l'image corrigée short Largeur_lue; short Pos_X; short Pos_Y; @@ -3474,7 +3476,7 @@ void Load_PCX(void) Initialiser_preview(Principal_Largeur_image,Principal_Hauteur_image,Taille_du_fichier,FORMAT_PCX); if (Erreur_fichier==0) { - // On pr‚pare la palette … accueillir les valeurs du fichier PCX + // On prépare la palette à accueillir les valeurs du fichier PCX if (Config.Clear_palette) memset(Principal_Palette,0,sizeof(T_Palette)); else @@ -3490,7 +3492,7 @@ void Load_PCX(void) Principal_Palette[1].B=0; Octet1=Header.Palette_16c[3]>>5; if (Nb_couleurs==4) - { // Pal. CGA "alakon" (du Turc Allahkoum qui signifie "… la con" :)) + { // Pal. CGA "alakon" (du Turc Allahkoum qui signifie "à la con" :)) memcpy(Principal_Palette+1,Palette_CGA,9); if (!(Octet1&2)) { @@ -3507,16 +3509,16 @@ void Load_PCX(void) } } - // On se positionne … la fin du fichier - 769 octets pour voir s'il y + // On se positionne à la fin du fichier - 769 octets pour voir s'il y // a une palette. if ( (Header.Depth==8) && (Header.Version>=5) && (Taille_du_fichier>sizeof(T_Palette)) ) { lseek(Fichier,Taille_du_fichier-(sizeof(T_Palette)+1),SEEK_SET); - // On regarde s'il y a une palette aprŠs les donn‚es de l'image + // On regarde s'il y a une palette aprŠs les données de l'image if (read(Fichier,&Octet1,1)==1) if (Octet1==12) // Lire la palette si c'est une image en 256 couleurs { - // On lit la palette 256c que ces cr‚tins ont foutue … la fin du fichier + // On lit la palette 256c que ces crétins ont foutue à la fin du fichier if (read(Fichier,Principal_Palette,sizeof(T_Palette))!=sizeof(T_Palette)) Erreur_fichier=2; } @@ -3525,22 +3527,22 @@ void Load_PCX(void) Set_palette(Principal_Palette); Remapper_fileselect(); - // Maintenant qu'on a lu la palette que ces cr‚tins sont all‚s foutre - // … la fin, on retourne juste aprŠs le header pour lire l'image. + // Maintenant qu'on a lu la palette que ces crétins sont allés foutre + // à la fin, on retourne juste aprŠs le header pour lire l'image. lseek(Fichier,sizeof(struct PCX_Header),SEEK_SET); if (!Erreur_fichier) { Taille_ligne=Header.Bytes_per_plane_line*Header.Plane; Vraie_taille_ligne=(short)Header.Bytes_per_plane_line<<3; - // On se sert de donn‚es LBM car le dessin de ligne en moins de 256 + // On se sert de données LBM car le dessin de ligne en moins de 256 // couleurs se fait comme avec la structure ILBM. Image_HAM=0; HBPm1=Header.Plane-1; LBM_Buffer=(byte *)malloc(Taille_ligne); // Chargement de l'image - if (Header.Compression) // Image compress‚e + if (Header.Compression) // Image compressée { Init_lecture(); @@ -3550,14 +3552,14 @@ void Load_PCX(void) { for (Position=0; ((Positionst_size)-sizeof(struct CEL_Header1); if ( (!Taille) || ( (((Header1.Width+1)>>1)*Header1.Height)!=Taille ) ) @@ -3989,7 +3991,7 @@ void Load_CEL(void) } else { - // On r‚essaye avec le nouveau format + // On réessaye avec le nouveau format lseek(Fichier,0,SEEK_SET); if (read(Fichier,&Header2,sizeof(struct CEL_Header2))==sizeof(struct CEL_Header2)) @@ -4008,7 +4010,7 @@ void Load_CEL(void) if (!Erreur_fichier) { - // Effacement du d‚calage + // Effacement du décalage for (Pos_Y=0;Pos_Y16 sont utilis‚es dans l'image + // On regarde si des couleurs >16 sont utilisées dans l'image for (Pos_X=16;((Pos_X<256) && (!Utilisation[Pos_X]));Pos_X++); if (Pos_X==256) { - // Cas d'une image 16 couleurs (‚criture … l'ancien format) + // Cas d'une image 16 couleurs (écriture à l'ancien format) Header1.Width =Principal_Largeur_image; Header1.Height=Principal_Hauteur_image; @@ -4128,9 +4130,9 @@ void Save_CEL(void) } else { - // Cas d'une image 256 couleurs (‚criture au nouveau format) + // Cas d'une image 256 couleurs (écriture au nouveau format) - // Recherche du d‚calage + // Recherche du décalage for (Pos_Y=0;Pos_Y>4)!=0) @@ -4278,8 +4280,8 @@ void Load_KCF(void) byte Kind; // Type de fichier ($10=PALette $20=BitMaP) byte Nbbits; // Nombre de bits word Filler1; // ??? - word Largeur; // Largeur de l'image ou nb de couleurs d‚finies - word Hauteur; // Hauteur de l'image ou nb de palettes d‚finies + word Largeur; // Largeur de l'image ou nb de couleurs définies + word Hauteur; // Hauteur de l'image ou nb de palettes définies word Decalage_X; // Decalage en X de l'image word Decalage_Y; // Decalage en Y de l'image byte Filler2[16]; // ??? @@ -4298,7 +4300,7 @@ void Load_KCF(void) Taille_du_fichier=filelength(Fichier); if (Taille_du_fichier==sizeof(struct KCF_Header)) { - // Fichier KCF … l'ancien format + // Fichier KCF à l'ancien format if (read(Fichier,&Buffer,sizeof(struct KCF_Header))==sizeof(struct KCF_Header)) { @@ -4413,8 +4415,8 @@ void Save_KCF(void) byte Kind; // Type de fichier ($10=PALette $20=BitMaP) byte Nbbits; // Nombre de bits word Filler1; // ??? - word Largeur; // Largeur de l'image ou nb de couleurs d‚finies - word Hauteur; // Hauteur de l'image ou nb de palettes d‚finies + word Largeur; // Largeur de l'image ou nb de couleurs définies + word Hauteur; // Hauteur de l'image ou nb de palettes définies word Decalage_X; // Decalage en X de l'image word Decalage_Y; // Decalage en Y de l'image byte Filler2[16]; // ??? @@ -4434,12 +4436,12 @@ void Save_KCF(void) { // Sauvegarde de la palette - // On regarde si des couleurs >16 sont utilis‚es dans l'image + // On regarde si des couleurs >16 sont utilisées dans l'image for (Indice=16;((Indice<256) && (!Utilisation[Indice]));Indice++); if (Indice==256) { - // Cas d'une image 16 couleurs (‚criture … l'ancien format) + // Cas d'une image 16 couleurs (écriture à l'ancien format) for (Indice_palette=0;Indice_palette<10;Indice_palette++) for (Indice_couleur=0;Indice_couleur<16;Indice_couleur++) @@ -4454,7 +4456,7 @@ void Save_KCF(void) } else { - // Cas d'une image 256 couleurs (‚criture au nouveau format) + // Cas d'une image 256 couleurs (écriture au nouveau format) memcpy(Header2.Signa,"KiSS",4); // Initialisation de la signature Header2.Kind=0x10; // Initialisation du type (PALette) @@ -4462,8 +4464,8 @@ void Save_KCF(void) Header2.Filler1=0; // Initialisation du filler 1 (???) Header2.Largeur=256; // Initialisation du nombre de couleurs Header2.Hauteur=1; // Initialisation du nombre de palettes - Header2.Decalage_X=0; // Initialisation du d‚calage X - Header2.Decalage_Y=0; // Initialisation du d‚calage Y + Header2.Decalage_X=0; // Initialisation du décalage X + Header2.Decalage_Y=0; // Initialisation du décalage Y for (Indice=0;Indice<16;Indice++) // Initialisation du filler 2 (???) Header2.Filler2[Indice]=0; @@ -4505,7 +4507,7 @@ void Test_SCx(void) { int Handle; // Handle du fichier char Nom_du_fichier[256]; // Nom complet du fichier - byte Signature[3]; + //byte Signature[3]; struct Header { byte Filler1[4]; @@ -4524,7 +4526,7 @@ void Test_SCx(void) Handle=open(Nom_du_fichier,O_RDONLY); if (Handle!=-1) { - // Lecture et v‚rification de la signature + // Lecture et vérification de la signature if ((read(Handle,&SCx_Header,sizeof(struct Header)))==sizeof(struct Header)) { if ( (!memcmp(SCx_Header.Filler1,"RIX",3)) @@ -4673,7 +4675,7 @@ void Save_SCx(void) if (Erreur_fichier) remove(Nom_du_fichier); } - else // Erreur d'‚criture (disque plein ou prot‚g‚) + else // Erreur d'écriture (disque plein ou protégé) { close(Fichier); remove(Nom_du_fichier); @@ -4703,9 +4705,9 @@ void Save_SCx(void) void PI1_8b_to_16p(byte * Src,byte * Dst) { - int i; // Indice du pixel … calculer + int i; // Indice du pixel à calculer word masque; // Masque de decodage - word w0,w1,w2,w3; // Les 4 words bien ordonn‚s de la source + word w0,w1,w2,w3; // Les 4 words bien ordonnés de la source masque=0x8000; w0=(((word)Src[0])<<8) | Src[1]; @@ -4714,8 +4716,8 @@ void PI1_8b_to_16p(byte * Src,byte * Dst) w3=(((word)Src[6])<<8) | Src[7]; for (i=0;i<16;i++) { - // Pour d‚coder le pixel nøi, il faut traiter les 4 words sur leur bit - // correspondant … celui du masque + // Pour décoder le pixel nøi, il faut traiter les 4 words sur leur bit + // correspondant à celui du masque Dst[i]=((w0 & masque)?0x01:0x00) | ((w1 & masque)?0x02:0x00) | @@ -4729,16 +4731,16 @@ void PI1_8b_to_16p(byte * Src,byte * Dst) void PI1_16p_to_8b(byte * Src,byte * Dst) { - int i; // Indice du pixel … calculer + int i; // Indice du pixel à calculer word masque; // Masque de codage - word w0,w1,w2,w3; // Les 4 words bien ordonn‚s de la destination + word w0,w1,w2,w3; // Les 4 words bien ordonnés de la destination masque=0x8000; w0=w1=w2=w3=0; for (i=0;i<16;i++) { // Pour coder le pixel nøi, il faut modifier les 4 words sur leur bit - // correspondant … celui du masque + // correspondant à celui du masque w0|=(Src[i] & 0x01)?masque:0x00; w1|=(Src[i] & 0x02)?masque:0x00; @@ -4760,11 +4762,11 @@ void PI1_16p_to_8b(byte * Src,byte * Dst) void PI1_Decoder_palette(byte * Src,byte * Pal) { - int i; // Num‚ro de la couleur trait‚e + int i; // Numéro de la couleur traitée int ip; // Indice dans la palette word w; // Word contenant le code - // Sch‚ma d'un word = + // Schéma d'un word = // // Low High // VVVV RRRR | 0000 BBBB @@ -4786,11 +4788,11 @@ void PI1_Decoder_palette(byte * Src,byte * Pal) void PI1_Coder_palette(byte * Pal,byte * Dst) { - int i; // Num‚ro de la couleur trait‚e + int i; // Numéro de la couleur traitée int ip; // Indice dans la palette word w; // Word contenant le code - // Sch‚ma d'un word = + // Schéma d'un word = // // Low High // VVVV RRRR | 0000 BBBB @@ -4816,7 +4818,7 @@ void Test_PI1(void) int Handle; // Handle du fichier char Nom_du_fichier[256]; // Nom complet du fichier int Taille; // Taille du fichier - word Res; // R‚solution de l'image + word Res; // Résolution de l'image Nom_fichier_complet(Nom_du_fichier,0); @@ -4827,11 +4829,11 @@ void Test_PI1(void) Handle=open(Nom_du_fichier,O_RDONLY); if (Handle!=-1) { - // V‚rification de la taille + // Vérification de la taille Taille=filelength(Handle); if ((Taille==32034) || (Taille==32066)) { - // Lecture et v‚rification de la r‚solution + // Lecture et vérification de la résolution if ((read(Handle,&Res,2))==2) { if (Res==0x0000) @@ -4859,7 +4861,7 @@ void Load_PI1(void) Erreur_fichier=0; if ((Fichier=open(Nom_du_fichier,O_RDONLY))!=-1) { - // allocation d'un buffer m‚moire + // allocation d'un buffer mémoire buffer=(byte *)malloc(32034); if (buffer!=NULL) { @@ -4880,7 +4882,7 @@ void Load_PI1(void) Principal_Largeur_image=320; Principal_Hauteur_image=200; - // Chargement/d‚compression de l'image + // Chargement/décompression de l'image ptr=buffer+34; for (Pos_Y=0;Pos_Y<200;Pos_Y++) { @@ -4924,9 +4926,9 @@ void Save_PI1(void) Fichier=open(Nom_du_fichier,O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR|S_IRGRP); if (Fichier!=-1) { - // allocation d'un buffer m‚moire + // allocation d'un buffer mémoire buffer=(byte *)malloc(32034); - // Codage de la r‚solution + // Codage de la résolution buffer[0]=0x00; buffer[1]=0x00; // Codage de la palette @@ -4954,13 +4956,13 @@ void Save_PI1(void) { close(Fichier); } - else // Erreur d'‚criture (disque plein ou prot‚g‚) + else // Erreur d'écriture (disque plein ou protégé) { close(Fichier); remove(Nom_du_fichier); Erreur_fichier=1; } - // Lib‚ration du buffer m‚moire + // Libération du buffer mémoire free(buffer); } else @@ -4982,7 +4984,7 @@ void Save_PI1(void) ///////////////////////////////////////////////////////////////////////////// -//// DECOMPRESSION d'un buffer selon la m‚thode PACKBITS //// +//// DECOMPRESSION d'un buffer selon la méthode PACKBITS //// void PC1_Decompresser_PackBits(byte * Src,byte * Dst) { @@ -5003,7 +5005,7 @@ void PC1_Decompresser_PackBits(byte * Src,byte * Dst) } else { - // Recopier n+1 octets litt‚ralement + // Recopier n+1 octets littéralement n=n+1; for (;(n>0) && (id<32000);n--) Dst[id++]=Src[is++]; @@ -5015,19 +5017,19 @@ void PC1_Decompresser_PackBits(byte * Src,byte * Dst) } } -//// COMPRESSION d'un buffer selon la m‚thode PACKBITS //// +//// COMPRESSION d'un buffer selon la méthode PACKBITS //// void PC1_Compresser_PackBits(byte * Src,byte * Dst,int TailleS,int * TailleD) { int is; // Indice dans la source int id; // Indice dans la destination - int ir; // Indice de la r‚p‚tition - int n; // Taille des s‚quences - int repet; // "Il y a r‚p‚tition" + int ir; // Indice de la répétition + int n; // Taille des séquences + int repet; // "Il y a répétition" for (is=id=0;is] [