m/grafX2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Made it compile under windows with Open Watcom

Browse Source 
git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@66 416bcca6-2ee7-4201-b75f-2eb2f807beb1
This commit is contained in:
Adrien Destugues 2008-07-27 21:04:12 +00:00
parent ae9a534ad8
commit b2f9193e85
22 changed files with 10132 additions and 9389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
aide.c
View File

@ -8,7 +8,11 @@
#include <string.h>
#include <sys/vfs.h>
#ifdef __linux__
#include <sys/vfs.h>
#elif __WATCOMC__
#include <windows.h>
#endif
// -- Menu d'aide -----------------------------------------------------------
@ -199,13 +203,20 @@ void Bouton_Stats(void)
short Bouton_clicke;
char Buffer[37];
dword Utilisation_couleur[256];
unsigned long long Taille;
struct statfs Informations_Disque;
unsigned long long freeRam;
#ifdef __linux__
struct statfs Informations_Disque;
unsigned long long Taille = 0;
#elif __WATCOMC__
unsigned __int64 Taille;
ULARGE_INTEGER tailleU;
#endif
Ouvrir_fenetre(310,174,"Statistics");
// dessiner de la fenˆtre o— va s'afficher le texte
// Dessin de la fenetre ou va s'afficher le texte
Fenetre_Afficher_cadre_creux(8,17,294,132);
Block(Fenetre_Pos_X+(Menu_Facteur_X*9),
Fenetre_Pos_Y+(Menu_Facteur_Y*18),
@ -219,33 +230,42 @@ void Bouton_Stats(void)
Print_dans_fenetre(82,19,Buffer,STATS_COULEUR_DONNEES,CM_Noir);
// Affichage de la mémoire restante
Print_dans_fenetre(10,35,"Free memory:",STATS_COULEUR_TITRES,CM_Noir);
unsigned long long freeRam = Memoire_libre();
Print_dans_fenetre(10,35,"Free memory: ",STATS_COULEUR_TITRES,CM_Noir);
freeRam = Memoire_libre();
if(freeRam > (100ULL*1024*1024*1024))
sprintf(Buffer,"%d Gigabytes",(unsigned int)(freeRam/(1024*1024*1024)));
sprintf(Buffer,"%d Gigabytes",(unsigned int)(freeRam/(1024*1024*1024)));
else if(freeRam > (100*1024*1024))
sprintf(Buffer,"%d Megabytes",(unsigned int)(freeRam/(1024*1024)));
sprintf(Buffer,"%d Megabytes",(unsigned int)(freeRam/(1024*1024)));
else if(freeRam > 100*1024)
sprintf(Buffer,"%d Kilobytes",(unsigned int)(freeRam/1024));
sprintf(Buffer,"%d Kilobytes",(unsigned int)(freeRam/1024));
else
sprintf(Buffer,"%d bytes",(unsigned int)freeRam);
sprintf(Buffer,"%d bytes",(unsigned int)freeRam);
Print_dans_fenetre(114,35,Buffer,STATS_COULEUR_DONNEES,CM_Noir);
// Affichage de l'espace disque libre
sprintf(Buffer,"Free space on %c:",Principal_Repertoire_courant[0]);
Print_dans_fenetre(10,51,Buffer,STATS_COULEUR_TITRES,CM_Noir);
statfs(Principal_Repertoire_courant,&Informations_Disque);
Taille=Informations_Disque.f_bfree * Informations_Disque.f_bsize;
#ifdef __linux__
statfs(Principal_Repertoire_courant,&Informations_Disque);
Taille=Informations_Disque.f_bfree * Informations_Disque.f_bsize;
#elif __WATCOMC__
GetDiskFreeSpaceEx(Principal_Repertoire_courant,&tailleU,NULL,NULL);
Taille = tailleU.QuadPart;
#endif
if (Taille>=0)
{
if(Taille > (100ULL*1024*1024*1024))
sprintf(Buffer,"%d Gigabytes",(unsigned int)(Taille/(1024*1024*1024)));
sprintf(Buffer,"%d Gigabytes",(unsigned int)(Taille/(1024*1024*1024)));
else if(Taille > (100*1024*1024))
sprintf(Buffer,"%d Megabytes",(unsigned int)(Taille/(1024*1024)));
sprintf(Buffer,"%d Megabytes",(unsigned int)(Taille/(1024*1024)));
else if(Taille > (100*1024))
sprintf(Buffer,"%d Kilobytes",(unsigned int)(Taille/1024));
sprintf(Buffer,"%d Kilobytes",(unsigned int)(Taille/1024));
else
sprintf(Buffer,"%d bytes",(unsigned int)Taille);
sprintf(Buffer,"%d bytes",(unsigned int)Taille);
Print_dans_fenetre(146,51,Buffer,STATS_COULEUR_DONNEES,CM_Noir);
}
else

30
boutons.c
View File

@ -21,6 +21,12 @@
#include "pages.h"
#include "erreurs.h"
#ifdef __WATCOMC__
#include <windows.h>
#define chdir(x) SetCurrentDirectory(x)
#define rmdir(x) DeleteFile(x)
#endif
//-- MODELE DE BOUTON DE MENU ------------------------------------------------
/*
void Bouton_***(void)
@ -122,7 +128,7 @@ void Bouton_Message_initial(void)
Print_dans_fenetre( 7,128,"file before using this program",CM_Fonce,CM_Clair);
Print_dans_fenetre( 7,136,"for the first time.",CM_Fonce,CM_Clair);
if ((*ALPHA_BETA)=='Ó')
if ((*ALPHA_BETA)=='á')
{
Print_char_transparent_dans_fenetre(43,119,'M',CM_Noir);
Print_char_transparent_dans_fenetre(53,121,'U',CM_Noir);
@ -1685,7 +1691,7 @@ void Degrade_Dessiner_bouton_de_technique(short Pos_X,short Pos_Y,int Technique)
}
SDL_UpdateRect(Ecran_SDL,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);
Menu_Facteur_X*10,Menu_Facteur_Y*10);
}
void Degrade_Charger_infos_du_tableau(int Indice)
@ -2105,12 +2111,12 @@ void Print_repertoire_courant(void)
// le reste de la chaine (Ouaaaaaah!!! Vachement fort le mec!!)
for (Indice++;Indice<Longueur;Indice++)
if ( (Principal_Repertoire_courant[Indice]=='\\') &&
(Longueur-Indice<=TAILLE_MAXI_PATH-6) )
(Longueur-Indice<=TAILLE_MAXI_PATH-6) )
{
// Ouf: on vient de trouver un endroit dans la chaîne à partir duquel
// on peut faire la copie:
strcpy(Nom_temporaire+6,Principal_Repertoire_courant+Indice);
break;
// Ouf: on vient de trouver un endroit dans la chaîne à partir duquel
// on peut faire la copie:
strcpy(Nom_temporaire+6,Principal_Repertoire_courant+Indice);
break;
}
// Enfin, on peut afficher la chaîne tronquée
@ -2449,7 +2455,7 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
do
{
puts("boutons.c 2454\n");
puts("boutons.c 2454\n");
//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));
@ -2584,7 +2590,7 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
break;
case 8 : // Saisie du nom de fichier
Effacer_curseur();
if (Readline(202,73,Principal_Nom_fichier,12,2))
if (Readline(202,73,Principal_Nom_fichier,12,2))
{
// On regarde s'il faut rajouter une extension. C'est-à-dire s'il
// n'y a pas de '.' dans le nom du fichier.
@ -2597,10 +2603,10 @@ byte Bouton_Load_ou_Save(byte Load, byte Image)
if (Principal_Format)
strcat(Principal_Nom_fichier,Format_Extension[Principal_Format-1]);
}
On_a_clicke_sur_OK=1;
On_a_clicke_sur_OK=1;
}
Afficher_curseur();
break;
Afficher_curseur();
break;
default : // Drives
Effacer_curseur();
// On change de lecteur: Lecteur = Drive[Bouton_clicke-9].Lettre-64

9
boutons.h
View File

@ -158,12 +158,3 @@ void Menu_Tag_couleurs(char * En_tete, byte * Table, byte * Mode, byte Cancel);
void Bouton_Smooth_Menu(void);
void Bouton_Smear_Mode(void);
// -- Gestion du chrono --
byte Etat_chrono; // Etat du chrono: 0=Attente d'un Xème de seconde
// 1=Il faut afficher la preview
// 2=Plus de chrono à gerer pour l'instant
long Chrono_delay; // Nombre de 18.2ème de secondes demandés
long Chrono_cmp; // Heure de départ du chrono
byte Nouvelle_preview; // Booléen "Il faut relancer le chrono de preview"
// Les fonctions de manipulation du chrono se trouvent dans DIVERS.ASM

634
divers.c
View File

@ -5,12 +5,14 @@
#include "graph.h" //Afficher_curseur
#include "erreurs.h"
#include "boutons.h"
#include "moteur.h"
#include "divers.h"
// Gestion du mode texte de départ (pour pouvoir y retourner en cas de problème
byte Recuperer_nb_lignes(void)
{
puts("Recuperer_nb_lignes non implémenté!\n");
return 0;
puts("Recuperer_nb_lignes non implémenté!\n");
return 0;
}
word Palette_Compter_nb_couleurs_utilisees(dword* Tableau)
@ -38,8 +40,8 @@ word Palette_Compter_nb_couleurs_utilisees(dword* Tableau)
//On va maintenant compter dans la table les couleurs utilisées:
for(i=0;i<256;i++)
{
if (Tableau[i]!=0)
Nombre_Couleurs++;
if (Tableau[i]!=0)
Nombre_Couleurs++;
}
return Nombre_Couleurs;
@ -47,15 +49,15 @@ word Palette_Compter_nb_couleurs_utilisees(dword* Tableau)
void Set_palette(T_Palette Palette)
{
register int i;
SDL_Color PaletteSDL[256];
for(i=0;i<256;i++)
{
PaletteSDL[i].r=Palette[i].R*4; //Les couleurs VGA ne vont que de 0 à 63
PaletteSDL[i].g=Palette[i].V*4;
PaletteSDL[i].b=Palette[i].B*4;
}
SDL_SetPalette(Ecran_SDL,SDL_PHYSPAL|SDL_LOGPAL,PaletteSDL,0,256);
register int i;
SDL_Color PaletteSDL[256];
for(i=0;i<256;i++)
{
PaletteSDL[i].r=Palette[i].R*4; //Les couleurs VGA ne vont que de 0 à 63
PaletteSDL[i].g=Palette[i].V*4;
PaletteSDL[i].b=Palette[i].B*4;
}
SDL_SetPalette(Ecran_SDL,SDL_PHYSPAL|SDL_LOGPAL,PaletteSDL,0,256);
}
void Attendre_fin_de_click(void)
@ -77,15 +79,14 @@ void Effacer_image_courante_Stencil(byte Couleur, byte * Pochoir)
int Nombre_De_Pixels=0; //ECX
//al=Couleur
//edi=Ecran
Uint8* Pixel_Courant=Ecran; //dl
byte* Pixel_Courant=Ecran; //dl
int i;
Nombre_De_Pixels=Principal_Hauteur_image*Principal_Largeur_image;
for(i=0;i<Nombre_De_Pixels;i++)
{
if (Pochoir[*Pixel_Courant]==0);
if (Pochoir[*Pixel_Courant]==0)
*Pixel_Courant=Couleur;
Pixel_Courant++;
}
@ -95,15 +96,15 @@ void Effacer_image_courante(byte Couleur)
// Effacer l'image courante avec une certaine couleur
{
memset(
Principal_Ecran ,
Couleur ,
Principal_Largeur_image * Principal_Hauteur_image
Principal_Ecran ,
Couleur ,
Principal_Largeur_image * Principal_Hauteur_image
);
}
void Sensibilite_souris(word X,word Y)
{
puts("Sensibilite_souris non implémenté!");
puts("Sensibilite_souris non implémenté!");
}
void Get_input(void)
@ -116,112 +117,115 @@ void Get_input(void)
if( SDL_PollEvent(&event)) /* Il y a un évènement en attente */
{
switch( event.type)
{
case SDL_MOUSEMOTION:
//Mouvement de la souris
INPUT_Nouveau_Mouse_X = event.motion.x>>Mouse_Facteur_de_correction_X;
INPUT_Nouveau_Mouse_Y = event.motion.y>>Mouse_Facteur_de_correction_Y;
break;
case SDL_MOUSEBUTTONDOWN:
//Clic sur un des boutons de la souris
INPUT_Nouveau_Mouse_K=event.button.button;
break;
case SDL_MOUSEBUTTONUP:
//Bouton souris relaché
INPUT_Nouveau_Mouse_K=0;
break;
case SDL_KEYDOWN:
//Appui sur une touche du clavier
switch( event.type)
{
case SDL_MOUSEMOTION:
//Mouvement de la souris
INPUT_Nouveau_Mouse_X = event.motion.x>>Mouse_Facteur_de_correction_X;
INPUT_Nouveau_Mouse_Y = event.motion.y>>Mouse_Facteur_de_correction_Y;
break;
case SDL_MOUSEBUTTONDOWN:
//Clic sur un des boutons de la souris
INPUT_Nouveau_Mouse_K=event.button.button;
break;
case SDL_MOUSEBUTTONUP:
//Bouton souris relaché
INPUT_Nouveau_Mouse_K=0;
break;
case SDL_KEYDOWN:
{
byte ok = 0;
//Appui sur une touche du clavier
//On met le scancode dans Touche"
Touche = event.key.keysym.scancode;
//On met le scancode dans Touche"
Touche = event.key.keysym.scancode;
//...et le code ASCII dans Touche_ASCII
Touche_ASCII=event.key.keysym.sym;
//...et le code ASCII dans Touche_ASCII
Touche_ASCII=event.key.keysym.sym;
//On ajoute aussi l'état des modifiers
#define ekkm event.key.keysym.mod
if (ekkm & (KMOD_LSHIFT | KMOD_RSHIFT))
{
Touche |= 0x0100;
}
if (ekkm & (KMOD_LCTRL | KMOD_RCTRL))
{
Touche |= 0x0200;
}
if (ekkm & (KMOD_LALT | KMOD_RALT))
{
Touche |= 0x0400;
}
#undef ekkm
//On ajoute aussi l'état des modifiers
#define ekkm event.key.keysym.mod
if (ekkm & (KMOD_LSHIFT | KMOD_RSHIFT))
{
Touche |= 0x0100;
}
if (ekkm & (KMOD_LCTRL | KMOD_RCTRL))
{
Touche |= 0x0200;
}
if (ekkm & (KMOD_LALT | KMOD_RALT))
{
Touche |= 0x0400;
}
#undef ekkm
//TODO revoir les scancodes qui sont dans le tableau
//Config_Touche, ça correspond à rien !
//TODO revoir les scancodes qui sont dans le tableau
//Config_Touche, ça correspond à rien !
//Cas particulier: déplacement du curseur avec haut bas gauche droite
//On doit interpréter ça comme un mvt de la souris
byte ok=0;
if(Touche == Config_Touche[0])
{
//[Touche] = Emulation de MOUSE UP
//si on est déjà en haut on peut plus bouger
if(INPUT_Nouveau_Mouse_Y!=0)
{
INPUT_Nouveau_Mouse_Y--;
ok=1;
}
}
else if(Touche == Config_Touche[1])
{
//[Touche] = Emulation de MOUSE DOWN
if(INPUT_Nouveau_Mouse_Y<Hauteur_ecran-1)
{
INPUT_Nouveau_Mouse_Y++;
ok=1;
}
}
else if(Touche == Config_Touche[2])
{
//[Touche] = Emulation de MOUSE LEFT
if(INPUT_Nouveau_Mouse_X!=0)
{
INPUT_Nouveau_Mouse_X--;
ok=1;
}
}
else if(Touche == Config_Touche[3])
{
//[Touche] = Emulation de MOUSE RIGHT
//Cas particulier: déplacement du curseur avec haut bas gauche droite
//On doit interpréter ça comme un mvt de la souris
if(INPUT_Nouveau_Mouse_X<Largeur_ecran-1)
{
INPUT_Nouveau_Mouse_X++;
ok=1;
}
}
else if(Touche == Config_Touche[4])
{
//[Touche] = Emulation de MOUSE CLICK LEFT
INPUT_Nouveau_Mouse_K=1;
ok=1;
}
else if(Touche == Config_Touche[5])
{
//[Touche] = Emulation de MOUSE CLICK RIGHT
INPUT_Nouveau_Mouse_K=2;
ok=1;
}
if(Touche == Config_Touche[0])
{
//[Touche] = Emulation de MOUSE UP
//si on est déjà en haut on peut plus bouger
if(INPUT_Nouveau_Mouse_Y!=0)
{
INPUT_Nouveau_Mouse_Y--;
ok=1;
}
}
else if(Touche == Config_Touche[1])
{
//[Touche] = Emulation de MOUSE DOWN
if(INPUT_Nouveau_Mouse_Y<Hauteur_ecran-1)
{
INPUT_Nouveau_Mouse_Y++;
ok=1;
}
}
else if(Touche == Config_Touche[2])
{
//[Touche] = Emulation de MOUSE LEFT
if(INPUT_Nouveau_Mouse_X!=0)
{
INPUT_Nouveau_Mouse_X--;
ok=1;
}
}
else if(Touche == Config_Touche[3])
{
//[Touche] = Emulation de MOUSE RIGHT
if(ok)
{
SDL_WarpMouse(
INPUT_Nouveau_Mouse_X<<Mouse_Facteur_de_correction_X,
INPUT_Nouveau_Mouse_Y<<Mouse_Facteur_de_correction_Y
);
}
break;
}
if(INPUT_Nouveau_Mouse_X<Largeur_ecran-1)
{
INPUT_Nouveau_Mouse_X++;
ok=1;
}
}
else if(Touche == Config_Touche[4])
{
//[Touche] = Emulation de MOUSE CLICK LEFT
INPUT_Nouveau_Mouse_K=1;
ok=1;
}
else if(Touche == Config_Touche[5])
{
//[Touche] = Emulation de MOUSE CLICK RIGHT
INPUT_Nouveau_Mouse_K=2;
ok=1;
}
if(ok)
{
SDL_WarpMouse(
INPUT_Nouveau_Mouse_X<<Mouse_Facteur_de_correction_X,
INPUT_Nouveau_Mouse_Y<<Mouse_Facteur_de_correction_Y
);
}
}
break;
}
}
//Gestion "avancée" du curseur: interdire la descente du curseur dans le
@ -229,88 +233,88 @@ void Get_input(void)
if(Operation_Taille_pile!=0)
{
byte bl=0;//BL va indiquer si on doit corriger la position du curseur
byte bl=0;//BL va indiquer si on doit corriger la position du curseur
//Si le curseur ne se trouve plus dans l'image
if(Menu_Ordonnee<INPUT_Nouveau_Mouse_Y)
{
//On bloque le curseur en fin d'image
bl++;
INPUT_Nouveau_Mouse_Y=Menu_Ordonnee-1; //La ligne !!au-dessus!! du menu
}
//Si le curseur ne se trouve plus dans l'image
if(Menu_Ordonnee<INPUT_Nouveau_Mouse_Y)
{
//On bloque le curseur en fin d'image
bl++;
INPUT_Nouveau_Mouse_Y=Menu_Ordonnee-1; //La ligne !!au-dessus!! du menu
}
if(Loupe_Mode)
{
if(Operation_dans_loupe==0)
{
if(INPUT_Nouveau_Mouse_X>=Principal_Split)
{
bl++;
INPUT_Nouveau_Mouse_X=Principal_Split-1;
}
}
else
{
if(INPUT_Nouveau_Mouse_X<Principal_X_Zoom)
{
bl++;
INPUT_Nouveau_Mouse_X=Principal_X_Zoom;
}
}
}
if(Loupe_Mode)
{
if(Operation_dans_loupe==0)
{
if(INPUT_Nouveau_Mouse_X>=Principal_Split)
{
bl++;
INPUT_Nouveau_Mouse_X=Principal_Split-1;
}
}
else
{
if(INPUT_Nouveau_Mouse_X<Principal_X_Zoom)
{
bl++;
INPUT_Nouveau_Mouse_X=Principal_X_Zoom;
}
}
}
if (bl)
{
SDL_WarpMouse(
INPUT_Nouveau_Mouse_X<<Mouse_Facteur_de_correction_X,
INPUT_Nouveau_Mouse_Y<<Mouse_Facteur_de_correction_Y
);
}
if (bl)
{
SDL_WarpMouse(
INPUT_Nouveau_Mouse_X<<Mouse_Facteur_de_correction_X,
INPUT_Nouveau_Mouse_Y<<Mouse_Facteur_de_correction_Y
);
}
if (Touche != 0)
{
//Enfin, on inhibe les touches (sauf si c'est un changement de couleur
//ou de taille de pinceau lors d'une des operations suivantes:
//OPERATION_DESSIN_CONTINU, OPERATION_DESSIN_DISCONTINU, OPERATION_SPRAY)
if(Autoriser_changement_de_couleur_pendant_operation)
{
//A ce stade là, on sait qu'on est dans une des 3 opérations
//supportant le changement de couleur ou de taille de pinceau.
if (Touche != 0)
{
//Enfin, on inhibe les touches (sauf si c'est un changement de couleur
//ou de taille de pinceau lors d'une des operations suivantes:
//OPERATION_DESSIN_CONTINU, OPERATION_DESSIN_DISCONTINU, OPERATION_SPRAY)
if(Autoriser_changement_de_couleur_pendant_operation)
{
//A ce stade là, on sait qu'on est dans une des 3 opérations
//supportant le changement de couleur ou de taille de pinceau.
if(
(Touche != Config_Touche[6]) &&
(Touche != Config_Touche[7]) &&
(Touche != Config_Touche[8]) &&
(Touche != Config_Touche[9]) &&
(Touche != Config_Touche[10]) &&
(Touche != Config_Touche[11]) &&
(Touche != Config_Touche[12]) &&
(Touche != Config_Touche[13]) &&
(Touche != Config_Touche[14]) &&
(Touche != Config_Touche[15])
)
{
Touche=0;
}
}
else Touche = 0;
}
if(
(Touche != Config_Touche[6]) &&
(Touche != Config_Touche[7]) &&
(Touche != Config_Touche[8]) &&
(Touche != Config_Touche[9]) &&
(Touche != Config_Touche[10]) &&
(Touche != Config_Touche[11]) &&
(Touche != Config_Touche[12]) &&
(Touche != Config_Touche[13]) &&
(Touche != Config_Touche[14]) &&
(Touche != Config_Touche[15])
)
{
Touche=0;
}
}
else Touche = 0;
}
}
if (
(INPUT_Nouveau_Mouse_X != Mouse_X) ||
(INPUT_Nouveau_Mouse_Y != Mouse_Y) ||
(INPUT_Nouveau_Mouse_K != Mouse_K)
(INPUT_Nouveau_Mouse_X != Mouse_X) ||
(INPUT_Nouveau_Mouse_Y != Mouse_Y) ||
(INPUT_Nouveau_Mouse_K != Mouse_K)
)
{
Forcer_affichage_curseur=0;
Effacer_curseur(); // On efface le curseur AVANT de le déplacer...
Mouse_X=INPUT_Nouveau_Mouse_X;
Mouse_Y=INPUT_Nouveau_Mouse_Y;
Mouse_K=INPUT_Nouveau_Mouse_K;
Calculer_coordonnees_pinceau();
Afficher_curseur();
Forcer_affichage_curseur=0;
Effacer_curseur(); // On efface le curseur AVANT de le déplacer...
Mouse_X=INPUT_Nouveau_Mouse_X;
Mouse_Y=INPUT_Nouveau_Mouse_Y;
Mouse_K=INPUT_Nouveau_Mouse_K;
Calculer_coordonnees_pinceau();
Afficher_curseur();
}
}
@ -326,44 +330,44 @@ void Initialiser_chrono(dword Delai)
void Wait_VBL(void)
// Attente de VBL. Pour avoir des scrollbars qui ont une vitesse raisonnable par exemple. SDL ne sait pas faire ?
{
puts("Wait_VBL non implémenté!");
puts("Wait_VBL non implémenté!");
}
void Passer_en_mode_texte(byte Nb_lignes)
{
SDL_Quit(); //Ceci sera appellé à chaque sortie de mode vidéo == sortie du programme. le Nb_Lignes serait à enlever, cela dit, SDL s'en occupe très bien tout seul.
SDL_Quit(); //Ceci sera appellé à chaque sortie de mode vidéo == sortie du programme. le Nb_Lignes serait à enlever, cela dit, SDL s'en occupe très bien tout seul.
}
void Pixel_dans_brosse (word X,word Y,byte Couleur)
{
puts("Pixel_dans_brosse non implémenté!");
puts("Pixel_dans_brosse non implémenté!");
}
byte Lit_pixel_dans_brosse (word X,word Y)
{
puts("Lit_pixel_dans_brosse non implémenté!");
return 0;
puts("Lit_pixel_dans_brosse non implémenté!");
return 0;
}
void Clavier_de_depart(void)
{
puts("Clavier_de_depart non implémenté!");
puts("Clavier_de_depart non implémenté!");
}
void Clavier_americain(void)
{
puts("Clavier_americain non implémenté!");
puts("Clavier_americain non implémenté!");
}
word Detection_souris(void)
{
puts("Detection_souris non implémenté!");
return 0;
puts("Detection_souris non implémenté!");
return 0;
}
byte Lit_pixel_dans_ecran_courant (word X,word Y)
{
return *(Principal_Ecran+Y*Principal_Largeur_image+X);
return *(Principal_Ecran+Y*Principal_Largeur_image+X);
}
void Pixel_dans_ecran_courant (word X,word Y,byte Couleur)
@ -374,65 +378,65 @@ void Pixel_dans_ecran_courant (word X,word Y,byte Couleur)
void Remplacer_une_couleur(byte Ancienne_couleur, byte Nouvelle_couleur)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
void Ellipse_Calculer_limites(short Rayon_horizontal,short Rayon_vertical)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
byte Pixel_dans_ellipse(void)
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
byte Pixel_dans_cercle(void)
{
if((Table_des_carres[abs(Cercle_Curseur_X)] +
Table_des_carres[abs(Cercle_Curseur_Y)] ) <= Cercle_Limite)
return 255;
return 0;
if((Table_des_carres[abs(Cercle_Curseur_X)] +
Table_des_carres[abs(Cercle_Curseur_Y)] ) <= Cercle_Limite)
return 255;
return 0;
}
void Copier_une_partie_d_image_dans_une_autre(byte * Source,word S_Pos_X,word S_Pos_Y,word Largeur,word Hauteur,word Largeur_source,byte * Destination,word D_Pos_X,word D_Pos_Y,word Largeur_destination)
{
// ESI = adresse de la source en (S_Pox_X,S_Pos_Y)
byte* esi = Source + S_Pos_Y * Largeur_source + S_Pos_X;
// ESI = adresse de la source en (S_Pox_X,S_Pos_Y)
byte* esi = Source + S_Pos_Y * Largeur_source + S_Pos_X;
// EDI = adresse de la destination (D_Pos_X,D_Pos_Y)
byte* edi = Destination + D_Pos_Y * Largeur_destination + D_Pos_X;
// EDI = adresse de la destination (D_Pos_X,D_Pos_Y)
byte* edi = Destination + D_Pos_Y * Largeur_destination + D_Pos_X;
int Ligne;
int Ligne;
// Pour chaque ligne
for (Ligne=0;Ligne < Hauteur; Ligne++)
{
memcpy(edi,esi,Largeur);
// Pour chaque ligne
for (Ligne=0;Ligne < Hauteur; Ligne++)
{
memcpy(edi,esi,Largeur);
// Passe à la ligne suivante
esi+=Largeur_source - Largeur;
edi+=Largeur_destination - Largeur;
}
// Passe à la ligne suivante
esi+=Largeur_source - Largeur;
edi+=Largeur_destination - Largeur;
}
}
byte Lit_pixel_dans_ecran_brouillon(word X,word Y)
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
void Rotate_90_deg_LOWLEVEL(byte * Source,byte * Destination)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
void Remap_general_LOWLEVEL(byte * Table_conv,byte * Buffer,short Largeur,short Hauteur,short Largeur_buffer)
{
puts("Remap_general_LOWLEVEL non implémenté!");
puts("Remap_general_LOWLEVEL non implémenté!");
}
void Copier_image_dans_brosse(short Debut_X,short Debut_Y,short Brosse_Largeur,short Brosse_Hauteur,word Largeur_image)
@ -457,70 +461,70 @@ void Copier_image_dans_brosse(short Debut_X,short Debut_Y,short Brosse_Largeur,s
byte Lit_pixel_dans_ecran_feedback (word X,word Y)
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
dword Round_div(dword Numerateur,dword Diviseur)
{
return Numerateur/Diviseur;
return Numerateur/Diviseur;
}
byte Effet_Trame(word X,word Y)
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
void Set_mouse_position(void)
{
SDL_WarpMouse(
Mouse_X << Mouse_Facteur_de_correction_X,
Mouse_Y << Mouse_Facteur_de_correction_Y
Mouse_X << Mouse_Facteur_de_correction_X,
Mouse_Y << Mouse_Facteur_de_correction_Y
);
}
void Clip_mouse(void)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
void Remplacer_toutes_les_couleurs_dans_limites(byte * Table_de_remplacement)
{
// ESI pointe sur le début de la ligne d'écran actuelle
byte* esi = Principal_Ecran + Limite_Gauche +
Limite_Haut * Principal_Largeur_image;
// ESI pointe sur le début de la ligne d'écran actuelle
byte* esi = Principal_Ecran + Limite_Gauche +
Limite_Haut * Principal_Largeur_image;
// EDI pointe sur la position actuelle dans l'écran
byte* edi = esi;
// EDI pointe sur la position actuelle dans l'écran
byte* edi = esi;
// On place dans CX le nombre de lignes à traiter
int Ligne;
int Compteur;
// On place dans CX le nombre de lignes à traiter
int Ligne;
int Compteur;
// Pour chaque ligne :
for(Ligne = Limite_Haut;Ligne < Limite_Bas; Ligne++)
{
// Pour chaque pixel sur la ligne :
for (Compteur = Limite_Gauche;Compteur < Limite_Droite;Compteur ++);
{
if(*edi!=0) DEBUG("c",*edi);
*edi = Table_de_remplacement[*edi];
edi++;
}
// Pour chaque ligne :
for(Ligne = Limite_Haut;Ligne < Limite_Bas; Ligne++)
{
// Pour chaque pixel sur la ligne :
for (Compteur = Limite_Gauche;Compteur < Limite_Droite;Compteur ++);
{
if(*edi!=0) DEBUG("c",*edi);
*edi = Table_de_remplacement[*edi];
edi++;
}
// Passage à la ligne suivante
esi += Principal_Largeur_image;
edi = esi;
}
// Passage à la ligne suivante
esi += Principal_Largeur_image;
edi = esi;
}
DEBUG("Ligne",Ligne);
DEBUG("Compteur",Compteur);
DEBUG("Ligne",Ligne);
DEBUG("Compteur",Compteur);
}
byte inline Lit_pixel_dans_ecran_backup (word X,word Y)
byte Lit_pixel_dans_ecran_backup (word X,word Y)
{
return *(Ecran_backup + X + Principal_Largeur_image * Y);
return *(Ecran_backup + X + Principal_Largeur_image * Y);
}
byte Type_de_lecteur_de_disquette(byte Numero_de_lecteur)
@ -534,146 +538,146 @@ byte Type_de_lecteur_de_disquette(byte Numero_de_lecteur)
// 5 : Lecteur 2.8 Mo (??? pas sur ???)
// 6 : Lecteur 2.8 Mo
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
byte Disk_map(byte Numero_de_lecteur)
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
byte Disque_dur_present(byte Numero_de_disque)
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
byte Lecteur_CDROM_present(byte Numero_de_lecteur)
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
long Freespace(byte Numero_de_lecteur)
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
byte Couleur_ILBM_line(word Pos_X, word Vraie_taille_ligne)
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
void Palette_256_to_64(T_Palette Palette)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
void Palette_64_to_256(T_Palette Palette)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
byte Effet_Colorize_interpole (word X,word Y,byte Couleur)
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
byte Effet_Colorize_additif (word X,word Y,byte Couleur)
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
byte Effet_Colorize_soustractif(word X,word Y,byte Couleur)
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
void inline Tester_chrono(void)
void Tester_chrono(void)
{
if((SDL_GetTicks()/55)-Chrono_delay>Chrono_cmp) Etat_chrono=1;
if((SDL_GetTicks()/55)-Chrono_delay>Chrono_cmp) Etat_chrono=1;
}
void Flip_Y_LOWLEVEL(void)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
void Flip_X_LOWLEVEL(void)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
void Rotate_180_deg_LOWLEVEL(void)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
void Tempo_jauge(byte Vitesse)
//Boucle d'attente pour faire bouger les scrollbars à une vitesse correcte
{
while (Vitesse!=0)
{
Wait_VBL();
Vitesse--;
}
while (Vitesse!=0)
{
Wait_VBL();
Vitesse--;
}
}
byte Meilleure_couleur_sans_exclusion(byte Rouge,byte Vert,byte Bleu)
{
UNIMPLEMENTED
return 0;
UNIMPLEMENTED
return 0;
}
void Set_color(byte Couleur, byte Rouge, byte Vert, byte Bleu)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
void Scroll_picture(short Decalage_X,short Decalage_Y)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
byte Get_key(void)
{
SDL_Event event;
SDL_Event event;
SDL_EnableUNICODE(SDL_ENABLE); // On a besoin du caractère
SDL_EnableUNICODE(SDL_ENABLE); // On a besoin du caractère
while(1)
{
SDL_PollEvent(&event);
if(event.type == SDL_KEYDOWN)
{
// On retourne en mode standard pour la gestion normale
SDL_EnableUNICODE(SDL_DISABLE);
return (byte)(event.key.keysym.unicode);
}
}
while(1)
{
SDL_PollEvent(&event);
if(event.type == SDL_KEYDOWN)
{
// On retourne en mode standard pour la gestion normale
SDL_EnableUNICODE(SDL_DISABLE);
return (byte)(event.key.keysym.unicode);
}
}
}
void Zoomer_une_ligne(byte* Ligne_originale, byte* Ligne_zoomee,
word Facteur, word Largeur
word Facteur, word Largeur
)
{
byte couleur;
word larg;
byte couleur;
word larg;
// Pour chaque pixel
for(larg=0;larg<Largeur;larg++){
couleur = *Ligne_originale;
// Pour chaque pixel
for(larg=0;larg<Largeur;larg++){
couleur = *Ligne_originale;
memset(Ligne_zoomee,couleur,Facteur);
Ligne_zoomee+=Facteur;
memset(Ligne_zoomee,couleur,Facteur);
Ligne_zoomee+=Facteur;
Ligne_originale++;
}
Ligne_originale++;
}
}

10
divers.h
View File

@ -111,7 +111,7 @@ byte Couleur_ILBM_line(word Pos_X, word Vraie_taille_ligne);
// Renvoie la couleur du pixel (ILBM) en Pos_X.
// Gestion du chrono dans les fileselects
void Initialiser_chrono(long Delai);
void Initialiser_chrono(dword Delai);
void Tester_chrono(void);
void Remplacer_une_couleur(byte Ancienne_couleur, byte Nouvelle_couleur);
@ -131,3 +131,11 @@ void Rotate_90_deg_LOWLEVEL(byte * Source,byte * Destination);
void Rotate_180_deg_LOWLEVEL(void);
void Zoomer_une_ligne(byte * Ligne_originale,byte * Ligne_zoomee,word Facteur,word Largeur);
void Copier_une_partie_d_image_dans_une_autre(byte * Source,word S_Pos_X,word S_Pos_Y,word Largeur,word Hauteur,word Largeur_source,byte * Destination,word D_Pos_X,word D_Pos_Y,word Largeur_destination);
// -- Gestion du chrono --
byte Etat_chrono; // Etat du chrono: 0=Attente d'un Xème de seconde
// 1=Il faut afficher la preview
// 2=Plus de chrono à gerer pour l'instant
dword Chrono_delay; // Nombre de 18.2ème de secondes demandés
dword Chrono_cmp; // Heure de départ du chrono
byte Nouvelle_preview; // Booléen "Il faut relancer le chrono de preview"

61
files.c
View File

@ -7,15 +7,24 @@
#include <fcntl.h>
#include <string.h>
#include <dirent.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "linux.h"
#ifdef __linux__
#include "linux.h"
#include <dirent.h>
#define isDir(Enreg) ((Enreg)->d_type == DT_DIR)
#define isHidden(Enreg) ((Enreg)->d_name[0]=='.')
#define isFile(Enreg) (Enreg->d_type==DT_REG)
#elif __WATCOMC__
#include <direct.h>
#define isDir(Enreg) ((Enreg)->d_attr & _A_SUBDIR)
#define isHidden(Enreg) ((Enreg)->d_attr & _A_HIDDEN)
#define isFile(Enreg) ((Enreg)->d_attr & _A_SUBDIR == 0)
#endif
#define COULEUR_FICHIER_NORMAL CM_Clair // Couleur du texte pour une ligne de fichier non sélectionné
#define COULEUR_REPERTOIRE_NORMAL CM_Fonce // Couleur du texte pour une ligne de répertoire non sélectionné
@ -133,19 +142,23 @@ char * Nom_formate(char * Nom)
}
// -- Rajouter … la liste des ‚l‚ments de la liste un ‚l‚ment ---------------
// -- Rajouter a la liste des elements de la liste un element ---------------
void Ajouter_element_a_la_liste(struct dirent* Enreg)
// Cette proc‚dure ajoute … la liste chain‚e un fichier pass‚ en argument.
// Cette procedure ajoute a la liste chainee un fichier pass‚ en argument.
{
// Pointeur temporaire d'insertion
struct Element_de_liste_de_fileselect * Element_temporaire;
// On alloue de la place pour un nouvel ‚l‚ment
// On alloue de la place pour un nouvel element
Element_temporaire=(struct Element_de_liste_de_fileselect *)malloc(sizeof(struct Element_de_liste_de_fileselect));
// On met … jour le nouvel emplacement:
// On met a jour le nouvel emplacement:
strcpy(Element_temporaire->Nom,Nom_formate(Enreg->d_name));
Element_temporaire->Type =(Enreg->d_type == DT_DIR);
#ifdef __linux__
Element_temporaire->Type = (Enreg->d_type == DT_DIR);
#elif __WATCOMC__
Element_temporaire->Type = (Enreg->d_attr & _A_SUBDIR);
#endif
Element_temporaire->Suivant =Liste_du_fileselect;
Element_temporaire->Precedent=NULL;
@ -187,22 +200,22 @@ void Lire_liste_des_fichiers(byte Format_demande)
// Si l'élément n'est pas le répertoire courant
if ( (Enreg->d_name[0]!='.') && (Enreg->d_name[1] != 0))
{
// et que l'élément trouvé est un répertoire
if( (Enreg->d_type == DT_DIR) &&
// et qu'il n'est pas caché
(Enreg->d_name[0]!='.' || Config.Lire_les_repertoires_caches))
{
// On rajoute le répertore à la liste
Ajouter_element_a_la_liste(Enreg);
Liste_Nb_repertoires++;
}
else if ((Enreg->d_type==DT_REG) //Il s'agit d'un fichier
&& (Enreg->d_name[0]!='.' || Config.Lire_les_fichiers_caches)) //Il n'est pas caché
{
// On rajoute le fichier à la liste
Ajouter_element_a_la_liste(Enreg);
Liste_Nb_fichiers++;
}
// et que l'élément trouvé est un répertoire
if( isDir(Enreg) &&
// et qu'il n'est pas caché
((!isHidden(Enreg)) || Config.Lire_les_repertoires_caches))
{
// On rajoute le répertore à la liste
Ajouter_element_a_la_liste(Enreg);
Liste_Nb_repertoires++;
}
else if (isFile(Enreg) //Il s'agit d'un fichier
&& ((!isHidden(Enreg)) || Config.Lire_les_fichiers_caches)) //Il n'est pas caché
{
// On rajoute le fichier à la liste
Ajouter_element_a_la_liste(Enreg);
Liste_Nb_fichiers++;
}
}
// On cherche l'élément suivant

6
global.h
View File

@ -159,7 +159,7 @@ GLOBAL fonction_lecteur Lit_pixel; // Teste la couleur d'un pixel dans l'
GLOBAL fonction_effaceur Clear_screen; // Efface rapidement tout l'écran (en faisant attention de ne pas effacer le menu)
GLOBAL fonction_display Display_screen; // Affiche rapidement tout l'écran (en faisant attention de ne pas effacer le menu)
GLOBAL fonction_block Block; // Affiche rapidement un bloc à l'écran
GLOBAL fonction_block Block_Fast; // Affiche rapidement un bloc à l'écran sans rafraichir
GLOBAL fonction_block Block_Fast; // Affiche rapidement un bloc à l'écran sans rafraichir
GLOBAL fonction_afficheur Pixel_Preview_Normal; // Affiche un point de l'image à l'Úcran en mode normal (pas en mode loupe)
GLOBAL fonction_afficheur Pixel_Preview_Loupe; // Affiche un point de l'image à l'Úcran en mode loupe
GLOBAL fonction_afficheur Pixel_Preview; // Affiche un point de l'image à l'Úcran en fonction de l'Útat du mode loupe
@ -212,6 +212,10 @@ GLOBAL short Principal_Decalage_Y; // D
GLOBAL short Ancien_Principal_Decalage_X;
GLOBAL short Ancien_Principal_Decalage_Y;
#ifdef __WATCOMC__
GLOBAL char Principal_Drive_fichier[2];
#endif
GLOBAL char Principal_Repertoire_fichier[256]; // |_ Nom complet =
GLOBAL char Principal_Nom_fichier[13]; // | Repertoire_fichier+"\"+Nom_fichier
GLOBAL byte Principal_Format_fichier; // Format auquel il faut lire et Úcrire le fichier

238
graph.c
View File

@ -4,7 +4,6 @@
#include <math.h>
#include <malloc.h>
#include <sys/sysinfo.h>
#include <string.h>
#include <stdlib.h>
#include "moteur.h"
@ -14,6 +13,13 @@
#include "struct.h"
#include "erreurs.h"
#ifdef __linux__
#include <sys/sysinfo.h>
#elif __WATCOMC__
#define _WIN32_WINNT 0x0500
#include <windows.h>
#endif
byte Meilleure_couleur(byte R,byte V,byte B)
{
short Coul;
@ -399,10 +405,16 @@ unsigned long Memoire_libre(void)
A revoir, mais est-ce vraiment utile?
_heapmin();
*/
struct sysinfo info;
sysinfo(&info);
return info.freeram*info.mem_unit;
#ifdef __linux__
struct sysinfo info;
sysinfo(&info);
return info.freeram*info.mem_unit;
#elif __WATCOMC__
MEMORYSTATUSEX mstt;
mstt.dwLength = sizeof(MEMORYSTATUSEX);
GlobalMemoryStatusEx(&mstt);
return mstt.ullAvailPhys;
#endif
}
@ -877,7 +889,7 @@ void Initialiser_mode_video(int Numero)
Clear_screen = Effacer_Tout_l_Ecran_SDL;
Display_screen = Afficher_partie_de_l_ecran_SDL;
Block = Block_SDL;
Block_Fast = Block_SDL_Fast;
Block_Fast = Block_SDL_Fast;
Pixel_Preview_Normal = Pixel_Preview_Normal_SDL;
Pixel_Preview_Loupe = Pixel_Preview_Loupe_SDL;
Ligne_horizontale_XOR = Ligne_horizontale_XOR_SDL;
@ -1632,27 +1644,27 @@ void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview)
// Preview: "Il ne faut l'afficher qu'à l'écran"
{
short Debut_X; // Position X (dans l'image) à partir de laquelle on
// affiche la brosse/pinceau
// affiche la brosse/pinceau
short Debut_Y; // Position Y (dans l'image) à partir de laquelle on
// affiche la brosse/pinceau
// affiche la brosse/pinceau
short Largeur; // Largeur dans l'écran selon laquelle on affiche la
// brosse/pinceau
// brosse/pinceau
short Hauteur; // Hauteur dans l'écran selon laquelle on affiche la
// brosse/pinceau
// brosse/pinceau
short Debut_Compteur_X; // Position X (dans la brosse/pinceau) à partir
// de laquelle on affiche la brosse/pinceau
// de laquelle on affiche la brosse/pinceau
short Debut_Compteur_Y; // Position Y (dans la brosse/pinceau) à partir
// de laquelle on affiche la brosse/pinceau
// de laquelle on affiche la brosse/pinceau
short Pos_X; // Position X (dans l'image) en cours d'affichage
short Pos_Y; // Position Y (dans l'image) en cours d'affichage
short Compteur_X; // Position X (dans la brosse/pinceau) en cours
// d'affichage
// d'affichage
short Compteur_Y; // Position Y (dans la brosse/pinceau) en cours
// d'affichage
// d'affichage
short Fin_Compteur_X; // Position X ou s'arrête l'affichade de la
// brosse/pinceau
// brosse/pinceau
short Fin_Compteur_Y; // Position Y ou s'arrête l'affichade de la
// brosse/pinceau
// brosse/pinceau
byte Couleur_temporaire; // Couleur de la brosse en cours d'affichage
int Position;
byte * Temp;
@ -1666,14 +1678,14 @@ void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview)
&& (Pinceau_X<=Limite_Droite)
&& (Pinceau_Y>=Limite_Haut)
&& (Pinceau_Y<=Limite_Bas) )
{
Pixel_Preview(Pinceau_X,Pinceau_Y,Couleur);
SDL_UpdateRect(Ecran_SDL,
Max(Pinceau_X - Principal_Decalage_X,0),
Max(Pinceau_Y - Principal_Decalage_Y,0), 1,1 );
// Attention au zoom !
if(Loupe_Mode) UpdateZoom(X,Y,1,1);
}
{
Pixel_Preview(Pinceau_X,Pinceau_Y,Couleur);
SDL_UpdateRect(Ecran_SDL,
Max(Pinceau_X - Principal_Decalage_X,0),
Max(Pinceau_Y - Principal_Decalage_Y,0), 1,1 );
// Attention au zoom !
if(Loupe_Mode) UpdateZoom(X,Y,1,1);
}
break;
case FORME_PINCEAU_BROSSE_COULEUR : // Brosse en couleur
@ -1692,21 +1704,21 @@ void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview)
{
if ( (Largeur>0) && (Hauteur>0) )
Display_brush_Color(
Debut_X-Principal_Decalage_X,
Debut_Y-Principal_Decalage_Y,
Debut_X-Principal_Decalage_X,
Debut_Y-Principal_Decalage_Y,
Debut_Compteur_X,
Debut_Compteur_Y,
Debut_Compteur_Y,
Largeur,
Hauteur,
Back_color,
Hauteur,
Back_color,
Brosse_Largeur
);
);
if (Loupe_Mode)
{
Calculer_dimensions_clipees_zoom(&Debut_X,&Debut_Y,&Largeur,
&Hauteur
);
&Hauteur
);
Debut_Compteur_X=Debut_X-(X-Brosse_Decalage_X);
Debut_Compteur_Y=Debut_Y-(Y-Brosse_Decalage_Y);
@ -1735,41 +1747,41 @@ void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview)
if (Smear_Debut)
{
if ((Largeur>0) && (Hauteur>0))
{
{
Copier_une_partie_d_image_dans_une_autre(
Principal_Ecran, Debut_X, Debut_Y, Largeur, Hauteur,
Principal_Ecran, Debut_X, Debut_Y, Largeur, Hauteur,
Principal_Largeur_image, Smear_Brosse,
Debut_Compteur_X, Debut_Compteur_Y,
Smear_Brosse_Largeur
);
// UPDATERECT
}
);
// UPDATERECT
}
Smear_Debut=0;
}
else
{
for (Pos_Y = Debut_Y, Compteur_Y = Debut_Compteur_Y;
Compteur_Y < Fin_Compteur_Y;
Pos_Y++, Compteur_Y++
)
Compteur_Y < Fin_Compteur_Y;
Pos_Y++, Compteur_Y++
)
for (Pos_X = Debut_X, Compteur_X = Debut_Compteur_X;
Compteur_X < Fin_Compteur_X;
Pos_X++, Compteur_X++
)
Compteur_X < Fin_Compteur_X;
Pos_X++, Compteur_X++
)
{
Couleur_temporaire = Lit_pixel_dans_ecran_courant(
Pos_X,Pos_Y
);
Pos_X,Pos_Y
);
Position = (Compteur_Y * Smear_Brosse_Largeur)+ Compteur_X;
if ( (Lit_pixel_dans_brosse(Compteur_X,Compteur_Y) != Back_color)
&& (Compteur_Y<Smear_Max_Y) && (Compteur_X<Smear_Max_X)
&& (Compteur_Y>=Smear_Min_Y) && (Compteur_X>=Smear_Min_X) )
Afficher_pixel(Pos_X,Pos_Y,Smear_Brosse[Position]);
Afficher_pixel(Pos_X,Pos_Y,Smear_Brosse[Position]);
Smear_Brosse[Position]=Couleur_temporaire;
}
SDL_UpdateRect(Ecran_SDL,Max(Debut_X,0),Max(Debut_Y,0),
Fin_Compteur_X,Fin_Compteur_Y );
SDL_UpdateRect(Ecran_SDL,Max(Debut_X,0),Max(Debut_Y,0),
Fin_Compteur_X,Fin_Compteur_Y );
}
Smear_Min_X=Debut_Compteur_X;
@ -1795,7 +1807,7 @@ void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview)
Afficher_pixel(Pos_X,Pos_Y,Couleur);
}
}
SDL_UpdateRect(Ecran_SDL, Max(Debut_X,0), Max(Debut_Y,0), Fin_Compteur_X, Fin_Compteur_Y);
SDL_UpdateRect(Ecran_SDL, Max(Debut_X,0), Max(Debut_Y,0), Fin_Compteur_X, Fin_Compteur_Y);
}
break;
@ -1859,7 +1871,7 @@ void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview)
Debut_Compteur_X,
Debut_Compteur_Y,
Smear_Brosse_Largeur);
//UPDATERECT
//UPDATERECT
Smear_Debut=0;
}
else
@ -1876,9 +1888,9 @@ void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview)
Smear_Brosse[Position]=Couleur_temporaire;
}
SDL_UpdateRect(Ecran_SDL,Max(Debut_X,0),Max(Debut_Y,0),
Fin_Compteur_X,Fin_Compteur_Y
);
SDL_UpdateRect(Ecran_SDL,Max(Debut_X,0),Max(Debut_Y,0),
Fin_Compteur_X,Fin_Compteur_Y
);
}
@ -1896,16 +1908,16 @@ void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview)
Afficher_pixel(Pos_X,Pos_Y,Couleur);
}
//ok
SDL_UpdateRect(Ecran_SDL,
Max(Debut_X-Principal_Decalage_X,0),
Max(Debut_Y-Principal_Decalage_Y,0),
Fin_Compteur_X-Debut_Compteur_X,Fin_Compteur_Y-Debut_Compteur_Y
);
DEBUG("X",Debut_X-Principal_Decalage_X);
DEBUG("Y",Debut_Y-Principal_Decalage_Y);
DEBUG("W",Fin_Compteur_X-Debut_Compteur_X);
DEBUG("H",Fin_Compteur_Y-Debut_Compteur_Y);
if(Loupe_Mode) UpdateZoom(Debut_X,Debut_Y,Fin_Compteur_X-Debut_Compteur_X,Fin_Compteur_Y-Debut_Compteur_Y);
SDL_UpdateRect(Ecran_SDL,
Max(Debut_X-Principal_Decalage_X,0),
Max(Debut_Y-Principal_Decalage_Y,0),
Fin_Compteur_X-Debut_Compteur_X,Fin_Compteur_Y-Debut_Compteur_Y
);
DEBUG("X",Debut_X-Principal_Decalage_X);
DEBUG("Y",Debut_Y-Principal_Decalage_Y);
DEBUG("W",Fin_Compteur_X-Debut_Compteur_X);
DEBUG("H",Fin_Compteur_Y-Debut_Compteur_Y);
if(Loupe_Mode) UpdateZoom(Debut_X,Debut_Y,Fin_Compteur_X-Debut_Compteur_X,Fin_Compteur_Y-Debut_Compteur_Y);
}
}
break;
@ -1974,7 +1986,7 @@ void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview)
Debut_Compteur_X,
Debut_Compteur_Y,
Smear_Brosse_Largeur);
// UPDATERECT
// UPDATERECT
Smear_Debut=0;
}
else
@ -1992,9 +2004,9 @@ void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview)
}
}
SDL_UpdateRect(Ecran_SDL,Debut_X,Debut_Y,
Fin_Compteur_X,Fin_Compteur_Y
);
SDL_UpdateRect(Ecran_SDL,Debut_X,Debut_Y,
Fin_Compteur_X,Fin_Compteur_Y
);
Smear_Min_X=Debut_Compteur_X;
Smear_Min_Y=Debut_Compteur_Y;
@ -2010,21 +2022,21 @@ void Afficher_pinceau(short X,short Y,byte Couleur,byte Preview)
Afficher_pixel(Pos_X,Pos_Y,Couleur);
}
// Ceci est testé et fonctionne :)
if(Fin_Compteur_X-Debut_Compteur_X > 0
&& Fin_Compteur_Y - Debut_Compteur_Y > 0)
{
SDL_UpdateRect(Ecran_SDL,
Max(Debut_X-Principal_Decalage_X,1),
Max(Debut_Y-Principal_Decalage_Y,1),
Fin_Compteur_X-Debut_Compteur_X,
Fin_Compteur_Y-Debut_Compteur_Y
);
if(Fin_Compteur_X-Debut_Compteur_X > 0
&& Fin_Compteur_Y - Debut_Compteur_Y > 0)
{
SDL_UpdateRect(Ecran_SDL,
Max(Debut_X-Principal_Decalage_X,1),
Max(Debut_Y-Principal_Decalage_Y,1),
Fin_Compteur_X-Debut_Compteur_X,
Fin_Compteur_Y-Debut_Compteur_Y
);
if(Loupe_Mode)
UpdateZoom(Debut_X,Debut_Y,
Fin_Compteur_X-Debut_Compteur_X,
Fin_Compteur_Y-Debut_Compteur_Y);
}
if(Loupe_Mode)
UpdateZoom(Debut_X,Debut_Y,
Fin_Compteur_X-Debut_Compteur_X,
Fin_Compteur_Y-Debut_Compteur_Y);
}
}
}
}
@ -2036,21 +2048,21 @@ void Effacer_pinceau(short X,short Y)
// X,Y: position du centre du pinceau
{
short Debut_X; // Position X (dans l'image) à partir de laquelle on
// affiche la brosse/pinceau
// affiche la brosse/pinceau
short Debut_Y; // Position Y (dans l'image) à partir de laquelle on
// affiche la brosse/pinceau
// affiche la brosse/pinceau
short Largeur; // Largeur dans l'écran selon laquelle on affiche la
// brosse/pinceau
// brosse/pinceau
short Hauteur; // Hauteur dans l'écran selon laquelle on affiche la
// brosse/pinceau
// brosse/pinceau
short Debut_Compteur_X; // Position X (dans la brosse/pinceau) à partir
// de laquelle on affiche la brosse/pinceau
// de laquelle on affiche la brosse/pinceau
short Debut_Compteur_Y; // Position Y (dans la brosse/pinceau) à partir
// de laquelle on affiche la brosse/pinceau
// de laquelle on affiche la brosse/pinceau
//short Pos_X; // Position X (dans l'image) en cours d'affichage
//short Pos_Y; // Position Y (dans l'image) en cours d'affichage
//short Compteur_X; // Position X (dans la brosse/pinceau) en cours
//d'affichage
//d'affichage
//short Compteur_Y; // Position Y (dans la brosse/pinceau) en cours d'affichage
short Fin_Compteur_X; // Position X ou s'arrête l'affichade de la brosse/pinceau
short Fin_Compteur_Y; // Position Y ou s'arrête l'affichade de la brosse/pinceau
@ -2066,8 +2078,8 @@ void Effacer_pinceau(short X,short Y)
&& (Pinceau_Y<=Limite_Bas) )
{
Pixel_Preview(Pinceau_X,Pinceau_Y,Lit_pixel_dans_ecran_courant(Pinceau_X,Pinceau_Y));
SDL_UpdateRect(Ecran_SDL,Max(Pinceau_X-Principal_Decalage_X,0),Max(Pinceau_Y-Principal_Decalage_Y,0),1,1);
if(Loupe_Mode) UpdateZoom(Pinceau_X,Pinceau_Y,1,1);
SDL_UpdateRect(Ecran_SDL,Max(Pinceau_X-Principal_Decalage_X,0),Max(Pinceau_Y-Principal_Decalage_Y,0),1,1);
if(Loupe_Mode) UpdateZoom(Pinceau_X,Pinceau_Y,1,1);
}
break;
case FORME_PINCEAU_BROSSE_COULEUR : // Brosse en couleur
@ -2271,7 +2283,7 @@ void Afficher_curseur(void)
}
}
SDL_UpdateRect(Ecran_SDL,Max(Debut_X,0),Max(Debut_Y,0),16,16);
SDL_UpdateRect(Ecran_SDL,Max(Debut_X,0),Max(Debut_Y,0),16,16);
}
}
break;
@ -2337,7 +2349,7 @@ void Afficher_curseur(void)
Pixel(Pos_X,Pos_Y,Couleur);
}
}
SDL_UpdateRect(Ecran_SDL,Debut_X,Debut_Y,16,16);
SDL_UpdateRect(Ecran_SDL,Debut_X,Debut_Y,16,16);
}
}
break;
@ -2356,7 +2368,7 @@ void Afficher_curseur(void)
if ( (Pos_X<Largeur_ecran) && (Pos_Y<Hauteur_ecran)
&& (Pos_X>=0) && (Pos_Y>=0) )
{
// On sauvegarde dans FOND_CURSEUR pour restaurer plus tard
// On sauvegarde dans FOND_CURSEUR pour restaurer plus tard
FOND_CURSEUR[Compteur_Y][Compteur_X]=Lit_pixel(Pos_X,Pos_Y);
if (Couleur!=CM_Trans)
Pixel(Pos_X,Pos_Y,Couleur);
@ -2378,12 +2390,12 @@ void Afficher_curseur(void)
if ((Pos_X<Compteur_X) && (Pinceau_X>=Limite_Gauche))
{
Ligne_verticale_XOR(Pinceau_X-Principal_Decalage_X,0,Menu_Ordonnee);
SDL_UpdateRect(Ecran_SDL,Pinceau_X-Principal_Decalage_X,0,1,Menu_Ordonnee);
SDL_UpdateRect(Ecran_SDL,Pinceau_X-Principal_Decalage_X,0,1,Menu_Ordonnee);
}
if (Loupe_Mode)
{
// UPDATERECT
// UPDATERECT
if ((Pinceau_Y>=Limite_Haut_Zoom) && (Pinceau_Y<=Limite_visible_Bas_Zoom))
Ligne_horizontale_XOR_Zoom(Limite_Gauche_Zoom,Pinceau_Y,Loupe_Largeur);
if ((Pinceau_X>=Limite_Gauche_Zoom) && (Pinceau_X<=Limite_visible_Droite_Zoom))
@ -2517,7 +2529,7 @@ void Effacer_curseur(void)
if ( ( (Mouse_Y<Menu_Ordonnee)
&& ( (!Loupe_Mode) || (Mouse_X<Principal_Split)
|| (Mouse_X>=Principal_X_Zoom) ) )
|| (Mouse_X>=Principal_X_Zoom) ) )
|| (Une_fenetre_est_ouverte) || (Forme_curseur==FORME_CURSEUR_SABLIER) )
Forme=Forme_curseur;
else
@ -2546,7 +2558,7 @@ void Effacer_curseur(void)
if (Fin_Y<4)
Ligne_verticale_XOR (Mouse_X,Mouse_Y+3,4-Fin_Y);
SDL_UpdateRect(Ecran_SDL,Debut_X,Debut_Y,Fin_X-Debut_X,Fin_Y-Debut_Y);
SDL_UpdateRect(Ecran_SDL,Debut_X,Debut_Y,Fin_X-Debut_X,Fin_Y-Debut_Y);
}
else
{
@ -2620,7 +2632,7 @@ void Effacer_curseur(void)
if ( (Pos_X>=0) && (Pos_X<Largeur_ecran) && (Pos_Y>=0) && (Pos_Y<Hauteur_ecran) )
Pixel(Pos_X,Pos_Y,FOND_CURSEUR[Compteur_Y][Compteur_X]);
SDL_UpdateRect(Ecran_SDL,Max(Debut_X,0),Max(Debut_Y,0),16,16);
SDL_UpdateRect(Ecran_SDL,Max(Debut_X,0),Max(Debut_Y,0),16,16);
}
}
if (!Cacher_pinceau)
@ -2657,12 +2669,12 @@ void Effacer_curseur(void)
if ((Pos_X<Compteur_X) && (Pinceau_X>=Limite_Gauche))
{
Ligne_verticale_XOR(Pinceau_X-Principal_Decalage_X,0,Menu_Ordonnee);
SDL_UpdateRect(Ecran_SDL,Pinceau_X-Principal_Decalage_X,0,1,Menu_Ordonnee);
SDL_UpdateRect(Ecran_SDL,Pinceau_X-Principal_Decalage_X,0,1,Menu_Ordonnee);
}
if (Loupe_Mode)
{
// UPDATERECT
// UPDATERECT
if ((Pinceau_Y>=Limite_Haut_Zoom) && (Pinceau_Y<=Limite_visible_Bas_Zoom))
Ligne_horizontale_XOR_Zoom(Limite_Gauche_Zoom,Pinceau_Y,Loupe_Largeur);
if ((Pinceau_X>=Limite_Gauche_Zoom) && (Pinceau_X<=Limite_visible_Droite_Zoom))
@ -3022,8 +3034,8 @@ void Afficher_pinceau_dans_fenetre(word X,word Y,int Numero)
#define ToWinH(h) ((h)*Menu_Facteur_X)
SDL_UpdateRect(Ecran_SDL, ToWinX(Orig_X), ToWinY(Orig_Y),
ToWinL(Pinceau_predefini_Largeur[Numero]),
ToWinH(Pinceau_predefini_Hauteur[Numero])
ToWinL(Pinceau_predefini_Largeur[Numero]),
ToWinH(Pinceau_predefini_Hauteur[Numero])
);
}
@ -3656,8 +3668,8 @@ void Fill(short * Limite_atteinte_Haut , short * Limite_atteinte_Bas,
{
// On cherche son début
while((Debut_X<=Limite_Droite) &&
(Lit_pixel_dans_ecran_courant(Debut_X,Ligne)!=1))
Debut_X++;
(Lit_pixel_dans_ecran_courant(Debut_X,Ligne)!=1))
Debut_X++;
if (Debut_X<=Limite_Droite)
{
@ -3973,9 +3985,7 @@ void Remplir(byte Couleur_de_remplissage)
{
Pos_X-=Brosse_Decalage_X;
Pos_Y-=Brosse_Decalage_Y;
if ( (Pos_X>=0) &&
(Pos_X<Brosse_Largeur) &&
(Pos_Y>=0) &&
if ( (Pos_X<Brosse_Largeur) && // Les pos sont des word donc jamais < 0 ...
(Pos_Y<Brosse_Hauteur) )
Pixel_dans_brosse(Pos_X,Pos_Y,Couleur);
}
@ -4040,7 +4050,7 @@ void Tracer_cercle_vide_General(short Centre_X,short Centre_Y,short Rayon,byte C
Pixel_figure(Centre_X,Centre_Y+Rayon,Couleur); // Bas
SDL_UpdateRect(Ecran_SDL,Max(Centre_X-Rayon-Principal_Decalage_X,0),
Max(Centre_Y-Rayon-Principal_Decalage_Y,0),2*Rayon+1,2*Rayon+1);
Max(Centre_Y-Rayon-Principal_Decalage_Y,0),2*Rayon+1,2*Rayon+1);
if(Loupe_Mode) UpdateZoom(Centre_X-Rayon,Centre_Y-Rayon,2*Rayon+1,2*Rayon+1);
}
@ -4101,7 +4111,7 @@ void Tracer_cercle_plein(short Centre_X,short Centre_Y,short Rayon,byte Couleur)
Afficher_pixel(Pos_X,Pos_Y,Couleur);
SDL_UpdateRect(Ecran_SDL,Max(Debut_X+Principal_Decalage_X,0),
Max(Debut_Y+Principal_Decalage_Y,0),Fin_X+1-Debut_X,Fin_Y+1-Debut_Y);
Max(Debut_Y+Principal_Decalage_Y,0),Fin_X+1-Debut_X,Fin_Y+1-Debut_Y);
if(Loupe_Mode) UpdateZoom(Debut_X,Debut_Y,Fin_X+1-Debut_X,Fin_Y+1-Debut_Y);
}
@ -4421,10 +4431,10 @@ void Tracer_rectangle_plein(short Debut_X,short Debut_Y,short Fin_X,short Fin_Y,
// Donc on ne peut pas otimiser en traçant ligne par ligne avec memset :(
Afficher_pixel(Pos_X,Pos_Y,Couleur);
SDL_UpdateRect(Ecran_SDL,
Debut_X-Principal_Decalage_X,
Debut_Y-Principal_Decalage_Y,
Fin_X-Debut_X,
Fin_Y-Debut_Y);
Debut_X-Principal_Decalage_X,
Debut_Y-Principal_Decalage_Y,
Fin_X-Debut_X,
Fin_Y-Debut_Y);
if(Loupe_Mode) UpdateZoom(Debut_X,Debut_Y,Fin_X-Debut_X,Fin_Y-Debut_Y);
}
@ -5050,7 +5060,7 @@ void Polyfill_General(int Vertices, short * Points, int Color)
if (edge->bottom > bottom)
bottom = edge->bottom;
inactive_edges = add_edge(inactive_edges, edge, 0);
inactive_edges = add_edge(inactive_edges, edge, 0);
edge++;
}
}

163
init.c
View File

@ -21,8 +21,11 @@
#include "divers.h"
#include "errno.h"
#include <endian.h>
#include <byteswap.h>
#ifdef __linux__
#include <endian.h>
#include <byteswap.h>
#endif
// On déclare méchamment le prototype de Erreur pour éviter de faire un
// fichier "main.h":
@ -244,24 +247,26 @@ void Charger_DAT(void)
strcat(Nom_du_fichier,"gfx2.dat");
if(stat(Nom_du_fichier,&Informations_Fichier))
switch errno
{
case EACCES: puts("La permission de parcours est refusée pour un des répertoires contenu dans le chemin path."); break;
case EBADF: puts("filedes est un mauvais descripteur."); break;
case EFAULT: puts("Un pointeur se trouve en dehors de l'espace d'adressage."); break;
case ELOOP: puts("Trop de liens symboliques rencontrés dans le chemin d'accès."); break;
case ENAMETOOLONG: puts("Nom de fichier trop long."); break;
case ENOENT: puts("Un composant du chemin path n'existe pas, ou il s'agit d'une chaîne vide."); break;
case ENOMEM: puts("Pas assez de mémoire pour le noyau."); break;
case ENOTDIR: puts("Un composant du chemin d'accès n'est pas un répertoire."); break;
}
switch errno
{
case EACCES: puts("La permission de parcours est refusée pour un des répertoires contenu dans le chemin path."); break;
case EBADF: puts("filedes est un mauvais descripteur."); break;
case EFAULT: puts("Un pointeur se trouve en dehors de l'espace d'adressage."); break;
case ENAMETOOLONG: puts("Nom de fichier trop long."); break;
case ENOENT: puts("Un composant du chemin path n'existe pas, ou il s'agit d'une chaîne vide."); break;
case ENOMEM: puts("Pas assez de mémoire pour le noyau."); break;
case ENOTDIR: puts("Un composant du chemin d'accès n'est pas un répertoire."); break;
#ifdef __linux__
case ELOOP: puts("Trop de liens symboliques rencontrés dans le chemin d'accès."); break;
#endif
}
Taille_fichier=Informations_Fichier.st_size;
if (Taille_fichier!=TAILLE_FICHIER_DATA)
Erreur(ERREUR_DAT_CORROMPU);
Handle=open(Nom_du_fichier,O_RDONLY);
if (Handle==-1)
Erreur(ERREUR_DAT_ABSENT);
Handle=open(Nom_du_fichier,O_RDONLY);
if (Handle==-1)
Erreur(ERREUR_DAT_ABSENT);
if (read(Handle,Palette_defaut,sizeof(T_Palette))!=sizeof(T_Palette))
Erreur(ERREUR_DAT_CORROMPU);
@ -345,10 +350,11 @@ void Charger_DAT(void)
// On lit le nombre de lignes:
if (read(Handle,&Mot_temporaire,2)!=2)
Erreur(ERREUR_DAT_CORROMPU);
#if __BYTE_ORDER == __BIG_ENDIAN
//Si on est en big endian il faut échanger les octets car la structure est prévue pour du x86.
Mot_temporaire=bswap_16(Mot_temporaire);
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
//Si on est en big endian il faut échanger les octets car la structure est prévue pour du x86.
Mot_temporaire=bswap_16(Mot_temporaire);
#endif
#endif
// On copie ce nombre de lignes dans la table:
@ -357,10 +363,11 @@ void Charger_DAT(void)
// On lit la place que la section prend en mémoire:
if (read(Handle,&Mot_temporaire,2)!=2)
Erreur(ERREUR_DAT_CORROMPU);
#if __BYTE_ORDER == __BIG_ENDIAN
//Si on est en big endian il faut échanger les octets car la structure est prévue pour du x86.
Mot_temporaire=bswap_16(Mot_temporaire);
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
//Si on est en big endian il faut échanger les octets car la structure est prévue pour du x86.
Mot_temporaire=bswap_16(Mot_temporaire);
#endif
#endif
// On alloue la mémoire correspondante:
@ -762,7 +769,7 @@ void Initialisation_des_boutons(void)
69,19,
15,15,
FORME_BOUTON_TRIANGLE_BAS_DROITE,
Bouton_Cercle_plein,Bouton_Ellipse_pleine,
Bouton_Cercle_plein,Bouton_Ellipse_pleine,
Rien_du_tout,
FAMILLE_OUTIL);
@ -819,13 +826,13 @@ void Initialisation_des_boutons(void)
Initialiser_bouton(BOUTON_EFFETS_BROSSE,
106,18,
16,16,
FORME_BOUTON_RECTANGLE,
FORME_BOUTON_RECTANGLE,
Bouton_Brush_FX,Bouton_Brush_FX,
Rien_du_tout,
FAMILLE_INSTANTANE);
Initialiser_bouton(BOUTON_EFFETS,
123,1,
123,1,
16,16,
FORME_BOUTON_RECTANGLE,
Bouton_Effets,Bouton_Effets,
@ -1797,10 +1804,12 @@ int Charger_CFG(int Tout_charger)
// - Lecture des infos contenues dans le fichier de config -
while (read(Handle,&(Chunk.Numero),sizeof(byte))==sizeof(byte))
{
read(Handle,&(Chunk.Taille),sizeof(word));
#if __BYTE_ORDER == __BIG_ENDIAN
Chunk.Taille=bswap_16(Chunk.Taille);
#endif
read(Handle,&(Chunk.Taille),sizeof(word));
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
Chunk.Taille=bswap_16(Chunk.Taille);
#endif
#endif
switch (Chunk.Numero)
{
case CHUNK_TOUCHES: // Touches
@ -1814,27 +1823,29 @@ int Charger_CFG(int Tout_charger)
goto Erreur_lecture_config;
else
{
#if __BYTE_ORDER == __BIG_ENDIAN
CFG_Infos_touche.Touche=bswap_16(CFG_Infos_touche.Touche);
CFG_Infos_touche.Touche2=bswap_16(CFG_Infos_touche.Touche2);
CFG_Infos_touche.Numero=bswap_16(CFG_Infos_touche.Numero);
#endif
for (Indice2=0;
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
CFG_Infos_touche.Touche=bswap_16(CFG_Infos_touche.Touche);
CFG_Infos_touche.Touche2=bswap_16(CFG_Infos_touche.Touche2);
CFG_Infos_touche.Numero=bswap_16(CFG_Infos_touche.Numero);
#endif
#endif
for (Indice2=0;
((Indice2<NB_TOUCHES) && (Numero_option[Indice2]!=CFG_Infos_touche.Numero));
Indice2++);
if (Indice2<NB_TOUCHES)
{
if (Indice2<NB_TOUCHES)
{
switch(Ordonnancement[Indice2]>>8)
{
case 0 :
Config_Touche[Ordonnancement[Indice2]&0xFF]=CFG_Infos_touche.Touche;
break;
Config_Touche[Ordonnancement[Indice2]&0xFF]=CFG_Infos_touche.Touche;
break;
case 1 :
Bouton[Ordonnancement[Indice2]&0xFF].Raccourci_gauche = CFG_Infos_touche.Touche;
break;
Bouton[Ordonnancement[Indice2]&0xFF].Raccourci_gauche = CFG_Infos_touche.Touche;
break;
case 2 :
Bouton[Ordonnancement[Indice2]&0xFF].Raccourci_droite = CFG_Infos_touche.Touche;
break;
Bouton[Ordonnancement[Indice2]&0xFF].Raccourci_droite = CFG_Infos_touche.Touche;
break;
}
}
else
@ -1853,8 +1864,8 @@ int Charger_CFG(int Tout_charger)
goto Erreur_lecture_config;
for (Indice=1; Indice<=NB_MODES_VIDEO; Indice++)
{
read(Handle,&(CFG_Mode_video.Etat),1);
read(Handle,&(CFG_Mode_video.Largeur),2);
read(Handle,&(CFG_Mode_video.Etat),1);
read(Handle,&(CFG_Mode_video.Largeur),2);
if (read(Handle,&(CFG_Mode_video.Hauteur),2)!=2)
goto Erreur_lecture_config;
else
@ -1921,15 +1932,15 @@ int Charger_CFG(int Tout_charger)
{
if (read(Handle,&Degrade_Courant,1)!=1)
goto Erreur_lecture_config;
for(Indice=0;Indice<16;Indice++)
{
read(Handle,&(Degrade_Tableau[Indice].Debut),1);
read(Handle,&(Degrade_Tableau[Indice].Fin),1);
read(Handle,&(Degrade_Tableau[Indice].Inverse),4);
read(Handle,&(Degrade_Tableau[Indice].Melange),4);
if (read(Handle,&(Degrade_Tableau[Indice]).Technique,4)!=4)
goto Erreur_lecture_config;
}
for(Indice=0;Indice<16;Indice++)
{
read(Handle,&(Degrade_Tableau[Indice].Debut),1);
read(Handle,&(Degrade_Tableau[Indice].Fin),1);
read(Handle,&(Degrade_Tableau[Indice].Inverse),4);
read(Handle,&(Degrade_Tableau[Indice].Melange),4);
if (read(Handle,&(Degrade_Tableau[Indice]).Technique,4)!=4)
goto Erreur_lecture_config;
}
Degrade_Charger_infos_du_tableau(Degrade_Courant);
}
else
@ -2025,10 +2036,12 @@ int Sauver_CFG(void)
// Enregistrement des touches
Chunk.Numero=CHUNK_TOUCHES;
Chunk.Taille=NB_TOUCHES*sizeof(CFG_Infos_touche);
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
//On remet les octets dans l'ordre "normal"
Chunk.Taille=bswap_16(Chunk.Taille);
#endif
#endif
if (write(Handle,&(Chunk.Numero),sizeof(byte))!=sizeof(byte)||write(Handle,&(Chunk.Taille),sizeof(word))!=sizeof(word))
goto Erreur_sauvegarde_config;
for (Indice=0; Indice<NB_TOUCHES; Indice++)
@ -2041,10 +2054,12 @@ int Sauver_CFG(void)
case 2 : CFG_Infos_touche.Touche=Bouton[Ordonnancement[Indice]&0xFF].Raccourci_droite; break;
}
CFG_Infos_touche.Touche2=0x00FF;
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
CFG_Infos_touche.Touche=bswap_16(CFG_Infos_touche.Touche);
CFG_Infos_touche.Touche2=bswap_16(CFG_Infos_touche.Touche2);
CFG_Infos_touche.Numero=bswap_16(CFG_Infos_touche.Numero);
CFG_Infos_touche.Touche=bswap_16(CFG_Infos_touche.Touche);
CFG_Infos_touche.Touche2=bswap_16(CFG_Infos_touche.Touche2);
CFG_Infos_touche.Numero=bswap_16(CFG_Infos_touche.Numero);
#endif
#endif
if (write(Handle,&CFG_Infos_touche,sizeof(CFG_Infos_touche))!=sizeof(CFG_Infos_touche))
goto Erreur_sauvegarde_config;
@ -2053,10 +2068,12 @@ int Sauver_CFG(void)
// Sauvegarde de l'état de chaque mode vidéo
Chunk.Numero=CHUNK_MODES_VIDEO;
Chunk.Taille=NB_MODES_VIDEO*5 /*sizeof(CFG_Mode_video)*/;
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
//On remet les octets dans l'ordre "normal"
Chunk.Taille=bswap_16(Chunk.Taille);
#endif
#endif
if (write(Handle,&(Chunk.Numero),sizeof(byte))!=sizeof(byte)||write(Handle,&(Chunk.Taille),sizeof(word))!=sizeof(word))
goto Erreur_sauvegarde_config;
for (Indice=0; Indice<NB_MODES_VIDEO; Indice++)
@ -2071,10 +2088,12 @@ int Sauver_CFG(void)
// Ecriture des données du Shade (précédées du shade en cours)
Chunk.Numero=CHUNK_SHADE;
Chunk.Taille=sizeof(Shade_Liste)+sizeof(Shade_Actuel);
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
//On remet les octets dans l'ordre "normal"
Chunk.Taille=bswap_16(Chunk.Taille);
#endif
#endif
if (write(Handle,&(Chunk.Numero),sizeof(byte))!=sizeof(byte)||write(Handle,&(Chunk.Taille),sizeof(word))!=sizeof(word))
goto Erreur_sauvegarde_config;
if (write(Handle,&Shade_Actuel,sizeof(Shade_Actuel))!=sizeof(Shade_Actuel))
@ -2085,10 +2104,12 @@ int Sauver_CFG(void)
// Sauvegarde des informations du Masque
Chunk.Numero=CHUNK_MASQUE;
Chunk.Taille=sizeof(Mask);
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
//On remet les octets dans l'ordre "normal"
Chunk.Taille=bswap_16(Chunk.Taille);
#endif
#endif
if (write(Handle,&(Chunk.Numero),sizeof(byte))!=sizeof(byte)||write(Handle,&(Chunk.Taille),sizeof(word))!=sizeof(word))
goto Erreur_sauvegarde_config;
if (write(Handle,Mask,sizeof(Mask))!=sizeof(Mask))
@ -2097,10 +2118,12 @@ int Sauver_CFG(void)
// Sauvegarde des informations du Stencil
Chunk.Numero=CHUNK_STENCIL;
Chunk.Taille=sizeof(Stencil);
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
//On remet les octets dans l'ordre "normal"
Chunk.Taille=bswap_16(Chunk.Taille);
#endif
#endif
if (write(Handle,&(Chunk.Numero),sizeof(byte))!=sizeof(byte)||write(Handle,&(Chunk.Taille),sizeof(word))!=sizeof(word))
goto Erreur_sauvegarde_config;
if (write(Handle,Stencil,sizeof(Stencil))!=sizeof(Stencil))
@ -2109,10 +2132,12 @@ int Sauver_CFG(void)
// Sauvegarde des informations des dégradés
Chunk.Numero=CHUNK_DEGRADES;
Chunk.Taille=sizeof(Degrade_Tableau)+1;
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
//On remet les octets dans l'ordre "normal"
Chunk.Taille=bswap_16(Chunk.Taille);
#endif
#endif
if (write(Handle,&(Chunk.Numero),sizeof(byte))!=sizeof(byte)||write(Handle,&(Chunk.Taille),sizeof(word))!=sizeof(word))
goto Erreur_sauvegarde_config;
if (write(Handle,&Degrade_Courant,1)!=1)
@ -2120,20 +2145,22 @@ int Sauver_CFG(void)
for(Indice=0;Indice<16;Indice++)
{
if (write(Handle,&(Degrade_Tableau[Indice].Debut),1)!=1 ||
write(Handle,&(Degrade_Tableau[Indice].Fin),1)!=1 ||
write(Handle,&(Degrade_Tableau[Indice].Inverse),4)!=4 ||
write(Handle,&(Degrade_Tableau[Indice].Melange),4)!=4 ||
write(Handle,&(Degrade_Tableau[Indice].Technique),4)!=4 )
goto Erreur_sauvegarde_config;
write(Handle,&(Degrade_Tableau[Indice].Fin),1)!=1 ||
write(Handle,&(Degrade_Tableau[Indice].Inverse),4)!=4 ||
write(Handle,&(Degrade_Tableau[Indice].Melange),4)!=4 ||
write(Handle,&(Degrade_Tableau[Indice].Technique),4)!=4 )
goto Erreur_sauvegarde_config;
}
// Sauvegarde de la matrice du Smooth
Chunk.Numero=CHUNK_SMOOTH;
Chunk.Taille=sizeof(Smooth_Matrice);
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
//On remet les octets dans l'ordre "normal"
Chunk.Taille=bswap_16(Chunk.Taille);
#endif
#endif
if (write(Handle,&(Chunk.Numero),sizeof(byte))!=sizeof(byte)||write(Handle,&(Chunk.Taille),sizeof(word))!=sizeof(word))
goto Erreur_sauvegarde_config;
if (write(Handle,Smooth_Matrice,sizeof(Smooth_Matrice))!=sizeof(Smooth_Matrice))
@ -2142,10 +2169,12 @@ int Sauver_CFG(void)
// Sauvegarde des couleurs à exclure
Chunk.Numero=CHUNK_EXCLUDE_COLORS;
Chunk.Taille=sizeof(Exclude_color);
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
//On remet les octets dans l'ordre "normal"
Chunk.Taille=bswap_16(Chunk.Taille);
#endif
#endif
if (write(Handle,&(Chunk.Numero),sizeof(byte))!=sizeof(byte)||write(Handle,&(Chunk.Taille),sizeof(word))!=sizeof(word))
goto Erreur_sauvegarde_config;
if (write(Handle,Exclude_color,sizeof(Exclude_color))!=sizeof(Exclude_color))
@ -2154,10 +2183,12 @@ int Sauver_CFG(void)
// Sauvegarde des informations du Quick-shade
Chunk.Numero=CHUNK_QUICK_SHADE;
Chunk.Taille=sizeof(Quick_shade_Step)+sizeof(Quick_shade_Loop);
#ifndef __WATCOMC__
#if __BYTE_ORDER == __BIG_ENDIAN
//On remet les octets dans l'ordre "normal"
Chunk.Taille=bswap_16(Chunk.Taille);
#endif
#endif
if (write(Handle,&(Chunk.Numero),sizeof(byte))!=sizeof(byte)||write(Handle,&(Chunk.Taille),sizeof(word))!=sizeof(word))
goto Erreur_sauvegarde_config;
if (write(Handle,&Quick_shade_Step,sizeof(Quick_shade_Step))!=sizeof(Quick_shade_Step))
@ -2234,7 +2265,3 @@ void Initialiser_la_table_precalculee_des_distances_de_couleur(void)
}
}
}
#include "readini.c"
#include "saveini.c"

2
linux.h
View File

@ -10,5 +10,3 @@ int filelength(int);
void itoa(int source,char* dest, int longueur);
/* Integer TO Ascii */
#define _A_SUBDIR 1

102
loadsave.c
View File

@ -16,7 +16,9 @@
#include <unistd.h>
#include "boutons.h"
#include "linux.h"
#ifdef __linux__
#include "linux.h"
#endif
// On déclare méchamment le prototype de Erreur pour éviter de faire un
// fichier "main.h":
@ -323,7 +325,7 @@ void Nom_fichier_complet(char * Nom_du_fichier, byte Sauve_Colorix)
//On va ajouter un / à la fin du chemin s'il n'y est pas encore
//Attention sous windows il faut un \...
if (Nom_du_fichier[strlen(Nom_du_fichier)-1]!='/')
strcat(Nom_du_fichier,"/");
strcat(Nom_du_fichier,"/");
// Si on est en train de sauvegarder une image Colorix, on calcule son ext.
if (Sauve_Colorix)
@ -695,9 +697,9 @@ void Save_PAL(void)
close(Fichier);
remove(Nom_du_fichier);
// On se fout du résultat de l'opération car si ‡a
// renvoie 0 c'est que le fichier avait été partiel-
// -lement écrit, sinon pas du tout. Or dans tous les
// cas ‡a revient au mˆme pour nous: Sauvegarde ratée!
// renvoie 0 c'est que le fichier avait été partiel-
// -lement écrit, sinon pas du tout. Or dans tous les
// cas ‡a revient au mˆme pour nous: Sauvegarde ratée!
}
}
@ -901,15 +903,15 @@ void Test_PKM(void)
{
char Ident[3]; // ChaŒne "PKM" }
byte Methode; // Méthode de compression:
// 0 = compression en ligne (c)KM
// autres = inconnues pour le moment
// 0 = compression en ligne (c)KM
// autres = inconnues pour le moment
byte Recon1; // Octet de reconnaissance sur 1 octet }
byte Recon2; // Octet de reconnaissance sur 2 octets }
word Largeur; // Largeur de l'image
word Hauteur; // Hauteur de l'image
T_Palette Palette; // Palette RVB 256*3
word Jump; // Taille du saut entre le header et l'image:
// On va s'en servir pour rajouter un commentaire
// On va s'en servir pour rajouter un commentaire
} Head;
@ -1160,8 +1162,8 @@ void Load_PKM(void)
for (Indice=1;Indice<=255;Indice++)
if (Find_recon[Indice]<NBest)
{
Best=Indice;
NBest=Find_recon[Indice];
Best=Indice;
NBest=Find_recon[Indice];
}
*Recon1=Best;
@ -1172,8 +1174,8 @@ void Load_PKM(void)
for (Indice=0;Indice<=255;Indice++)
if ( (Find_recon[Indice]<NBest) && (Indice!=*Recon1) )
{
Best=Indice;
NBest=Find_recon[Indice];
Best=Indice;
NBest=Find_recon[Indice];
}
*Recon2=Best;
}
@ -1187,15 +1189,15 @@ void Save_PKM(void)
{
char Ident[3]; // ChaŒne "PKM" }
byte Methode; // Méthode de compression:
// 0 = compression en ligne (c)KM
// autres = inconnues pour le moment
// 0 = compression en ligne (c)KM
// autres = inconnues pour le moment
byte Recon1; // Octet de reconnaissance sur 1 octet }
byte Recon2; // Octet de reconnaissance sur 2 octets }
word Largeur; // Largeur de l'image
word Hauteur; // Hauteur de l'image
T_Palette Palette; // Palette RVB 256*3
word Jump; // Taille du saut entre le header et l'image:
// On va s'en servir pour rajouter un commentaire
// On va s'en servir pour rajouter un commentaire
} Head;
dword Compteur_de_pixels;
dword Taille_image;
@ -1270,52 +1272,52 @@ void Save_PKM(void)
&& (Compteur_de_pixels<Taille_image)
&& (Compteur_de_repetitions<65535) )
{
Compteur_de_repetitions++;
Compteur_de_pixels++;
Compteur_de_repetitions++;
Compteur_de_pixels++;
Valeur_pixel=Lit_pixel_de_sauvegarde(Compteur_de_pixels % Principal_Largeur_image,Compteur_de_pixels / Principal_Largeur_image);
}
if ( (Derniere_couleur!=Head.Recon1) && (Derniere_couleur!=Head.Recon2) )
{
if (Compteur_de_repetitions==1)
if (Compteur_de_repetitions==1)
Ecrire_octet(Fichier,Derniere_couleur);
else
if (Compteur_de_repetitions==2)
{
Ecrire_octet(Fichier,Derniere_couleur);
Ecrire_octet(Fichier,Derniere_couleur);
}
if (Compteur_de_repetitions==2)
{
Ecrire_octet(Fichier,Derniere_couleur);
Ecrire_octet(Fichier,Derniere_couleur);
}
else
if ( (Compteur_de_repetitions>2) && (Compteur_de_repetitions<256) )
{ // RECON1/couleur/nombre
Ecrire_octet(Fichier,Head.Recon1);
Ecrire_octet(Fichier,Derniere_couleur);
Ecrire_octet(Fichier,Compteur_de_repetitions&0xFF);
}
if ( (Compteur_de_repetitions>2) && (Compteur_de_repetitions<256) )
{ // RECON1/couleur/nombre
Ecrire_octet(Fichier,Head.Recon1);
Ecrire_octet(Fichier,Derniere_couleur);
Ecrire_octet(Fichier,Compteur_de_repetitions&0xFF);
}
else
if (Compteur_de_repetitions>=256)
{ // RECON2/couleur/hi(nombre)/lo(nombre)
Ecrire_octet(Fichier,Head.Recon2);
Ecrire_octet(Fichier,Derniere_couleur);
Ecrire_octet(Fichier,Compteur_de_repetitions>>8);
Ecrire_octet(Fichier,Compteur_de_repetitions&0xFF);
}
if (Compteur_de_repetitions>=256)
{ // RECON2/couleur/hi(nombre)/lo(nombre)
Ecrire_octet(Fichier,Head.Recon2);
Ecrire_octet(Fichier,Derniere_couleur);
Ecrire_octet(Fichier,Compteur_de_repetitions>>8);
Ecrire_octet(Fichier,Compteur_de_repetitions&0xFF);
}
}
else
{
if (Compteur_de_repetitions<256)
if (Compteur_de_repetitions<256)
{
Ecrire_octet(Fichier,Head.Recon1);
Ecrire_octet(Fichier,Derniere_couleur);
Ecrire_octet(Fichier,Compteur_de_repetitions&0xFF);
}
else
{
Ecrire_octet(Fichier,Head.Recon2);
Ecrire_octet(Fichier,Derniere_couleur);
Ecrire_octet(Fichier,Compteur_de_repetitions>>8);
Ecrire_octet(Fichier,Compteur_de_repetitions&0xFF);
}
Ecrire_octet(Fichier,Head.Recon1);
Ecrire_octet(Fichier,Derniere_couleur);
Ecrire_octet(Fichier,Compteur_de_repetitions&0xFF);
}
else
{
Ecrire_octet(Fichier,Head.Recon2);
Ecrire_octet(Fichier,Derniere_couleur);
Ecrire_octet(Fichier,Compteur_de_repetitions>>8);
Ecrire_octet(Fichier,Compteur_de_repetitions&0xFF);
}
}
}
@ -1887,7 +1889,7 @@ void Load_LBM(void)
if (LBM_Mode_repetition)
{
Ecrire_octet(LBM_Fichier,257-LBM_Taille_de_file);
Ecrire_octet(LBM_Fichier,LBM_File_de_couleurs[0]);
Ecrire_octet(LBM_Fichier,LBM_File_de_couleurs[0]);
}
else
{
@ -1927,7 +1929,7 @@ void Load_LBM(void)
// On conserve le mode...
{
LBM_File_de_couleurs[LBM_Taille_de_file]=Couleur;
LBM_Taille_de_file++;
LBM_Taille_de_file++;
if (LBM_Taille_de_file==128)
Transferer_couleurs();
}

30
main.c
View File

@ -16,13 +16,21 @@
#include <time.h>
#include <SDL/SDL.h>
#include <unistd.h>
#include "linux.h" //Fichier avec diverses fonctions qui existaient sous dos mais pas sous linux...
#include "pages.h"
#include "files.h"
#include "loadsave.h"
#include "sdlscreen.h"
#include "erreurs.h"
#ifdef __linux__
#include "linux.h" //Fichier avec diverses fonctions qui existaient sous dos mais pas sous linux...
#elif __WATCOMC__
#include <windows.h>
#include <shlwapi.h>
#define chdir(dir) SetCurrentDirectory(dir)
#define M_PI 3.14159265358979323846
#endif
byte Ancien_nb_lignes; // Ancien nombre de lignes de l'écran
@ -181,7 +189,7 @@ void Erreur(int Code)
void Analyse_de_la_ligne_de_commande(int argc,char * argv[])
{
byte Option2=1;
char *Buffer;
char *Buffer ;
Un_fichier_a_ete_passe_en_parametre=0;
@ -201,9 +209,21 @@ void Analyse_de_la_ligne_de_commande(int argc,char * argv[])
Option2=2;
// On récupère le chemin complet du paramètre
Buffer=realpath(argv[1],NULL);
// Et on découpe ce chemin en répertoire(path) + fichier(.ext)
_splitpath(Buffer,Principal_Repertoire_fichier,Principal_Nom_fichier);
#ifdef __linux__
Buffer=realpath(argv[1],NULL);
_splitpath(Buffer,Principal_Repertoire_fichier,Principal_Nom_fichier);
#elif __WATCOMC__
Buffer = malloc(MAX_PATH);
PathCanonicalize(Buffer,argv[1]);
_splitpath(Buffer,
Principal_Repertoire_fichier,
Principal_Repertoire_fichier+3,
Principal_Nom_fichier,
Principal_Nom_fichier+8);
free(Buffer);
#endif
// chdir(Principal_Repertoire_fichier);
}
else
@ -474,7 +494,7 @@ void Initialisation_du_programme(int argc,char * argv[])
Pinceau_Largeur=1;
Pinceau_Hauteur=1;
puts("main.c init lister les modes SDL proprement!");
puts("main.c init lister les modes SDL proprement!");
// Détection des modes SDL en état de fonctionner:
// Liste_Modes_Videos_SDL= SDL_ListModes(NULL, 0);

13
moteur.c
View File

@ -12,12 +12,15 @@
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "linux.h"
#include "boutons.h"
#include "operatio.h"
#include "shade.h"
#include "erreurs.h"
#ifdef __linux__
#include "linux.h"
#endif
//---------- Annuler les effets des modes de dessin (sauf la grille) ---------
// Variables mémorisants les anciens effets
@ -267,10 +270,10 @@ void Tracer_cadre_de_bouton_du_menu(byte Numero,byte Enfonce)
}
}
SDL_UpdateRect(Ecran_SDL,
Debut_X*Menu_Facteur_X,
Debut_Y*Menu_Facteur_Y + Menu_Ordonnee,
(Fin_X+1-Debut_X)*Menu_Facteur_X,
(Fin_Y+1-Debut_Y)*Menu_Facteur_Y);
Debut_X*Menu_Facteur_X,
Debut_Y*Menu_Facteur_Y + Menu_Ordonnee,
(Fin_X+1-Debut_X)*Menu_Facteur_X,
(Fin_Y+1-Debut_Y)*Menu_Facteur_Y);
}

4
operatio.c
View File

@ -9,6 +9,10 @@
#include "boutons.h"
#include "pages.h"
#ifdef __WATCOMC__
#define M_PI 3.14159265358979323846
#endif
void Demarrer_pile_operation(word Operation_demandee)
{
Brosse_Centre_rotation_defini=0;

15
pages.c
View File

@ -6,12 +6,15 @@
#include <string.h>
#include <stdlib.h>
#include "linux.h"
#include "global.h"
#include "pages.h"
#include "graph.h"
#include "erreurs.h"
#ifdef __linux__
include "linux.h"
#endif
///
/// GESTION DES PAGES
///
@ -414,9 +417,9 @@ void Avancer_dans_une_liste_de_pages(S_Liste_de_pages * Liste)
}
int Nouvelle_page_possible(
S_Page * Nouvelle_page,
S_Liste_de_pages * Liste_courante,
S_Liste_de_pages * Liste_secondaire
S_Page * Nouvelle_page,
S_Liste_de_pages * Liste_courante,
S_Liste_de_pages * Liste_secondaire
)
{
unsigned long Taille_immediatement_disponible;
@ -427,7 +430,7 @@ int Nouvelle_page_possible(
unsigned long Taille_nouvelle_page;
Taille_immediatement_disponible = Memoire_libre()
- QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER;
- QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER;
Taille_liste_courante =Taille_d_une_liste_de_pages(Liste_courante);
Taille_liste_brouillon=Taille_d_une_liste_de_pages(Liste_secondaire);
Taille_page_courante =Taille_d_une_page(Liste_courante->Pages);
@ -683,7 +686,7 @@ int Initialiser_les_listes_de_backups_en_debut_de_programme(int Taille,int Large
}
else
{
// Il n'est pas possible de démarrer le programme avec la page
// Il n'est pas possible de démarrer le programme avec la page
// principale et la page de brouillon aux dimensions demandée par
// l'utilisateur. ==> On l'envoie ballader
Retour=0;

2
readini.h
View File

@ -1 +1,3 @@
int Charger_INI(struct S_Config * Conf);
int Charger_INI_Seek_pattern(char * Buffer,char * Pattern);
void Charger_INI_Clear_string(char * String);

23
readline.c
View File

@ -9,8 +9,11 @@
#include "global.h"
#include "graph.h"
#include "divers.h"
#include "linux.h"
void Erreur(int code);
#include "erreurs.h"
#ifdef __linux__
#include "linux.h"
#endif
#define COULEUR_TEXTE CM_Noir
#define COULEUR_FOND CM_Clair
@ -134,8 +137,8 @@ byte Readline(word Pos_X,word Pos_Y,char * Chaine,byte Taille_maxi,byte Type_sai
// Effacement de la chaŒne
Block(Fenetre_Pos_X+(Pos_X*Menu_Facteur_X),Fenetre_Pos_Y+(Pos_Y*Menu_Facteur_Y),
Taille_maxi*(Menu_Facteur_X<<3),(Menu_Facteur_Y<<3),COULEUR_FOND);
Rafficher_toute_la_chaine(Pos_X,Pos_Y,Chaine,Position);
}
Rafficher_toute_la_chaine(Pos_X,Pos_Y,Chaine,Position);
}
break;
case 75 : // Gauche
if (Position)
@ -144,12 +147,12 @@ byte Readline(word Pos_X,word Pos_Y,char * Chaine,byte Taille_maxi,byte Type_sai
if (Position==Taille)
Block(Fenetre_Pos_X+(Pos_X*Menu_Facteur_X),Fenetre_Pos_Y+(Pos_Y*Menu_Facteur_Y),
Taille_maxi*(Menu_Facteur_X<<3),(Menu_Facteur_Y<<3),COULEUR_FOND);
Rafficher_toute_la_chaine(Pos_X,Pos_Y,Chaine,--Position);
Rafficher_toute_la_chaine(Pos_X,Pos_Y,Chaine,--Position);
}
break;
case 77 : // Droite
if ((Position<Taille) && (Position<Taille_maxi-1))
Rafficher_toute_la_chaine(Pos_X,Pos_Y,Chaine,++Position);
Rafficher_toute_la_chaine(Pos_X,Pos_Y,Chaine,++Position);
break;
case 71 : // Home
if (Position)
@ -158,12 +161,12 @@ byte Readline(word Pos_X,word Pos_Y,char * Chaine,byte Taille_maxi,byte Type_sai
if (Position==Taille)
Block(Fenetre_Pos_X+(Pos_X*Menu_Facteur_X),Fenetre_Pos_Y+(Pos_Y*Menu_Facteur_Y),
Taille_maxi*(Menu_Facteur_X<<3),(Menu_Facteur_Y<<3),COULEUR_FOND);
Rafficher_toute_la_chaine(Pos_X,Pos_Y,Chaine,Position=0);
Rafficher_toute_la_chaine(Pos_X,Pos_Y,Chaine,Position=0);
}
break;
case 79 : // End
if ((Position<Taille) && (Position<Taille_maxi-1))
Rafficher_toute_la_chaine(Pos_X,Pos_Y,Chaine,Position=(Taille<Taille_maxi)?Taille:Taille-1);
Rafficher_toute_la_chaine(Pos_X,Pos_Y,Chaine,Position=(Taille<Taille_maxi)?Taille:Taille-1);
}
break;
case 8 :
@ -174,8 +177,8 @@ byte Readline(word Pos_X,word Pos_Y,char * Chaine,byte Taille_maxi,byte Type_sai
// Effacement de la chaŒne
Block(Fenetre_Pos_X+(Pos_X*Menu_Facteur_X),Fenetre_Pos_Y+(Pos_Y*Menu_Facteur_Y),
Taille_maxi*(Menu_Facteur_X<<3),(Menu_Facteur_Y<<3),COULEUR_FOND);
Rafficher_toute_la_chaine(Pos_X,Pos_Y,Chaine,Position);
}
Rafficher_toute_la_chaine(Pos_X,Pos_Y,Chaine,Position);
}
break;
case 13 :
if ( (Type_saisie!=2) || (Chaine_valide(Chaine)) )

1
saveini.c
View File

@ -1,6 +1,7 @@
#include <stdio.h>
#include "const.h"
#include "global.h"
#include "readini.h"
int Sauver_INI_Reach_group(FILE * Old_file,FILE * New_file,char * Buffer,char * Group)
{

340
sdlscreen.c
View File

@ -4,21 +4,21 @@
#include "divers.h"
#include "erreurs.h"
void inline Pixel_SDL (word X,word Y,byte Couleur)
void Pixel_SDL (word X,word Y,byte Couleur)
/* Affiche un pixel de la Couleur aux coords X;Y à l'écran */
{
*(Ecran + X + Y * Largeur_ecran)=Couleur;
}
byte inline Lit_Pixel_SDL (word X,word Y)
byte Lit_Pixel_SDL (word X,word Y)
/* On retourne la couleur du pixel aux coords données */
{
return *( Ecran + Y * Largeur_ecran + X );
return *( Ecran + Y * Largeur_ecran + X );
}
void Effacer_Tout_l_Ecran_SDL (byte Couleur)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
void Afficher_partie_de_l_ecran_SDL (word Largeur,word Hauteur,word Largeur_image)
@ -44,24 +44,24 @@ void Afficher_partie_de_l_ecran_SDL (word Largeur,word Hauteur,word Largeu
void Block_SDL (word Debut_X,word Debut_Y,word Largeur,word Hauteur,byte Couleur)
/* On affiche un rectangle de la couleur donnée */
{
SDL_Rect rectangle;
rectangle.x=Debut_X;
rectangle.y=Debut_Y;
rectangle.w=Largeur;
rectangle.h=Hauteur;
SDL_FillRect(Ecran_SDL,&rectangle,Couleur);
SDL_UpdateRect(Ecran_SDL,Debut_X,Debut_Y,Largeur,Hauteur);
SDL_Rect rectangle;
rectangle.x=Debut_X;
rectangle.y=Debut_Y;
rectangle.w=Largeur;
rectangle.h=Hauteur;
SDL_FillRect(Ecran_SDL,&rectangle,Couleur);
SDL_UpdateRect(Ecran_SDL,Debut_X,Debut_Y,Largeur,Hauteur);
}
void Block_SDL_Fast (word Debut_X,word Debut_Y,word Largeur,word Hauteur,byte Couleur)
/* On affiche un rectangle de la couleur donnée */
{
SDL_Rect rectangle;
rectangle.x=Debut_X;
rectangle.y=Debut_Y;
rectangle.w=Largeur;
rectangle.h=Hauteur;
SDL_FillRect(Ecran_SDL,&rectangle,Couleur);
SDL_Rect rectangle;
rectangle.x=Debut_X;
rectangle.y=Debut_Y;
rectangle.w=Largeur;
rectangle.h=Hauteur;
SDL_FillRect(Ecran_SDL,&rectangle,Couleur);
}
void Pixel_Preview_Normal_SDL (word X,word Y,byte Couleur)
@ -70,36 +70,36 @@ void Pixel_Preview_Normal_SDL (word X,word Y,byte Couleur)
* Note: si on modifie cette procédure, il faudra penser à faire également
* la modif dans la procédure Pixel_Preview_Loupe_SDL. */
{
// if(X-Principal_Decalage_X >= 0 && Y - Principal_Decalage_Y >= 0)
Pixel_SDL(X-Principal_Decalage_X,Y-Principal_Decalage_Y,Couleur);
// if(X-Principal_Decalage_X >= 0 && Y - Principal_Decalage_Y >= 0)
Pixel_SDL(X-Principal_Decalage_X,Y-Principal_Decalage_Y,Couleur);
}
void Pixel_Preview_Loupe_SDL (word X,word Y,byte Couleur)
{
// Affiche le pixel dans la partie non zoomée
Pixel_SDL(X-Principal_Decalage_X,Y-Principal_Decalage_Y,Couleur);
// Affiche le pixel dans la partie non zoomée
Pixel_SDL(X-Principal_Decalage_X,Y-Principal_Decalage_Y,Couleur);
// Regarde si on doit aussi l'afficher dans la partie zoomée
if (Y >= Limite_Haut_Zoom && Y <= Limite_visible_Bas_Zoom
&& X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom)
{
// On est dedans
int hauteur;
int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y];
// Regarde si on doit aussi l'afficher dans la partie zoomée
if (Y >= Limite_Haut_Zoom && Y <= Limite_visible_Bas_Zoom
&& X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom)
{
// On est dedans
int hauteur;
int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y];
if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur)
// On ne doit dessiner qu'un morceau du pixel
// sinon on dépasse sur le menu
hauteur = Menu_Ordonnee - Y_Zoom;
else
hauteur = Loupe_Facteur;
if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur)
// On ne doit dessiner qu'un morceau du pixel
// sinon on dépasse sur le menu
hauteur = Menu_Ordonnee - Y_Zoom;
else
hauteur = Loupe_Facteur;
Block_SDL_Fast(
Table_mul_facteur_zoom[X-Loupe_Decalage_X]
+ Principal_X_Zoom,
Y_Zoom, Loupe_Facteur, hauteur, Couleur
);
}
Block_SDL_Fast(
Table_mul_facteur_zoom[X-Loupe_Decalage_X]
+ Principal_X_Zoom,
Y_Zoom, Loupe_Facteur, hauteur, Couleur
);
}
}
void Ligne_horizontale_XOR_SDL(word Pos_X,word Pos_Y,word Largeur)
@ -110,7 +110,7 @@ void Ligne_horizontale_XOR_SDL(word Pos_X,word Pos_Y,word Largeur)
int ecx;
for (ecx=0;ecx<Largeur;ecx++)
*(edi+ecx)=~*(edi+ecx);
*(edi+ecx)=~*(edi+ecx);
}
void Ligne_verticale_XOR_SDL (word Pos_X,word Pos_Y,word Hauteur)
@ -119,44 +119,44 @@ void Ligne_verticale_XOR_SDL (word Pos_X,word Pos_Y,word Hauteur)
byte color;
for (i=Pos_Y;i<Pos_Y+Hauteur;i++)
{
color=*(Ecran+Pos_X+i*Largeur_ecran);
*(Ecran+Pos_X+i*Largeur_ecran)=~color;
color=*(Ecran+Pos_X+i*Largeur_ecran);
*(Ecran+Pos_X+i*Largeur_ecran)=~color;
}
}
void Display_brush_Color_SDL (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
void Display_brush_Mono_SDL (word Pos_X, word Pos_Y,
word Decalage_X, word Decalage_Y, word Largeur, word Hauteur,
byte Couleur_de_transparence, byte Couleur, word Largeur_brosse)
word Decalage_X, word Decalage_Y, word Largeur, word Hauteur,
byte Couleur_de_transparence, byte Couleur, word Largeur_brosse)
/* On affiche la brosse en monochrome */
{
byte* Dest=Pos_Y*Largeur_ecran+Pos_X+Ecran; // EDI = adr destination à
// l'écran
// l'écran
byte* Src=Largeur_brosse*Decalage_Y+Decalage_X+Brosse; // ESI = adr ds
// la brosse
// la brosse
int dx,cx;
for(dx=Hauteur;dx!=0;dx--)
//Pour chaque ligne
{
for(cx=Largeur;cx!=0;cx--)
//Pour chaque pixel
{
if (*Src!=Couleur_de_transparence)
*Dest=Couleur;
for(cx=Largeur;cx!=0;cx--)
//Pour chaque pixel
{
if (*Src!=Couleur_de_transparence)
*Dest=Couleur;
// On passe au pixel suivant
Src++;
Dest++;
}
// On passe au pixel suivant
Src++;
Dest++;
}
// On passe à la ligne suivante
Src+=Largeur_brosse-Largeur;
Dest+=Largeur_ecran-Largeur;
// On passe à la ligne suivante
Src+=Largeur_brosse-Largeur;
Dest+=Largeur_ecran-Largeur;
}
SDL_UpdateRect(Ecran_SDL,Pos_X,Pos_Y,Largeur,Hauteur);
}
@ -182,10 +182,10 @@ void Clear_brush_SDL (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word
void Remap_screen_SDL (word Pos_X,word Pos_Y,word Largeur,word Hauteur,byte * Table_de_conversion)
{
UNIMPLEMENTED
UNIMPLEMENTED
}
void inline Afficher_une_ligne_ecran_SDL (word Pos_X,word Pos_Y,word Largeur,byte * Ligne)
void Afficher_une_ligne_ecran_SDL (word Pos_X,word Pos_Y,word Largeur,byte * Ligne)
/* On affiche toute une ligne de pixels. Utilisé pour les textes. */
{
memcpy(Ecran+Pos_X+Pos_Y*Largeur_ecran,Ligne,Largeur);
@ -193,21 +193,21 @@ void inline Afficher_une_ligne_ecran_SDL (word Pos_X,word Pos_Y,word Largeur,byt
}
void Afficher_une_ligne_transparente_mono_a_l_ecran_SDL(
word Pos_X, word Pos_Y, word Largeur, byte* Ligne,
byte Couleur_transparence, byte Couleur)
word Pos_X, word Pos_Y, word Largeur, byte* Ligne,
byte Couleur_transparence, byte Couleur)
// Affiche une ligne à l'écran avec une couleur + transparence.
// Utilisé par les brosses en mode zoom
{
byte* Dest = Ecran+ Pos_Y * Largeur_ecran + Pos_X;
int Compteur;
// Pour chaque pixel
for(Compteur=0;Compteur<Largeur;Compteur++)
{
if (Couleur_transparence!=*Ligne)
*Dest = Couleur;
Ligne ++; // Pixel suivant
Dest++;
}
byte* Dest = Ecran+ Pos_Y * Largeur_ecran + Pos_X;
int Compteur;
// Pour chaque pixel
for(Compteur=0;Compteur<Largeur;Compteur++)
{
if (Couleur_transparence!=*Ligne)
*Dest = Couleur;
Ligne ++; // Pixel suivant
Dest++;
}
}
void Lire_une_ligne_ecran_SDL (word Pos_X,word Pos_Y,word Largeur,byte * Ligne)
@ -216,38 +216,41 @@ void Lire_une_ligne_ecran_SDL (word Pos_X,word Pos_Y,word Largeur,byte * Ligne)
}
void Afficher_partie_de_l_ecran_zoomee_SDL(
word Largeur, // Largeur non zoomée
word Hauteur, // Hauteur zoomée
word Largeur_image,byte * Buffer)
word Largeur, // Largeur non zoomée
word Hauteur, // Hauteur zoomée
word Largeur_image,byte * Buffer)
{
byte* ESI = Principal_Ecran + Loupe_Decalage_Y * Largeur_image
+ Loupe_Decalage_X;
+ Loupe_Decalage_X;
int EDX = 0; // Ligne en cours de traitement
// Pour chaque ligne à zoomer
while(1){
// On éclate la ligne
Zoomer_une_ligne(ESI,Buffer,Loupe_Facteur,Largeur);
// On l'affiche Facteur fois, sur des lignes consécutives
int CX = Loupe_Facteur;
// Pour chaque ligne
do{
// On affiche la ligne zoomée
Afficher_une_ligne_ecran_SDL(
Principal_X_Zoom, EDX, Largeur*Loupe_Facteur,
Buffer
);
// On passe à la suivante
EDX++;
if(EDX==Hauteur)
{
SDL_UpdateRect(Ecran_SDL,Principal_X_Zoom,0,
Largeur*Loupe_Facteur,Hauteur);
return;
}
CX--;
}while (CX > 0);
ESI += Largeur_image;
while(1)
{
int CX;
// On éclate la ligne
Zoomer_une_ligne(ESI,Buffer,Loupe_Facteur,Largeur);
// On l'affiche Facteur fois, sur des lignes consécutives
CX = Loupe_Facteur;
// Pour chaque ligne
do{
// On affiche la ligne zoomée
Afficher_une_ligne_ecran_SDL(
Principal_X_Zoom, EDX, Largeur*Loupe_Facteur,
Buffer
);
// On passe à la suivante
EDX++;
if(EDX==Hauteur)
{
SDL_UpdateRect(Ecran_SDL,Principal_X_Zoom,0,
Largeur*Loupe_Facteur,Hauteur);
return;
}
CX--;
}while (CX > 0);
ESI += Largeur_image;
}
// ATTENTION on n'arrive jamais ici !
}
@ -258,94 +261,95 @@ void Display_brush_Color_zoom_SDL (word Pos_X,word Pos_Y,word Decalage_X,word De
}
void Display_brush_Mono_zoom_SDL (word Pos_X, word Pos_Y,
word Decalage_X, word Decalage_Y,
word Largeur, // Largeur non zoomée
word Pos_Y_Fin,
byte Couleur_de_transparence, byte Couleur,
word Largeur_brosse, // Largeur réelle de la brosse
byte * Buffer
word Decalage_X, word Decalage_Y,
word Largeur, // Largeur non zoomée
word Pos_Y_Fin,
byte Couleur_de_transparence, byte Couleur,
word Largeur_brosse, // Largeur réelle de la brosse
byte * Buffer
)
{
byte* ESI = Brosse + Decalage_Y * Largeur_brosse + Decalage_X;
int DX=Pos_Y;
byte* ESI = Brosse + Decalage_Y * Largeur_brosse + Decalage_X;
int DX=Pos_Y;
//Pour chaque ligne à zoomer :
while(1)
{
// ESI = Ligne originale
// On éclate la ligne
Zoomer_une_ligne(ESI,Buffer,Loupe_Facteur,Largeur);
//Pour chaque ligne à zoomer :
while(1)
{
int BX;
// ESI = Ligne originale
// On éclate la ligne
Zoomer_une_ligne(ESI,Buffer,Loupe_Facteur,Largeur);
// On affiche la ligne Facteur fois à l'écran (sur des
// lignes consécutives)
int BX = Loupe_Facteur;
// On affiche la ligne Facteur fois à l'écran (sur des
// lignes consécutives)
BX = Loupe_Facteur;
// Pour chaque ligne écran
do
{
// On affiche la ligne zoomée
Afficher_une_ligne_transparente_mono_a_l_ecran_SDL(
Pos_X, DX, Largeur * Loupe_Facteur,
Buffer, Couleur_de_transparence, Couleur
);
// On passe à la ligne suivante
DX++;
// On vérifie qu'on est pas à la ligne finale
if(DX == Pos_Y_Fin)
{
SDL_UpdateRect(Ecran_SDL, Pos_X, Pos_Y,
Largeur * Loupe_Facteur, Pos_Y_Fin - Pos_Y );
return;
}
BX --;
}
while (BX > 0);
// Pour chaque ligne écran
do
{
// On affiche la ligne zoomée
Afficher_une_ligne_transparente_mono_a_l_ecran_SDL(
Pos_X, DX, Largeur * Loupe_Facteur,
Buffer, Couleur_de_transparence, Couleur
);
// On passe à la ligne suivante
DX++;
// On vérifie qu'on est pas à la ligne finale
if(DX == Pos_Y_Fin)
{
SDL_UpdateRect(Ecran_SDL, Pos_X, Pos_Y,
Largeur * Loupe_Facteur, Pos_Y_Fin - Pos_Y );
return;
}
BX --;
}
while (BX > 0);
// Passage à la ligne suivante dans la brosse aussi
ESI+=Largeur_brosse;
}
// Passage à la ligne suivante dans la brosse aussi
ESI+=Largeur_brosse;
}
}
void Clear_brush_zoom_SDL (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer)
{
// En fait on va recopier l'image non zoomée dans la partie zoomée !
byte* ESI = Principal_Ecran + Decalage_Y * Largeur_image + Decalage_X;
int DX = Pos_Y;
int bx;
// En fait on va recopier l'image non zoomée dans la partie zoomée !
byte* ESI = Principal_Ecran + Decalage_Y * Largeur_image + Decalage_X;
int DX = Pos_Y;
int bx;
// Pour chaque ligne à zoomer
while(1){
Zoomer_une_ligne(ESI,Buffer,Loupe_Facteur,Largeur);
// Pour chaque ligne à zoomer
while(1){
Zoomer_une_ligne(ESI,Buffer,Loupe_Facteur,Largeur);
bx=Loupe_Facteur;
bx=Loupe_Facteur;
// Pour chaque ligne
do{
Afficher_une_ligne_ecran_SDL(Pos_X,DX,
Largeur * Loupe_Facteur,Buffer);
// Pour chaque ligne
do{
Afficher_une_ligne_ecran_SDL(Pos_X,DX,
Largeur * Loupe_Facteur,Buffer);
// Ligne suivante
DX++;
if(DX==Pos_Y_Fin)
{
SDL_UpdateRect(Ecran_SDL,Pos_X,Pos_Y,
Largeur*Loupe_Facteur,Pos_Y_Fin-Pos_Y);
return;
}
bx--;
}while(bx!=0);
// Ligne suivante
DX++;
if(DX==Pos_Y_Fin)
{
SDL_UpdateRect(Ecran_SDL,Pos_X,Pos_Y,
Largeur*Loupe_Facteur,Pos_Y_Fin-Pos_Y);
return;
}
bx--;
}while(bx!=0);
ESI+= Largeur_image;
}
ESI+= Largeur_image;
}
}
void Set_Mode_SDL()
/* On règle la résolution de l'écran */
{
Ecran_SDL=SDL_SetVideoMode(Largeur_ecran,Hauteur_ecran,8,SDL_HWSURFACE/*|SDL_FULLSCREEN*/);
Ecran=Ecran_SDL->pixels;
Ecran_SDL=SDL_SetVideoMode(Largeur_ecran,Hauteur_ecran,8,SDL_HWSURFACE/*|SDL_FULLSCREEN*/);
Ecran=Ecran_SDL->pixels;
SDL_ShowCursor(0); // Cache le curseur SDL, on le gère en soft
SDL_ShowCursor(0); // Cache le curseur SDL, on le gère en soft
}

3
shade.c
View File

@ -1,5 +1,8 @@
#include "global.h"
#include "graph.h"
#include "moteur.h"
#include "divers.h"
#include "readline.h"
void Bouton_Shade_Mode(void)
{

574
windows-watcom/grafx2.tgt Normal file
View File

@ -0,0 +1,574 @@
40
targetIdent
0
MProject
1
MComponent
0
2
WString
4
NEXE
3
WString
5
nw2en
1
0
1
4
MCommand
0
5
MCommand
0
6
MItem
10
grafx2.exe
7
WString
4
NEXE
8
WVList
4
9
MVState
10
WString
7
WINLINK
11
WString
12
nw2??System:
1
12
WString
5
win95
0
13
MCState
14
WString
7
WINLINK
15
WString
24
?????Incremental Linking
1
1
16
MCState
17
WString
7
WINLINK
18
WString
10
?????Quiet
1
0
19
MCState
20
WString
7
WINLINK
21
WString
20
?????Quiet operation
1
0
22
WVList
2
23
ActionStates
24
WString
5
&Make
25
WVList
0
26
ActionStates
27
WString
4
&Run
28
WVList
0
-1
1
1
0
29
WPickList
21
30
MItem
3
*.c
31
WString
4
COBJ
32
WVList
6
33
MCState
34
WString
3
WCC
35
WString
28
?????Use precompiled headers
1
1
36
MCState
37
WString
3
WCC
38
WString
31
?????Force enums to be type int
1
1
39
MRState
40
WString
3
WCC
41
WString
39
??2??Pentium Pro Register based calling
1
0
42
MRState
43
WString
3
WCC
44
WString
36
??2??Pentium Pro Stack based calling
1
1
45
MRState
46
WString
3
WCC
47
WString
21
?????Compiler default
1
1
48
MRState
49
WString
3
WCC
50
WString
21
??2??32bit Flat model
1
0
51
WVList
0
-1
1
1
0
52
MItem
9
..\aide.c
53
WString
4
COBJ
54
WVList
0
55
WVList
0
30
1
1
0
56
MItem
12
..\boutons.c
57
WString
4
COBJ
58
WVList
0
59
WVList
0
30
1
1
0
60
MItem
11
..\divers.c
61
WString
4
COBJ
62
WVList
0
63
WVList
0
30
1
1
0
64
MItem
10
..\files.c
65
WString
4
COBJ
66
WVList
0
67
WVList
0
30
1
1
0
68
MItem
10
..\graph.c
69
WString
4
COBJ
70
WVList
0
71
WVList
0
30
1
1
0
72
MItem
9
..\init.c
73
WString
4
COBJ
74
WVList
0
75
WVList
0
30
1
1
0
76
MItem
13
..\loadsave.c
77
WString
4
COBJ
78
WVList
0
79
WVList
0
30
1
1
0
80
MItem
9
..\main.c
81
WString
4
COBJ
82
WVList
0
83
WVList
0
30
1
1
0
84
MItem
11
..\moteur.c
85
WString
4
COBJ
86
WVList
0
87
WVList
0
30
1
1
0
88
MItem
11
..\op_asm.c
89
WString
4
COBJ
90
WVList
0
91
WVList
0
30
1
1
0
92
MItem
9
..\op_c.c
93
WString
4
COBJ
94
WVList
0
95
WVList
0
30
1
1
0
96
MItem
13
..\operatio.c
97
WString
4
COBJ
98
WVList
0
99
WVList
0
30
1
1
0
100
MItem
10
..\pages.c
101
WString
4
COBJ
102
WVList
0
103
WVList
0
30
1
1
0
104
MItem
12
..\palette.c
105
WString
4
COBJ
106
WVList
0
107
WVList
0
30
1
1
0
108
MItem
12
..\readini.c
109
WString
4
COBJ
110
WVList
0
111
WVList
0
30
1
1
0
112
MItem
13
..\readline.c
113
WString
4
COBJ
114
WVList
0
115
WVList
0
30
1
1
0
116
MItem
12
..\saveini.c
117
WString
4
COBJ
118
WVList
0
119
WVList
0
30
1
1
0
120
MItem
14
..\sdlscreen.c
121
WString
4
COBJ
122
WVList
0
123
WVList
0
30
1
1
0
124
MItem
10
..\shade.c
125
WString
4
COBJ
126
WVList
0
127
WVList
0
30
1
1
0
128
MItem
12
..\special.c
129
WString
4
COBJ
130
WVList
0
131
WVList
1
132
ActionStates
133
WString
5
&Make
134
WVList
0
30
1
1
0

43
windows-watcom/grafx2.wpj Normal file
View File

@ -0,0 +1,43 @@
40
projectIdent
0
VpeMain
1
WRect
-40
-53
10320
10346
2
MProject
3
MCommand
0
4
MCommand
0
1
5
WFileName
10
grafx2.tgt
6
WVList
1
7
VComponent
8
WRect
0
0
1230
4840
0
0
9
WFileName
10
grafx2.tgt
0
20
7