/* Grafx2 - The Ultimate 256-color bitmap paint program Copyright 2008 Yves Rizoud Copyright 2007 Adrien Destugues Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud) Grafx2 is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; version 2 of the License. Grafx2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Grafx2; if not, see or write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include #include #include #include #include "const.h" #include "struct.h" #include "global.h" #include "divers.h" #include "graph.h" #include "moteur.h" #include "readline.h" #include "files.h" #include "loadsave.h" #include "init.h" #include "boutons.h" #include "operatio.h" #include "pages.h" #include "erreurs.h" #include "readini.h" #include "saveini.h" #include "shade.h" #include "io.h" #include "aide.h" #include "texte.h" #include "sdlscreen.h" #ifdef __WATCOMC__ #include #define chdir(x) SetCurrentDirectory(x) #define rmdir(x) DeleteFile(x) #endif #define FILENAMESPACE 13 #define Display_Window(X,Y) UpdateRect(Fenetre_Pos_X,Fenetre_Pos_Y,X*Menu_Facteur_X,Y*Menu_Facteur_Y); //-- MODELE DE BOUTON DE MENU ------------------------------------------------ /* void Bouton_***(void) { short Bouton_clicke; Ouvrir_fenetre(310,190,"***"); Fenetre_Definir_bouton_normal(103,137,80,14,"OK",0,1,SDLK_RETURN); // 1 Fenetre_Definir_bouton_scroller(18,44,88,16,4,0); // 2 Display_Window(310,190); Afficher_curseur(); do { Bouton_clicke=Fenetre_Bouton_clicke(); } while (Bouton_clicke!=1); Fermer_fenetre(); Desenclencher_bouton(BOUTON_***); Afficher_curseur(); } */ void Message_Non_disponible(void) { short Bouton_clicke; Ouvrir_fenetre(160,76,"Not available yet!"); Print_dans_fenetre(8,20,"This function will",CM_Noir,CM_Clair); Print_dans_fenetre(12,28,"be implemented in",CM_Noir,CM_Clair); Print_dans_fenetre(16,36,"a later version.",CM_Noir,CM_Clair); Fenetre_Definir_bouton_normal(60,53,40,14,"OK",1,1,SDLK_RETURN); // 1 Display_Window(160,76); Afficher_curseur(); do Bouton_clicke=Fenetre_Bouton_clicke(); while ((Bouton_clicke<=0) && (Touche!=SDLK_ESCAPE) && (Touche!=SDLK_o)); Fermer_fenetre(); // Puisque cette fonction peut être appelée par plusieurs boutons et qu'on // ne sait pas lequel c'est, on les désenclenche tous. De toutes façons, ça // ne sert à rien d'essayer d'optimiser ça puisque l'utilisateur ne devrait // pas souvent l'appeler, et en plus y'en a pas beaucoup à désenclencher. ;) // Desenclencher_bouton(BOUTON_GRADRECT); Desenclencher_bouton(BOUTON_TEXTE); Afficher_curseur(); } void Message_Memoire_insuffisante(void) { short Bouton_clicke; Ouvrir_fenetre(216,76,"Not enough memory!"); Print_dans_fenetre(8,20,"Please consult the manual",CM_Noir,CM_Clair); Print_dans_fenetre(24,28,"to know how to obtain",CM_Noir,CM_Clair); Print_dans_fenetre(36,36,"more memory space.",CM_Noir,CM_Clair); Fenetre_Definir_bouton_normal(60,53,40,14,"OK",1,1,SDLK_RETURN); // 1 Display_Window(216,76); Afficher_curseur(); do Bouton_clicke=Fenetre_Bouton_clicke(); while ((Bouton_clicke<=0) && (Touche!=SDLK_ESCAPE) && (Touche!=SDLK_o)); Fermer_fenetre(); Afficher_curseur(); } void Bouton_Message_initial(void) { short Bouton_clicke; char Chaine[21]; int Pos_X,Offs_Y,X,Y; sprintf(Chaine,"GrafX %d.%.2d%s%s",VERSION1, VERSION2, ALPHA_BETA,POURCENTAGE_VERSION); Ouvrir_fenetre(260,172,Chaine); Fenetre_Afficher_cadre_creux(10,20,239,62); Block(Fenetre_Pos_X+(Menu_Facteur_X*11), Fenetre_Pos_Y+(Menu_Facteur_Y*21), Menu_Facteur_X*237,Menu_Facteur_Y*60,CM_Noir); for (Y=23,Offs_Y=0; Y<79; Offs_Y+=231,Y++) for (X=14,Pos_X=0; Pos_X<231; Pos_X++,X++) Pixel_dans_fenetre(X,Y,Logo_GrafX2[Offs_Y+Pos_X]); Print_dans_fenetre(130-4*21,88,"Copyright (c) 2007 by",CM_Fonce,CM_Clair); Print_dans_fenetre(130-4*23,96,"the Grafx2 project team",CM_Noir,CM_Clair); Print_dans_fenetre(130-4*26,112,"Copyright (c) 1996-1999 by",CM_Fonce,CM_Clair); Print_dans_fenetre(130-4*13,120,"Sunset Design",CM_Noir,CM_Clair); //Print_dans_fenetre( 120-4*13,128,"(placeholder)",CM_Fonce,CM_Clair); Print_dans_fenetre(130-4*28,136,"http://grafx2.googlecode.com",CM_Fonce,CM_Clair); // Pour faire un vrai splash screen, voici un bouton qui prend toute la fenetre. Fenetre_Definir_bouton_normal(1,1,258,170,"",0,1,SDLK_RETURN); // 1 Display_Window(260,172); Afficher_curseur(); do { Bouton_clicke=Fenetre_Bouton_clicke(); } while (Bouton_clicke==0 && Touche==0); Fermer_fenetre(); Afficher_curseur(); // Si la page a été fermée par clic, ne pas faire un bête point vide dans la page. // Par contre, un clic dans le menu est bien pris en compte. if (Bouton_clicke && Mouse_Y=64)? Couleur_debut_palette-64 : 0; Afficher_palette_du_menu(); } Desenclencher_bouton(BOUTON_PAL_LEFT); Afficher_curseur(); } //--------------------------- SCROLL PALETTE RIGHT --------------------------- void Bouton_Pal_right(void) { Effacer_curseur(); if (Couleur_debut_palette<=184) { Couleur_debut_palette+=8; Afficher_palette_du_menu(); } Desenclencher_bouton(BOUTON_PAL_RIGHT); Afficher_curseur(); } void Bouton_Pal_right_fast(void) { Effacer_curseur(); if (Couleur_debut_palette<=184) { Couleur_debut_palette=(Couleur_debut_palette<=120)? Couleur_debut_palette+64 : 192; Afficher_palette_du_menu(); } Desenclencher_bouton(BOUTON_PAL_RIGHT); Afficher_curseur(); } //-------------------- Choix de la forecolor dans le menu -------------------- void Bouton_Choix_forecolor(void) { word Pos_X, Pos_Y; Pos_X=(Mouse_X/Menu_Facteur_X)-(LARGEUR_MENU+1); Pos_Y=((Mouse_Y-Menu_Ordonnee)/Menu_Facteur_Y)-2; if ((!Config.Couleurs_separees) || ((Pos_X%Menu_Taille_couleur!=Menu_Taille_couleur-1) && ((Pos_Y&3)!=3))) { Effacer_curseur(); Encadrer_couleur_menu(CM_Noir); Fore_color=Couleur_debut_palette+((Pos_X/Menu_Taille_couleur)<<3)+(Pos_Y>>2); Encadrer_couleur_menu(CM_Blanc); Afficher_foreback(); Afficher_curseur(); } } //-------------------- Choix de la backcolor dans le menu -------------------- void Bouton_Choix_backcolor(void) { word Pos_X, Pos_Y; Pos_X=(Mouse_X/Menu_Facteur_X)-(LARGEUR_MENU+1); Pos_Y=((Mouse_Y-Menu_Ordonnee)/Menu_Facteur_Y)-2; if ((!Config.Couleurs_separees) || ((Pos_X%Menu_Taille_couleur!=Menu_Taille_couleur-1) && ((Pos_Y&3)!=3))) { Effacer_curseur(); Back_color=Couleur_debut_palette+((Pos_X/Menu_Taille_couleur)<<3)+(Pos_Y>>2); Afficher_foreback(); Afficher_curseur(); } } //---------------------- Cacher ou réafficher le menu ------------------------ void Pixel_dans_barre_d_outil_cachee(__attribute__((unused)) word X,__attribute__((unused)) word Y,__attribute__((unused)) byte Couleur) { // C'est fait exprès que ce soit vide... // C'est parce que y'a rien du tout à afficher vu que la barre d'outil est // cachée... C'est simple non? } void Bouton_Cacher_menu(void) { Effacer_curseur(); if (Menu_visible) { Menu_visible=0; Pixel_dans_menu=Pixel_dans_barre_d_outil_cachee; Menu_Ordonnee=Hauteur_ecran; if (Loupe_Mode) { Calculer_donnees_loupe(); if (Loupe_Decalage_Y+Loupe_Hauteur>Principal_Hauteur_image) { if (Loupe_Hauteur>Principal_Hauteur_image) Loupe_Decalage_Y=0; else Loupe_Decalage_Y=Principal_Hauteur_image-Loupe_Hauteur; } } // On repositionne le décalage de l'image pour qu'il n'y ait pas d'in- // -cohérences lorsqu'on sortira du mode Loupe. if (Principal_Decalage_Y+Hauteur_ecran>Principal_Hauteur_image) { if (Hauteur_ecran>Principal_Hauteur_image) Principal_Decalage_Y=0; else Principal_Decalage_Y=Principal_Hauteur_image-Hauteur_ecran; } // On fait pareil pour le brouillon if (Brouillon_Decalage_Y+Hauteur_ecran>Brouillon_Hauteur_image) { if (Hauteur_ecran>Brouillon_Hauteur_image) Brouillon_Decalage_Y=0; else Brouillon_Decalage_Y=Brouillon_Hauteur_image-Hauteur_ecran; } Calculer_donnees_loupe(); if (Loupe_Mode) Recadrer_ecran_par_rapport_au_zoom(); Calculer_limites(); Calculer_coordonnees_pinceau(); Afficher_ecran(); } else { Menu_visible=1; Pixel_dans_menu=Pixel_dans_barre_d_outil; Menu_Ordonnee=Hauteur_ecran-(HAUTEUR_MENU*Menu_Facteur_Y); Calculer_donnees_loupe(); if (Loupe_Mode) Recadrer_ecran_par_rapport_au_zoom(); Calculer_limites(); Calculer_coordonnees_pinceau(); Afficher_menu(); if (Loupe_Mode) Afficher_ecran(); } Desenclencher_bouton(BOUTON_CACHER); Afficher_curseur(); } //--------------------------- Quitter le programme --------------------------- byte Bouton_Quitter_Routine_locale(void) { short Bouton_clicke; //byte Enregistrer; static char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; byte Ancienne_forme_curseur; if (!Principal_Image_modifiee) return 1; // On commence par afficher la fenêtre de QUIT Ouvrir_fenetre(160,84,"Quit ?"); Fenetre_Definir_bouton_normal(20,20,120,14,"Stay",0,1,SDLK_ESCAPE); // 1 Fenetre_Definir_bouton_normal(20,40,120,14,"Save & quit",1,1,SDLK_s); // 2 Fenetre_Definir_bouton_normal(20,60,120,14,"Discard (Quit)",1,1,SDLK_d);// 3 Display_Window(160,84); Afficher_curseur(); do { Bouton_clicke=Fenetre_Bouton_clicke(); if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) Fenetre_aide(BOUTON_QUIT, NULL); } while (Bouton_clicke<=0); Attendre_fin_de_click(); Fermer_fenetre(); Afficher_curseur(); switch(Bouton_clicke) { case 1 : return 0; // Rester case 2 : // Sauver et enregistrer Nom_fichier_complet(Nom_du_fichier,0); if ( (!Fichier_existe(Nom_du_fichier)) || Demande_de_confirmation("Erase old file ?") ) { Effacer_curseur(); Ancienne_forme_curseur=Forme_curseur; Forme_curseur=FORME_CURSEUR_SABLIER; Afficher_curseur(); Sauver_image(1); Effacer_curseur(); Forme_curseur=Ancienne_forme_curseur; Afficher_curseur(); if (!Erreur_fichier) // L'ayant sauvée avec succès, return 1; // On peut quitter else // Il y a eu une erreur lors de la sauvegarde, return 0; // On ne peut donc pas quitter } else // L'utilisateur ne veut pas écraser l'ancien fichier, return 0; // On doit donc rester case 3 : return 1; // Quitter } return 0; } void Bouton_Quit(void) { //short Bouton_clicke; if (Bouton_Quitter_Routine_locale()) { if (Brouillon_Image_modifiee) { Bouton_Page(); // On passe sur le brouillon // Si l'utilisateur présente les derniers symptomes de l'abandon if (Bouton_Quitter_Routine_locale()) Sortir_du_programme=1; } else Sortir_du_programme=1; } if ( (Menu_visible) && (Mouse_Y+8>Menu_Ordonnee) ) Effacer_curseur(); Desenclencher_bouton(BOUTON_QUIT); if ( (Menu_visible) && (Mouse_Y+8>Menu_Ordonnee) ) Afficher_curseur(); } //---------------------------- Effacer l'écran ------------------------------- void Bouton_Clear(void) { Effacer_curseur(); Backup(); if (Stencil_Mode && Config.Clear_with_stencil) Effacer_image_courante_Stencil(0,Stencil); else Effacer_image_courante(0); Afficher_ecran(); Desenclencher_bouton(BOUTON_CLEAR); Afficher_curseur(); } void Bouton_Clear_colore(void) { Effacer_curseur(); Backup(); if (Stencil_Mode && Config.Clear_with_stencil) Effacer_image_courante_Stencil(Back_color,Stencil); else Effacer_image_courante(Back_color); Afficher_ecran(); Desenclencher_bouton(BOUTON_CLEAR); Afficher_curseur(); } //---------- Menu dans lequel on tagge des couleurs (genre Stencil) ---------- void Menu_Tag_couleurs(char * En_tete, byte * Table, byte * Mode, byte Cancel, const char *Section_aide) { short Bouton_clicke; byte Backup_table[256]; word Indice; word Ancien_Mouse_X; word Ancien_Mouse_Y; byte Ancien_Mouse_K; byte Couleur_taggee; byte Couleur; byte Click; Ouvrir_fenetre(176,150,En_tete); Fenetre_Definir_bouton_palette(6,38); // 1 Fenetre_Definir_bouton_normal( 7, 19,78,14,"Clear" ,1,1,SDLK_c); // 2 Fenetre_Definir_bouton_normal(91, 19,78,14,"Invert",1,1,SDLK_i); // 3 if (Cancel) { Fenetre_Definir_bouton_normal(91,129,78,14,"OK" ,0,1,SDLK_RETURN); // 4 Fenetre_Definir_bouton_normal( 7,129,78,14,"Cancel",0,1,SDLK_ESCAPE); // 5 // On enregistre la table dans un backup au cas où on ferait Cancel memcpy(Backup_table,Table,256); } else Fenetre_Definir_bouton_normal(49,129,78,14,"OK" ,0,1,SDLK_RETURN); // 4 // On affiche l'état actuel de la table for (Indice=0; Indice<=255; Indice++) Stencil_Tagger_couleur(Indice, (Table[Indice])?CM_Noir:CM_Clair); Display_Window(176,150); Afficher_curseur(); do { Ancien_Mouse_X=Mouse_X; Ancien_Mouse_Y=Mouse_Y; Ancien_Mouse_K=Mouse_K; Bouton_clicke=Fenetre_Bouton_clicke(); switch (Bouton_clicke) { case 0 : break; case -1 : case 1 : // Palette if ( (Mouse_X!=Ancien_Mouse_X) || (Mouse_Y!=Ancien_Mouse_Y) || (Mouse_K!=Ancien_Mouse_K) ) { Effacer_curseur(); Couleur_taggee=(Bouton_clicke==1) ? Fenetre_Attribut2 : Lit_pixel(Mouse_X,Mouse_Y); Table[Couleur_taggee]=(Mouse_K==A_GAUCHE); Stencil_Tagger_couleur(Couleur_taggee,(Mouse_K==A_GAUCHE)?CM_Noir:CM_Clair); Afficher_curseur(); UpdateRect(Fenetre_Pos_X+(Menu_Facteur_X*(Fenetre_Liste_boutons_palette->Pos_X+4+(Couleur_taggee >> 4)*10)), Fenetre_Pos_Y+(Menu_Facteur_Y*(Fenetre_Liste_boutons_palette->Pos_Y+3+(Couleur_taggee & 15)* 5)), Menu_Facteur_X<<1,Menu_Facteur_Y*5); } break; case 2 : // Clear memset(Table,0,256); Effacer_curseur(); for (Indice=0; Indice<=255; Indice++) Stencil_Tagger_couleur(Indice,CM_Clair); Afficher_curseur(); Display_Window(Fenetre_Largeur, Fenetre_Hauteur); break; case 3 : // Invert Effacer_curseur(); for (Indice=0; Indice<=255; Indice++) Stencil_Tagger_couleur(Indice,(Table[Indice]^=1)?CM_Noir:CM_Clair); Afficher_curseur(); Display_Window(Fenetre_Largeur, Fenetre_Hauteur); } if (!Mouse_K) switch (Touche) { case SDLK_BACKQUOTE : // Récupération d'une couleur derrière le menu case SDLK_COMMA : Recuperer_couleur_derriere_fenetre(&Couleur,&Click); if (Click) { Effacer_curseur(); Couleur_taggee=Couleur; Table[Couleur_taggee]=(Click==A_GAUCHE); Stencil_Tagger_couleur(Couleur_taggee,(Click==A_GAUCHE)?CM_Noir:CM_Clair); UpdateRect(Fenetre_Pos_X+(Menu_Facteur_X*(Fenetre_Liste_boutons_palette->Pos_X+4+(Couleur_taggee >> 4)*10)), Fenetre_Pos_Y+(Menu_Facteur_Y*(Fenetre_Liste_boutons_palette->Pos_Y+3+(Couleur_taggee & 15)* 5)), Menu_Facteur_X<<1,Menu_Facteur_Y*5); Afficher_curseur(); } break; default: if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) { Fenetre_aide(BOUTON_EFFETS, Section_aide); break; } } } while (Bouton_clicke<4); Fermer_fenetre(); if (Bouton_clicke==5) // Cancel memcpy(Table,Backup_table,256); else // OK *Mode=1; Afficher_curseur(); } //--------------------------------- Stencil ---------------------------------- void Bouton_Stencil_Mode(void) { Stencil_Mode=!Stencil_Mode; } void Stencil_Tagger_couleur(byte Couleur, byte Couleur_de_taggage) { Block(Fenetre_Pos_X+(Menu_Facteur_X*(Fenetre_Liste_boutons_palette->Pos_X+4+(Couleur >> 4)*10)), Fenetre_Pos_Y+(Menu_Facteur_Y*(Fenetre_Liste_boutons_palette->Pos_Y+3+(Couleur & 15)* 5)), Menu_Facteur_X<<1,Menu_Facteur_Y*5,Couleur_de_taggage); } void Bouton_Menu_Stencil(void) { Menu_Tag_couleurs("Stencil",Stencil,&Stencil_Mode,1, "STENCIL"); } //--------------------------------- Masque ----------------------------------- void Bouton_Mask_Mode(void) { Mask_Mode=!Mask_Mode; } void Bouton_Mask_Menu(void) { Menu_Tag_couleurs("Mask",Mask_table,&Mask_Mode,1, "MASK"); } //------------------------------- Paramètres --------------------------------- void Settings_Afficher_config(struct S_Config * Conf) #define YES "YES" #define NO " NO" { struct Fenetre_Bouton_scroller * Jauge=Fenetre_Liste_boutons_scroller; char Chaine[4]; Effacer_curseur(); // Jauge = Jauge de sensibilité Y Jauge->Position=Conf->Indice_Sensibilite_souris_Y-1; Fenetre_Dessiner_jauge(Jauge); Jauge=Jauge->Next; // Jauge = Jauge de sensibilité X Jauge->Position=Conf->Indice_Sensibilite_souris_X-1; Fenetre_Dessiner_jauge(Jauge); Print_dans_fenetre(273, 31,(Conf->Lire_les_fichiers_caches)?YES:NO,CM_Noir,CM_Clair); Print_dans_fenetre(273, 46,(Conf->Lire_les_repertoires_caches)?YES:NO,CM_Noir,CM_Clair); Print_dans_fenetre(273, 61,(Conf->Lire_les_repertoires_systemes)?YES:NO,CM_Noir,CM_Clair); Print_dans_fenetre(223, 84,(Conf->Safety_colors)?YES:NO,CM_Noir,CM_Clair); Print_dans_fenetre(223, 99,(Conf->Adjust_brush_pick)?YES:NO,CM_Noir,CM_Clair); Print_dans_fenetre(223,114,(Conf->Couleurs_separees)?YES:NO,CM_Noir,CM_Clair); Print_dans_fenetre(223,129,(Conf->Auto_set_res)?YES:NO,CM_Noir,CM_Clair); Print_dans_fenetre(183,144,(Conf->Coords_rel)?"Relative":"Absolute",CM_Noir,CM_Clair); Print_dans_fenetre( 91, 84,(Conf->Afficher_limites_image)?YES:NO,CM_Noir,CM_Clair); Print_dans_fenetre( 91, 99,(Conf->Clear_palette)?YES:NO,CM_Noir,CM_Clair); Print_dans_fenetre( 91,114,(Conf->Maximize_preview)?YES:NO,CM_Noir,CM_Clair); Print_dans_fenetre( 91,129,(Conf->Backup)?YES:NO,CM_Noir,CM_Clair); switch (Conf->Curseur) { case 0 : Print_dans_fenetre(67,144," Solid",CM_Noir,CM_Clair); break; case 1 : Print_dans_fenetre(67,144,"Transp",CM_Noir,CM_Clair); break; default: Print_dans_fenetre(67,144," Thin",CM_Noir,CM_Clair); } if (Conf->Fonte) { // Fun Print_dans_fenetre( 8,31," ",CM_Noir,CM_Clair); Print_dans_fenetre( 78,31," ",CM_Noir,CM_Clair); Print_dans_fenetre( 82,31,"\020",CM_Noir,CM_Clair); Print_dans_fenetre(152,31,"\021",CM_Noir,CM_Clair); } else { // Classic Print_dans_fenetre( 82,31," ",CM_Noir,CM_Clair); Print_dans_fenetre(152,31," ",CM_Noir,CM_Clair); Print_dans_fenetre( 8,31,"\020",CM_Noir,CM_Clair); Print_dans_fenetre( 78,31,"\021",CM_Noir,CM_Clair); } Print_dans_fenetre(155,166,(Conf->Auto_save)?YES:NO,CM_Noir,CM_Clair); Num2str(Conf->Nb_pages_Undo,Chaine,2); Fenetre_Contenu_bouton_saisie(Fenetre_Liste_boutons_special,Chaine); Afficher_curseur(); } void Settings_Sauver_config(struct S_Config * Conf) { if (Sauver_CFG()) Erreur(0); else if (Sauver_INI(Conf)) Erreur(0); } void Settings_Charger_config(struct S_Config * Conf) { if (Charger_CFG(0)) Erreur(0); else if (Charger_INI(Conf)) Erreur(0); } void Bouton_Settings(void) { int Sensibilite_X; int Sensibilite_Y; short Bouton_clicke; struct S_Config Config_choisie; char Chaine[3]; byte On_a_recharge_la_config=0; Config_choisie=Config; Ouvrir_fenetre(307,182,"Settings"); // On commence par dessiner tous les Cadres Fenetre_Afficher_cadre( 5, 16,157,30); Fenetre_Afficher_cadre( 5, 47,157,17); Fenetre_Afficher_cadre(163, 16,139,60); Fenetre_Afficher_cadre(253, 77, 49,82); Fenetre_Afficher_cadre( 5, 77,247,82); // |_ Misc. Fenetre_Afficher_cadre( 5, 65,157,14); // | // On découpe le Cadre bizarre des "Miscellaneous" Pixel_dans_fenetre(6,77,CM_Blanc); Pixel_dans_fenetre(5,78,CM_Fonce); Block(Fenetre_Pos_X+(7*Menu_Facteur_X),Fenetre_Pos_Y+(77*Menu_Facteur_Y), Menu_Facteur_X*154,Menu_Facteur_Y<<1,CM_Clair); Pixel_dans_fenetre(161,77,CM_Clair); Pixel_dans_fenetre(160,77,CM_Fonce); // On affiche maintenant tout le blabla Print_dans_fenetre( 69, 19,"Font" ,CM_Fonce,CM_Clair); Print_dans_fenetre(169, 19,"Show in filelist",CM_Fonce,CM_Clair); Print_dans_fenetre( 9, 52,"Nb of UNDO pages",CM_Fonce,CM_Clair); Print_dans_fenetre( 32, 70,"Miscellaneous" ,CM_Fonce,CM_Clair); Print_dans_fenetre(258, 80,"Mouse" ,CM_Fonce,CM_Clair); Print_dans_fenetre(258, 88,"Sens." ,CM_Fonce,CM_Clair); Print_dans_fenetre(256,123,"X" ,CM_Fonce,CM_Clair); Print_dans_fenetre(292,123,"Y" ,CM_Fonce,CM_Clair); // Boutons de fontes Fenetre_Definir_bouton_normal(17,28,59,14,"Classic",0,1,SDLK_LAST); // 1 Fenetre_Definir_bouton_normal(91,28,59,14,"Fun" ,0,1,SDLK_LAST); // 2 // Bouton Show/Hide dans le fileselect Fenetre_Definir_bouton_normal(167, 28,131,14,"Hidden files: ",0,1,SDLK_LAST); // 3 Fenetre_Definir_bouton_normal(167, 43,131,14,"Hidden dir. : ",0,1,SDLK_LAST); // 4 Fenetre_Definir_bouton_normal(167, 58,131,14,"System dir. : ",0,1,SDLK_LAST); // 5 // Bouton Show/Hide Picture limits Fenetre_Definir_bouton_normal( 9, 81,107,14,"Limits : ",0,1,SDLK_LAST); // 6 // Bouton Show/Hide Picture limits Fenetre_Definir_bouton_normal( 9, 96,107,14,"Clear pal: ",0,1,SDLK_LAST); // 7 // Bouton Show/Hide Picture limits Fenetre_Definir_bouton_normal( 9,111,107,14,"Max prev.: ",0,1,SDLK_LAST); // 8 // Bouton Effectuer des backups à chaque sauvegarde Fenetre_Definir_bouton_normal( 9,126,107,14,"Backup : ",0,1,SDLK_LAST); // 9 // Bouton Choix du curseur Fenetre_Definir_bouton_normal( 9,141,107,14,"Cursor: ",0,1,SDLK_LAST); // 10 // Bouton Safety colors Fenetre_Definir_bouton_normal(117, 81,131,14,"Safe. colors: ",0,1,SDLK_LAST); // 11 // Bouton Adjust Brush Pick Fenetre_Definir_bouton_normal(117, 96,131,14,"AdjBrushPick: ",0,1,SDLK_LAST); // 12 // Bouton Separate colors Fenetre_Definir_bouton_normal(117,111,131,14,"Separate col: ",0,1,SDLK_LAST); // 13 // Bouton Passer dans la résolution appropriée après un chargement Fenetre_Definir_bouton_normal(117,126,131,14,"Auto-set res: ",0,1,SDLK_LAST); // 14 // Bouton Adapter la palette après un chargement (<=> Shift+BkSpc) Fenetre_Definir_bouton_normal(117,141,131,14,"Coords: ",0,1,SDLK_LAST); // 15 // Bouton Reload Fenetre_Definir_bouton_normal( 6,163, 51,14,"Reload" ,0,1,SDLK_LAST); // 16 // Bouton Auto-save Fenetre_Definir_bouton_normal( 73,163,107,14,"Auto-save: ",0,1,SDLK_LAST); // 17 // Bouton Save Fenetre_Definir_bouton_normal(183,163, 51,14,"Save" ,0,1,SDLK_LAST); // 18 // Bouton Close Fenetre_Definir_bouton_normal(250,163, 51,14,"Close" ,0,1,SDLK_ESCAPE); // 19 // Jauges de sensibilité de la souris (X puis Y) Fenetre_Definir_bouton_scroller(265,99,56,255,1,0); // 20 Fenetre_Definir_bouton_scroller(279,99,56,255,1,0); // 21 // Zone de saisie du nb de pages de Undo Fenetre_Definir_bouton_saisie(140,50,2); // 22 Display_Window(307,182); Afficher_curseur(); Settings_Afficher_config(&Config_choisie); do { Bouton_clicke=Fenetre_Bouton_clicke(); switch(Bouton_clicke) { case 1 : // Classic Config_choisie.Fonte=0; break; case 2 : // Fun Config_choisie.Fonte=1; break; case 3 : // Hidden files Config_choisie.Lire_les_fichiers_caches=(Config_choisie.Lire_les_fichiers_caches)?0:-1; break; case 4 : // Hidden dir. Config_choisie.Lire_les_repertoires_caches=(Config_choisie.Lire_les_repertoires_caches)?0:-1; break; case 5 : // System dir. Config_choisie.Lire_les_repertoires_systemes=(Config_choisie.Lire_les_repertoires_systemes)?0:-1; break; case 6 : // Draw limits Config_choisie.Afficher_limites_image=!Config_choisie.Afficher_limites_image; break; case 7 : // Clear palette Config_choisie.Clear_palette=!Config_choisie.Clear_palette; break; case 8 : // Maximize preview Config_choisie.Maximize_preview=!Config_choisie.Maximize_preview; break; case 9 : // Backup Config_choisie.Backup=!Config_choisie.Backup; break; case 10 : // Curseur Config_choisie.Curseur=(Config_choisie.Curseur+1)%3; break; case 11 : // Safety colors Config_choisie.Safety_colors=!Config_choisie.Safety_colors; break; case 12 : // Adjust brush pick Config_choisie.Adjust_brush_pick=!Config_choisie.Adjust_brush_pick; break; case 13 : // Separate colors Config_choisie.Couleurs_separees=!Config_choisie.Couleurs_separees; break; case 14 : // Auto-set resolution Config_choisie.Auto_set_res=!Config_choisie.Auto_set_res; break; case 15 : // Coordonnées Config_choisie.Coords_rel=!Config_choisie.Coords_rel; break; case 16 : // Reload Settings_Charger_config(&Config_choisie); On_a_recharge_la_config=1; break; case 17 : // Auto-save Config_choisie.Auto_save=!Config_choisie.Auto_save; break; case 18 : // Save Settings_Sauver_config(&Config_choisie); break; case 20 : // X Sensib. Config_choisie.Indice_Sensibilite_souris_X=Fenetre_Attribut2+1; break; case 21 : // Y Sensib. Config_choisie.Indice_Sensibilite_souris_Y=Fenetre_Attribut2+1; break; case 22 : // Nb pages Undo Effacer_curseur(); Num2str(Config_choisie.Nb_pages_Undo,Chaine,2); Readline(142,52,Chaine,2,1); Config_choisie.Nb_pages_Undo=atoi(Chaine); // On corrige la valeur if (Config_choisie.Nb_pages_Undo>NB_PAGES_UNDO_MAX) { Config_choisie.Nb_pages_Undo=NB_PAGES_UNDO_MAX; Num2str(Config_choisie.Nb_pages_Undo,Chaine,2); Fenetre_Contenu_bouton_saisie(Fenetre_Liste_boutons_special,Chaine); } else if (!Config_choisie.Nb_pages_Undo) { Config_choisie.Nb_pages_Undo=1; Num2str(Config_choisie.Nb_pages_Undo,Chaine,2); Fenetre_Contenu_bouton_saisie(Fenetre_Liste_boutons_special,Chaine); } Afficher_curseur(); } if ((Bouton_clicke>=3) && (Bouton_clicke<=5)) { Principal_File_list_Position=0; Principal_File_list_Decalage=0; Brouillon_File_list_Position=0; Brouillon_File_list_Decalage=0; } if ((Bouton_clicke>=1) && (Bouton_clicke<=17)) Settings_Afficher_config(&Config_choisie); if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) Fenetre_aide(BOUTON_PARAMETRES, NULL); } while ( (Bouton_clicke!=19) && (Touche!=SDLK_RETURN) ); Config=Config_choisie; // Prise en compte de la nouvelle config // Gestion de la sensibilité Sensibilite_X=(Config.Indice_Sensibilite_souris_X/Menu_Facteur_X); Sensibilite_Y=(Config.Indice_Sensibilite_souris_Y/Menu_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); // Gestion des fontes if (Config.Fonte) Fonte=Fonte_fun; else Fonte=Fonte_systeme; if (On_a_recharge_la_config) Calculer_couleurs_menu_optimales(Principal_Palette); Fermer_fenetre(); Desenclencher_bouton(BOUTON_PARAMETRES); // Raffichage du menu pour que les inscriptions qui y figurent soient retracées avec la nouvelle fonte Afficher_menu(); Afficher_curseur(); // On vérifie qu'on peut bien allouer le nombre de pages Undo. Nouveau_nombre_de_backups(Config.Nb_pages_Undo); } //---------------------------- Changement de page ---------------------------- void Bouton_Page(void) { byte Octet_temporaire; word Mot_temporaire; short Short_temporaire; float Float_temporaire; char Zone_temporaire[256]; Effacer_curseur(); // On dégrossit le travail avec les infos des listes de pages Interchanger_image_principale_et_brouillon(); // On fait le reste du travail "à la main": Short_temporaire=Brouillon_Decalage_X; Brouillon_Decalage_X=Principal_Decalage_X; Principal_Decalage_X=Short_temporaire; Short_temporaire=Brouillon_Decalage_Y; Brouillon_Decalage_Y=Principal_Decalage_Y; Principal_Decalage_Y=Short_temporaire; Short_temporaire=Ancien_Brouillon_Decalage_X; Ancien_Brouillon_Decalage_X=Ancien_Principal_Decalage_X; Ancien_Principal_Decalage_X=Short_temporaire; Short_temporaire=Ancien_Brouillon_Decalage_Y; Ancien_Brouillon_Decalage_Y=Ancien_Principal_Decalage_Y; Ancien_Principal_Decalage_Y=Short_temporaire; Short_temporaire=Brouillon_Split; Brouillon_Split=Principal_Split; Principal_Split=Short_temporaire; Short_temporaire=Brouillon_X_Zoom; Brouillon_X_Zoom=Principal_X_Zoom; Principal_X_Zoom=Short_temporaire; Float_temporaire=Brouillon_Proportion_split; Brouillon_Proportion_split=Principal_Proportion_split; Principal_Proportion_split=Float_temporaire; Octet_temporaire=Brouillon_Loupe_Mode; Brouillon_Loupe_Mode=Loupe_Mode; Loupe_Mode=Octet_temporaire; Pixel_Preview=(Loupe_Mode)?Pixel_Preview_Loupe:Pixel_Preview_Normal; Mot_temporaire=Brouillon_Loupe_Facteur; Brouillon_Loupe_Facteur=Loupe_Facteur; Loupe_Facteur=Mot_temporaire; Mot_temporaire=Brouillon_Loupe_Hauteur; Brouillon_Loupe_Hauteur=Loupe_Hauteur; Loupe_Hauteur=Mot_temporaire; Mot_temporaire=Brouillon_Loupe_Largeur; Brouillon_Loupe_Largeur=Loupe_Largeur; Loupe_Largeur=Mot_temporaire; Short_temporaire=Brouillon_Loupe_Decalage_X; Brouillon_Loupe_Decalage_X=Loupe_Decalage_X; Loupe_Decalage_X=Short_temporaire; Short_temporaire=Brouillon_Loupe_Decalage_Y; Brouillon_Loupe_Decalage_Y=Loupe_Decalage_Y; Loupe_Decalage_Y=Short_temporaire; // Swap du booléen "Image modifiée" Octet_temporaire =Brouillon_Image_modifiee; Brouillon_Image_modifiee=Principal_Image_modifiee; Principal_Image_modifiee=Octet_temporaire; // Swap des infos sur les fileselects strcpy(Zone_temporaire ,Brouillon_Repertoire_courant); strcpy(Brouillon_Repertoire_courant,Principal_Repertoire_courant); strcpy(Principal_Repertoire_courant,Zone_temporaire ); Octet_temporaire=Brouillon_Format; Brouillon_Format=Principal_Format; Principal_Format=Octet_temporaire; Mot_temporaire =Brouillon_File_list_Position; Brouillon_File_list_Position=Principal_File_list_Position; Principal_File_list_Position=Mot_temporaire; Mot_temporaire =Brouillon_File_list_Decalage; Brouillon_File_list_Decalage=Principal_File_list_Decalage; Principal_File_list_Decalage=Mot_temporaire; // A la fin, on affiche l'écran for (Octet_temporaire=0; FACTEUR_ZOOM[Octet_temporaire]!=Loupe_Facteur; Octet_temporaire++); Changer_facteur_loupe(Octet_temporaire); Set_palette(Principal_Palette); Calculer_couleurs_menu_optimales(Principal_Palette); Afficher_ecran(); Desenclencher_bouton(BOUTON_PAGE); Tracer_cadre_de_bouton_du_menu(BOUTON_LOUPE,Loupe_Mode); Afficher_menu(); Afficher_curseur(); } // -- Copie de page --------------------------------------------------------- void Copier_image_seule(void) { if (Backuper_et_redimensionner_brouillon(Principal_Largeur_image,Principal_Hauteur_image)) { // copie de l'image memcpy(Brouillon_Ecran,Principal_Ecran,Principal_Largeur_image*Principal_Hauteur_image); // Copie des dimensions de l'image /* C'est inutile, le "Backuper et redimensionner brouillon" a déjà modifié ces valeurs pour qu'elles soient correctes. */ Brouillon_Largeur_image=Principal_Largeur_image; Brouillon_Hauteur_image=Principal_Hauteur_image; // Copie des décalages de la fenêtre principale (non zoomée) de l'image Brouillon_Decalage_X=Principal_Decalage_X; Brouillon_Decalage_Y=Principal_Decalage_Y; // Copie du booléen "Mode loupe" de l'image Brouillon_Loupe_Mode=Loupe_Mode; // Copie du facteur de zoom du brouillon Brouillon_Loupe_Facteur=Loupe_Facteur; // Copie des dimensions de la fenêtre de zoom Brouillon_Loupe_Largeur=Loupe_Largeur; Brouillon_Loupe_Hauteur=Loupe_Hauteur; // Copie des décalages de la fenêtre de zoom Brouillon_Loupe_Decalage_X=Loupe_Decalage_X; Brouillon_Loupe_Decalage_Y=Loupe_Decalage_Y; // Copie des données du split du zoom Brouillon_Split=Principal_Split; Brouillon_X_Zoom=Principal_X_Zoom; Brouillon_Proportion_split=Principal_Proportion_split; } else Message_Memoire_insuffisante(); } void Copier_certaines_couleurs(void) { short Indice; byte Confirme=0; Menu_Tag_couleurs("Tag colors to copy",Masque_copie_couleurs,&Confirme,0, NULL); if (Confirme && (!Brouillon_Image_modifiee || Demande_de_confirmation("Spare page was modified. Proceed?"))) { for (Indice=0; Indice<256; Indice++) { if (Masque_copie_couleurs[Indice]) memcpy(Brouillon_Palette+Indice,Principal_Palette+Indice, sizeof(struct Composantes)); } } } void Bouton_Copy_page(void) { short Bouton_clicke; Ouvrir_fenetre(168,137,"Copy to spare page"); Fenetre_Definir_bouton_normal(10, 20,148,14,"Pixels + palette" , 0,1,SDLK_RETURN); // 1 Fenetre_Definir_bouton_normal(10, 37,148,14,"Pixels only" , 3,1,SDLK_x); // 2 Fenetre_Definir_bouton_normal(10, 54,148,14,"Palette only" , 1,1,SDLK_p); // 3 Fenetre_Definir_bouton_normal(10, 71,148,14,"Some colors only" , 6,1,SDLK_c); // 4 Fenetre_Definir_bouton_normal(10, 88,148,14,"Palette and remap",13,1,SDLK_r); // 5 Fenetre_Definir_bouton_normal(44,114, 80,14,"Cancel" , 0,1,SDLK_ESCAPE); // 6 Display_Window(168,137); Afficher_curseur(); do { Bouton_clicke=Fenetre_Bouton_clicke(); if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) Fenetre_aide(BOUTON_PAGE, NULL); } while (Bouton_clicke<=0); Fermer_fenetre(); Afficher_curseur(); if (Bouton_clicke!=6) { if (Bouton_clicke==4) Copier_certaines_couleurs(); else { if ( (!Brouillon_Image_modifiee) || (Demande_de_confirmation("Spare page was modified. Proceed?")) ) { if (Bouton_clicke<=2) Copier_image_seule(); if (Bouton_clicke==5) Remap_picture(); if (Bouton_clicke!=2) // copie de la palette memcpy(Brouillon_Palette,Principal_Palette,sizeof(T_Palette)); Brouillon_Image_modifiee=1; } } } Effacer_curseur(); Desenclencher_bouton(BOUTON_PAGE); Afficher_curseur(); } // -- Suppression d'une page ------------------------------------------------- void Bouton_Kill(void) { if ( (Principal_Backups->Nb_pages_allouees==1) || (!Demande_de_confirmation("Delete the current page?")) ) { if (Principal_Backups->Nb_pages_allouees==1) Warning_message("You can't delete the last page."); Effacer_curseur(); Desenclencher_bouton(BOUTON_KILL); Afficher_curseur(); } else { Effacer_curseur(); Detruire_la_page_courante(); Set_palette(Principal_Palette); Calculer_couleurs_menu_optimales(Principal_Palette); Afficher_ecran(); Desenclencher_bouton(BOUTON_KILL); Tracer_cadre_de_bouton_du_menu(BOUTON_LOUPE,Loupe_Mode); Afficher_menu(); Afficher_curseur(); } } //------------------------- Dimensions Image/Ecran --------------------------- void Cocher_bouton_mode(short Pos_X, short Pos_Y, byte Etat) { byte Couleur; switch (Etat & 0x7F) { case 0 : Couleur=CM_Blanc; break; case 1 : Couleur=CM_Clair; break; case 2 : Couleur=CM_Fonce; break; default: Couleur=CM_Noir; } Block(Fenetre_Pos_X+Menu_Facteur_X*Pos_X,Fenetre_Pos_Y+Menu_Facteur_Y*Pos_Y, Menu_Facteur_X*9,Menu_Facteur_Y*3,Couleur); UpdateRect(Fenetre_Pos_X+Menu_Facteur_X*Pos_X,Fenetre_Pos_Y+Menu_Facteur_Y*Pos_Y, Menu_Facteur_X*9,Menu_Facteur_Y*3); } void Afficher_liste_modes(short Debut_liste, short Position_curseur) { short Indice,Mode_courant; short Pos_Y; byte Couleur_texte,Couleur_fond; char Chaine[29]; char *Ratio; for (Mode_courant=Debut_liste,Indice=0; Indice<12 && Mode_courant < Nb_modes_video ; Indice++,Mode_courant++) { Pos_Y=70+(Indice<<3); Cocher_bouton_mode(19,Pos_Y+2,Mode_video[Mode_courant].Etat); if (Position_curseur!=Indice) { Couleur_fond =CM_Noir; if ((Mode_video[Mode_courant].Etat & 3) != 3) Couleur_texte=CM_Clair; else Couleur_texte=CM_Fonce; } else { Couleur_fond =CM_Fonce; if ((Mode_video[Mode_courant].Etat & 3) != 3) Couleur_texte=CM_Blanc; else Couleur_texte=CM_Clair; } Num2str(Mode_video[Mode_courant].Largeur,Chaine,4); Chaine[4]=' '; Num2str(Mode_video[Mode_courant].Hauteur,Chaine+5,4); if(Mode_video[Mode_courant].Fullscreen == 1) memcpy(Chaine+9," Fullscreen ",13); else memcpy(Chaine+9," Window ",13); if (Mode_video[Mode_courant].Largeur*3 == Mode_video[Mode_courant].Hauteur*4) Ratio=" 4:3"; else if (Mode_video[Mode_courant].Largeur*9 == Mode_video[Mode_courant].Hauteur*16) Ratio=" 16:9"; else if (Mode_video[Mode_courant].Largeur*10 == Mode_video[Mode_courant].Hauteur*16) Ratio=" 16:10"; else if (Mode_video[Mode_courant].Largeur*145 == Mode_video[Mode_courant].Hauteur*192) Ratio="192:145"; else if (Mode_video[Mode_courant].Largeur*2 == Mode_video[Mode_courant].Hauteur*3) Ratio=" 3:2"; else if (Mode_video[Mode_courant].Largeur*3 == Mode_video[Mode_courant].Hauteur*5) Ratio=" 5:3"; else if (Mode_video[Mode_courant].Largeur*4 == Mode_video[Mode_courant].Hauteur*5) Ratio=" 5:4"; else if (Mode_video[Mode_courant].Largeur*16 == Mode_video[Mode_courant].Hauteur*25) Ratio=" 25:16"; else Ratio=" "; if (Mode_courant == 0) Ratio=" "; strcat(Chaine,Ratio); Print_dans_fenetre(38,Pos_Y,Chaine,Couleur_texte,Couleur_fond); } } void Scroller_la_liste_des_modes(short Debut_liste, short Position_curseur, int * Mode_choisi) { Effacer_curseur(); *Mode_choisi=Debut_liste+Position_curseur; if (Fenetre_Liste_boutons_scroller->Position!=Debut_liste) { Fenetre_Liste_boutons_scroller->Position=Debut_liste; Fenetre_Dessiner_jauge(Fenetre_Liste_boutons_scroller); } Afficher_liste_modes(Debut_liste,Position_curseur); Afficher_curseur(); } void Bouton_Resol(void) { short Bouton_clicke; int Mode_choisi; word Largeur_choisie; word Hauteur_choisie; short Debut_liste; short Position_curseur; short Temp; char Chaine[5]; struct Fenetre_Bouton_special * Bouton_saisie_Width, * Bouton_saisie_Height; Ouvrir_fenetre(299,190,"Picture & screen sizes"); Fenetre_Afficher_cadre ( 8,17,195, 33); Fenetre_Afficher_cadre ( 8,56,283,126); Fenetre_Afficher_cadre_creux(37,68,228,100); Block(Fenetre_Pos_X+Menu_Facteur_X*38,Fenetre_Pos_Y+Menu_Facteur_Y*69, Menu_Facteur_X*226,Menu_Facteur_Y*98,CM_Noir); Print_dans_fenetre( 12, 21,"Picture size:" ,CM_Fonce,CM_Clair); Print_dans_fenetre( 12, 37,"Width:" ,CM_Fonce,CM_Clair); Print_dans_fenetre(108, 37,"Height:" ,CM_Fonce,CM_Clair); Print_dans_fenetre( 16, 60,"OK" ,CM_Fonce,CM_Clair); Print_dans_fenetre( 55, 60,"X Y" ,CM_Fonce,CM_Clair); Print_dans_fenetre(120, 60,"Win / Full" ,CM_Fonce,CM_Clair); Print_dans_fenetre(219, 60,"Ratio" ,CM_Fonce,CM_Clair); Print_dans_fenetre( 30,170,"\03" ,CM_Fonce,CM_Clair); Print_dans_fenetre( 62,170,"OK" ,CM_Fonce,CM_Clair); Print_dans_fenetre(102,170,"Imperfect" ,CM_Fonce,CM_Clair); Print_dans_fenetre(196,170,"Unsupported" ,CM_Fonce,CM_Clair); Fenetre_Definir_bouton_normal(223, 18,67,14,"OK" ,0,1,SDLK_RETURN); // 1 Fenetre_Definir_bouton_normal(223, 35,67,14,"Cancel" ,0,1,SDLK_ESCAPE); // 2 Fenetre_Definir_bouton_saisie( 60, 35,4); // 3 Bouton_saisie_Width=Fenetre_Liste_boutons_special; Fenetre_Definir_bouton_saisie(164, 35,4); // 4 Bouton_saisie_Height=Fenetre_Liste_boutons_special; Fenetre_Definir_bouton_special(38,70,225,96); // 5 Mode_choisi=Resolution_actuelle; if (Mode_choisi>=6) { if (Mode_choisi>3; if (Temp0) Position_curseur--; else if (Debut_liste>0) Debut_liste--; Scroller_la_liste_des_modes(Debut_liste,Position_curseur,&Mode_choisi); break; case SDLK_DOWN : // Bas if (Position_curseur<11 && Position_curseur<(Nb_modes_video-1)) Position_curseur++; else if (Debut_liste0) Position_curseur=0; else { if (Debut_liste>11) Debut_liste-=11; else Debut_liste=0; } Scroller_la_liste_des_modes(Debut_liste,Position_curseur,&Mode_choisi); break; case SDLK_PAGEDOWN : // PageDown if (Nb_modes_video<12) Position_curseur=Nb_modes_video-1; else if (Position_curseur<11) Position_curseur=11; else { if (Debut_liste> 1; Mouse_Y = Hauteur_ecran >> 1; Set_mouse_position(); Desenclencher_bouton(BOUTON_RESOL); Afficher_curseur(); } void Bouton_Safety_resol(void) { Effacer_curseur(); Desenclencher_bouton(BOUTON_LOUPE); Initialiser_mode_video(640, 400, 0); Resolution_actuelle=0; Afficher_menu(); Afficher_ecran(); Desenclencher_bouton(BOUTON_RESOL); Afficher_curseur(); } //------------------ Gestion des boutons de dessin à la main ----------------- void Bouton_Dessin(void) { Effacer_curseur(); Demarrer_pile_operation(Mode_de_dessin_en_cours); Afficher_curseur(); } void Bouton_Dessin_Switch_mode(void) { Mode_de_dessin_en_cours++; if (Mode_de_dessin_en_cours>OPERATION_DESSIN_POINT) Mode_de_dessin_en_cours=OPERATION_DESSIN_CONTINU; Effacer_curseur(); Afficher_sprite_dans_menu(BOUTON_DESSIN,Mode_de_dessin_en_cours); Demarrer_pile_operation(Mode_de_dessin_en_cours); Afficher_curseur(); } // -- Gestion des boutons de rectangle vide et plein ------------------------ void Bouton_Rectangle_vide(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_RECTANGLE_VIDE); Afficher_curseur(); } void Bouton_Rectangle_plein(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_RECTANGLE_PLEIN); Afficher_curseur(); } // -- Gestion des boutons de cercle (ellipse) vide et plein(e) -------------- void Bouton_Cercle_vide(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_CERCLE_VIDE); Afficher_curseur(); } void Bouton_Ellipse_vide(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_ELLIPSE_VIDE); Afficher_curseur(); } void Bouton_Cercle_plein(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_CERCLE_PLEIN); Afficher_curseur(); } void Bouton_Ellipse_pleine(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_ELLIPSE_PLEINE); Afficher_curseur(); } // -- Gestion du menu des dégradés ------------------------------------------ void Degrade_Dessiner_bouton_de_technique(short Pos_X,short Pos_Y,int Technique) { short Ligne; // On commence par afficher les 2 côtés qui constituent le dégradé de base: // Côté gauche (noir) Block(Fenetre_Pos_X+((Pos_X+2)*Menu_Facteur_X), Fenetre_Pos_Y+((Pos_Y+2)*Menu_Facteur_Y), Menu_Facteur_X*6, Menu_Facteur_Y*10,CM_Noir); // Côté droit (blanc) Block(Fenetre_Pos_X+((Pos_X+8)*Menu_Facteur_X), Fenetre_Pos_Y+((Pos_Y+2)*Menu_Facteur_Y), Menu_Facteur_X*5, Menu_Facteur_Y*10,CM_Blanc); switch(Technique) { case 1 : // Dégradé de trames simples // Au centre, on place 10 lignes tramées simplement for (Ligne=2;Ligne<2+10;Ligne++) if (Ligne&1) { // Lignes impaires Pixel_dans_fenetre(Pos_X+ 5,Pos_Y+Ligne,CM_Blanc); Pixel_dans_fenetre(Pos_X+ 7,Pos_Y+Ligne,CM_Blanc); Pixel_dans_fenetre(Pos_X+ 8,Pos_Y+Ligne,CM_Noir); } else { // Lignes paires Pixel_dans_fenetre(Pos_X+ 6,Pos_Y+Ligne,CM_Blanc); Pixel_dans_fenetre(Pos_X+ 9,Pos_Y+Ligne,CM_Noir); } break; case 2 : // Dégradé de trames étendues // Au centre, on place 10 lignes tramées de façon compliquée for (Ligne=2;Ligne<2+10;Ligne++) if (Ligne&1) { // Lignes impaires Pixel_dans_fenetre(Pos_X+ 7,Pos_Y+Ligne,CM_Blanc); Pixel_dans_fenetre(Pos_X+ 8,Pos_Y+Ligne,CM_Noir); Pixel_dans_fenetre(Pos_X+10,Pos_Y+Ligne,CM_Noir); } else { // Lignes paires Pixel_dans_fenetre(Pos_X+ 4,Pos_Y+Ligne,CM_Blanc); Pixel_dans_fenetre(Pos_X+ 6,Pos_Y+Ligne,CM_Blanc); } } UpdateRect(Fenetre_Pos_X+((Pos_X+2)*Menu_Facteur_X),Fenetre_Pos_Y+((Pos_Y+2)*Menu_Facteur_Y), Menu_Facteur_X*10,Menu_Facteur_Y*10); } void Degrade_Charger_infos_du_tableau(int Indice) { Degrade_Borne_Inferieure =Degrade_Tableau[Indice].Debut; Degrade_Borne_Superieure =Degrade_Tableau[Indice].Fin; Degrade_Inverse =Degrade_Tableau[Indice].Inverse; Degrade_Melange_aleatoire=Degrade_Tableau[Indice].Melange+1; Degrade_Intervalle_bornes=(Degrade_Borne_Inferieure indice du dégradé dans le tableau Fenetre_Definir_bouton_scroller(218,22,75,16,1,Degrade_Courant); // 2 // Définition du scrolleur de mélange du dégradé Fenetre_Definir_bouton_scroller(31,22,84,256,1,Degrade_Tableau[Degrade_Courant].Melange); // 3 Scroller_de_melange=Fenetre_Liste_boutons_scroller; // Définition du bouton de sens Fenetre_Definir_bouton_normal(8,22,15,14, (Degrade_Tableau[Degrade_Courant].Inverse)?"\033":"\032",0,1,SDLK_TAB); // 4 // Définition du bouton de technique Fenetre_Definir_bouton_normal(8,92,15,14,"",0,1,SDLK_TAB|MOD_SHIFT); // 5 Degrade_Dessiner_bouton_de_technique(8,92,Degrade_Tableau[Degrade_Courant].Technique); Fenetre_Definir_bouton_normal(178,112,51,14,"OK",0,1,SDLK_RETURN); // 6 Fenetre_Definir_bouton_normal(123,112,51,14,"Cancel",0,1,SDLK_ESCAPE); // 7 Print_dans_fenetre(5,60,"MIX",CM_Fonce,CM_Clair); // On tagge les couleurs qui vont avec Tagger_intervalle_palette(Degrade_Tableau[Degrade_Courant].Debut,Degrade_Tableau[Degrade_Courant].Fin); Num2str(Degrade_Courant+1,Chaine,2); Print_dans_fenetre(215,100,Chaine,CM_Noir,CM_Clair); // On affiche le cadre autour de la préview Fenetre_Afficher_cadre_creux(7,111,110,16); // On affiche la preview Degrade_Dessiner_preview(8,112,108,14,Degrade_Courant); Premiere_couleur=Derniere_couleur=(Degrade_Tableau[Degrade_Courant].Inverse)?Degrade_Tableau[Degrade_Courant].Fin:Degrade_Tableau[Degrade_Courant].Debut; Display_Window(237,133); Afficher_curseur(); do { Ancien_Mouse_X=Mouse_X; Ancien_Mouse_Y=Mouse_Y; Ancien_Mouse_K=Mouse_K; Bouton_clicke=Fenetre_Bouton_clicke(); switch(Bouton_clicke) { case -1 : case 1 : // Palette if ( (Mouse_X!=Ancien_Mouse_X) || (Mouse_Y!=Ancien_Mouse_Y) || (Mouse_K!=Ancien_Mouse_K) ) { Effacer_curseur(); Couleur_temporaire=(Bouton_clicke==1) ? Fenetre_Attribut2 : Lit_pixel(Mouse_X,Mouse_Y); if (!Ancien_Mouse_K) { // On vient de clicker // On met à jour l'intervalle du dégradé Premiere_couleur=Derniere_couleur=Degrade_Tableau[Degrade_Courant].Debut=Degrade_Tableau[Degrade_Courant].Fin=Couleur_temporaire; // On tagge le bloc Tagger_intervalle_palette(Degrade_Tableau[Degrade_Courant].Debut,Degrade_Tableau[Degrade_Courant].Fin); // Tracé de la preview: Degrade_Dessiner_preview(8,112,108,14,Degrade_Courant); } else { // On maintient le click, on va donc tester si le curseur bouge if (Couleur_temporaire!=Derniere_couleur) { // On commence par ordonner la 1ère et dernière couleur du bloc if (Premiere_couleurCouleur_temporaire) { Degrade_Tableau[Degrade_Courant].Debut=Couleur_temporaire; Degrade_Tableau[Degrade_Courant].Fin =Premiere_couleur; } else Degrade_Tableau[Degrade_Courant].Debut=Degrade_Tableau[Degrade_Courant].Fin=Premiere_couleur; // On tagge le bloc Tagger_intervalle_palette(Degrade_Tableau[Degrade_Courant].Debut,Degrade_Tableau[Degrade_Courant].Fin); // Tracé de la preview: Degrade_Dessiner_preview(8,112,108,14,Degrade_Courant); Derniere_couleur=Couleur_temporaire; } } Afficher_curseur(); } break; case 2 : // Nouvel indice de dégradé Effacer_curseur(); // Nouvel indice dans Fenetre_Attribut2 Degrade_Courant=Fenetre_Attribut2; // On affiche la valeur sous la jauge Num2str(Degrade_Courant+1,Chaine,2); Print_dans_fenetre(215,100,Chaine,CM_Noir,CM_Clair); // On tagge les couleurs qui vont avec Tagger_intervalle_palette(Degrade_Tableau[Degrade_Courant].Debut,Degrade_Tableau[Degrade_Courant].Fin); // On affiche le sens qui va avec Print_dans_fenetre(12,25,(Degrade_Tableau[Degrade_Courant].Inverse)?"\033":"\032",CM_Noir,CM_Clair); // On raffiche le mélange (jauge) qui va avec Scroller_de_melange->Position=Degrade_Tableau[Degrade_Courant].Melange; Fenetre_Dessiner_jauge(Scroller_de_melange); // On raffiche la technique qui va avec Degrade_Dessiner_bouton_de_technique(8,92,Degrade_Tableau[Degrade_Courant].Technique); // On affiche la nouvelle preview Degrade_Dessiner_preview(8,112,108,14,Degrade_Courant); Afficher_curseur(); break; case 3 : // Nouveau mélange de dégradé Effacer_curseur(); // Nouvel mélange dans Fenetre_Attribut2 Degrade_Tableau[Degrade_Courant].Melange=Fenetre_Attribut2; // On affiche la nouvelle preview Degrade_Dessiner_preview(8,112,108,14,Degrade_Courant); Afficher_curseur(); break; case 4 : // Changement de sens Effacer_curseur(); // On inverse le sens (par un XOR de 1) Degrade_Tableau[Degrade_Courant].Inverse^=1; Print_dans_fenetre(12,25,(Degrade_Tableau[Degrade_Courant].Inverse)?"\033":"\032",CM_Noir,CM_Clair); // On affiche la nouvelle preview Degrade_Dessiner_preview(8,112,108,14,Degrade_Courant); Afficher_curseur(); break; case 5 : // Changement de technique Effacer_curseur(); // On change la technique par (+1)%3 Degrade_Tableau[Degrade_Courant].Technique=(Degrade_Tableau[Degrade_Courant].Technique+1)%3; Degrade_Dessiner_bouton_de_technique(8,92,Degrade_Tableau[Degrade_Courant].Technique); // On affiche la nouvelle preview Degrade_Dessiner_preview(8,112,108,14,Degrade_Courant); Afficher_curseur(); } if (!Mouse_K) switch (Touche) { case SDLK_BACKQUOTE : // Récupération d'une couleur derrière le menu case SDLK_COMMA : Recuperer_couleur_derriere_fenetre(&Couleur,&Click); if (Click) { Effacer_curseur(); Couleur_temporaire=Couleur; // On met à jour l'intervalle du dégradé Premiere_couleur=Derniere_couleur=Degrade_Tableau[Degrade_Courant].Debut=Degrade_Tableau[Degrade_Courant].Fin=Couleur_temporaire; // On tagge le bloc Tagger_intervalle_palette(Degrade_Tableau[Degrade_Courant].Debut,Degrade_Tableau[Degrade_Courant].Fin); // Tracé de la preview: Degrade_Dessiner_preview(8,112,108,14,Degrade_Courant); Afficher_curseur(); } break; default: if (Touche==Bouton[BOUTON_GRADMENU].Raccourci_gauche) { Fenetre_aide(BOUTON_PINCEAUX, NULL); break; } } } while (Bouton_clicke<6); Fermer_fenetre(); Desenclencher_bouton(BOUTON_GRADMENU); Afficher_curseur(); Traiter_pixel_de_degrade=Afficher_pixel; if (Bouton_clicke==7) // Cancel { Degrade_Courant=Ancien_Degrade_Courant; memcpy(Degrade_Tableau,Backup_Degrade_Tableau,sizeof(struct T_Degrade_Tableau)*16); Degrade_Charger_infos_du_tableau(Degrade_Courant); } } // -- Gestion des boutons de cercle / ellipse / rectangle dégradés -------------------- void Bouton_Cercle_degrade(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_CERCLE_DEGRADE); Afficher_curseur(); } void Bouton_Ellipse_degrade(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_ELLIPSE_DEGRADEE); Afficher_curseur(); } void Bouton_Rectangle_degrade(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_RECTANGLE_DEGRADE); Afficher_curseur(); } // -- Gestion du bouton de remplissage --------------------------------------- void Bouton_Fill(void) { if (Operation_en_cours!=OPERATION_FILL) { Effacer_curseur(); if (Operation_en_cours!=OPERATION_REMPLACER) { Pinceau_Forme_avant_fill=Pinceau_Forme; Pinceau_Forme=FORME_PINCEAU_POINT; } else if ( (Mouse_Y=Principal_X_Zoom) ) ) Print_dans_menu("X: Y: ",0); Demarrer_pile_operation(OPERATION_FILL); Afficher_curseur(); } } void Bouton_Remplacer(void) { if (Operation_en_cours!=OPERATION_REMPLACER) { Effacer_curseur(); if (Operation_en_cours!=OPERATION_FILL) { Pinceau_Forme_avant_fill=Pinceau_Forme; Pinceau_Forme=FORME_PINCEAU_POINT; } if ( (Mouse_Y=Principal_X_Zoom) ) ) Print_dans_menu("X: Y: ( )",0); Demarrer_pile_operation(OPERATION_REMPLACER); Afficher_curseur(); } } void Bouton_desenclencher_Fill(void) { Pinceau_Forme=Pinceau_Forme_avant_fill; if (Operation_en_cours==OPERATION_REMPLACER) if ( (Mouse_Y=Principal_X_Zoom) ) ) Print_dans_menu("X: Y: ",0); } //---------------------------- Menu des pinceaux ----------------------------- void Bouton_Menu_pinceaux(void) { short Bouton_clicke; short Pos_X,Pos_Y; byte Indice; Ouvrir_fenetre(310,155,"Paintbrush menu"); Fenetre_Afficher_cadre(8,21,294,107); Fenetre_Definir_bouton_normal(122,133,67,14,"Cancel",0,1,SDLK_ESCAPE); // 1 for (Indice=0; IndiceTAILLE_MAXI_PATH) { // Doh! il va falloir tronquer le répertoire (bouh !) // On commence par copier bêtement les 3 premiers caractères (e.g. "C:\") for (Indice=0;Indice<3;Indice++) Nom_temporaire[Indice]=Principal_Repertoire_courant[Indice]; // On y rajoute 3 petits points: strcpy(Nom_temporaire+3,"..."); // Ensuite, on cherche un endroit à partir duquel on pourrait loger tout // le reste de la chaine (Ouaaaaaah!!! Vachement fort le mec!!) for (Indice++;IndiceNb_elements=Liste_Nb_elements; Enreg->Position=Position; Calculer_hauteur_curseur_jauge(Enreg); Fenetre_Dessiner_jauge(Enreg); // On efface les anciens noms de fichier: Block(Fenetre_Pos_X+(Menu_Facteur_X<<3),Fenetre_Pos_Y+(Menu_Facteur_Y*(89+FILENAMESPACE)),Menu_Facteur_X*98,Menu_Facteur_Y*82,CM_Noir); // On affiche les nouveaux: Afficher_la_liste_des_fichiers(Position,Decalage); UpdateRect(Fenetre_Pos_X+(Menu_Facteur_X<<3),Fenetre_Pos_Y+(Menu_Facteur_Y*(89+FILENAMESPACE)),Menu_Facteur_X*98,Menu_Facteur_Y*82); // On récupère le nom du schmilblick à "accéder" Determiner_element_de_la_liste(Position,Decalage,Principal_Nom_fichier,&Type_selectionne); // On affiche le nouveau nom de fichier Print_Nom_fichier_dans_selecteur(); // On affiche le nom du répertoire courant Print_repertoire_courant(); } void Relire_liste_fichiers(byte Filtre, short Position, short Decalage, struct Fenetre_Bouton_scroller * Enreg) { Lire_liste_des_fichiers(Filtre); Trier_la_liste_des_fichiers(); Preparer_et_afficher_liste_fichiers(Position,Decalage,Enreg); } void On_vient_de_scroller_dans_le_fileselect(struct Fenetre_Bouton_scroller * Scroller_de_fichiers) { char Ancien_nom_de_fichier[TAILLE_CHEMIN_FICHIER]; strcpy(Ancien_nom_de_fichier,Principal_Nom_fichier); // On regarde si la liste a bougé if (Scroller_de_fichiers->Position!=Principal_File_list_Position) { // Si c'est le cas, il faut mettre à jour la jauge Scroller_de_fichiers->Position=Principal_File_list_Position; Fenetre_Dessiner_jauge(Scroller_de_fichiers); } // On récupére le nom du schmilblick à "accéder" Determiner_element_de_la_liste(Principal_File_list_Position,Principal_File_list_Decalage,Principal_Nom_fichier,&Type_selectionne); if (strcmp(Ancien_nom_de_fichier,Principal_Nom_fichier)) Nouvelle_preview=1; // On affiche le nouveau nom de fichier Print_Nom_fichier_dans_selecteur(); Afficher_curseur(); } short Position_fichier_dans_liste(char * Nom) { struct Element_de_liste_de_fileselect * Element_courant; short Indice; for (Indice=0, Element_courant=Liste_du_fileselect; ((Element_courant!=NULL) && (strcmp(Element_courant->NomComplet,Nom))); Indice++,Element_courant=Element_courant->Suivant); return (Element_courant!=NULL)?Indice:0; } void Placer_barre_de_selection_sur(char * Nom) { short Indice; Indice=Position_fichier_dans_liste(Nom); if ((Liste_Nb_elements<=10) || (Indice<5)) { Principal_File_list_Position=0; Principal_File_list_Decalage=Indice; } else { if (Indice>=Liste_Nb_elements-5) { Principal_File_list_Position=Liste_Nb_elements-10; Principal_File_list_Decalage=Indice-Principal_File_list_Position; } else { Principal_File_list_Position=Indice-4; Principal_File_list_Decalage=4; } } } char FFF_Meilleur_nom[TAILLE_CHEMIN_FICHIER]; char * Nom_correspondant_le_mieux_a(char * Nom) { char * Pointeur_Meilleur_nom; struct Element_de_liste_de_fileselect * Element_courant; byte Lettres_identiques=0; byte Compteur; strcpy(FFF_Meilleur_nom,Principal_Nom_fichier); Pointeur_Meilleur_nom=NULL; for (Element_courant=Liste_du_fileselect; Element_courant!=NULL; Element_courant=Element_courant->Suivant) { if ( (!Config.Find_file_fast) || (Config.Find_file_fast==(Element_courant->Type+1)) ) { // On compare et si c'est mieux, on stocke dans Meilleur_nom for (Compteur=0; Nom[Compteur]!='\0' && tolower(Element_courant->NomComplet[Compteur])==tolower(Nom[Compteur]); Compteur++); if (Compteur>Lettres_identiques) { Lettres_identiques=Compteur; strcpy(FFF_Meilleur_nom,Element_courant->NomComplet); Pointeur_Meilleur_nom=Element_courant->NomComplet; } } } return Pointeur_Meilleur_nom; } byte Bouton_Load_ou_Save(byte Load, byte Image) // Load=1 => On affiche le menu du bouton LOAD // Load=0 => On affiche le menu du bouton SAVE { short Bouton_clicke; struct Fenetre_Bouton_scroller * Scroller_de_fichiers; short Temp; int Bidon=0; // Sert à appeler SDL_GetKeyState word Drives_Debut_Y; byte Charger_ou_sauver_l_image=0; char Nom_drive[3]=" "; byte On_a_clicke_sur_OK=0;// Indique si on a clické sur Load ou Save ou sur //un bouton enclenchant Load ou Save juste après. struct Composantes * Palette_initiale; // | Données concernant l'image qui byte Image_modifiee_initiale; // | sont mémorisées pour pouvoir short Largeur_image_initiale; // |- être restaurées en sortant, short Hauteur_image_initiale; // | parce que la preview elle les byte Back_color_initiale; // | fout en l'air (c'te conne). char Nom_fichier_initial[TAILLE_CHEMIN_FICHIER]; // Sert à laisser le nom courant du fichier en cas de sauvegarde char Repertoire_precedent[TAILLE_CHEMIN_FICHIER]; // Répertoire d'où l'on vient après un CHDIR char Commentaire_initial[TAILLE_COMMENTAIRE+1]; char Fichier_recherche[TAILLE_CHEMIN_FICHIER]=""; char Nom_fichier_Save[TAILLE_CHEMIN_FICHIER]; char * Fichier_le_plus_ressemblant; Palette_initiale=(struct Composantes *)malloc(sizeof(T_Palette)); memcpy(Palette_initiale,Principal_Palette,sizeof(T_Palette)); Back_color_initiale=Back_color; Image_modifiee_initiale=Principal_Image_modifiee; Largeur_image_initiale=Principal_Largeur_image; Hauteur_image_initiale=Principal_Hauteur_image; strcpy(Nom_fichier_initial,Principal_Nom_fichier); strcpy(Commentaire_initial,Principal_Commentaire); if (Load) { if (Image) Ouvrir_fenetre(310,187+FILENAMESPACE,"Load picture"); else Ouvrir_fenetre(310,187+FILENAMESPACE,"Load brush"); Fenetre_Definir_bouton_normal(125,157+FILENAMESPACE,51,14,"Load",0,1,SDLK_RETURN); // 1 } else { if (Image) Ouvrir_fenetre(310,187+FILENAMESPACE,"Save picture"); else Ouvrir_fenetre(310,187+FILENAMESPACE,"Save brush"); Fenetre_Definir_bouton_normal(125,157+FILENAMESPACE,51,14,"Save",0,1,SDLK_RETURN); // 1 if (Principal_Format==0) // Correction du *.* { Principal_Format=Principal_Format_fichier; Principal_File_list_Position=0; Principal_File_list_Decalage=0; } if (Principal_Format>NB_FORMATS_SAVE) // Correction d'un format insauvable { Principal_Format=FORMAT_PAR_DEFAUT; Principal_File_list_Position=0; Principal_File_list_Decalage=0; } // Affichage du commentaire if (Format_Commentaire[Principal_Format-1]) Print_dans_fenetre(46,175+FILENAMESPACE,Principal_Commentaire,CM_Noir,CM_Clair); } Fenetre_Definir_bouton_normal(125,139+FILENAMESPACE,51,14,"Cancel",0,1,SDLK_ESCAPE); // 2 Fenetre_Definir_bouton_normal(125, 89+FILENAMESPACE,51,14,"Delete",0,1,SDLK_DELETE); // 3 // Cadre autour des formats Fenetre_Afficher_cadre( 7, 51,103, 35); // Cadre autour des infos sur le fichier de dessin Fenetre_Afficher_cadre(116, 51,187, 35); // Cadre autour de la preview Fenetre_Afficher_cadre_creux(179,88+FILENAMESPACE,124,84); // Cadre autour du fileselector Fenetre_Afficher_cadre_creux( 7,88+FILENAMESPACE,100,84); Fenetre_Definir_bouton_special(9,90+FILENAMESPACE,96,80); // 4 // Scroller du fileselector Fenetre_Definir_bouton_scroller(110,89+FILENAMESPACE,82,1,10,0); // 5 Scroller_de_fichiers=Fenetre_Liste_boutons_scroller; // Scroller des formats Fenetre_Definir_bouton_scroller(12,55,27,(Load)?NB_FORMATS_LOAD+1:NB_FORMATS_SAVE,1,(Load)?Principal_Format:Principal_Format-1); // 6 // Texte de commentaire des dessins Print_dans_fenetre(7,174+FILENAMESPACE,"Txt:",CM_Fonce,CM_Clair); Fenetre_Definir_bouton_saisie(44,173+FILENAMESPACE,TAILLE_COMMENTAIRE); // 7 // Cadre autour du nom de fichier //Fenetre_Afficher_cadre_creux( 7,87,296,15); Print_dans_fenetre(9,90,"Filename:",CM_Fonce,CM_Clair); // Saisie du nom de fichier Fenetre_Definir_bouton_saisie(11+9*8,88,27); // 8 Print_dans_fenetre( 27,65,"Format:",CM_Fonce,CM_Clair); Print_dans_fenetre(120,55,"Image size :",CM_Fonce,CM_Clair); Print_dans_fenetre(120,63,"File size :",CM_Fonce,CM_Clair); Print_dans_fenetre(120,72,"Format :",CM_Fonce,CM_Clair); Print_Format(); // Selecteur de Lecteur / Volume Fenetre_Definir_bouton_normal(8,21,120,14,"Select drive",0,1,SDLK_LAST); // 9 // Définition des boutons représentant les lecteurs Drives_Debut_Y=(Nb_drives<=8)? 23 : 18; for (Temp=0; Temp=Liste_Nb_repertoires) { Print_dans_fenetre(127,107+FILENAMESPACE,"Delete",CM_Fonce,CM_Clair); Print_dans_fenetre(127,115+FILENAMESPACE,"file ?",CM_Fonce,CM_Clair); } else { Print_dans_fenetre(127,107+FILENAMESPACE,"Remove",CM_Fonce,CM_Clair); Print_dans_fenetre(127,115+FILENAMESPACE,"dir. ?",CM_Fonce,CM_Clair); } Print_dans_fenetre(127,123+FILENAMESPACE,"Yes/No",CM_Fonce,CM_Clair); do { SDL_PumpEvents(); Etat_Du_Clavier=SDL_GetKeyState(&Bidon); } while ((Etat_Du_Clavier[SDLK_y]==0) && (Etat_Du_Clavier[SDLK_n]==0) && (Etat_Du_Clavier[SDLK_ESCAPE]==0)); // On efface la demande de confirmation Block(Fenetre_Pos_X+127*Menu_Facteur_X,Fenetre_Pos_Y+(107+FILENAMESPACE)*Menu_Facteur_Y, Menu_Facteur_X*48,Menu_Facteur_Y*24,CM_Clair); UpdateRect(Fenetre_Pos_X+127*Menu_Facteur_X,Fenetre_Pos_Y+(107+FILENAMESPACE)*Menu_Facteur_Y, Menu_Facteur_X*48,Menu_Facteur_Y*24); // Si l'utilisateur confirme, if (Etat_Du_Clavier[SDLK_y]) { // Si c'est un fichier if (Principal_File_list_Position+Principal_File_list_Decalage>=Liste_Nb_repertoires) // On efface le fichier (si on peut) Temp=(!remove(Principal_Nom_fichier)); else // Si c'est un repertoire // On efface le repertoire (si on peut) Temp=(!rmdir(Principal_Nom_fichier)); if (Temp) // Temp indique si l'effacement s'est bien passé { // On remonte si c'était le dernier élément de la liste if (Principal_File_list_Position+Principal_File_list_Decalage==Liste_Nb_elements-1) { if (Principal_File_list_Position) Principal_File_list_Position--; else if (Principal_File_list_Decalage) Principal_File_list_Decalage--; } else // Si ce n'était pas le dernier, il faut faire gaffe à ce { // que ses copains d'en dessous ne remontent pas trop. if ( (Principal_File_list_Position) && (Principal_File_list_Position+10==Liste_Nb_elements) ) { Principal_File_list_Position--; Principal_File_list_Decalage++; } } // On relit les informations Relire_liste_fichiers(Principal_Format,Principal_File_list_Position,Principal_File_list_Decalage,Scroller_de_fichiers); // On demande la preview du nouveau fichier sur lequel on se trouve Nouvelle_preview=1; } else Erreur(0); // On place la barre de sélection du brouillon au début s'il a le // même répertoire que l'image principale. if (!strcmp(Principal_Repertoire_courant,Brouillon_Repertoire_courant)) { Brouillon_File_list_Position=0; Brouillon_File_list_Decalage=0; } } Afficher_curseur(); } break; case 4 : // Zone d'affichage de la liste de fichiers Effacer_curseur(); Temp=Calculer_decalage_click_dans_fileselector(); if (Temp>=0) { if (Temp!=Principal_File_list_Decalage) { // On met à jour le décalage Principal_File_list_Decalage=Temp; // On récupére le nom du schmilblick à "accéder" Determiner_element_de_la_liste(Principal_File_list_Position,Principal_File_list_Decalage,Principal_Nom_fichier,&Type_selectionne); // On affiche le nouveau nom de fichier Print_Nom_fichier_dans_selecteur(); // On affiche à nouveau la liste Afficher_la_liste_des_fichiers(Principal_File_list_Position,Principal_File_list_Decalage); // On vient de changer de nom de fichier, donc on doit s'appreter // a rafficher une preview Nouvelle_preview=1; } else { // En sauvegarde, si on a double-clické sur un répertoire, il // faut mettre le nom de fichier au nom du répertoire. Sinon, dans // certains cas, on risque de sauvegarder avec le nom du fichier // actuel au lieu de changer de répertoire. if (Principal_File_list_Position+Principal_File_list_Decalage On se place sur le nom de fichier qui correspond if (Bouton_clicke<=0) { if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) { Fenetre_aide(Load?BOUTON_CHARGER:BOUTON_SAUVER, NULL); break; } Temp=strlen(Fichier_recherche); if (Touche_ANSI>= ' ' && Touche_ANSI < 255 && Temp<50) { Fichier_recherche[Temp]=Touche_ANSI; Fichier_recherche[Temp+1]='\0'; Fichier_le_plus_ressemblant=Nom_correspondant_le_mieux_a(Fichier_recherche); if ( (Fichier_le_plus_ressemblant) ) { Temp=Principal_File_list_Position+Principal_File_list_Decalage; Effacer_curseur(); Placer_barre_de_selection_sur(Fichier_le_plus_ressemblant); Preparer_et_afficher_liste_fichiers(Principal_File_list_Position,Principal_File_list_Decalage,Scroller_de_fichiers); Afficher_curseur(); if (Temp!=Principal_File_list_Position+Principal_File_list_Decalage) Nouvelle_preview=1; } else *Fichier_recherche=0; } } else *Fichier_recherche=0; } if (On_a_clicke_sur_OK) { // Si c'est un répertoire, on annule "On_a_clicke_sur_OK" et on passe // dedans. if (Type_selectionne!=0) { Effacer_curseur(); On_a_clicke_sur_OK=0; // On mémorise le répertoire dans lequel on était if (strcmp(Principal_Nom_fichier,"..")) strcpy(Repertoire_precedent,Nom_formate("..", 1)); else { strcpy(Repertoire_precedent, Nom_formate(Position_dernier_slash(Principal_Repertoire_courant), 1) ); } // On doit rentrer dans le répertoire: chdir(Principal_Nom_fichier); Determiner_repertoire_courant(); // On lit le nouveau répertoire Lire_liste_des_fichiers(Principal_Format); Trier_la_liste_des_fichiers(); // On place la barre de sélection sur le répertoire d'où l'on vient Placer_barre_de_selection_sur(Repertoire_precedent); // Affichage des premiers fichiers visibles: Preparer_et_afficher_liste_fichiers(Principal_File_list_Position,Principal_File_list_Decalage,Scroller_de_fichiers); Afficher_curseur(); Nouvelle_preview=1; } else // Sinon on essaye de charger ou sauver le fichier { strcpy(Principal_Repertoire_fichier,Principal_Repertoire_courant); if (!Load) Principal_Format_fichier=Principal_Format; Charger_ou_sauver_l_image=1; } } // Gestion du chrono et des previews if (Nouvelle_preview) { // On efface les infos de la preview précédente s'il y en a une // d'affichée if (Etat_chrono==2) { Effacer_curseur(); // On efface le commentaire précédent Block(Fenetre_Pos_X+ 46*Menu_Facteur_X,Fenetre_Pos_Y+(175+FILENAMESPACE)*Menu_Facteur_Y, Menu_Facteur_X<<8,Menu_Facteur_Y<<3,CM_Clair); // On nettoie la zone où va s'afficher la preview: Block(Fenetre_Pos_X+180*Menu_Facteur_X,Fenetre_Pos_Y+ (89+FILENAMESPACE)*Menu_Facteur_Y, Menu_Facteur_X*122,Menu_Facteur_Y*82,CM_Clair); // On efface les dimensions de l'image Block(Fenetre_Pos_X+226*Menu_Facteur_X,Fenetre_Pos_Y+ 55*Menu_Facteur_Y, Menu_Facteur_X*72,Menu_Facteur_Y<<3,CM_Clair); // On efface la taille du fichier Block(Fenetre_Pos_X+226*Menu_Facteur_X,Fenetre_Pos_Y+ 63*Menu_Facteur_Y, Menu_Facteur_X*72,Menu_Facteur_Y<<3,CM_Clair); // On efface le format du fichier Block(Fenetre_Pos_X+226*Menu_Facteur_X,Fenetre_Pos_Y+ 72*Menu_Facteur_Y, Menu_Facteur_X*72,Menu_Facteur_Y<<3,CM_Clair); // Affichage du commentaire if ( (!Load) && (Format_Commentaire[Principal_Format-1]) ) { Print_dans_fenetre(46,175+FILENAMESPACE,Principal_Commentaire,CM_Noir,CM_Clair); } Afficher_curseur(); // Un update pour couvrir les 4 zones: 3 libellés plus la zone de preview UpdateRect(Fenetre_Pos_X+180*Menu_Facteur_X,Fenetre_Pos_Y+55*Menu_Facteur_Y,Menu_Facteur_X*122,Menu_Facteur_Y*(116+FILENAMESPACE)); // Zone de commentaire UpdateRect(Fenetre_Pos_X+46*Menu_Facteur_X,Fenetre_Pos_Y+(175+FILENAMESPACE)*Menu_Facteur_Y,Menu_Facteur_X*32*8,Menu_Facteur_Y*8); } Nouvelle_preview=0; Etat_chrono=0; // Etat du chrono = Attente d'un Xème de seconde // On lit le temps de départ du chrono Initialiser_chrono(Config.Chrono_delay); } if (!Etat_chrono) // Prendre une nouvelle mesure du chrono et regarder Tester_chrono(); // s'il ne faut pas afficher la preview if (Etat_chrono==1) // Il faut afficher la preview { if ( (Principal_File_list_Position+Principal_File_list_Decalage>=Liste_Nb_repertoires) && (Liste_Nb_elements) ) { strcpy(Principal_Repertoire_fichier,Principal_Repertoire_courant); Effacer_curseur(); Charger_image(Image); UpdateRect(ToWinX(179),ToWinY(88+FILENAMESPACE),ToWinL(124),ToWinH(84)); Afficher_curseur(); // Après le chargement de la preview, on restaure tout ce qui aurait // pu être modifié par le chargement de l'image: memcpy(Principal_Palette,Palette_initiale,sizeof(T_Palette)); Principal_Image_modifiee=Image_modifiee_initiale; Principal_Largeur_image=Largeur_image_initiale; Principal_Hauteur_image=Hauteur_image_initiale; } Etat_chrono=2; // On arrête le chrono } } while ( (!On_a_clicke_sur_OK) && (Bouton_clicke!=2) ); // Si on annule, on restaure l'ancien commentaire if (Bouton_clicke==2) strcpy(Principal_Commentaire,Commentaire_initial); // On restaure les données de l'image qui ont certainement été modifiées // par la preview. memcpy(Principal_Palette,Palette_initiale,sizeof(T_Palette)); Back_color=Back_color_initiale; Principal_Image_modifiee=Image_modifiee_initiale; Principal_Largeur_image=Largeur_image_initiale; Principal_Hauteur_image=Hauteur_image_initiale; Set_palette(Principal_Palette); Calculer_couleurs_menu_optimales(Principal_Palette); Temp=(Fenetre_Pos_Y+(Fenetre_Hauteur*Menu_Facteur_Y)1024) || (Ecran_original_Y>768)) { Ecran_original_X=1024; Ecran_original_Y=768; } // Maintenant on peut chercher le mode qui correspond le mieux Meilleur_mode=Resolution_actuelle; Meilleure_largeur=0; Meilleure_hauteur=0; for (Mode=1; Mode On charge/sauve une image // Image=0 => On charge/sauve une brosse { // Données initiales du fichier (au cas où on voudrait annuler) char Repertoire_fichier_initial[TAILLE_CHEMIN_FICHIER]; char Nom_fichier_initial[TAILLE_CHEMIN_FICHIER]; byte Format_fichier_initial; byte Ne_pas_restaurer; byte Utiliser_palette_brosse = 0; struct Composantes * Palette_initiale=NULL; byte Ancienne_forme_curseur; short Principal_Largeur_image_initiale=Principal_Largeur_image; short Principal_Hauteur_image_initiale=Principal_Hauteur_image; //char Commentaire_initial[TAILLE_COMMENTAIRE+1]; int Nouveau_mode; if (!Image) Swapper_infos_selecteurs_image_et_brosse(); strcpy(Repertoire_fichier_initial,Principal_Repertoire_fichier); strcpy(Nom_fichier_initial ,Principal_Nom_fichier); Format_fichier_initial=Principal_Format_fichier; if (!Image) { Palette_initiale=(struct Composantes *)malloc(sizeof(T_Palette)); memcpy(Palette_initiale,Principal_Palette,sizeof(T_Palette)); } Ne_pas_restaurer=Bouton_Load_ou_Save(1,Image); if (Ne_pas_restaurer) { if (Image) { if (Principal_Image_modifiee) Ne_pas_restaurer=Demande_de_confirmation("Discard unsaved changes?"); } else Utiliser_palette_brosse=Demande_de_confirmation("Use the palette of the brush?"); } if (Ne_pas_restaurer) { Ancienne_forme_curseur=Forme_curseur; Effacer_curseur(); Forme_curseur=FORME_CURSEUR_SABLIER; Afficher_curseur(); if (Image) { // Si c'est une image qu'on charge, on efface l'ancien commentaire // C'est loin d'être indispensable, m'enfin bon... if (Format_Backup_done[Principal_Format_fichier-1]) Principal_Commentaire[0]='\0'; Ecran_original_X=0; Ecran_original_Y=0; } else Pixel_de_chargement=Pixel_Chargement_dans_brosse; Charger_image(Image); if (!Image) { if (!Utiliser_palette_brosse) memcpy(Principal_Palette,Palette_initiale,sizeof(T_Palette)); if (Erreur_fichier==3) // On ne peut pas allouer la brosse { if (Brosse) free(Brosse); Brosse=(byte *)malloc(1*1); Brosse_Hauteur=1; Brosse_Largeur=1; *Brosse=Fore_color; if (Smear_Brosse) free(Smear_Brosse); Smear_Brosse=(byte *)malloc(TAILLE_MAXI_PINCEAU*TAILLE_MAXI_PINCEAU); Smear_Brosse_Hauteur=TAILLE_MAXI_PINCEAU; Smear_Brosse_Largeur=TAILLE_MAXI_PINCEAU; } else { Brosse_Largeur=Principal_Largeur_image; Brosse_Hauteur=Principal_Hauteur_image; 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; } Tiling_Decalage_X=0; Tiling_Decalage_Y=0; Brosse_Decalage_X=(Brosse_Largeur>>1); Brosse_Decalage_Y=(Brosse_Hauteur>>1); Principal_Largeur_image=Principal_Largeur_image_initiale; Principal_Hauteur_image=Principal_Hauteur_image_initiale; Pixel_de_chargement=Pixel_Chargement_dans_ecran_courant; Enclencher_bouton(BOUTON_DESSIN,A_GAUCHE); if (Config.Auto_discontinuous) { // On se place en mode Dessin discontinu à la main while (Operation_en_cours!=OPERATION_DESSIN_DISCONTINU) Enclencher_bouton(BOUTON_DESSIN,A_DROITE); } Effacer_curseur(); // On passe en brosse couleur: Changer_la_forme_du_pinceau(FORME_PINCEAU_BROSSE_COULEUR); } else { Effacer_curseur(); Forme_curseur=Ancienne_forme_curseur; } if ( (Erreur_fichier==1) || (!Format_Backup_done[Principal_Format_fichier-1]) ) { Ne_pas_restaurer=0; if (Erreur_fichier!=1) Calculer_couleurs_menu_optimales(Principal_Palette); } else { if (Image) { if (Loupe_Mode) { Tracer_cadre_de_bouton_du_menu(BOUTON_LOUPE,0); Pixel_Preview=Pixel_Preview_Normal; Loupe_Mode=0; } Nouveau_mode=Meilleur_mode_video(); if ((Config.Auto_set_res) && (Nouveau_mode!=Resolution_actuelle)) { Initialiser_mode_video( Mode_video[Nouveau_mode].Largeur, Mode_video[Nouveau_mode].Hauteur, Mode_video[Nouveau_mode].Fullscreen); Afficher_menu(); } else { Principal_Decalage_X=0; Principal_Decalage_Y=0; Calculer_limites(); Calculer_coordonnees_pinceau(); } } Calculer_couleurs_menu_optimales(Principal_Palette); Afficher_ecran(); if (Image) Principal_Image_modifiee=0; } Afficher_menu(); Afficher_curseur(); } if (!Image) free(Palette_initiale); if (!Ne_pas_restaurer) { strcpy(Principal_Nom_fichier ,Nom_fichier_initial); strcpy(Principal_Repertoire_fichier,Repertoire_fichier_initial); Principal_Format_fichier =Format_fichier_initial; } if (!Image) Swapper_infos_selecteurs_image_et_brosse(); Print_nom_fichier(); Set_palette(Principal_Palette); } void Bouton_Load(void) { // On sauve l'état actuel des paramètres de l'image pour pouvoir les // restituer en cas d'erreur n'affectant pas l'image Upload_infos_page_principal(Principal_Backups->Pages); Load_picture(1); } void Bouton_Reload(void) { byte Ancienne_forme_curseur; int Nouveau_mode; // On sauve l'état actuel des paramètres de l'image pour pouvoir les // restituer en cas d'erreur n'affectant pas l'image Upload_infos_page_principal(Principal_Backups->Pages); if ( (!Principal_Image_modifiee) || Demande_de_confirmation("Discard unsaved changes ?") ) { Effacer_curseur(); Ancienne_forme_curseur=Forme_curseur; Forme_curseur=FORME_CURSEUR_SABLIER; Afficher_curseur(); Ecran_original_X=0; Ecran_original_Y=0; Charger_image(1); Effacer_curseur(); Forme_curseur=Ancienne_forme_curseur; if (Erreur_fichier!=1) { if (Loupe_Mode) { Tracer_cadre_de_bouton_du_menu(BOUTON_LOUPE,0); Pixel_Preview=Pixel_Preview_Normal; Loupe_Mode=0; } Nouveau_mode=Meilleur_mode_video(); if ( ((Config.Auto_set_res) && (Nouveau_mode!=Resolution_actuelle)) && (!Une_resolution_a_ete_passee_en_parametre) ) { Initialiser_mode_video( Mode_video[Nouveau_mode].Largeur, Mode_video[Nouveau_mode].Hauteur, Mode_video[Nouveau_mode].Fullscreen); Afficher_menu(); } else { Principal_Decalage_X=0; Principal_Decalage_Y=0; Calculer_limites(); Calculer_coordonnees_pinceau(); } Afficher_ecran(); Principal_Image_modifiee=0; } } else Effacer_curseur(); Calculer_couleurs_menu_optimales(Principal_Palette); Afficher_menu(); if (Config.Afficher_limites_image) Afficher_limites_de_l_image(); Desenclencher_bouton(BOUTON_CHARGER); Afficher_curseur(); } void Nom_fichier_backup(char * Nom, char * Nom_backup) { short Curseur; strcpy(Nom_backup,Nom); for (Curseur=strlen(Nom)-strlen(Principal_Nom_fichier); Nom_backup[Curseur]!='.'; Curseur++); Nom_backup[Curseur+1]='\0'; strcat(Nom_backup,"BAK"); } void Backup_du_fichier_sauvegarde(void) { char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier char Nouveau_nom_du_fichier[TAILLE_CHEMIN_FICHIER]; // Nom complet du fichier backup Nom_fichier_complet(Nom_du_fichier,0); // Calcul du nom complet du fichier backup Nom_fichier_backup(Nom_du_fichier,Nouveau_nom_du_fichier); Erreur_fichier=0; // On fait un backup si le nom du fichier n'est pas celui qu'on a choisi // pour nommer les backups (c'est évident!). if (strcmp(Nouveau_nom_du_fichier,Nom_du_fichier)) { // S'il y avait déjà un fichier Backup, on l'efface if ((Fichier_existe(Nouveau_nom_du_fichier)) && (remove(Nouveau_nom_du_fichier)!=0)) Erreur_fichier=1; if ((!Erreur_fichier) && (rename(Nom_du_fichier,Nouveau_nom_du_fichier)!=0)) Erreur_fichier=1; } } void Save_picture(byte Image) // Image=1 => On charge/sauve une image // Image=0 => On charge/sauve une brosse { // Données initiales du fichier (au cas où on voudrait annuler) char Repertoire_fichier_initial[TAILLE_CHEMIN_FICHIER]; char Nom_fichier_initial[TAILLE_CHEMIN_FICHIER]; byte Format_fichier_initial; byte Ne_pas_restaurer; byte Ancienne_forme_curseur; short Principal_Largeur_image_Backup=Principal_Largeur_image; short Principal_Hauteur_image_Backup=Principal_Hauteur_image; //char Commentaire_initial[TAILLE_COMMENTAIRE+1]; if (!Image) Swapper_infos_selecteurs_image_et_brosse(); strcpy(Repertoire_fichier_initial,Principal_Repertoire_fichier); strcpy(Nom_fichier_initial ,Principal_Nom_fichier); Format_fichier_initial=Principal_Format_fichier; Ne_pas_restaurer=Bouton_Load_ou_Save(0,Image); if (Ne_pas_restaurer && Fichier_existe(Principal_Nom_fichier)) { Ne_pas_restaurer=Demande_de_confirmation("Erase old file ?"); if ((Ne_pas_restaurer) && (Config.Backup)) { Backup_du_fichier_sauvegarde(); if (Erreur_fichier) { Ne_pas_restaurer=0; Erreur(0); } } } if (Ne_pas_restaurer) { Ancienne_forme_curseur=Forme_curseur; Effacer_curseur(); Forme_curseur=FORME_CURSEUR_SABLIER; Afficher_curseur(); if (Image) Sauver_image(Image); else { Principal_Largeur_image=Brosse_Largeur; Principal_Hauteur_image=Brosse_Hauteur; Sauver_image(Image); Principal_Largeur_image=Principal_Largeur_image_Backup; Principal_Hauteur_image=Principal_Hauteur_image_Backup; } Effacer_curseur(); Forme_curseur=Ancienne_forme_curseur; if ((Erreur_fichier==1) || (!Format_Backup_done[Principal_Format_fichier-1])) Ne_pas_restaurer=0; Afficher_curseur(); } if (!Ne_pas_restaurer) { strcpy(Principal_Nom_fichier ,Nom_fichier_initial); strcpy(Principal_Repertoire_fichier,Repertoire_fichier_initial); Principal_Format_fichier =Format_fichier_initial; } if (!Image) Swapper_infos_selecteurs_image_et_brosse(); Print_nom_fichier(); Set_palette(Principal_Palette); } void Bouton_Save(void) { Save_picture(1); } void Bouton_Autosave(void) { byte Ancienne_forme_curseur; static char Nom_du_fichier[TAILLE_CHEMIN_FICHIER]; byte Le_fichier_existe; Nom_fichier_complet(Nom_du_fichier,0); Le_fichier_existe=Fichier_existe(Nom_du_fichier); if ( (!Le_fichier_existe) || Demande_de_confirmation("Erase old file ?") ) { if ((Le_fichier_existe) && (Config.Backup)) Backup_du_fichier_sauvegarde(); else Erreur_fichier=0; Effacer_curseur(); if (!Erreur_fichier) { Ancienne_forme_curseur=Forme_curseur; Forme_curseur=FORME_CURSEUR_SABLIER; Afficher_curseur(); Sauver_image(1); Effacer_curseur(); Forme_curseur=Ancienne_forme_curseur; } else Erreur(0); } else Effacer_curseur(); Desenclencher_bouton(BOUTON_SAUVER); Afficher_curseur(); } // -- Gestion des boutons de ligne ------------------------------------------ void Bouton_Lignes(void) { Effacer_curseur(); Demarrer_pile_operation(Ligne_en_cours); Afficher_curseur(); } void Bouton_Lignes_Switch_mode(void) { if (Ligne_en_cours==OPERATION_LIGNE) Ligne_en_cours=OPERATION_K_LIGNE; else { if (Ligne_en_cours==OPERATION_K_LIGNE) Ligne_en_cours=OPERATION_LIGNES_CENTREES; else Ligne_en_cours=OPERATION_LIGNE; } Effacer_curseur(); Afficher_sprite_dans_menu(BOUTON_LIGNES,Ligne_en_cours-OPERATION_LIGNE+6); Demarrer_pile_operation(Ligne_en_cours); Afficher_curseur(); } // -- Bouton de brosse ------------------------------------------------------ void Bouton_Brosse(void) { Effacer_curseur(); if (Operation_en_cours!=OPERATION_PRISE_BROSSE) Demarrer_pile_operation(OPERATION_PRISE_BROSSE); else Desenclencher_bouton(BOUTON_BROSSE); Afficher_curseur(); } void Bouton_desenclencher_Brosse(void) { // On fait de notre mieux pour restaurer l'ancienne opération: Demarrer_pile_operation(Operation_avant_interruption); } void Bouton_Restaurer_brosse(void) { Effacer_curseur(); // On passe en brosse couleur: Changer_la_forme_du_pinceau(FORME_PINCEAU_BROSSE_COULEUR); Desenclencher_bouton(BOUTON_BROSSE); Desenclencher_bouton(BOUTON_POLYBROSSE); Afficher_curseur(); } // -- Bouton de prise de brosse au lasso ------------------------------------ void Bouton_Lasso(void) { Effacer_curseur(); if (Operation_en_cours!=OPERATION_POLYBROSSE) { Pinceau_Forme_avant_lasso=Pinceau_Forme; Pinceau_Forme=FORME_PINCEAU_POINT; Demarrer_pile_operation(OPERATION_POLYBROSSE); } else Desenclencher_bouton(BOUTON_POLYBROSSE); Afficher_curseur(); } void Bouton_desenclencher_Lasso(void) { // On fait de notre mieux pour restaurer l'ancienne opération: Demarrer_pile_operation(Operation_avant_interruption); Pinceau_Forme=Pinceau_Forme_avant_lasso; } // -- Bouton de pipette ----------------------------------------------------- void Bouton_Pipette(void) { Effacer_curseur(); if (Operation_en_cours!=OPERATION_PIPETTE) { Pipette_Couleur=-1; Demarrer_pile_operation(OPERATION_PIPETTE); Pinceau_Forme_avant_pipette=Pinceau_Forme; Pinceau_Forme=FORME_PINCEAU_POINT; if (Operation_avant_interruption!=OPERATION_REMPLACER) if ( (Mouse_Y=Principal_X_Zoom) ) ) Print_dans_menu("X: Y: ( )",0); } else Desenclencher_bouton(BOUTON_PIPETTE); Afficher_curseur(); } void Bouton_desenclencher_Pipette(void) { if (Operation_avant_interruption!=OPERATION_REMPLACER) if ( (Mouse_Y=Principal_X_Zoom) ) ) Print_dans_menu("X: Y: ",0); // On fait de notre mieux pour restaurer l'ancienne opération: if (Operation_en_cours==OPERATION_PIPETTE) { Demarrer_pile_operation(Operation_avant_interruption); Pinceau_Forme=Pinceau_Forme_avant_pipette; } } // -- Inversion de la couleur Fore et de la couleur Back -- void Bouton_Inverser_foreback(void) { byte Couleur_temporaire; Effacer_curseur(); Encadrer_couleur_menu(CM_Noir); Couleur_temporaire=Fore_color; Fore_color =Back_color; Back_color =Couleur_temporaire; Recadrer_palette(); Encadrer_couleur_menu(CM_Blanc); Afficher_foreback(); Desenclencher_bouton(BOUTON_PIPETTE); Afficher_curseur(); } // -- Gestion du bouton Loupe ----------------------------------------------- byte On_vient_du_menu_de_facteurs_de_zoom=0; void Bouton_Loupe(void) { Effacer_curseur(); if ( (Operation_en_cours==OPERATION_LOUPE) || (Loupe_Mode) ) { Desenclencher_bouton(BOUTON_LOUPE); } else { Ancien_Principal_Decalage_X=Principal_Decalage_X; Ancien_Principal_Decalage_Y=Principal_Decalage_Y; Calculer_donnees_loupe(); if ((!Config.Fast_zoom) || (Mouse_Y>=Menu_Ordonnee) || On_vient_du_menu_de_facteurs_de_zoom) { On_vient_du_menu_de_facteurs_de_zoom=0; Demarrer_pile_operation(OPERATION_LOUPE); } else { /* Ceci est de la duplication de code de presque toute l'opération de */ /* la loupe... Il serait peut-être plus propre de faire une procédure */ /* qui s'en charge... */ // On passe en mode loupe Loupe_Mode=1; // La fonction d'affichage dans la partie image est désormais un affichage // spécial loupe. Pixel_Preview=Pixel_Preview_Loupe; // On calcule l'origine de la loupe Loupe_Decalage_X=Mouse_X-(Loupe_Largeur>>1); Loupe_Decalage_Y=Mouse_Y-(Loupe_Hauteur>>1); // Calcul du coin haut_gauche de la fenêtre devant être zoomée DANS L'ECRAN if (Loupe_Decalage_X+Loupe_Largeur>=Limite_Droite-Principal_Decalage_X) Loupe_Decalage_X=Limite_Droite-Loupe_Largeur-Principal_Decalage_X+1; if (Loupe_Decalage_Y+Loupe_Hauteur>=Limite_Bas-Principal_Decalage_Y) Loupe_Decalage_Y=Limite_Bas-Loupe_Hauteur-Principal_Decalage_Y+1; // Calcul des coordonnées absolues de ce coin DANS L'IMAGE Loupe_Decalage_X+=Principal_Decalage_X; Loupe_Decalage_Y+=Principal_Decalage_Y; if (Loupe_Decalage_X<0) Loupe_Decalage_X=0; if (Loupe_Decalage_Y<0) Loupe_Decalage_Y=0; // On calcule les bornes visibles dans l'écran Recadrer_ecran_par_rapport_au_zoom(); Calculer_limites(); Afficher_ecran(); // Repositionner le curseur en fonction des coordonnées visibles Calculer_coordonnees_pinceau(); } } Afficher_curseur(); UpdateRect(0,0,0,0); } void Bouton_Menu_Loupe(void) { short Bouton_clicke; Ouvrir_fenetre(141,114,"Zoom factors"); Fenetre_Definir_bouton_normal(45,88,51,14,"Cancel",0,1,SDLK_ESCAPE); // 1 Fenetre_Definir_bouton_normal( 9,25,27,14, "x2",0,Loupe_Facteur!= 2,SDLK_F1); // 2 Fenetre_Definir_bouton_normal( 41,25,27,14, "x3",0,Loupe_Facteur!= 3,SDLK_F2); // 3 Fenetre_Definir_bouton_normal( 73,25,27,14, "x4",0,Loupe_Facteur!= 4,SDLK_F3); // 4 Fenetre_Definir_bouton_normal(105,25,27,14, "x5",0,Loupe_Facteur!= 5,SDLK_F4); // 5 Fenetre_Definir_bouton_normal( 9,45,27,14, "x6",0,Loupe_Facteur!= 6,SDLK_F5); // 6 Fenetre_Definir_bouton_normal( 41,45,27,14, "x8",0,Loupe_Facteur!= 8,SDLK_F6); // 7 Fenetre_Definir_bouton_normal( 73,45,27,14,"x10",0,Loupe_Facteur!=10,SDLK_F7); // 8 Fenetre_Definir_bouton_normal(105,45,27,14,"x12",0,Loupe_Facteur!=12,SDLK_F8); // 9 Fenetre_Definir_bouton_normal( 9,65,27,14,"x14",0,Loupe_Facteur!=14,SDLK_F9); // 10 Fenetre_Definir_bouton_normal( 41,65,27,14,"x16",0,Loupe_Facteur!=16,SDLK_F10); // 11 Fenetre_Definir_bouton_normal( 73,65,27,14,"x18",0,Loupe_Facteur!=18,SDLK_F11); // 12 Fenetre_Definir_bouton_normal(105,65,27,14,"x20",0,Loupe_Facteur!=20,SDLK_F12); // 13 Display_Window(141,114); Afficher_curseur(); do { Bouton_clicke=Fenetre_Bouton_clicke(); if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) Fenetre_aide(BOUTON_LOUPE, NULL); } while (Bouton_clicke<=0); if (Bouton_clicke>1) { Menu_Ordonnee=Menu_Ordonnee_avant_fenetre; Changer_facteur_loupe(Bouton_clicke-2); } Fermer_fenetre(); if ( (Bouton_clicke==1) && (!Loupe_Mode) && (Operation_en_cours!=OPERATION_LOUPE) ) // Cancel Desenclencher_bouton(BOUTON_LOUPE); Afficher_curseur(); Afficher_ecran(); UpdateRect(Principal_Split,0,Largeur_ecran-Principal_Split,Menu_Ordonnee); if ( (Bouton_clicke>1) && (!Loupe_Mode) && (Operation_en_cours!=OPERATION_LOUPE) ) // Passage en mode zoom { On_vient_du_menu_de_facteurs_de_zoom=1; Enclencher_bouton(BOUTON_LOUPE,A_GAUCHE); } } void Bouton_desenclencher_Loupe(void) { if (Loupe_Mode) { // On sort du mode loupe Loupe_Mode=0; /* // --> Recalculer le décalage de l'écran lorsqu'on sort de la loupe <-- // Centrage "brut" de lécran par rapport à la loupe Principal_Decalage_X=Loupe_Decalage_X-((Largeur_ecran-Loupe_Largeur)>>1); Principal_Decalage_Y=Loupe_Decalage_Y-((Menu_Ordonnee-Loupe_Hauteur)>>1); */ // Correction en cas de débordement de l'image if (Ancien_Principal_Decalage_X+Largeur_ecran>Principal_Largeur_image) Principal_Decalage_X=Principal_Largeur_image-Largeur_ecran; else Principal_Decalage_X=Ancien_Principal_Decalage_X; if (Principal_Decalage_X<0) Principal_Decalage_X=0; if (Ancien_Principal_Decalage_Y+Menu_Ordonnee>Principal_Hauteur_image) Principal_Decalage_Y=Principal_Hauteur_image-Menu_Ordonnee; else Principal_Decalage_Y=Ancien_Principal_Decalage_Y; if (Principal_Decalage_Y<0) Principal_Decalage_Y=0; // La fonction d'affichage dans l'image est désormais un affichage normal. Pixel_Preview=Pixel_Preview_Normal; // Calculer les bornes visibles dans l'écran Calculer_limites(); Afficher_ecran(); // <=> Display_screen(); // Repositionner le curseur en fonction des coordonnées visibles Calculer_coordonnees_pinceau(); } else // On fait de notre mieux pour restaurer l'ancienne opération: Demarrer_pile_operation(Operation_avant_interruption); } // -------------------------------- Grille ----------------------------------- void Bouton_Snap_Mode(void) { Effacer_curseur(); Snap_Mode=!Snap_Mode; Calculer_coordonnees_pinceau(); Afficher_curseur(); } void Bouton_Menu_Grille(void) { short Bouton_clicke; word X_choisi =Snap_Largeur; word Y_choisi =Snap_Hauteur; short dX_choisi=Snap_Decalage_X; short dY_choisi=Snap_Decalage_Y; struct Fenetre_Bouton_special * Bouton_saisie_X; struct Fenetre_Bouton_special * Bouton_saisie_Y; struct Fenetre_Bouton_special * Bouton_saisie_dX; struct Fenetre_Bouton_special * Bouton_saisie_dY; char Chaine[3]; Ouvrir_fenetre(133,98,"Grid"); Fenetre_Definir_bouton_normal(12,72,51,14,"Cancel",0,1,SDLK_ESCAPE); // 1 Fenetre_Definir_bouton_normal(70,72,51,14,"OK" ,0,1,SDLK_RETURN); // 2 Print_dans_fenetre(19,26, "X:",CM_Fonce,CM_Clair); Fenetre_Definir_bouton_saisie(37,24,2); // 3 Bouton_saisie_X=Fenetre_Liste_boutons_special; Num2str(X_choisi,Chaine,2); Fenetre_Contenu_bouton_saisie(Bouton_saisie_X,Chaine); Print_dans_fenetre(19,47, "Y:",CM_Fonce,CM_Clair); Fenetre_Definir_bouton_saisie(37,45,2); // 4 Bouton_saisie_Y=Fenetre_Liste_boutons_special; Num2str(Y_choisi,Chaine,2); Fenetre_Contenu_bouton_saisie(Bouton_saisie_Y,Chaine); Print_dans_fenetre(69,26,"dX:",CM_Fonce,CM_Clair); Fenetre_Definir_bouton_saisie(95,24,2); // 5 Bouton_saisie_dX=Fenetre_Liste_boutons_special; Num2str(dX_choisi,Chaine,2); Fenetre_Contenu_bouton_saisie(Bouton_saisie_dX,Chaine); Print_dans_fenetre(69,47,"dY:",CM_Fonce,CM_Clair); Fenetre_Definir_bouton_saisie(95,45,2); // 6 Bouton_saisie_dY=Fenetre_Liste_boutons_special; Num2str(dY_choisi,Chaine,2); Fenetre_Contenu_bouton_saisie(Bouton_saisie_dY,Chaine); Display_Window(133,98); Afficher_curseur(); do { Bouton_clicke=Fenetre_Bouton_clicke(); switch (Bouton_clicke) { case 3 : Effacer_curseur(); Num2str(X_choisi,Chaine,2); Readline(39,26,Chaine,2,1); X_choisi=atoi(Chaine); // On corrige les dimensions if ((!X_choisi) || (X_choisi>80)) { if (!X_choisi) X_choisi=1; else X_choisi=80; Num2str(X_choisi,Chaine,2); Fenetre_Contenu_bouton_saisie(Bouton_saisie_X,Chaine); } if (dX_choisi>=X_choisi) { dX_choisi=X_choisi-1; Num2str(dX_choisi,Chaine,2); Fenetre_Contenu_bouton_saisie(Bouton_saisie_dX,Chaine); } Afficher_curseur(); break; case 4 : Effacer_curseur(); Num2str(Y_choisi,Chaine,2); Readline(39,47,Chaine,2,1); Y_choisi=atoi(Chaine); // On corrige les dimensions if ((!Y_choisi) || (Y_choisi>80)) { if (!Y_choisi) Y_choisi=1; else Y_choisi=80; Num2str(Y_choisi,Chaine,2); Fenetre_Contenu_bouton_saisie(Bouton_saisie_Y,Chaine); } if (dY_choisi>=Y_choisi) { dY_choisi=Y_choisi-1; Num2str(dY_choisi,Chaine,2); Fenetre_Contenu_bouton_saisie(Bouton_saisie_dY,Chaine); } Afficher_curseur(); break; case 5 : Effacer_curseur(); Num2str(dX_choisi,Chaine,2); Readline(97,26,Chaine,2,1); dX_choisi=atoi(Chaine); // On corrige les dimensions if (dX_choisi>79) dX_choisi=79; if (dX_choisi>=X_choisi) dX_choisi=X_choisi-1; Num2str(dX_choisi,Chaine,2); Fenetre_Contenu_bouton_saisie(Bouton_saisie_dX,Chaine); Afficher_curseur(); break; case 6 : Effacer_curseur(); Num2str(dY_choisi,Chaine,2); Readline(97,47,Chaine,2,1); dY_choisi=atoi(Chaine); // On corrige les dimensions if (dY_choisi>79) dY_choisi=79; if (dY_choisi>=Y_choisi) dY_choisi=Y_choisi-1; Num2str(dY_choisi,Chaine,2); Fenetre_Contenu_bouton_saisie(Bouton_saisie_dY,Chaine); Afficher_curseur(); } if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) Fenetre_aide(BOUTON_EFFETS, "GRID"); } while ( (Bouton_clicke!=1) && (Bouton_clicke!=2) ); if (Bouton_clicke==2) // OK { Snap_Largeur=X_choisi; Snap_Hauteur=Y_choisi; Snap_Decalage_X=dX_choisi; Snap_Decalage_Y=dY_choisi; Snap_Mode=1; } Fermer_fenetre(); if ( (Bouton_clicke==2) && (!Snap_Mode) ) Bouton_Snap_Mode(); Afficher_curseur(); } // ----------------------- Modifications de brosse --------------------------- void Bouton_Brush_FX(void) { short Bouton_clicke; short Indice; Ouvrir_fenetre(310,162,"Brush effects"); Fenetre_Afficher_cadre( 6,19,298,61); Fenetre_Afficher_cadre( 6,83,122,53); Fenetre_Afficher_cadre(137,83,167,53); Fenetre_Definir_bouton_normal(236,141, 67,14,"Cancel" ,0,1,SDLK_ESCAPE); // 1 Fenetre_Definir_bouton_normal( 19, 46, 27,14,"X\035" ,1,1,SDLK_x); // 2 Fenetre_Definir_bouton_normal( 19, 61, 27,14,"Y\022" ,1,1,SDLK_y); // 3 Fenetre_Definir_bouton_normal( 58, 46, 37,14,"90°" ,0,1,SDLK_LAST); // 4 Fenetre_Definir_bouton_normal( 96, 46, 37,14,"180°" ,0,1,SDLK_LAST); // 5 Fenetre_Definir_bouton_normal( 58, 61, 75,14,"any angle" ,0,1,SDLK_LAST); // 6 Fenetre_Definir_bouton_normal(145, 46, 67,14,"Stretch" ,2,1,SDLK_t); // 7 Fenetre_Definir_bouton_normal(145, 61, 67,14,"Distort" ,1,1,SDLK_d); // 8 Fenetre_Definir_bouton_normal(155, 99,131,14,"Recolorize" ,1,1,SDLK_r); // 9 Fenetre_Definir_bouton_normal(155,117,131,14,"Get brush colors",1,1,SDLK_g); // 10 // Boutons représentant les coins du brush handle: (HG,HD,C,BG,BD) Fenetre_Definir_bouton_normal( 75, 90,11,11,"",0,1,SDLK_HOME); // 11 Fenetre_Definir_bouton_normal(103, 90,11,11,"",0,1,SDLK_PAGEUP); // 12 Fenetre_Definir_bouton_normal( 89,104,11,11,"",0,1,SDLK_KP5); // 13 Fenetre_Definir_bouton_normal( 75,118,11,11,"",0,1,SDLK_END); // 14 Fenetre_Definir_bouton_normal(103,118,11,11,"",0,1,SDLK_PAGEDOWN); // 15 Fenetre_Definir_bouton_normal(224,46,67,14,"Outline",1,1,SDLK_o); // 16 Fenetre_Definir_bouton_normal(224,61,67,14,"Nibble" ,1,1,SDLK_n); // 17 Fenetre_Definir_bouton_normal( 7,141, 60,14,"Load",1,1,SDLK_l); // 18 Fenetre_Definir_bouton_normal( 70,141, 60,14,"Save",1,1,SDLK_s); // 19 Print_dans_fenetre( 80, 24,"Shape modifications",CM_Fonce,CM_Clair); Print_dans_fenetre( 10, 36,"Mirror",CM_Fonce,CM_Clair); Print_dans_fenetre( 72, 36,"Rotate",CM_Fonce,CM_Clair); Print_dans_fenetre(155, 36,"Deform",CM_Fonce,CM_Clair); Print_dans_fenetre(230, 36,"Borders",CM_Fonce,CM_Clair); Print_dans_fenetre(141, 88,"Colors modifications",CM_Fonce,CM_Clair); Print_dans_fenetre( 20,102,"Brush",CM_Fonce,CM_Clair); Print_dans_fenetre( 16,110,"handle",CM_Fonce,CM_Clair); // Dessin des pointillés pour le "brush handle" for (Indice=0; Indice<13; Indice+=2) { Pixel_dans_fenetre( 88+Indice, 92,CM_Fonce); Pixel_dans_fenetre( 88+Indice,126,CM_Fonce); Pixel_dans_fenetre( 77,103+Indice,CM_Fonce); Pixel_dans_fenetre(111,103+Indice,CM_Fonce); } // Dessin des coins et du centre pour les boutons du "brush handle" // Coin HG Block(Fenetre_Pos_X+(Menu_Facteur_X* 77),Fenetre_Pos_Y+(Menu_Facteur_Y* 92),Menu_Facteur_X*7,Menu_Facteur_Y,CM_Noir); Block(Fenetre_Pos_X+(Menu_Facteur_X* 77),Fenetre_Pos_Y+(Menu_Facteur_Y* 92),Menu_Facteur_X,Menu_Facteur_Y*7,CM_Noir); // Coin HD Block(Fenetre_Pos_X+(Menu_Facteur_X*105),Fenetre_Pos_Y+(Menu_Facteur_Y* 92),Menu_Facteur_X*7,Menu_Facteur_Y,CM_Noir); Block(Fenetre_Pos_X+(Menu_Facteur_X*111),Fenetre_Pos_Y+(Menu_Facteur_Y* 92),Menu_Facteur_X,Menu_Facteur_Y*7,CM_Noir); // Centre Block(Fenetre_Pos_X+(Menu_Facteur_X* 91),Fenetre_Pos_Y+(Menu_Facteur_Y*109),Menu_Facteur_X*7,Menu_Facteur_Y,CM_Noir); Block(Fenetre_Pos_X+(Menu_Facteur_X* 94),Fenetre_Pos_Y+(Menu_Facteur_Y*106),Menu_Facteur_X,Menu_Facteur_Y*7,CM_Noir); // Coin BG Block(Fenetre_Pos_X+(Menu_Facteur_X* 77),Fenetre_Pos_Y+(Menu_Facteur_Y*126),Menu_Facteur_X*7,Menu_Facteur_Y,CM_Noir); Block(Fenetre_Pos_X+(Menu_Facteur_X* 77),Fenetre_Pos_Y+(Menu_Facteur_Y*120),Menu_Facteur_X,Menu_Facteur_Y*7,CM_Noir); // Coin BD Block(Fenetre_Pos_X+(Menu_Facteur_X*105),Fenetre_Pos_Y+(Menu_Facteur_Y*126),Menu_Facteur_X*7,Menu_Facteur_Y,CM_Noir); Block(Fenetre_Pos_X+(Menu_Facteur_X*111),Fenetre_Pos_Y+(Menu_Facteur_Y*120),Menu_Facteur_X,Menu_Facteur_Y*7,CM_Noir); Display_Window(310,162); Afficher_curseur(); do { Bouton_clicke=Fenetre_Bouton_clicke(); if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) Fenetre_aide(BOUTON_EFFETS_BROSSE, NULL); } while (Bouton_clicke<=0); Fermer_fenetre(); Desenclencher_bouton(BOUTON_EFFETS_BROSSE); // Gestion du bouton clické switch (Bouton_clicke) { case 2 : // Flip X Flip_X_LOWLEVEL(); break; case 3 : // Flip Y Flip_Y_LOWLEVEL(); break; case 4 : // 90° Rotation Rotate_90_deg(); break; case 5 : // 180° Rotation if (Brosse_Hauteur&1) { // Brosse de hauteur impaire Flip_X_LOWLEVEL(); Flip_Y_LOWLEVEL(); } else Rotate_180_deg_LOWLEVEL(); Brosse_Decalage_X=(Brosse_Largeur>>1); Brosse_Decalage_Y=(Brosse_Hauteur>>1); break; case 6 : // Any angle rotation Demarrer_pile_operation(OPERATION_TOURNER_BROSSE); break; case 7 : // Stretch Demarrer_pile_operation(OPERATION_ETIRER_BROSSE); break; case 8 : // Distort Afficher_curseur(); Message_Non_disponible(); // !!! TEMPORAIRE !!! Effacer_curseur(); break; case 9 : // Recolorize Remap_brosse(); break; case 10 : // Get brush colors Afficher_curseur(); Get_colors_from_brush(); Effacer_curseur(); break; case 11 : // Brush Attachment: Top-Left Brosse_Decalage_X=0; Brosse_Decalage_Y=0; break; case 12 : // Brush Attachment: Top-Right Brosse_Decalage_X=(Brosse_Largeur-1); Brosse_Decalage_Y=0; break; case 13 : // Brush Attachment: Center Brosse_Decalage_X=(Brosse_Largeur>>1); Brosse_Decalage_Y=(Brosse_Hauteur>>1); break; case 14 : // Brush Attachment: Bottom-Left Brosse_Decalage_X=0; Brosse_Decalage_Y=(Brosse_Hauteur-1); break; case 15 : // Brush Attachment: Bottom-Right Brosse_Decalage_X=(Brosse_Largeur-1); Brosse_Decalage_Y=(Brosse_Hauteur-1); break; case 16 : // Outline Outline_brush(); break; case 17 : // Nibble Nibble_brush(); break; case 18 : // Load Afficher_curseur(); Load_picture(0); Effacer_curseur(); break; case 19 : // Save Afficher_curseur(); Save_picture(0); Effacer_curseur(); break; } Afficher_curseur(); } // -- Mode Smooth ----------------------------------------------------------- void Bouton_Smooth_Mode(void) { if (Smooth_Mode) Fonction_effet=Aucun_effet; else { Fonction_effet=Effet_Smooth; Shade_Mode=0; Quick_shade_Mode=0; Colorize_Mode=0; Tiling_Mode=0; Smear_Mode=0; } Smooth_Mode=!Smooth_Mode; } byte Smooth_Matrice_defaut[4][3][3]= { { {1,2,1}, {2,4,2}, {1,2,1} }, { {1,3,1}, {3,9,3}, {1,3,1} }, { {0,1,0}, {1,2,1}, {0,1,0} }, { {2,3,2}, {3,1,3}, {2,3,2} } }; void Bouton_Smooth_Menu(void) { short Bouton_clicke; short X,Y,I,J; byte Matrice_choisie[3][3]; struct Fenetre_Bouton_special * Matrice_Zone_saisie[3][3]; char Chaine[3]; Ouvrir_fenetre(142,109,"Smooth"); Fenetre_Definir_bouton_normal(82,59,53,14,"Cancel",0,1,SDLK_ESCAPE); // 1 Fenetre_Definir_bouton_normal(82,88,53,14,"OK" ,0,1,SDLK_RETURN); // 2 Fenetre_Afficher_cadre(6,17,130,37); for (X=11,Y=0; Y<4; X+=31,Y++) { Fenetre_Definir_bouton_normal(X,22,27,27,"",0,1,SDLK_LAST); // 3,4,5,6 for (J=0; J<3; J++) for (I=0; I<3; I++) Print_char_dans_fenetre(X+2+(I<<3),24+(J<<3),'0'+Smooth_Matrice_defaut[Y][I][J],CM_Noir,CM_Clair); } Fenetre_Afficher_cadre(6,58, 69,45); for (J=0; J<3; J++) for (I=0; I<3; I++) { Fenetre_Definir_bouton_saisie(10+(I*21),62+(J*13),2); // 7..15 Matrice_Zone_saisie[I][J]=Fenetre_Liste_boutons_special; Num2str(Matrice_choisie[I][J]=Smooth_Matrice[I][J],Chaine,2); Fenetre_Contenu_bouton_saisie(Fenetre_Liste_boutons_special,Chaine); } Display_Window(142,109); Afficher_curseur(); do { Bouton_clicke=Fenetre_Bouton_clicke(); if (Bouton_clicke>2) { if (Bouton_clicke<=6) { memcpy(Matrice_choisie,Smooth_Matrice_defaut[Bouton_clicke-3],sizeof(Matrice_choisie)); Effacer_curseur(); for (J=0; J<3; J++) for (I=0; I<3; I++) { Num2str(Matrice_choisie[I][J],Chaine,2); Fenetre_Contenu_bouton_saisie(Matrice_Zone_saisie[I][J],Chaine); } Afficher_curseur(); } else { Effacer_curseur(); I=Bouton_clicke-7; X=I%3; Y=I/3; Num2str(Matrice_choisie[X][Y],Chaine,2); Readline(Matrice_Zone_saisie[X][Y]->Pos_X+2, Matrice_Zone_saisie[X][Y]->Pos_Y+2, Chaine,2,1); Matrice_choisie[X][Y]=atoi(Chaine); Afficher_curseur(); } } if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) Fenetre_aide(BOUTON_EFFETS, "SMOOTH"); } while ((Bouton_clicke!=1) && (Bouton_clicke!=2)); Fermer_fenetre(); if (Bouton_clicke==2) // OK { memcpy(Smooth_Matrice,Matrice_choisie,sizeof(Smooth_Matrice)); Smooth_Mode=0; // On le met à 0 car la fonct° suivante va le passer à 1 Bouton_Smooth_Mode(); } Afficher_curseur(); } // -- Mode Smear ------------------------------------------------------------ void Bouton_Smear_Mode(void) { if (!Smear_Mode) { if (!Colorize_Mode) Fonction_effet=Aucun_effet; Shade_Mode=0; Quick_shade_Mode=0; Smooth_Mode=0; Tiling_Mode=0; } Smear_Mode=!Smear_Mode; } // -- Mode Colorize --------------------------------------------------------- void Calculer_les_tables_de_Colorize(void) { word Indice; word Facteur_A; word Facteur_B; Facteur_A=256*(100-Colorize_Opacite)/100; Facteur_B=256*( Colorize_Opacite)/100; for (Indice=0;Indice<256;Indice++) { Table_de_multiplication_par_Facteur_A[Indice]=Indice*Facteur_A; Table_de_multiplication_par_Facteur_B[Indice]=Indice*Facteur_B; } } void Bouton_Colorize_Mode(void) { if (Colorize_Mode) Fonction_effet=Aucun_effet; else { switch(Colorize_Mode_en_cours) { case 0 : Fonction_effet=Effet_Colorize_interpole; break; case 1 : Fonction_effet=Effet_Colorize_additif; break; case 2 : Fonction_effet=Effet_Colorize_soustractif; } Shade_Mode=0; Quick_shade_Mode=0; Smooth_Mode=0; Tiling_Mode=0; } Colorize_Mode=!Colorize_Mode; } void Bouton_Colorize_Afficher_la_selection(int Numero) { short Pos_Y=0; // Ligne où afficher les flèches de sélection // On commence par effacer les anciennes sélections: // Partie gauche Print_dans_fenetre(4,37," ",CM_Noir,CM_Clair); Print_dans_fenetre(4,57," ",CM_Noir,CM_Clair); Print_dans_fenetre(4,74," ",CM_Noir,CM_Clair); // Partie droite Print_dans_fenetre(129,37," ",CM_Noir,CM_Clair); Print_dans_fenetre(129,57," ",CM_Noir,CM_Clair); Print_dans_fenetre(129,74," ",CM_Noir,CM_Clair); // Ensuite, on affiche la flèche là où il le faut: switch(Numero) { case 0 : // Méthode interpolée Pos_Y=37; break; case 1 : // Méthode additive Pos_Y=57; break; case 2 : // Méthode soustractive Pos_Y=74; } Print_dans_fenetre(4,Pos_Y,"\020",CM_Noir,CM_Clair); Print_dans_fenetre(129,Pos_Y,"\021",CM_Noir,CM_Clair); } void Bouton_Colorize_Menu(void) { short Opacite_choisie; short Mode_choisi; short Bouton_clicke; char Chaine[4]; Ouvrir_fenetre(140,118,"Transparency"); Print_dans_fenetre(16,23,"Opacity:",CM_Fonce,CM_Clair); Fenetre_Definir_bouton_saisie(87,21,3); // 1 Print_dans_fenetre(117,23,"%",CM_Fonce,CM_Clair); Fenetre_Definir_bouton_normal(16,34,108,14,"Interpolate",1,1,SDLK_i); // 2 Fenetre_Afficher_cadre(12,18,116,34); Fenetre_Definir_bouton_normal(16,54,108,14,"Additive" ,2,1,SDLK_d); // 3 Fenetre_Definir_bouton_normal(16,71,108,14,"Subtractive",1,1,SDLK_s); // 4 Fenetre_Definir_bouton_normal(16,94, 51,14,"Cancel" ,0,1,SDLK_ESCAPE); // 5 Fenetre_Definir_bouton_normal(73,94, 51,14,"OK" ,0,1,SDLK_RETURN); // 6 Num2str(Colorize_Opacite,Chaine,3); Fenetre_Contenu_bouton_saisie(Fenetre_Liste_boutons_special,Chaine); Bouton_Colorize_Afficher_la_selection(Colorize_Mode_en_cours); Opacite_choisie=Colorize_Opacite; Mode_choisi =Colorize_Mode_en_cours; Display_Window(140,118); Afficher_curseur(); do { Bouton_clicke=Fenetre_Bouton_clicke(); switch(Bouton_clicke) { case 1: // Zone de saisie de l'opacité Effacer_curseur(); Num2str(Opacite_choisie,Chaine,3); Readline(89,23,Chaine,3,1); Opacite_choisie=atoi(Chaine); // On corrige le pourcentage if (Opacite_choisie>100) { Opacite_choisie=100; Num2str(Opacite_choisie,Chaine,3); Fenetre_Contenu_bouton_saisie(Fenetre_Liste_boutons_special,Chaine); } Afficher_curseur(); break; case 2: // Méthode interpolée case 3: // Méthode additive case 4: // Méthode soustractive Mode_choisi=Bouton_clicke-2; Effacer_curseur(); Bouton_Colorize_Afficher_la_selection(Mode_choisi); Afficher_curseur(); } if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) Fenetre_aide(BOUTON_EFFETS, "TRANSPARENCY"); } while (Bouton_clicke<5); Fermer_fenetre(); if (Bouton_clicke==6) // OK { Colorize_Opacite =Opacite_choisie; Colorize_Mode_en_cours=Mode_choisi; Calculer_les_tables_de_Colorize(); Colorize_Mode=0; // On le met à 0 car la fonct° suivante va le passer à 1 Bouton_Colorize_Mode(); } Afficher_curseur(); } // -- Mode Tiling ----------------------------------------------------------- void Bouton_Tiling_Mode(void) { if (Tiling_Mode) Fonction_effet=Aucun_effet; else { Fonction_effet=Effet_Tiling; Shade_Mode=0; Quick_shade_Mode=0; Colorize_Mode=0; Smooth_Mode=0; Smear_Mode=0; } Tiling_Mode=!Tiling_Mode; } void Bouton_Tiling_Menu(void) { short Bouton_clicke; short Offset_X_choisi=Tiling_Decalage_X; short Offset_Y_choisi=Tiling_Decalage_Y; char Chaine[5]; struct Fenetre_Bouton_special * Bouton_saisie_Decalage_X; struct Fenetre_Bouton_special * Bouton_saisie_Decalage_Y; Ouvrir_fenetre(138,79,"Tiling"); Fenetre_Definir_bouton_normal(13,55,51,14,"Cancel",0,1,SDLK_ESCAPE); // 1 Fenetre_Definir_bouton_normal(74,55,51,14,"OK" ,0,1,SDLK_RETURN); // 2 Fenetre_Definir_bouton_saisie(91,21,4); // 3 Bouton_saisie_Decalage_X=Fenetre_Liste_boutons_special; Fenetre_Definir_bouton_saisie(91,35,4); // 4 Bouton_saisie_Decalage_Y=Fenetre_Liste_boutons_special; Print_dans_fenetre(12,23,"Offset X:",CM_Fonce,CM_Clair); Print_dans_fenetre(12,37,"Offset Y:",CM_Fonce,CM_Clair); Num2str(Tiling_Decalage_X,Chaine,4); Fenetre_Contenu_bouton_saisie(Bouton_saisie_Decalage_X,Chaine); Num2str(Tiling_Decalage_Y,Chaine,4); Fenetre_Contenu_bouton_saisie(Bouton_saisie_Decalage_Y,Chaine); Display_Window(138,79); Afficher_curseur(); do { Bouton_clicke=Fenetre_Bouton_clicke(); if (Bouton_clicke==3) // Zone de saisie du décalage X { Effacer_curseur(); Num2str(Offset_X_choisi,Chaine,4); Readline(93,23,Chaine,4,1); Offset_X_choisi=atoi(Chaine); // On corrige le décalage en X if (Offset_X_choisi>=Brosse_Largeur) { Offset_X_choisi=Brosse_Largeur-1; Num2str(Offset_X_choisi,Chaine,4); Fenetre_Contenu_bouton_saisie(Bouton_saisie_Decalage_X,Chaine); } Afficher_curseur(); } else if (Bouton_clicke==4) // Zone de saisie du décalage Y { Effacer_curseur(); Num2str(Offset_Y_choisi,Chaine,4); Readline(93,37,Chaine,4,1); Offset_Y_choisi=atoi(Chaine); // On corrige le décalage en Y if (Offset_Y_choisi>=Brosse_Hauteur) { Offset_Y_choisi=Brosse_Hauteur-1; Num2str(Offset_Y_choisi,Chaine,4); Fenetre_Contenu_bouton_saisie(Bouton_saisie_Decalage_Y,Chaine); } Afficher_curseur(); } if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) Fenetre_aide(BOUTON_EFFETS, "TILING"); } while ( (Bouton_clicke!=1) && (Bouton_clicke!=2) ); Fermer_fenetre(); if (Bouton_clicke==2) // OK { Tiling_Decalage_X=Offset_X_choisi; Tiling_Decalage_Y=Offset_Y_choisi; if (!Tiling_Mode) Bouton_Tiling_Mode(); } Afficher_curseur(); } //---------------------------- Courbes de Bézier ---------------------------- void Bouton_Courbes(void) { Effacer_curseur(); Demarrer_pile_operation(Courbe_en_cours); Afficher_curseur(); } void Bouton_Courbes_Switch_mode(void) { if (Courbe_en_cours==OPERATION_COURBE_4_POINTS) Courbe_en_cours=OPERATION_COURBE_3_POINTS; else Courbe_en_cours=OPERATION_COURBE_4_POINTS; Effacer_curseur(); Afficher_sprite_dans_menu(BOUTON_COURBES,Courbe_en_cours-OPERATION_COURBE_3_POINTS+4); Demarrer_pile_operation(Courbe_en_cours); Afficher_curseur(); } //--------------------------------- Spray ----------------------------------- void Bouton_Spray(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_SPRAY); Afficher_curseur(); } void Spray_Rafficher_infos(byte Couleur_selectionnee, byte Rafficher_jauge) { char Chaine[3]; if (Rafficher_jauge) { Fenetre_Liste_boutons_scroller->Position=49-Spray_Multi_flow[Couleur_selectionnee]; Fenetre_Dessiner_jauge(Fenetre_Liste_boutons_scroller); } Num2str(Spray_Multi_flow[Couleur_selectionnee],Chaine,2); Print_dans_fenetre(196,130,Chaine,CM_Noir,CM_Clair); } void Bouton_Spray_Menu(void) { static byte Spray_Init=0; short Bouton_clicke; char Chaine[4]; word Indice; byte Couleur_selectionnee=Fore_color; byte Old_Spray_Mode =Spray_Mode; short Old_Spray_Size =Spray_Size; byte Old_Spray_Delay =Spray_Delay; byte Old_Spray_Mono_flow=Spray_Mono_flow; byte Old_Spray_Multi_flow[256]; struct Fenetre_Bouton_special * Saisie_Size; struct Fenetre_Bouton_special * Saisie_Delay; struct Fenetre_Bouton_special * Saisie_Mono_flow; struct Fenetre_Bouton_special * Saisie_Init; word Ancien_Mouse_X; word Ancien_Mouse_Y; byte Ancien_Mouse_K; byte Couleur; byte Click; memcpy(Old_Spray_Multi_flow,Spray_Multi_flow,256); Ouvrir_fenetre(226,170,"Spray"); Fenetre_Definir_bouton_normal(110,148,51,14,"Cancel" ,0,1,SDLK_ESCAPE); // 1 Fenetre_Definir_bouton_normal(166,148,51,14,"OK" ,0,1,SDLK_RETURN); // 2 Fenetre_Definir_bouton_scroller(178,62,74,50,1,49-Spray_Multi_flow[Couleur_selectionnee]); // 3 Fenetre_Definir_bouton_palette(7,56); // 4 Fenetre_Definir_bouton_normal( 8,148,83,14,"Mode: ",0,1,SDLK_TAB); // 5 if (Spray_Mode) Print_dans_fenetre(50,151," Mono",CM_Noir,CM_Clair); else Print_dans_fenetre(50,151,"Multi",CM_Noir,CM_Clair); Fenetre_Definir_bouton_normal(194, 62,19,14,"+1" ,0,1,SDLK_KP_PLUS); // 6 Fenetre_Definir_bouton_normal(194, 79,19,14,"-1" ,0,1,SDLK_KP_MINUS); // 7 Fenetre_Definir_bouton_normal(194, 96,19,14,"x2" ,0,1,SDLK_KP_MULTIPLY); // 8 Fenetre_Definir_bouton_normal(194,113,19,14,"÷2" ,0,1,SDLK_KP_ENTER); // 9 Fenetre_Definir_bouton_normal( 8, 37,43,14,"Clear" ,1,1,SDLK_c); // 10 Print_dans_fenetre(142,25,"Size:" ,CM_Fonce,CM_Clair); Fenetre_Definir_bouton_saisie(186,23,3); // 11 Saisie_Size=Fenetre_Liste_boutons_special; Num2str(Spray_Size,Chaine,3); Fenetre_Contenu_bouton_saisie(Saisie_Size,Chaine); Print_dans_fenetre(142,39,"Delay:" ,CM_Fonce,CM_Clair); Fenetre_Definir_bouton_saisie(194,37,2); // 12 Saisie_Delay=Fenetre_Liste_boutons_special; Num2str(Spray_Delay,Chaine,2); Fenetre_Contenu_bouton_saisie(Saisie_Delay,Chaine); Print_dans_fenetre( 27,24,"Mono-Flow:",CM_Fonce,CM_Clair); Fenetre_Definir_bouton_saisie(111,22,2); // 13 Saisie_Mono_flow=Fenetre_Liste_boutons_special; Num2str(Spray_Mono_flow,Chaine,2); Fenetre_Contenu_bouton_saisie(Saisie_Mono_flow,Chaine); Print_dans_fenetre( 67,40,"Init:",CM_Fonce,CM_Clair); Fenetre_Definir_bouton_saisie(111,38,2); // 14 Saisie_Init=Fenetre_Liste_boutons_special; Num2str(Spray_Init,Chaine,2); Fenetre_Contenu_bouton_saisie(Saisie_Init,Chaine); Fenetre_Afficher_cadre(173,56,45,86); Fenetre_Afficher_cadre(137,19,81,33); // On tagge toutes les couleurs utilisées for (Indice=0; Indice<256; Indice++) if (Spray_Multi_flow[Indice]) Stencil_Tagger_couleur(Indice,CM_Noir); // Et enfin, on tagge la couleur sélectionnée Stencil_Tagger_couleur(Couleur_selectionnee,CM_Blanc); Spray_Rafficher_infos(Couleur_selectionnee,0); Display_Window(226,170); Afficher_curseur(); do { Ancien_Mouse_X=Mouse_X; Ancien_Mouse_Y=Mouse_Y; Ancien_Mouse_K=Mouse_K; Bouton_clicke=Fenetre_Bouton_clicke(); switch (Bouton_clicke) { case 0 : case 2 : // OK break; case 1 : // Cancel Spray_Mode =Old_Spray_Mode; Spray_Size =Old_Spray_Size; Spray_Delay =Old_Spray_Delay; Spray_Mono_flow=Old_Spray_Mono_flow; memcpy(Spray_Multi_flow,Old_Spray_Multi_flow,256); break; case 3 : // Scroller Effacer_curseur(); Spray_Multi_flow[Couleur_selectionnee]=49-Fenetre_Attribut2; Spray_Rafficher_infos(Couleur_selectionnee,0); Afficher_curseur(); break; case -1 : case 4 : // Palette if ( (Mouse_X!=Ancien_Mouse_X) || (Mouse_Y!=Ancien_Mouse_Y) || (Mouse_K!=Ancien_Mouse_K) ) { Effacer_curseur(); Stencil_Tagger_couleur(Couleur_selectionnee,(Spray_Multi_flow[Couleur_selectionnee])?CM_Noir:CM_Clair); // Mettre la couleur sélectionnée à jour suivant le click Couleur_selectionnee=(Bouton_clicke==1) ? Fenetre_Attribut2 : Lit_pixel(Mouse_X,Mouse_Y); if (Mouse_K==2) Spray_Multi_flow[Couleur_selectionnee]=0; else if (Spray_Multi_flow[Couleur_selectionnee]==0) Spray_Multi_flow[Couleur_selectionnee]=Spray_Init; // Tagger la couleur sélectionnée en blanc Stencil_Tagger_couleur(Couleur_selectionnee,CM_Blanc); Spray_Rafficher_infos(Couleur_selectionnee,1); Afficher_curseur(); } break; case 5 : // Toggle Mode Spray_Mode=(Spray_Mode+1)&1; Effacer_curseur(); if (Spray_Mode) Print_dans_fenetre(50,151," Mono",CM_Noir,CM_Clair); else Print_dans_fenetre(50,151,"Multi",CM_Noir,CM_Clair); Afficher_curseur(); break; case 6 : // +1 for (Indice=0; Indice<256; Indice++) { if ( (Spray_Multi_flow[Indice]) && (Spray_Multi_flow[Indice]<49) ) Spray_Multi_flow[Indice]++; } Effacer_curseur(); Spray_Rafficher_infos(Couleur_selectionnee,1); Afficher_curseur(); break; case 7 : // -1 for (Indice=0; Indice<256; Indice++) { if (Spray_Multi_flow[Indice]>1) Spray_Multi_flow[Indice]--; } Effacer_curseur(); Spray_Rafficher_infos(Couleur_selectionnee,1); Afficher_curseur(); break; case 8 : // x2 for (Indice=0; Indice<256; Indice++) { if (Spray_Multi_flow[Indice]) { Spray_Multi_flow[Indice]<<=1; if (Spray_Multi_flow[Indice]>49) Spray_Multi_flow[Indice]=49; } } Effacer_curseur(); Spray_Rafficher_infos(Couleur_selectionnee,1); Afficher_curseur(); break; case 9 : // ÷2 for (Indice=0; Indice<256; Indice++) { if (Spray_Multi_flow[Indice]>1) Spray_Multi_flow[Indice]>>=1; } Effacer_curseur(); Spray_Rafficher_infos(Couleur_selectionnee,1); Afficher_curseur(); break; case 10 : // Clear memset(Spray_Multi_flow,0,256); // On raffiche les infos de la couleur sélectionnée Spray_Rafficher_infos(Couleur_selectionnee,1); // On efface les anciens TAGs Fenetre_Effacer_tags(); // Tagger la couleur sélectionnée en blanc Stencil_Tagger_couleur(Couleur_selectionnee,CM_Blanc); break; case 11 : // Size Effacer_curseur(); Num2str(Spray_Size,Chaine,3); Readline(188,25,Chaine,3,1); Spray_Size=atoi(Chaine); // On corrige les dimensions if (Spray_Size>256) { Spray_Size=256; Num2str(Spray_Size,Chaine,3); Fenetre_Contenu_bouton_saisie(Saisie_Size,Chaine); } else if (!Spray_Size) { Spray_Size=1; Num2str(Spray_Size,Chaine,3); Fenetre_Contenu_bouton_saisie(Saisie_Size,Chaine); } Afficher_curseur(); break; case 12 : // Delay Effacer_curseur(); Num2str(Spray_Delay,Chaine,2); Readline(196,39,Chaine,2,1); Spray_Delay=atoi(Chaine); // On corrige le delai if (Spray_Delay>10) { Spray_Delay=10; Num2str(Spray_Delay,Chaine,2); Fenetre_Contenu_bouton_saisie(Saisie_Delay,Chaine); } Afficher_curseur(); break; case 13 : // Mono-Flow Effacer_curseur(); Num2str(Spray_Mono_flow,Chaine,2); Readline(113,24,Chaine,2,1); Spray_Mono_flow=atoi(Chaine); // On corrige le flux if (!Spray_Mono_flow) { Spray_Mono_flow=1; Num2str(Spray_Mono_flow,Chaine,2); Fenetre_Contenu_bouton_saisie(Saisie_Mono_flow,Chaine); } Afficher_curseur(); break; case 14 : // Init Effacer_curseur(); Num2str(Spray_Init,Chaine,2); Readline(113,40,Chaine,2,1); Spray_Init=atoi(Chaine); // On corrige la valeur if (Spray_Init>=50) { Spray_Init=49; Num2str(Spray_Init,Chaine,2); Fenetre_Contenu_bouton_saisie(Saisie_Init,Chaine); } Afficher_curseur(); break; } if (!Mouse_K) switch (Touche) { case SDLK_BACKQUOTE : // Récupération d'une couleur derrière le menu case SDLK_COMMA : Recuperer_couleur_derriere_fenetre(&Couleur,&Click); if (Click) { Effacer_curseur(); Stencil_Tagger_couleur(Couleur_selectionnee,(Spray_Multi_flow[Couleur_selectionnee])?CM_Noir:CM_Clair); // Mettre la couleur sélectionnée à jour suivant le click Couleur_selectionnee=Couleur; if (Click==2) Spray_Multi_flow[Couleur_selectionnee]=0; else if (Spray_Multi_flow[Couleur_selectionnee]==0) Spray_Multi_flow[Couleur_selectionnee]=Spray_Init; // Tagger la couleur sélectionnée en blanc Stencil_Tagger_couleur(Couleur_selectionnee,CM_Blanc); Spray_Rafficher_infos(Couleur_selectionnee,1); Afficher_curseur(); } break; default: if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) { Fenetre_aide(BOUTON_SPRAY, NULL); break; } } } while ( (Bouton_clicke!=1) && (Bouton_clicke!=2) ); Fermer_fenetre(); /* // Tant que l'on aura pas résolu le problème du désenclenchement du mode // de dessin précedent, il faudra laisser ça en remarque et donc passer en // spray même si on a clické sur Cancel (idem pour OK (un peu plus bas)). if (Bouton_clicke==1) // Cancel { if (Operation_en_cours!=OPERATION_SPRAY) Desenclencher_bouton(BOUTON_SPRAY); } */ Afficher_curseur(); /* if (Bouton_clicke==2) // OK */ if (Operation_en_cours!=OPERATION_SPRAY) Enclencher_bouton(BOUTON_SPRAY,A_GAUCHE); } // -- Mode Trame (Sieve) ---------------------------------------------------- void Bouton_Trame_Mode(void) { Trame_Mode=!Trame_Mode; } void Dessiner_trame_zoomee(short Orig_X, short Orig_Y) { short Pos_X; short Pos_Y; short Taille_X; short Taille_Y; short Debut_X=Fenetre_Pos_X+(Menu_Facteur_X*230); short Debut_Y=Fenetre_Pos_Y+(Menu_Facteur_Y*78); Taille_X=Menu_Facteur_X*5; // |_ Taille d'une case Taille_Y=Menu_Facteur_Y*5; // | de la trame zoomée // On efface de contenu précédent Block(Orig_X,Orig_Y, Menu_Facteur_X*Fenetre_Liste_boutons_special->Largeur, Menu_Facteur_Y*Fenetre_Liste_boutons_special->Hauteur,CM_Clair); for (Pos_Y=0; Pos_Y>(15-i))&1)?CM_Blanc:CM_Noir); UpdateRect(ToWinX(10),ToWinY(22),ToWinL(12*23+16),ToWinH(16)); } void Copier_trame_predefinie(byte Indice) { short i,j; for (j=0; j<16; j++) for (i=0; i<16; i++) Trame[i][j]=(TRAME_PREDEFINIE[Indice][j]>>(15-i))&1; Trame_Largeur=16; Trame_Hauteur=16; } void Inverser_trame(void) { byte Pos_X,Pos_Y; for (Pos_Y=0; Pos_Y plus grande short Preview_Fin_Y; // | rapidité. memcpy(Old_Trame,Trame,256); Ouvrir_fenetre(290,179,"Sieve"); Preview_Debut_X=Fenetre_Pos_X+(Menu_Facteur_X*230); Preview_Debut_Y=Fenetre_Pos_Y+(Menu_Facteur_Y*78); Preview_Fin_X=Preview_Debut_X+(Menu_Facteur_X*51); Preview_Fin_Y=Preview_Debut_Y+(Menu_Facteur_Y*71); Fenetre_Afficher_cadre ( 7, 65,130,43); Fenetre_Afficher_cadre ( 7,110,130,43); Fenetre_Afficher_cadre_creux(142, 68, 82,82); Fenetre_Afficher_cadre_creux(229, 77, 53,73); Print_dans_fenetre(228, 68,"Preview",CM_Fonce,CM_Clair); Print_dans_fenetre( 27, 83,"Scroll" ,CM_Fonce,CM_Clair); Print_dans_fenetre( 23,120,"Width:" ,CM_Fonce,CM_Clair); Print_dans_fenetre( 15,136,"Height:",CM_Fonce,CM_Clair); Fenetre_Definir_bouton_special(143,69,80,80); // 1 Fenetre_Definir_bouton_normal(175,157,51,14,"Cancel",0,1,SDLK_ESCAPE); // 2 Fenetre_Definir_bouton_normal(230,157,51,14,"OK" ,0,1,SDLK_RETURN); // 3 Fenetre_Definir_bouton_normal( 8,157,51,14,"Clear" ,1,1,SDLK_c); // 4 Fenetre_Definir_bouton_normal( 63,157,51,14,"Invert",1,1,SDLK_i); // 5 Fenetre_Definir_bouton_normal( 8,46,131,14,"Get from brush" ,1,1,SDLK_g); // 6 Fenetre_Definir_bouton_normal(142,46,139,14,"Transfer to brush",1,1,SDLK_t); // 7 Fenetre_Definir_bouton_normal(109,114,11,11,"\030",0,1,SDLK_UP|MOD_SHIFT); // 8 Fenetre_Definir_bouton_normal(109,138,11,11,"\031",0,1,SDLK_DOWN|MOD_SHIFT); // 9 Fenetre_Definir_bouton_normal( 97,126,11,11,"\033",0,1,SDLK_LEFT|MOD_SHIFT); // 10 Fenetre_Definir_bouton_normal(121,126,11,11,"\032",0,1,SDLK_RIGHT|MOD_SHIFT); // 11 Fenetre_Definir_bouton_normal(109,126,11,11,"" ,0,1,SDLK_INSERT); // 12 Bouton_Octet_insere=Fenetre_Liste_boutons_normal; Block(Fenetre_Pos_X+(Menu_Facteur_X*(Bouton_Octet_insere->Pos_X+2)), Fenetre_Pos_Y+(Menu_Facteur_Y*(Bouton_Octet_insere->Pos_Y+2)), Menu_Facteur_X*7, Menu_Facteur_Y*7, (Octet_insere)?CM_Blanc:CM_Noir); Fenetre_Definir_bouton_normal(109, 69,11,11,"\030",0,1,SDLK_UP); // 13 Fenetre_Definir_bouton_normal(109, 93,11,11,"\031",0,1,SDLK_DOWN); // 14 Fenetre_Definir_bouton_normal( 97, 81,11,11,"\033",0,1,SDLK_LEFT); // 15 Fenetre_Definir_bouton_normal(121, 81,11,11,"\032",0,1,SDLK_RIGHT); // 16 for (Indice=0; Indice<12; Indice++) Fenetre_Definir_bouton_normal((Indice*23)+8,20,20,20,"",0,1,SDLK_F1+Indice); // 17 -> 28 Dessiner_trames_predefinies(); Orig_X=Fenetre_Pos_X+(Menu_Facteur_X*Fenetre_Liste_boutons_special->Pos_X); Orig_Y=Fenetre_Pos_Y+(Menu_Facteur_Y*Fenetre_Liste_boutons_special->Pos_Y); Num2str(Trame_Largeur,Chaine,2); Print_dans_fenetre(71,120,Chaine,CM_Noir,CM_Clair); Num2str(Trame_Hauteur,Chaine,2); Print_dans_fenetre(71,136,Chaine,CM_Noir,CM_Clair); Dessiner_trame_zoomee(Orig_X,Orig_Y); Display_Window(290,179); Afficher_curseur(); do { Bouton_clicke=Fenetre_Bouton_clicke(); Orig_X=Fenetre_Pos_X+(Menu_Facteur_X*Fenetre_Liste_boutons_special->Pos_X); Orig_Y=Fenetre_Pos_Y+(Menu_Facteur_Y*Fenetre_Liste_boutons_special->Pos_Y); switch (Bouton_clicke) { case -1 : case 0 : break; case 1 : // Zone de dessin de la trame /* // Version qui n'accepte pas les clicks sur la grille Pos_X=(Mouse_X-Orig_X)/Menu_Facteur_X; Pos_Y=(Mouse_Y-Orig_Y)/Menu_Facteur_Y; if ( (Pos_X%5<4) && (Pos_Y%5<4) ) { Pos_X/=5; Pos_Y/=5; if ( (Pos_X16)?16:Brosse_Largeur; Trame_Hauteur=(Brosse_Hauteur>16)?16:Brosse_Hauteur; for (Pos_Y=0; Pos_Y>1); Brosse_Decalage_Y=(Brosse_Hauteur>>1); Changer_la_forme_du_pinceau(FORME_PINCEAU_BROSSE_COULEUR); break; case 8 : // Réduire hauteur if (Trame_Hauteur>1) { Effacer_curseur(); Trame_Hauteur--; Num2str(Trame_Hauteur,Chaine,2); Print_dans_fenetre(71,136,Chaine,CM_Noir,CM_Clair); Dessiner_trame_zoomee(Orig_X,Orig_Y); Afficher_curseur(); Mettre_a_jour_trame(Orig_X, Orig_Y); } break; case 9 : // Agrandir hauteur if (Trame_Hauteur<16) { Effacer_curseur(); for (Indice=0; Indice1) { Effacer_curseur(); Trame_Largeur--; Num2str(Trame_Largeur,Chaine,2); Print_dans_fenetre(71,120,Chaine,CM_Noir,CM_Clair); Dessiner_trame_zoomee(Orig_X,Orig_Y); Afficher_curseur(); Mettre_a_jour_trame(Orig_X, Orig_Y); } break; case 11 : // Agrandir largeur if (Trame_Largeur<16) { Effacer_curseur(); for (Indice=0; IndicePos_X+2)), Fenetre_Pos_Y+(Menu_Facteur_Y*(Bouton_Octet_insere->Pos_Y+2)), Menu_Facteur_X*7, Menu_Facteur_Y*7, (Octet_insere)?CM_Blanc:CM_Noir); Afficher_curseur(); UpdateRect( Fenetre_Pos_X+(Menu_Facteur_X*(Bouton_Octet_insere->Pos_X+2)), Fenetre_Pos_Y+(Menu_Facteur_Y*(Bouton_Octet_insere->Pos_Y+2)), Menu_Facteur_X*7, Menu_Facteur_Y*7); break; case 13 : // Scroll vers le haut Effacer_curseur(); for (Pos_X=0; Pos_X0; Pos_Y--) Trame[Pos_X][Pos_Y]=Trame[Pos_X][Pos_Y-1]; Trame[Pos_X][0]=Temp; } Dessiner_trame_zoomee(Orig_X,Orig_Y); Afficher_curseur(); Mettre_a_jour_trame(Orig_X, Orig_Y); break; case 15 : // Scroll vers la gauche Effacer_curseur(); for (Pos_Y=0; Pos_Y0; Pos_X--) Trame[Pos_X][Pos_Y]=Trame[Pos_X-1][Pos_Y]; Trame[0][Pos_Y]=Temp; } Dessiner_trame_zoomee(Orig_X,Orig_Y); Afficher_curseur(); Mettre_a_jour_trame(Orig_X, Orig_Y); break; default : // Boutons de trames prédéfinies Effacer_curseur(); Copier_trame_predefinie(Bouton_clicke-17); Dessiner_trame_zoomee(Orig_X,Orig_Y); Num2str(Trame_Largeur,Chaine,2); Print_dans_fenetre(71,120,Chaine,CM_Noir,CM_Clair); Num2str(Trame_Hauteur,Chaine,2); Print_dans_fenetre(71,136,Chaine,CM_Noir,CM_Clair); Dessiner_trame_zoomee(Orig_X,Orig_Y); Afficher_curseur(); Mettre_a_jour_trame(Orig_X, Orig_Y); } if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) Fenetre_aide(BOUTON_EFFETS, "SIEVE"); } while ( (Bouton_clicke!=2) && (Bouton_clicke!=3) ); Fermer_fenetre(); if (Bouton_clicke==2) // Cancel { Trame_Largeur=Old_Trame_Largeur; Trame_Hauteur=Old_Trame_Hauteur; memcpy(Trame,Old_Trame,256); } if ( (Bouton_clicke==3) && (!Trame_Mode) ) // OK Bouton_Trame_Mode(); Afficher_curseur(); } // -- Gestion des boutons de polygone vide et plein ------------------------- void Bouton_Polygone(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_POLYGONE); Afficher_curseur(); } void Bouton_Polyform(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_POLYFORM); Afficher_curseur(); } void Bouton_Polyfill(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_POLYFILL); Afficher_curseur(); } void Bouton_Filled_polyform(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_FILLED_POLYFORM); Afficher_curseur(); } // -- Boutons d'ajustement de l'image --------------------------------------- void Bouton_Ajuster(void) { Effacer_curseur(); Demarrer_pile_operation(OPERATION_SCROLL); Afficher_curseur(); } // -- Menu des effets (Shade, Stencil, etc...) ------------------------------ void Afficher_sprite_effet(short Numero_sprite, short Debut_X, short Debut_Y) { short X,Y,Pos_X,Pos_Y; for (Y=0,Pos_Y=Debut_Y;YPos_X*Menu_Facteur_X, Fenetre_Pos_Y+Bouton_preview->Pos_Y*Menu_Facteur_Y, Bouton_preview->Largeur*Menu_Facteur_X, Bouton_preview->Hauteur*Menu_Facteur_Y, CM_Clair); Nouvelle_Brosse = Rendu_Texte(Chaine_preview, Position_curseur+Debut_liste, Taille_police, AntiAlias, Style_Bold, Style_Italic, &Nouvelle_Largeur, &Nouvelle_Hauteur); if (Nouvelle_Brosse) { Affiche_brosse_SDL( Nouvelle_Brosse, Fenetre_Pos_X+Bouton_preview->Pos_X*Menu_Facteur_X, Fenetre_Pos_Y+Bouton_preview->Pos_Y*Menu_Facteur_Y, 0, 0, Min(Bouton_preview->Largeur*Menu_Facteur_X, Nouvelle_Largeur), Min(Bouton_preview->Hauteur*Menu_Facteur_Y, Nouvelle_Hauteur), Back_color, Nouvelle_Largeur); } UpdateRect( Fenetre_Pos_X+Bouton_preview->Pos_X*Menu_Facteur_X, Fenetre_Pos_Y+Bouton_preview->Pos_Y*Menu_Facteur_Y, Bouton_preview->Largeur*Menu_Facteur_X, Bouton_preview->Hauteur*Menu_Facteur_Y); } if (A_redessiner || A_previsionner) { A_redessiner=0; A_previsionner=0; Afficher_curseur(); } Bouton_clicke=Fenetre_Bouton_clicke(); if (Bouton_clicke==0) { if (Touche==SDLK_UP && (Position_curseur+Debut_liste)>0) { Touche=0; Effacer_curseur(); Position_curseur--; if (Position_curseur<0) { Debut_liste=Debut_liste+Position_curseur; Position_curseur=0; // Mise à jour du scroller Scroller_de_fontes->Position=Debut_liste; Fenetre_Dessiner_jauge(Scroller_de_fontes); } A_redessiner=1; A_previsionner=1; } if (Touche==SDLK_DOWN && (Position_curseur+Debut_liste)<(Fonte_nombre-1)) { Touche=0; Effacer_curseur(); Position_curseur++; if (Position_curseur>(NB_FONTES-1)) { Debut_liste=Debut_liste+Position_curseur-(NB_FONTES-1); Position_curseur=(NB_FONTES-1); // Mise à jour du scroller Scroller_de_fontes->Position=Debut_liste; Fenetre_Dessiner_jauge(Scroller_de_fontes); } A_redessiner=1; A_previsionner=1; } if (Touche==SDLK_HOME && (Position_curseur!=0 || Debut_liste!=0)) { Touche=0; Effacer_curseur(); Position_curseur=0; Debut_liste=0; // Mise à jour du scroller Scroller_de_fontes->Position=Debut_liste; Fenetre_Dessiner_jauge(Scroller_de_fontes); A_redessiner=1; A_previsionner=1; } if (Touche==SDLK_END && (Position_curseur+Debut_liste)<(Fonte_nombre-1)) { Touche=0; Effacer_curseur(); Position_curseur=(Fonte_nombre-1)-Debut_liste; if (Position_curseur>(NB_FONTES-1)) { Debut_liste=Debut_liste+Position_curseur-(NB_FONTES-1); Position_curseur=(NB_FONTES-1); // Mise à jour du scroller Scroller_de_fontes->Position=Debut_liste; Fenetre_Dessiner_jauge(Scroller_de_fontes); } A_redessiner=1; A_previsionner=1; } if (Touche==SDLK_PAGEDOWN && (Position_curseur+Debut_liste)<(Fonte_nombre-1)) { Touche=0; Effacer_curseur(); if (Fonte_nombreFonte_nombre) { Debut_liste=Fonte_nombre-NB_FONTES; } // Mise à jour du scroller Scroller_de_fontes->Position=Debut_liste; Fenetre_Dessiner_jauge(Scroller_de_fontes); } A_redessiner=1; A_previsionner=1; } if (Touche==SDLK_PAGEUP && (Position_curseur+Debut_liste)>0) { Touche=0; Effacer_curseur(); if(Position_curseur!=0) { Position_curseur=0; } else { Debut_liste-=NB_FONTES; if (Debut_liste<0) { Debut_liste=0; } // Mise à jour du scroller Scroller_de_fontes->Position=Debut_liste; Fenetre_Dessiner_jauge(Scroller_de_fontes); } A_redessiner=1; A_previsionner=1; } if (Touche==Bouton[BOUTON_AIDE].Raccourci_gauche) Fenetre_aide(BOUTON_TEXTE, NULL); } switch(Bouton_clicke) { case 1: // Texte saisi Effacer_curseur(); Readline_ex(50,20,Chaine,29,250,0); A_previsionner=1; break; case 2: // AA AntiAlias = (AntiAlias==0); Effacer_curseur(); Print_dans_fenetre(191,60,AntiAlias?"X":" ", CM_Noir, CM_Clair); A_previsionner=1; break; case 3: // Bold Style_Bold = (Style_Bold==0); Effacer_curseur(); Print_dans_fenetre(191,74,Style_Bold?"X":" ", CM_Noir, CM_Clair); A_previsionner=1; break; case 4: // Italic Style_Italic = (Style_Italic==0); Effacer_curseur(); Print_dans_fenetre(191,88,Style_Italic?"X":" ", CM_Noir, CM_Clair); A_previsionner=1; break; case 5: // Scroller des fontes if (Debut_liste!=Fenetre_Attribut2) { Position_curseur+=Debut_liste; Debut_liste=Fenetre_Attribut2; Position_curseur-=Debut_liste; // On affiche à nouveau la liste Effacer_curseur(); A_redessiner=1; } break; case 6: // Selecteur de fonte Temp=(((Mouse_Y-Fenetre_Pos_Y)/Menu_Facteur_Y)-32)>>3; if (Temp!=Position_curseur && Temp < Fonte_nombre) { Position_curseur=Temp; // On affiche à nouveau la liste Effacer_curseur(); A_redessiner=1; A_previsionner=1; } break; case 7: // Taille du texte (nombre) Effacer_curseur(); Readline(222,45,Buffer_taille,3,1); Taille_police=atoi(Buffer_taille); // On corrige les dimensions if (Taille_police < 1) { Taille_police = 1; } else if (Taille_police>500) { Taille_police = 500; } A_redessiner=1; A_previsionner=1; break; case 8: // Taille - if (Taille_police > 1) { Taille_police--; Effacer_curseur(); A_redessiner=1; A_previsionner=1; } break; case 9: // Taille + if (Taille_police < 255) { Taille_police++; Effacer_curseur(); A_redessiner=1; A_previsionner=1; } break; case 11: // OK if (!Nouvelle_Brosse) { // Si echec de rendu Fermer_fenetre(); Desenclencher_bouton(BOUTON_TEXTE); Afficher_curseur(); Erreur(0); return; } if (Brosse) free(Brosse); Brosse=Nouvelle_Brosse; Brosse_Largeur=Nouvelle_Largeur; Brosse_Hauteur=Nouvelle_Hauteur; Brosse_Decalage_X=Brosse_Largeur>>1; Brosse_Decalage_Y=Brosse_Hauteur>>1; // Fermeture Fermer_fenetre(); Desenclencher_bouton(BOUTON_TEXTE); // On passe en brosse: Afficher_curseur(); if (AntiAlias || !TrueType_fonte(Position_curseur+Debut_liste)) Changer_la_forme_du_pinceau(FORME_PINCEAU_BROSSE_COULEUR); else Changer_la_forme_du_pinceau(FORME_PINCEAU_BROSSE_MONOCHROME); Enclencher_bouton(BOUTON_DESSIN,A_GAUCHE); if (Config.Auto_discontinuous) { // On se place en mode Dessin discontinu à la main while (Operation_en_cours!=OPERATION_DESSIN_DISCONTINU) Enclencher_bouton(BOUTON_DESSIN,A_DROITE); } //Afficher_curseur(); return; case 12: // Cancel if (Nouvelle_Brosse) free(Nouvelle_Brosse); Fermer_fenetre(); Desenclencher_bouton(BOUTON_TEXTE); Afficher_curseur(); return; } } } /* BOUTON_GRADRECT -BOUTON_SPHERES (Ellipses dégradées à améliorer) BOUTON_TEXTE -BOUTON_AJUSTER (Effets sur l'image) -BOUTON_EFFETS_BROSSE (Distort, Rot. any angle) */