Ludovic Deruffe - Programmation

Page d'accueil

Espace Pro

Mon CV

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT: Logiciel de visualisation graphique Vu pour faire
// des traces interactifs graphiques X et PostScript
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// AUTEUR du X : PERRONNET Alain ANALYSE NUMERIQUE UPMC PARIS NOVEMBRE 2000
// AUTEUR du PS: DOURSAT Christophe ANALYSE NUMERIQUE UPMC PARIS NOVEMBRE 1994
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//=======================================================================
//Les SPECIFICATIONS ou ENTETES de Rn et Vu
//=======================================================================
#include "Rn.h"
#include "Vu.h"

//=======================================================================
// Les DONNEES PUBLIQUES de Vu
//=======================================================================
// le numero des couleurs imposees dans la palette des couleurs
int Noir=0, Rouge=1, Vert=2, Bleu=3, Cyan=4, Jaune=5, Magenta=6, Blanc=7,
GrisSombre=8, Gris=9, GrisClair=10, Beige=11, Orange=12, Saumon=13,
Rose=14, Turquoise=15;

//Le Systeme de Coordonnees Global SCG et Utilisateur SCU
R3 SCG[4]={ R3(0,0,0), R3(1,0,0), R3(0,1,0), R3(0,0,1) };
R3 SCU[4]={ R3(0,0,0), R3(1,0,0), R3(0,1,0), R3(0,0,1) };
//Le point origine et les 3 vecteurs orthonormes du SC
//dans le Systeme de Coordonnees Generales SCG
//Au depart, le SCU est le SCG

int AccrocherGrilleSCU=1; //Mode Accrocher aux coins de la grille 0:non actif 1:actif
int CouleurGrilleSCU=Noir; //couleur de trace de la grille. si <0 pas de trace de la grille
R2 PasGrilleSCU=R2(0.2,0.2); //pas de la grille en largeur et hauteur

int CouleurChiffre=GrisSombre; //couleur de trace des chiffres des graduations sur les axes

int noforeground, nobackground; // no dans norgb des couleurs de trace et du fond
unsigned long foreground, background; // couleur X de trace et couleur du fond

int lapxfe, lhpxfe; // nombre de pixels de la fenetre en largeur et hauteur
int largbouton, hautbouton, hauttexte; //trace d'un bouton de Menu, Invite ...

//=======================================================================
// Les DONNEES PRIVEES de Vu
//=======================================================================
#define MAX_SHORT 0xFFFF // Plus grande valeur d'un entier short
#define X_COIN_FENETRE 0 // Position du COIN SUPERIEUR GAUCHE de la fenetre X
#define Y_COIN_FENETRE 0
#define CMAPSIZE 256 // Nombre de couleurs pour 8 Plans 256=2**8

static Display *display_vu; // la structure display Vu = le SERVEUR X
static int ecran_vu; // les caracteristiques de l'ecran graphique
static GC gc_vu; // le contexte graphique Vu
static XSetWindowAttributes attributs_vu; // attributs de la fenetre Vu

Window fenetre_vu0, fenetre_vu; // la fenetre Vu

//Le Drawable sera lors des traces soit fenetre_vu soit un des pixmaps
//static Drawable *fenpix_vu; //destine a servir de support des differents traces

//Les donnees pour les couleurs
static Visual *visual; // Choix du type d'utilisation de l'ecran c-a-d
// PseudoColor ou TrueColor ou ...
static int visual_class; // visual->class = PseudoColor, TrueColor,...
static R red[CMAPSIZE], green[CMAPSIZE], blue[CMAPSIZE];
// rouge vert bleu de la palette des couleurs
static unsigned long norgb[CMAPSIZE];
// numero dans la palette physique de la couleur i dans la palette des couleurs de Vu
// en PseudoColor: c'est l'identite norgb[i]=i
// la i_eme couleur de la palette Vu est celle
// de la palette physique
// en TrueColor : c'est le no dans la palette physique en lecture seule
// norgb[i]=fonction de (rouge, vert, bleu)
// cette valeur est calculee par XAllocColor
// qui determine a partir de RGB la couleur la plus
// proche parmi les couleurs de la palette physique
#define MAXPACL 14 // nombre maximal de palettes de couleurs cf VuPaletteCouleurs
static int nbpacl; // nombre de palettes de couleurs
static int nopacl; // numero de 1 a nbpacl de la palette de couleurs active
static Colormap color_map0; // palette initiale (En lecture SEULE)
static Colormap color_map; // palette courante des couleurs (en LECTURE/ECRITURE)
static int lammec, lhmmec; // nombre de mm de l'ecran en largeur et hauteur
static int lapxec, lhpxec; // nombre de pixels de l'ecran en largeur et hauteur
static R cxmmpx, cymmpx; // nombre de pixels par mm en largeur et hauteur sur l'ecran
static int n1core; //numero dans la palette des couleurs de la premiere couleur reservee
static int ndcore; //numero dans la palette des couleurs de la dernierere couleur reservee
static int n1coel; //numero dans la palette des couleurs de la premiere couleur elementaire
static int ndcoel; //numero dans la palette des couleurs de la derniere couleur elementaire
static int n1coul; //numero dans la palette des couleurs de la premiere couleur modifiable
static int ndcoul; //numero dans la palette des couleurs de la derniere couleur modifiable
static int nbcolo; // nombre de couleurs de la palette Vu ( 2 ou 256 )
static int nbepai; // nombre d'epaisseurs supplementaires des traits (>=0)
static int notytr; // type de traits: 0 continu, 1 tirete, 2 double tirete

//Les fontes X de caracteres
#define MAXFONTS 512 // nombre maximal de fontes declarables
static char **listfonts; // pointe sur le tableau des noms de fontes fourni par X
static int lhpxfo[MAXFONTS];// le nombre de pixels en hauteur de chaque fonte
static int nbfontes; // nombre de polices ou fontes de caracteres disponibles
static Font font_id; // nom de la fonte actuelle
static XFontStruct *struc_police ; // structure de la police courante
static int ascent_pol, // nombre de pixels au dessus de la ligne de base
descent_pol; // nombre de pixels au dessous de la ligne de base
static XCharStruct mesure ; // qualifiants des dimensions d'une chaine de caracteres
static int nofoca; // numero de la fonte actuelle dans X
static int nplaca, nphaca; // nombre de pixels en largeur et hauteur de la fonte actuelle
static int nphfco; // nombre de pixels en hauteur de la fonte actuelle

//Les parametres contenus dans les communs decrivant les tailles des divers menus
//dans gsmenu.inc
#define MXRECT 8 // nombre maximal de rectangles menus
#define NBCAME 80 // nombre de caracteres d'une ligne du menu
#define MXLGME 48 // nombre maximal de lignes du menu
#define NBCAHI 48 // nombre de caracteres d'une ligne de l'historique
#define MXLGHI 16 // nombre maximal de lignes de l'historique
#define NBCADO 80 // nombre de caracteres d'une ligne de la documentation
#define MXLGDO 31 // nombre maximal de lignes de la documentation
#define NBCAIN 48 // nombre de caracteres d'une ligne de l'invite
#define MXLGIN 2 // nombre maximal de lignes de l'invite
#define NBCALG 96 // nombre de caracteres d'une ligne de saisie
#define MXLGSA 1 // nombre maximal de lignes de la ligne de saisie
#define NBCAER 96 // nombre de caracteres d'une ligne des erreurs
#define MXLGER 32 // nombre maximal de lignes des erreurs

//dans lu.inc
#define NBCALI 96 // nombre de caracteres par ligne lue
#define MXKLG 256 // nombre maximal de lignes de lignes lues
#define NBCALIP10 106 // NBCALI+10 pour ajout dans kliglue du texte Ligne lue:

//Les donnees PostScript
static int lasopsc; // sortie ou non du trace en PostScript
static int modepsc;
static FILE *fpi, *fpo;
static R counb, courgb[3];
static int palcourc;
static int xpixels, ypixels;
static char *chaine[MXRECT] ;
static int longchaine[MXRECT];
static char format[255];
static int menu;
static int icolorm;
static int nbrcon, xinic, yinic, xcouc, ycouc;
static int iTe, iFa, ity, iep, iPo, ire , iRe, iel, iEl, iFP;
static char buf[512], concat[512], fontcour[512];

int decaltexte, nbepbordbouton; //trace d'un bouton
int larginvite, hautinvite, nbepbordinvite; //trace de l'invite
int couleurinvite=Jaune, couleurtexteinvite=0;
char TexteInvite[128]; //sauvegarde du texte de la ligne d'invite
char TexteClavier[128]; //texte saisi au clavier

//Les donnees pour les COURBES et les SURFACES
static const int mxsucb=64; //nombre maximal de sous-aretes d'une courbe
static const int mxsuar=16; //nombre maximal de sous-aretes d'un
//cote de triangle ou quadrangle

//=======================================================================
//DEBUT de la REALISATION des FONCTIONS de Vu
//=======================================================================

void VuPxEcran(int & lapxec, int & lhpxec)
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT :RECUPERER le nombre de pixels de la largeur et hauteur de l'ecran total
// -----
//
// SORTIES :
// ---------
// lapxec : nombre de pixels de la largeur de l'ecran
// lhpxec : nombre de pixels de la hauteur de l'ecran
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
lapxec = XDisplayWidth ( display_vu, ecran_vu );
lhpxec = XDisplayHeight ( display_vu, ecran_vu );
}

void VuMMEcran(int & lammec, int & lhmmec)
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : RECUPERER la largeur et hauteur de l'ecran total en MILLIMETRES
// -----
//
// SORTIES :
// ---------
// lammec : nombre de MM de la largeur de l'ecran
// lhmmec : nombre de MM de la hauteur de l'ecran
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
lammec = XDisplayWidthMM ( display_vu, ecran_vu );
lhmmec = XDisplayHeightMM ( display_vu, ecran_vu );
}

void VuInitier(void)
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : Initialiser le display et l'ecran X
// ce qui permet ensuite de recuperer
// le nombre de pixels en largeur et hauteur de l'ecran par Vupxecran
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
//Ouverture du Display de Vu
//=====================
display_vu = XOpenDisplay(NULL);
if ( display_vu == (Display *) NULL )
{
cout << "Initialisation Graphique X IMPOSSIBLE\n";
exit(1);
}
//cout << "Le Display est ouvert avec display_vu=" << display_vu << endl;

//Ouverture de l'ecran de Vu
//============================
ecran_vu = DefaultScreen( display_vu );
//cout << "L'ecran est ouvert avec ecran_vu=" << ecran_vu << endl;
cout << "Le display et l'ecran sont ouverts" << endl;

//INITIALISATION DES CARACTERISTIQUES DE L'ECRAN
// ==============================================
// LARGEUR ET HAUTEUR DE L'ECRAN EN MM
VuMMEcran( lammec, lhmmec );

//LARGEUR ET HAUTEUR EN PIXELS DE L'ECRAN
VuPxEcran( lapxec, lhpxec);

cout << "Largeur de l'ecran = " << lammec << " millimetres = " << lapxec << " pixels" << endl;
cout << "Hauteur de l'ecran = " << lhmmec << " millimetres = " << lhpxec << " pixels" << endl;

// nombre de pixels par mm en largeur et hauteur de l'ecran
cxmmpx = (R) lapxec / (R) lammec;
cymmpx = (R) lhpxec / (R) lhmmec;
}

void VuCouleursImposees( int & n1coel, int & ndcoel,
R red[], R green[], R blue[] )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
BUT : Definir les 16 couleurs imposees dans toute palette
----- ( procedure interne a Vu )

ENTREES :
---------
n1coel : numero de la premiere couleur imposee

MODIFIES:
---------
red, green, blue : les tableaux ROUGE VERT BLEU de la palette

SORTIES :
---------
ndcoel : numero de la derniere couleur imposee
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
// Noir
red[Noir] = 0.0 ;
green[Noir] = 0.0 ;
blue[Noir] = 0.0 ;

// Rouge
red[Rouge] = 1.0 ;
green[Rouge] = 0.0 ;
blue[Rouge] = 0.0 ;

// Vert
red[Vert] = 0.0 ;
green[Vert] = 1.0 ;
blue[Vert] = 0.0 ;

// Bleu
red[Bleu] = 0.0 ;
green[Bleu] = 0.0 ;
blue[Bleu] = 1.0 ;

// Cyan
red[Cyan] = 0.0 ;
green[Cyan] = 0.8 ;
blue[Cyan] = 0.9 ;

// Jaune
red[Jaune] = 1.0 ;
green[Jaune] = 1.0 ;
blue[Jaune] = 0.0 ;

// Magenta
red[Magenta] = 1.0 ;
green[Magenta] = 0.0 ;
blue[Magenta] = 1.0 ;

// Blanc
red[Blanc] = 1.0 ;
green[Blanc] = 1.0 ;
blue[Blanc] = 1.0 ;

// GrisSombre
red[GrisSombre] = 90./256. ;
green[GrisSombre] = 90./256. ;
blue[GrisSombre] = 100./256. ;

// Gris
red[Gris] = 170./256. ;
green[Gris] = 170./256. ;
blue[Gris] = 180./256. ;

// GrisClair
red[GrisClair] = 240./256. ;
green[GrisClair] = 240./256. ;
blue[GrisClair] = 250./256. ;

// Beige
red[Beige] = 245./256. ;
green[Beige] = 245./256. ;
blue[Beige] = 220./256. ;

// Orange
red[Orange] = 1.0;
green[Orange] = 130./256. ;
blue[Orange] = 0. ;

// Saumon
red[Saumon] = 250./256. ;
green[Saumon] = 128./256. ;
blue[Saumon] = 114./256. ;

// Rose
red[Rose] = 1.0 ;
green[Rose] = 181./256. ;
blue[Rose] = 197./256. ;

// Turquoise
red[Turquoise] = 64./256. ;
green[Turquoise] = 224./256. ;
blue[Turquoise] = 188./256. ;

/* 16 COULEURS IMPOSEES */
ndcoel = n1coel + (int) 15 ;
}

void VuColormapToRGB( Colormap color_map,
R r[], R g[], R b[], int nbcolor)
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
BUT : TRANSFERER les nbcolor couleurs de la palette color_map dans les
----- tableaux r, v, b de C dans la classe PseudoColor
( procedure interne a Vu )

ENTREE :
--------
nbcolor : nombre de couleurs dans la palette des couleurs a charger

SORTIES :
---------
r, g, b : les tableaux ROUGE VERT BLEU de la palette en C
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
XColor colorcell_defs;
int i;

for ( i = 0 ; i < nbcolor ; i++ )
{
colorcell_defs.pixel = (unsigned long) i;
/* Recuperation du rouge vert bleu de la couleur i de la colormap */
XQueryColor (display_vu, color_map, &colorcell_defs);

r[i] = ( (R) colorcell_defs.red / (R) MAX_SHORT );
g[i] = ( (R) colorcell_defs.green / (R) MAX_SHORT );
b[i] = ( (R) colorcell_defs.blue / (R) MAX_SHORT );
}
}

void VuRGBtoColormap( int visual_class, int nbcells,
R red[], R green[], R blue[],
unsigned long norgb[], Colormap color_map )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
BUT : IMPOSER dans la palette des couleurs color_map modifiable
----- les couleurs red green blue tableaux C
( Fonction interne a Vu )

ENTREES :
---------
visual_class : type de visual TrueColor, PseudoColor, ...
nbcells : nombre de couleurs dans la palette des couleurs a charger
red, green, blue : les tableaux red green blue des couleurs primaires

SORTIES :
---------
norgb : numero des couleurs de la palette Vu dans la palette physique
color_map : recoit les nbcells couleurs
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
unsigned long index;
XColor colorcell_defs[CMAPSIZE];

if ( (visual_class != TrueColor) && (visual_class != GrayScale) )
{ /* PseudoColor par exemple */
for ( index = 0 ; index < nbcells ; index++ )
{
norgb[index] = (unsigned long) index; // valeur ici imposee
colorcell_defs[index].pixel = (unsigned long) index;
colorcell_defs[index].red = (unsigned short) ( red[index] * (R) MAX_SHORT );
colorcell_defs[index].green = (unsigned short) ( green[index] * (R) MAX_SHORT );
colorcell_defs[index].blue = (unsigned short) ( blue[index] * (R) MAX_SHORT );
colorcell_defs[index].flags = DoRed | DoGreen | DoBlue;
colorcell_defs[index].pad = '.';
}
/* Stockage des couleurs Vu dans la colormap lecture/ecriture NON PARTAGEABLE */
XStoreColors ( display_vu, color_map, colorcell_defs, nbcells );
}
else /* TrueColor ou GrayScale */
{
for ( index = 0 ; index < nbcells ; index++ )
{
/* colorcell_defs[index].pixel = (unsigned long) index; */
colorcell_defs[index].red = (unsigned short) ( red[index] * (R) MAX_SHORT );
colorcell_defs[index].green = (unsigned short) ( green[index] * (R) MAX_SHORT );
colorcell_defs[index].blue = (unsigned short) ( blue[index] * (R) MAX_SHORT );
colorcell_defs[index].flags = DoRed | DoGreen | DoBlue;
colorcell_defs[index].pad = '.';

/* Initialisation de colorcell_defs[index].pixel par recherche X de la couleur
RGB la plus proche dans la palette physique palette lecture seule PARTAGEABLE */
XAllocColor ( display_vu, color_map, &colorcell_defs[index] );
norgb[index] = colorcell_defs[index].pixel; /* valeur ici retrouvee */
}
}
}

void VuPaletteCouleurs(int nopacoul)
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : Construire et charger la palette nopacoul de couleurs
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
int nbcoul, i,j,k,l,n;
R r,v,b, c,d,d0,d1;

//protection pour un ecran noir et blanc
if( ndcoul == n1coul+1 ) return;
if( nopacoul <=0 || nopacoul > nbpacl ) nopacoul=1;
if( nopacoul == nopacl ) return;

// le nouvelle palette active
nopacl = nopacoul;

// la premiere couleur modifiable
l = n1coul;

//le nombre de couleurs a initialiser
nbcoul = ndcoul-n1coul+1;

// traitement selon le numero de palette
switch( nopacoul )
{
case 1: // La couleur varie vite et du noir est ajoute
c = 1.0;
while( l<nbcolo )
{
red[l] = c; // rouge
green[l] = 0.0;
blue[l] = 0.0;
l += 1;

red[l] = 0.0; // vert
green[l] = c;
blue[l] = 0.0;
l += 1;

red[l] = 0.0; // bleu
green[l] = 0.0;
blue[l] = c;
l += 1;

red[l] = c; // cyan
green[l] = c;
blue[l] = 0.0;
l += 1;

red[l] = 0.0; // jaune
green[l] = c;
blue[l] = c;
l += 1;

red[l] = c; // magenta
green[l] = 0.0;
blue[l] = c;
l += 1;

c -= (R) nbcolo / 6.0;
}
break;

case 2: // La couleur varie vite et du blanc est ajoute
r = 0.27;
v = 0.22;
b = 0.17;
c = 0.3;
while( l<nbcolo )
{
red[l] = c; // rouge
green[l] = v;
blue[l] = b;
l += 1;

red[l] = r; // vert
green[l] = c;
blue[l] = b;
l += 1;

red[l] = r; // bleu
green[l] = v;
blue[l] = c;
l += 1;

red[l] = c; // cyan
green[l] = c;
blue[l] = b;
l += 1;

red[l] = r; // jaune
green[l] = c;
blue[l] = c;
l += 1;

red[l] = c; // magenta
green[l] = v;
blue[l] = c;
l += 1;

r += (R) nbcolo / 6.0;
v += (R) nbcolo / 6.0;
b += (R) nbcolo / 6.0;
c += (R) nbcolo * 0.7 / 6.0;
}
break;

case 3:
//La palette des bleus
d = 0.7 / ndcoul;
c = 0.3;
for ( l=n1coul; l<=ndcoul; l++ )
{
red[l] = c;
green[l] = c;
blue[l] = 0.3 + l * d;
c -= (R) 0.28 / nbcoul;
}
break;

case 4:
//La palette des cyans
d = 0.7 / ndcoul;
c = 0.3;
for ( l=n1coul; l<=ndcoul; l++ )
{
red[l] = c;
green[l] = 0.3 + l * d;
blue[l] = 0.3 + l * d;
c -= (R) 0.28 / nbcoul; }
break;

case 5:
//La palette des verts
d = 0.7 / ndcoul;
c = 0.3;
for ( l=n1coul; l<=ndcoul; l++ )
{
red[l] = c;
green[l] = 0.3 + l * d;
blue[l] = c;
c -= (R) 0.28 / nbcoul; }
break;

case 6:
//La palette des jaunes
d = 0.7 / ndcoul;
c = 0.3;
for ( l=n1coul; l<=ndcoul; l++ )
{
red[l] = 0.3 + l * d;
green[l] = 0.3 + l * d;
blue[l] = c;
c -= (R) 0.28 / nbcoul;
}
break;

case 7:
//La palette des oranges
d = 1.0 / ndcoul;
for ( l=n1coul; l<=ndcoul; l++ )
{
red[l] = l * d;
green[l] = l * d / 2 + 20./256.;
blue[l] = 0.0;
}
break;

case 8:
//La palette des rouges
d = 0.7 / ndcoul;
c = 0.3;
for ( l=n1coul; l<=ndcoul; l++ )
{
red[l] = 0.3 + l * d;
green[l] = c;
blue[l] = c;
c -= (R) 0.28 / nbcoul;
}
break;

case 9:
//La palette des magentas
d = 0.7 / ndcoul;
c = 0.3;
for ( l=n1coul; l<=ndcoul; l++ )
{
red[l] = 0.3 + l * d;
green[l] = c;
blue[l] = 0.3 + l * d;
c -= (R) 0.28 / nbcoul;
}
break;

case 10:
//La palette des gris (du gris-noir au blanc pur)
d = 1.0 / ndcoul;
for ( l=n1coul; l<=ndcoul; l++ )
{
red[l] = l * d;
green[l] = l * d;
blue[l] = l * d;
}
break;

case 11:
//La palette Arc en ciel en fondu des couleurs
n = (int) (nbcoul/6.5+0.5); // nombre de couleurs par passage
j = (int) (n * 1.7);
for ( k=0; k<=j; k++ ) // du bleu au cyan
{
red[l] = 0;
green[l] = ( (R) k ) / j;
blue[l] = 1.0;
l += 1;
}
j = (int) (n * 0.9);
for ( k=0; k<=j; k++ ) // du cyan au vert
{
red[l] = 0;
green[l] = 1.0;
blue[l] = 1.0 - ( (R) k ) / j;
l += 1;
}
j = (int) (n * 0.9);
for ( k=0; k<=j; k++ ) // du vert au jaune
{
red[l] = ( (R) k ) / j;
green[l] = 1.0;
blue[l] = 0;
l += 1;
}
j = (int) (n * 1.7);
for ( k=0; k<=j; k++ ) // du jaune au rouge
{
red[l] = 1.0;
green[l] = 1.0 - ( (R) k ) / j;
blue[l] = 0;
l += 1;
}
j = (int) (n * 1.32);
for ( k=0; k<=j; k++ ) // du rouge au magenta
{
if(l > ndcoul ) break;
red[l] = 1.0;
green[l] = 0;
blue[l] = ( (R) k ) / j;
l += 1;
}

break;

case 12:
//La palette 12 Arc en ciel discontinue en couleurs
n = (int) (nbcoul/6.8+0.5); // nombre de nuances par couleur
for ( k=0; k<n; k++ ) // des bleus
{
d = 0.5 * ( (R) k ) / n;
red[l] = d;
green[l] = d;
blue[l] = 1.0-d/5;
l += 1;
}

for ( k=0; k<n; k++ ) // des cyans
{
d = 0.5 * ( (R) k ) / n;
red[l] = d;
green[l] = 1.0-d/5;
blue[l] = 1.0-d/5;
l += 1;
}

for ( k=0; k<n; k++ ) // des verts
{
d = 0.5 * ( (R) k ) / n;
red[l] = d;
green[l] = 1.0-d/5;
blue[l] = d;
l += 1;
}

for ( k=0; k<n; k++ ) // des jaunes
{
d = 0.5 * ( (R) k ) / n;
red[l] = 1.0-d/5;
green[l] = 1.0-d/5;
blue[l] = d;
l += 1;
}

for ( k=0; k<n; k++ ) // des oranges
{
d = 0.5 * ( (R) k ) / n;
red[l] = 1.0-d/5;
green[l] = 0.6-d/5;
blue[l] = d;
l += 1;
}

for ( k=0; k<n; k++ ) // des rouges
{
d = 0.5 * ( (R) k ) / n;
red[l] = 1.0-d/5;
green[l] = d;
blue[l] = d;
l += 1;
}

for ( k=0; k<n; k++ ) // des magentas
{
if( l > ndcoul ) break;
d = 0.5 * ( (R) k ) / n;
red[l] = 1.0-d/5;
green[l] = d;
blue[l] = 1.0-d/5;
l += 1;
}
break;

case 13:
//La palette 13 Arc en ciel avec 10 nuances pour chaque couleur
n = (int) (nbcoul/10.0+0.5); // nombre de nuances par couleur
d0 = 0.3;
d1 = 1.0 - d0;
for ( k=0; k<n; k++ )
{
// des bleus
d = d0 * ( (R) k ) / n;
red[l] = d;
green[l] = d;
blue[l] = d+d1;
l += 1;
// des cyans
red[l] = d;
green[l] = d+d1;
blue[l] = d+d1;
l += 1;
// des verts
red[l] = d;
green[l] = d+d1;
blue[l] = d;
l += 1;
// des verts turquoises
red[l] = d+ 64./256.*d1 ;
green[l] = d+224./256.*d1;
blue[l] = d+188./256.*d1;
l += 1;

// des beiges
red[l] = d+245./256.*d1;
green[l] = d+245./256.*d1;
blue[l] = d+220./256.*d1;
l += 1;
// des jaunes
red[l] = d+0.7;
green[l] = d+0.7;
blue[l] = d;
l += 1;
// des oranges
red[l] = d+1.0*d1;
green[l] = d+0.5*d1;
blue[l] = d;
l += 1;
// des saumons
red[l] = d+250./256.*d1;
green[l] = d+140./256.*d1;
blue[l] = d+105./256.*d1;
l += 1;
// des rouges
red[l] = d+d1;
green[l] = d;
blue[l] = d;
l += 1;
// des magentas
red[l] = d+d1;
green[l] = d;
blue[l] = d+d1;
l += 1;
}
break;

case 14:
//La palette 14 Bleu Blanc Rouge
n = (int) (nbcoul/2.0+0.5); // nombre de nuances par couleur
for ( k=0; k<n; k++ ) // les bleus et les cyans
{
red[l] = 0.2 + ( (R) k * 0.79 ) / n;
green[l] = 0.2 + ( (R) k * 0.79 ) / n;
blue[l] = 1.0;
l += 1;
}
for ( k=0; k<n; k++ ) // les rouges
{
if( l > ndcoul ) break;
red[l] = 1.0;
green[l] = 0.2 + ( (R) (n-k)* 0.79 ) / n;
blue[l] = 0.2 + ( (R) (n-k)* 0.79 ) / n;
l += 1;
}
break;
}

//les nbcolo couleurs sont allouees dans la colormap partageable
VuRGBtoColormap( visual_class, nbcolo,
red, green, blue,
norgb, color_map );
}

void MemoirePx::VuCreerPixmap( unsigned int largpix, unsigned int hautpix,
XPoint csgdf )
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT: Creer un pixmap de largpix pixels en largeur et hautpix pixels en hauteur
// associe a fenetre_vu
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
largeurpx = largpix;
hauteurpx = hautpix;
pxcsgdf = csgdf;
mempx = XCreatePixmap( display_vu, fenetre_vu,
largeurpx, hauteurpx,
DefaultDepth( display_vu, ecran_vu ) );
VuEffacerMemoirePx(); //le pixmap a pour couleur celle du fond
visee = 0; //pas de type de visee defini
}

MemoirePx::~MemoirePx()
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT: Tuer un pixmap associe a fenetre_vu
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
//cout << "Appel XFreePixmap\n"; //pour voir quand le destructeur agit
XFreePixmap( display_vu, mempx );
}

void MemoirePxAccroche::VuCreerPixmap( unsigned int largpx, unsigned int hautpx )
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT: Creer le pixmap contenant le carre de visualisation d'un accrochage
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
XGCValues gcvalues;
unsigned long colour;
int nbep=3;

//creation du Pixmap avec position nulle du pixel coin superieur gauche
//cette valeur sera actualisee avant emploi dans l'accrochage
XPoint csgdf={0,0};
MemoirePx::VuCreerPixmap( largpx, hautpx, csgdf );

// le fond de pixmap a pour couleur celle du fond de la fenetre
XSetForeground( display_vu, gc_vu, background );
XFillRectangle( display_vu, mempx, gc_vu, 0, 0, largeurpx, hauteurpx );

// nbep epaisseurs supplementaires de trait pour le symbole de l'accrochage
gcvalues.line_width = nbep;
XChangeGC( display_vu, gc_vu, GCLineWidth, &gcvalues );

//le symbole d'accrochage est un carre
colour = norgb[Jaune];
//cout << "La couleur du carre d'accrochage est " << colour << endl;
XSetForeground( display_vu, gc_vu, colour );
XDrawRectangle( display_vu, mempx, gc_vu, 1, 1,
largeurpx-nbep, hauteurpx-nbep );
}

void VuChargerLaFonte( int & n, char *namefonts,
int & largpx, int & hautpx )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
BUT : CHARGER la fonte n de nom namefonts parmi les fontes disponibles
-----

MODIFIE :
---------
n : numero de la fonte de X
si fonte indisponible, c'est la premiere fonte disponible suivante

ENTREES :
---------
namefonts : nom de la fonte a charger

SORTIES :
---------
largpx : nombre de pixels en largeur de la fonte
hautpx : nombre de pixels en hauteur de la fonte
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
int i, j, ideb, ifin, ilon, direction ;
char *font, mp[3] ;

if ( ( 0 <= n ) && ( n < nbfontes ) )
{
j = 0 ;
for ( i = n ; nbfontes - 1 ; i++ )
{
font = *(listfonts + i);
strcpy( namefonts, font );
struc_police = XLoadQueryFont(display_vu, font);
if (struc_police != NULL)
{
XSetFont (display_vu, gc_vu, struc_police->fid);
if ( i != n )
{
sprintf(&format[0],"\n VuChargerLaFonte: fonte %d indisponible => remplacee par la fonte %d\n\n",n,i);
printf(format) ; n = i ;
}
j = 1 ; break ;
}
}
if ( j == 0 )
{
for ( i = 1 ; n - 1 ; i++ )
{
font = *(listfonts + n);
strcpy( namefonts, font );
struc_police = XLoadQueryFont(display_vu, font);
if (struc_police != NULL)
{
XSetFont (display_vu, gc_vu, struc_police->fid) ;
if ( i != n )
{
sprintf(&format[0],"\n VuChargerLaFonte: fonte %d indisponible => remplacee par la fonte %d\n\n",n,i);
printf(format) ; n = i ;
}
j = 1 ; break ;
}
}
}
if ( j == 0 )
{
sprintf(&format[0],"\n VuchargerLaFonte: AUCUNE FONTE N'EST DISPONIBLE\n");
printf(format) ;
}

sprintf(&format[0],"abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890") ;
XTextExtents(struc_police , format , strlen(format) , &direction ,
&ascent_pol , &descent_pol , &mesure ) ;
largpx = (int) (mesure.width / 64.0) ;
largpx = largpx + 1 ;
/* hautpx = ascent_pol + descent_pol ; VALEUR MAX TROP GRANDE */
hautpx = mesure.ascent + mesure.descent;

/* Traitement en vue du PostScript */
ideb = 0 ; ifin = 0 ;
for ( i = 1 ; i < strlen(font) ; i++ )
{ if (font[i] == '-') { if (ifin == 0) { ideb = i ; ifin = i ;
} else { ifin = i ; sprintf(format,"/%%.%ds ",ifin-ideb-1) ;
sprintf(fontcour,format,&font[ideb+1]) ;
if (strcmp("/new century schoolbook ",fontcour) == 0 ) {
sprintf(fontcour,"/NewCenturySchlbk \0") ; }
fontcour[1] = toupper(fontcour[1]) ; break ; } } }
ideb = ifin ;
for ( i = ideb + 1 ; i < strlen(font) ; i++ )
{ if (font[i] == '-') { ifin = i ; sprintf(format,"/%%.%ds ",ifin-ideb-1) ;
ilon = strlen(fontcour) ; sprintf(&fontcour[ilon],format,&font[ideb+1]) ;
fontcour[ilon+1] = toupper(fontcour[ilon+1]) ; break ; } }
ideb = ifin ;
for ( i = ideb + 1 ; i < strlen(font) ; i++ )
{ if (font[i] == '-') { ifin = i ; sprintf(format,"%.1s",&font[ideb+1]) ;
if (format[0] == 'o') { sprintf(&fontcour[strlen(fontcour)],"/Oblique ") ;
} else { if (format[0] == 'i') { sprintf(&fontcour[strlen(fontcour)],"/Italic ") ;
} else { if (format[0] == 'r') { sprintf(&fontcour[strlen(fontcour)],"/ ") ;
} else { sprintf(&fontcour[strlen(fontcour)],"/ ") ; } } } break ; } }
ideb = ifin ; ilon = 0 ;
for ( i = ideb + 1 ; i < strlen(font) ; i++ )
{ if (font[i] == '-') { ilon = ilon + 1 ;
if (ilon < 7) { ideb = i ; ifin = i ;
} else { ifin = i ;
sprintf(format,"(%%.%ds)",ifin-ideb-1) ;
sprintf(mp,format,&font[ideb+1]) ;
if (strcmp("(p)",mp) != 0 ) {
sprintf(mp,"(m)") ; }
break ; } } }
sprintf(&fontcour[strlen(fontcour)],"%d %d %s charge\n",mesure.ascent,
mesure.rbearing-mesure.lbearing,mp) ;
}
else
{
printf("VuchargerLaFonte: fonte indisponible => fonte inchangee\n");
}
/* Traitement du postscript */
if (lasopsc > 0){
if (nbrcon > 0){
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
}
if (lasopsc < 3){
fprintf(fpo,fontcour) ;
}
else{
sprintf(&chaine[lasopsc-4][strlen(chaine[lasopsc-4])],fontcour) ;
}
}
}

void VuChargerFonte( int nufont )
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// but : charger la fonte nufont pour les traces
// -----
//
// entree :
// --------
// nufont : numero de la fonte dans X
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
if( nufont < 0 || nufont >= nbfontes )
{
cout << "Erreur ChargerFonte nufont=" << nufont << " incorrect" << endl;
return;
}

if( nofoca == nufont ) return;

//la fonte de caracteres choisie est chargee
nofoca = nufont;

//en sortie:
//nplaca largeur en pixels des caracteres de cette fonte
//nphaca hauteur en pixels des caracteres de cette fonte
VuChargerLaFonte( nofoca, listfonts[nofoca], nplaca, nphaca );

//affichage des caracteristiques de la fonte effectivement chargee
//cout << "Nom de la FONTE " << nofoca << " chargee="
// << listfonts[nofoca] << endl;
//cout << "Caracteres de " << nplaca << " pixels en largeur et "
// << nphaca << " pixels en hauteur" << endl;
}

void VuChoisirFonte( int lhpxfonte )
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : CHOISIR ET CHARGER UNE FONTE CORRECTE POUR Vu
// -----
//
// ENTREES:
// --------
// lhpxfonte: LA HAUTEUR LA PLUS PROCHE EN PIXELS DE LA FONTE A CHARGER
// DE PREFERENCE GRASSE et courier et roman
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
int k, l, lecapx, nufont;

lecapx = 10000;
for ( k=0; k<nbfontes; k++ )
{
l = lhpxfonte - lhpxfo[k];
if ( l < 0 ) l=-l;

if ( l < lecapx )
{
nufont = k; // la fonte aura lhpxfonte pixels en hauteur
lecapx = l;
}
else if( l == lecapx
&& strstr( listfonts[k], "-adobe-" ) != NULL
&& strstr( listfonts[k], "-courier-" ) != NULL
&& strstr( listfonts[k], "-bold-" ) != NULL
&& strstr( listfonts[k], "-r-" ) != NULL )
nufont = k;
}

// CHARGEMENT DE LA FONTE TROUVEE
VuChargerFonte( nufont );
}

void VuEpaisseur( int epais )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
BUT : IMPOSER le nombre d'epaisseurs des traits

ENTREE :
--------
epais : nombre d'epaisseurs des traces a venir
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
XGCValues gcvalues;

gcvalues.line_width = epais;
XChangeGC(display_vu, gc_vu, GCLineWidth, &gcvalues);

/* Traitement du postscript :
destination : TEMPORAIRE.EPS si l'instruction est de type dessin
: chaine si l'instruction correspond a un menu */
if ( lasopsc > 0){
iep = 1 ;
if (nbrcon > 0){
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
}
if (lasopsc < 3){
fprintf(fpo,"%2i epais\n" , epais) ;
}
else{
sprintf(&chaine[lasopsc-4][strlen(chaine[lasopsc-4])],
"%2i epais\n" , epais) ;
}
}
}

void VuTypeTrait( int type )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : IMPOSER le type de trace d'un trait
//
// ENTREE :
// --------
// type : 0 LIGNE CONTINUE
// 1 LIGNE TIRETEE
// 2 LIGNE TIRETEE D'EPAISSEUR DOUBLE
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
XGCValues gcvalues;

switch (type)
{
case 0 : { gcvalues.line_style = LineSolid; break; }
case 1 : { gcvalues.line_style = LineOnOffDash; break; }
default : { gcvalues.line_style = LineDoubleDash; break; }
}
XChangeGC(display_vu, gc_vu, GCLineStyle, &gcvalues);

/* Traitement du postscript :
destination : TEMPORAIRE.EPS si l'instruction est de type dessin
: chaine si l'instruction correspond a un menu */
if ( lasopsc > 0){
ity = 1 ;
if (nbrcon > 0){
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
}
sprintf(buf,"%2i typet\n",type) ;
if (lasopsc < 3){
fprintf(fpo,buf) ;
}
else{
sprintf(&chaine[lasopsc-4][strlen(chaine[lasopsc-4])],buf) ;
}
}
}

void VuOuvrir( char *titre_fen_vu,
int lafepx, int hafepx, int nphfco )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : INITIALISER et OUVRIR la fenetre graphique X
//------ DEFINIR la largeur et hauteur PIXELS de la FENETRE A OUVRIR
// a partir du coin superieur gauche de l'ecran
// DEFINIR la palette des couleurs
// Recuperer les caracteristiques des fontes de caracteres
// CHARGER la fonte de hauteur pixels precisee
// ENTREES :
// ---------
// titre_fen_vu : titre de la fenetre Vu
// lafepx : nombre de pixels de la largeur de la fenetre a ouvrir
// hafepx : nombre de pixels de la hauteur de la fenetre a ouvrir
// nphfco : nombre de pixels en hauteur de la fonte de caracteres X a charger
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
int x, y, i, j, k, nbcafo;
char *car;
char data[7];
int ntab[32];
unsigned int largeurpx, hauteurpx, bordurepx;
XGCValues gcvalues;

//Initialisation du Display et de l'ecran X sont deja faits
//===================================================

// Creation de la fenetre avec lapxfe et lhpxfe pixels en largeur et hauteur
x = (int) X_COIN_FENETRE;
y = (int) Y_COIN_FENETRE;

lapxfe = lafepx;
lhpxfe = hafepx;
xpixels = lafepx; // pour le PostScript
ypixels = hafepx;

largeurpx = (unsigned int) lafepx;
hauteurpx = (unsigned int) hafepx;
bordurepx = (unsigned int) 5 ;

fenetre_vu0 = RootWindow( display_vu, ecran_vu );
visual = DefaultVisual( display_vu, ecran_vu );
visual_class = visual->c_class; /* c_class en C++ et class en C */
cout << "Visual_classe = ";
nbcolo = visual->map_entries;

relance:
switch ( visual_class )
{
/*-----------------------------------------*/
/* Les 3 CLASSES avec PALETTES MODIFIABLES */
/*-----------------------------------------*/

case PseudoColor: /* Classe des ecrans avec 8 plans ecrans couleurs => 256 couleurs */
/*--------------- Les palettes colormap sont en Lecture/ecriture non partageables */
/* Le no couleur Vu = celui de la palette physique */
/* Tout pixel de l'ecran a un no de couleur dans la palette */
/* auquel correspond dans la palette 3 valeurs rouge vert bleu tracees */
{
cout << "PseudoColor" << endl;
/* Creation d'une nouvelle resource X de type colormap aupres du serveur X */
/* toutes les cellules de la colormap doivent etre allouees et reservees au
client X c-a-d qu'il est le seul a en disposer tant en lecture qu'en ecriture */
color_map = XCreateColormap ( display_vu, fenetre_vu0, visual, AllocAll );

/* le nombre de couleurs de la palette colormap */
nbcolo = visual->map_entries;
if (DefaultDepth(display_vu, ecran_vu) == 1)
{
/* Black and white: tout ce qui n'est pas noir est blanc */
/* La palette est blanche */
for (i = 1; i < nbcolo; i++)
{ /* au dela 0 toutes les couleurs sont blanches */
red[i] =1.0;
green[i]=1.0;
blue[i] =1.0;
}
}
else
{ /* Il y a nbcolo>2 couleurs dans la palette
Remplissage de red green blue a partir de la palette par defaut
qui est partageable donc necessairement en lecture seule */
color_map0 = DefaultColormap(display_vu, ecran_vu);
if ( nbcolo > CMAPSIZE ) nbcolo = CMAPSIZE;
VuColormapToRGB( color_map0, red, green, blue, nbcolo);
}

// le nombre de palettes de couleurs disponibles dans Vu
nbpacl = MAXPACL;

/* Definition des couleurs imposees pour toutes les palettes */
VuCouleursImposees( n1coel, ndcoel, red, green, blue );

/* Stockage de ces couleurs dans la palette colormap */
VuRGBtoColormap(visual_class, nbcolo,
red, green, blue, norgb, color_map);

/* le numero des couleurs reservees 0 a ndcore et modifiables ndcore + 1 a nbcolo-1 */
ndcore = ndcoel ;
n1coul = ndcore + (int) 1 ;
ndcoul = (int) nbcolo-1 ;
break;
}

case GrayScale : /* Classe des ecrans gris avec 8 plans => 256 niveaux de gris */
/*-------------- Les palettes colormap sont en Lecture/ecriture non partageables */
/* Le no couleur Vu = celui de la palette physique */
/* Tout pixel de l'ecran a un no de couleur dans la palette */
/* auquel correspond dans la palette 3 valeurs rouge vert bleu tracees */
/* Par exemple si rouge vert bleu sont connus alors */
/* intensite du gris = = 0.3*rouge + 0.59*vert + 0.11*bleu */
/* donne une bonne valeur */
{
cout << "GrayScale ATTENTION: NON teste dans Vu\n";
color_map = DefaultColormap( display_vu, ecran_vu );
nbcolo = visual->map_entries; /* nbcolo = 256; */

/* stockage des red green blue dans color_map la palette courante Read/Write */
n1core = (int) 0 ; /* Premiere couleur reservee (non modifiee) */
/* Derniere couleur reservee = derniere couleur elementaire */
n1coel = (int) 0 ; /* Premiere couleur elementaire pour le noir */
/* Ici aucune couleur reservee a part les couleurs elementaires*/
/* Definition des couleurs imposees pour toutes les palettes */
VuCouleursImposees( n1coel, ndcoel, red, green, blue );

/* le numero des couleurs reservees et modifiables */
ndcoel = (int) 1 ;
ndcore = (int) 15 ;
n1coul = (int) 16 ;
ndcoul = (int) 255 ;

// le nombre de palettes de couleurs disponibles dans Vu
nbpacl = MAXPACL;
break;
}

case DirectColor : /* Classe des ecrans avec >8 plans ecrans couleurs => >256 couleurs */
/*--------------- Les palettes colormap sont en Lecture/ecriture non partageables */
/* Tout pixel de l'ecran a un no de couleur dans la palette physique */
/* qui se decompose en 3 valeurs rouge vert bleu qui */
/* donnent le RVB trace par une fonction du type */
/* no palette= rouge + vert*2**nbplansrouge + bleu*2**(nbplansrouge+vert) */
{
cout << "DirectColor ATTENTION: NON teste dans Vu\n";
cout << "Essai de remplacer DirectColor par PseudoColor...\n";
visual->c_class=PseudoColor;
goto relance;
}

/*----------------------------------------------------------------------*/
/* Les 3 CLASSES avec une PALETTE NON MODIFIABLE (C'est celle du serveur X) */
/*----------------------------------------------------------------------*/

case StaticColor: /* idem PseudoColor: Classe ecrans avec 8 plans ecrans couleurs=>256 couleurs */
/*--------------- La palette colormap est en Lecture seule, partageable, non modifiable */
/* Le no couleur Vu = celui de la palette physique */
/* Tout pixel de l'ecran a un no de couleur dans la palette */
/* auquel correspond dans la palette 3 valeurs rouge vert bleu tracees */
{
cout << "StaticColor ATTENTION: NON teste dans Vu\n";
color_map = DefaultColormap( display_vu, ecran_vu );
nbcolo = visual->map_entries;
VuColormapToRGB( color_map, red, green, blue, nbcolo);
/* le numero des couleurs reservees et modifiables */
n1core = (int) 0 ;
n1coel = (int) 0 ;
ndcoel = (int) 1 ;
ndcore = (int) 1 ;
n1coul = (int) 1 ;
ndcoul = (int) 1 ;

// le nombre de palettes de couleurs disponibles dans Vu
nbpacl = 1;
break;
}

case StaticGray : /* idem GrayScale mais avec une colormap fixe */
/*--------------- La palette colormap est en Lecture seule, partageable, non modifiable */
/* Le no couleur Vu = celui de la palette physique */
/* Tout pixel de l'ecran a un no de gris dans la palette => trace */
{
cout << "StaticGray ATTENTION: NON teste dans Vu\n";
color_map = DefaultColormap( display_vu, ecran_vu );
nbcolo = 2;
/* le numero des couleurs reservees et modifiables */
n1core = (int) 0 ;
n1coel = (int) 0 ;
ndcoel = (int) 1 ;
ndcore = (int) 1 ;
n1coul = (int) 1 ;
ndcoul = (int) 1 ;

// le nombre de palettes de couleurs disponibles dans Vu
nbpacl = 1;
break;
}

case TrueColor : /* Classe des ecrans avec >8 plans ecrans couleurs => >256 couleurs */
/*--------------- La palette colormap est en Lecture seule partageable */
/* Le no couleur Vu est different de celui de la palette physique */
/* Tout pixel de l'ecran a un no de couleur dans la palette physique */
/* ce no se decompose en 3 valeurs rouge vert bleu qui */
/* donnent le RVB trace par une fonction du type */
/* no palette= rouge + vert*2**nbplansrouge + bleu*2**(nbplansrouge+vert) */
{
cout << "TrueColor\n";
/* Palette de couleurs en lecture seule donc partageable */
/* Recuperation de la colormap du serveur X */
color_map = DefaultColormap( display_vu, ecran_vu );

/* le nombre de couleurs de la palette Vu est celui du stockage de red,...*/
/* Attention: nbcolo n'est plus ensuite le nombre de couleurs de la palette physique! */
nbcolo = 256;

// le nombre de palettes de couleurs disponibles dans Vu
nbpacl = MAXPACL;

/* Il y a nbcolo>2 couleurs dans la palette Vu
Remplissage de red green blue a partir de la palette par defaut
qui est partageable donc necessairement en lecture seule */

/* Initialisation des red green blue du C */
n1core = (int) 0 ; /* Premiere couleur reservee (non modifiee) */
/* Derniere couleur reservee = derniere couleur elementaire */
n1coel = (int) 0 ; /* Premiere couleur elementaire pour le noir */
/* Ici aucune couleur reservee a part les couleurs elementaires*/

/* Definition des couleurs imposees */
VuCouleursImposees( n1coel, ndcoel, red, green, blue );

/* le numero des couleurs reservees 0 a ndcore et modifiables ndcore+1 a nbcolo-1 */
ndcore = ndcoel ;
n1coul = ndcore + (int) 1 ;
ndcoul = (int) nbcolo-1 ;

/* les couleurs Vu modifiables sont momentanement grises */
for (i = n1coul; i <= ndcoul; i++)
{ /* au dela de ndcore toutes les couleurs sont grises */
red[i] = (R) i / (R) ndcoul;
green[i]= (R) i / (R) ndcoul;
blue[i] = (R) i / (R) ndcoul;
}

/* les nbcolo couleurs sont allouees dans la colormap partageable */
/* le norgb[i] de chaque couleur i de la palette Vu est celui de la couleur
la plus approchante dans la palette physique */
VuRGBtoColormap( visual_class, nbcolo,
red, green, blue, norgb, color_map);
break;
}
}

/* Traitement quelquesoit la classe */
/*----------------------------------*/
cout << "Palette X initiale de " << visual->map_entries << " couleurs\n";
cout << "Palette Vu utile de " << nbcolo << " couleurs\n";
cout << "Nombre de plans des couleurs = " << DefaultDepth(display_vu,ecran_vu) << endl;
nobackground = 0;
background = (unsigned long) BlackPixel(display_vu,ecran_vu);
noforeground = 1;
foreground = (unsigned long) WhitePixel(display_vu,ecran_vu);

attributs_vu.background_pixel = background;
attributs_vu.border_pixel = foreground;
attributs_vu.backing_store = Always;
attributs_vu.colormap = color_map;

/*==========================*/
/* Creation de la fenetre X */
/*==========================*/
fenetre_vu = XCreateWindow( display_vu,
fenetre_vu0,
x, y, largeurpx, hauteurpx, bordurepx,
CopyFromParent,
InputOutput,
visual,
CWBackPixel | CWBorderPixel | CWBackingStore | CWColormap,
&attributs_vu);
//cout << "Creation de fenetre_vu=" << fenetre_vu << endl;

strcpy(data,titre_fen_vu); // le nouveau titre de la fenetre
XChangeProperty( display_vu, fenetre_vu, XA_WM_NAME, XA_STRING, 8,
PropModeReplace,(unsigned char *) data, strlen(titre_fen_vu) );

// les seuls EVENEMENTS qui interessent Vu sont indiques AU DESSOUS
// 18/ 1/1999 attributs_vu.event_mask = ExposureMask | KeyPressMask | ButtonPressMask;
// 10/10/2000 ajout de | ButtonMotionMask | ButtonReleaseMask
// 19/01/2001 ajout de | PointerMotionMask pour tout deplacement du pointeur de la souris
// sans bouton enfonce ou relache

XChangeWindowAttributes( display_vu, fenetre_vu,
CWEventMask, &attributs_vu);

XMapWindow(display_vu, fenetre_vu); /* la fenetre devient visible */

//Pas de trace PostScript pour commencer
lasopsc = 0;
//cout << "Pas de PostScript au depart\n";

/*-----------------------------*/
/* Le traitement des fontes */
/*-----------------------------*/
//cout << "Traitement des fontes X\n";

listfonts = XListFonts (display_vu, "*adobe*", 1, &nbfontes);
if ( nbfontes != 0 )
font_id = XLoadFont (display_vu, *listfonts);
else
{
cout << "AUCUNE FONTE X N'EST DISPONIBLE!\n";
exit(1);
}

gcvalues.foreground = foreground;
gcvalues.background = background;
gcvalues.function = GXcopy;
gcvalues.font = font_id;
gc_vu = XCreateGC( display_vu,
fenetre_vu,
GCForeground | GCBackground | GCFunction | GCFont,
&gcvalues );
XSetFillRule( display_vu,gc_vu,WindingRule );

XSetArcMode( display_vu,gc_vu,ArcChord );

listfonts = XListFonts (display_vu, "*adobe*", MAXFONTS, &nbfontes);

/* si necessaire, on prend un filtre plus large */
if (nbfontes == 0)
listfonts = XListFonts (display_vu, "*", MAXFONTS, &nbfontes);

cout << "Nombre de fontes X disponibles = " << nbfontes << endl;

// analyse des noms des fontes
for ( k=0; k<nbfontes; k++ )
{
// le nombre de caracteres du nom de la fonte k
nbcafo = strlen( listfonts[k] );

// DECOUPE DU NOM DE LA FONTE EN CHAMPS SEPARES PAR '-'
for (i=0; i<32; i++ )
ntab[i] = nbcafo;

// le nombre ntab[i] de champs de chaque nom de fonte
i=0;
for (j=0; j<nbcafo; j++ )
{
if ( listfonts[k][j] == '-' )
{
i = i+1;
ntab[i] = j;
}
}

// HAUTEUR en PIXELS DE CHAQUE FONTE
j = ntab[8]-ntab[7]-1;
if ( j<1 || j>3 )
{
cout << "ntab[7]=" << ntab[7] << " ntab[8]=" << ntab[8] << endl;
lhpxfo[i]=-1;
cout << "SAUT DE " << listfonts[k] << endl;
continue; // saut de la police k
}
else
lhpxfo[k] = atoi( &(listfonts[k][ntab[7]+1]) );
}

//Chargement de la fonte de hauteur nphfco pixels
VuChoisirFonte( nphfco );

// definition des traits initiaux
nbepai = 1; // une epaisseur en plus
VuEpaisseur( nbepai );
//cout << "Epaisseur des traits=" << nbepai << endl;

notytr = 0; // trace de trait continu
VuTypeTrait( notytr );
//cout << "Type de trace des traits=" << notytr << endl;

//Ajuster la taille des boutons des menus
larginvite = lapxfe;
if( lapxfe > 1100 )
{
largbouton = 125; // definition ecran 1280 x 1024
hautbouton = 24;
nbepbordbouton = 2;
hauttexte = 16;
decaltexte = 4;
hautinvite = hautbouton;
}
else if( lapxfe > 900 )
{
largbouton = 100; // definition ecran 1024 x 768
hautbouton = 22;
nbepbordbouton = 2;
hauttexte = 14;
decaltexte = 4;
hautinvite = hautbouton;
}
else
{
largbouton = 90; // definition ecran 800 x 600
hautbouton = 20;
nbepbordbouton = 2;
hauttexte = 12;
decaltexte = 3;
hautinvite = hautbouton;
}
}

void VuCouleur( int icolor )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : IMPOSER pour tous les traces a venir la couleur icolor de la palette
//
// ENTREES:
// --------
// icolor : le numero de la couleur de trace dans la palette Vu actuelle
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
unsigned long colour;

// indirection necessaire pour traiter a la fois PseudoColor et TrueColor
// colour est le numero de la couleur icolor dans la palette physique de Vu
noforeground = icolor;
colour = norgb[icolor];
foreground = colour;
XSetForeground(display_vu, gc_vu, colour);

// Traitement du postscript :
// counb est ramenee sur [0,1] suivant la palette utilisee
// counb = -1 si icolor est une des couleurs non modifiable de la palette
if (lasopsc > 0)
{
if (icolorm != icolor)
{
icolorm = icolor ;
if (nbrcon > 0)
{
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
}
courgb[0] = red[icolor] ;
courgb[1] = green[icolor] ;
courgb[2] = blue[icolor] ;
if (icolor < n1coul)
{
counb = -1 ;
}
else
{
if (palcourc == 2)
{
/* icolor varie sur palette de 6 couleurs */
counb = ( (icolor-n1coul) % 6 ) / 5.0 ;
}
else
{
if (palcourc == 12)
{
/* icolor varie sur palette de 10 couleurs */
counb = ( (icolor-n1coul) % 10 ) / 9.0 ;
}
else
{
/* icolor varie sur palette totale */
counb = ((R) (ndcoul - icolor)) / (ndcoul - n1coul) ;
}
}
}
}
}
}

void VuPostscript( int lasops )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
BUT : IMPOSER la nouvelle option de sortie du trace du maillage en POSTSCRIPT
A NE PAS APPELER DIRECTEMENT LORSQU'ON UTILISE Vu
==========================
ENTREE :
---------
lasops : DEMANDE OU NON DE SORTIE DU TRACE DU MAILLAGE EN POSTSCRIPT
0 : PAS DE SORTIE POSTSCRIPT
NON 0 : SORTIE DU TRACE EN POSTSCRIPT
1 trace normal
2 trace normal avec menu
3 ... 10 trace dans les differents menus
-3 ...-10 effacement des differents menus
11 12 trace menu qualites ou histos (resp 1 ou 2)
-11 -12 effacement menu qualites ou histos (resp 1 ou 2)
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AUTEUR : DOURSAT CHRISTOPHE UPMC ANALYSE NUMERIQUE PARIS JUIN 1994
12345X7...................................................012345678*/
{
int i ;
/*int j;*/
/*char nom[3] ;*/

/* Traitement du postscript */

/* ouverture du postscript */
if ( lasops > 0 && lasopsc == 0 ) {
lasopsc = lasops ;
if (fpo != NULL) {
fclose(fpo) ;
fpo = NULL ;
}
if ( modepsc != 0 ){
if ((fpo = fopen("TEMPORAIRE.QUA","r"))!=NULL) {
fclose(fpo) ;
fpo = NULL ;
remove("TEMPORAIRE.QUA") ;
}
}
if ((fpo = fopen("TEMPORAIRE.EPS","w"))==NULL) {
printf ("Erreur de creation de fichier...Sortie immediate\n") ;
exit (1);
}
if ( modepsc != 0 ){
for (i = 0; i < 8 ; i++) chaine[i] = (char*) calloc(longchaine[i],sizeof(char)) ;
}
nbrcon = 0 ;
concat[0] = '\0' ;
iTe = 0 ; iFa = 0 ; ity = 0 ; iep = 0 ; iPo = 0 ;
ire = 0 ; iRe = 0 ; iel = 0 ; iEl = 0 ; iFP = 0 ;
}
else {
if ( lasops == 0 ) {
lasopsc = lasops ;
if (fpo != NULL) {
fprintf(fpo,concat) ;
fclose(fpo) ;
fpo = NULL ;
if ( modepsc != 0 ){
for (i = 0; i < 8 ; i++) { chaine[i] = '\0' ; free(chaine[i]) ; }
}
menu = 0 ;
}
}
else {
if ( lasops > 100) {
/* remise a zero des controles de macros */
iTe = 0 ; iFa = 0 ; ity = 0 ; iep = 0 ; iPo = 0 ;
ire = 0 ; iRe = 0 ; iel = 0 ; iEl = 0 ; iFP = 0 ;
/* effacement des differents fichiers temporaires */
if (fpo != NULL) {
fclose(fpo) ;
fpo = NULL ;
}
/* effacement du fichier temporaire des histogrammes de qualite */
if ( modepsc != 0 ){
if ((fpo = fopen("TEMPORAIRE.QUA","r"))!=NULL) {
fclose(fpo) ;
fpo = NULL ;
remove("TEMPORAIRE.QUA") ;
}
}
/* effacement du fichier temporaire postscript */
if ((fpo = fopen("TEMPORAIRE.EPS","w"))==NULL) {
printf ("Erreur de creation de fichier...Sortie immediate\n") ;
exit (1);
}
/* effacement des menus postscript */
if ( modepsc != 0 ){for (i = 0; i < 8 ; i++) *chaine[i] = '\0' ;}
lasopsc = lasopsc - 100 ;
}
else {
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
if (lasops < -1) {
/* effacement du menu correspondant */
lasopsc = Max(lasops,-11) ;
if ( modepsc != 0 ){*chaine[-lasopsc-4] = '\0' ;}
}
else{
lasopsc = Min(lasops,11) ;
if (lasopsc == 2) menu = 1 ;
}
}
}
}
}

void VuEffacer()
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : EFFACER la fenetre actuelle et tracer la fenetre avec la couleur de fond
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
XClearWindow( display_vu, fenetre_vu );
XFlush( display_vu );

// Traitement du postscript :
// 101 ou 102 effacement en mode sans (1) ou avec (2) menus
if (lasopsc > 0)
{
lasopsc = 100 + lasopsc ;
VuPostscript(lasopsc) ;
}
}

void VuCouleurFond( int icolor )
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : IMPOSER une couleur comme FOND de FENETRE
// ----- EFFACER LA FENETRE et la retracer avec la nouvelle couleur de fond
//
// ENTREES :
// ---------
// icolor : le numero dans la palette Vu de la couleur du fond
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
// indirection necessaire pour traiter a la fois PseudoColor et TrueColor
// background est le numero de la couleur icolor Vu dans la palette physique
nobackground = icolor;
background = norgb[icolor];

//stockage de la couleur de fond
attributs_vu.background_pixel = background;
XChangeWindowAttributes( display_vu, fenetre_vu,
CWBackPixel | CWBorderPixel | CWBackingStore | CWColormap,
&attributs_vu);
XSetBackground( display_vu, gc_vu, background );
XSetWindowBackground( display_vu, fenetre_vu, background );

VuEffacer(); //Efface l'ecran qui prend la nouvelle couleur de fond
}

void VuNbPxTexte( char *texte, int & nbpxla, int & nbpxha )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
BUT : Retrouver les dimensions en pixels d'une chaine de caracteres

ENTREES :
---------
texte : la chaine de caracteres

SORTIES :
---------
nbpxla : le nombre de pixels de la largeur de la chaine de caracteres
nbpxha : le nombre de pixels de la hauteur de la chaine de caracteres
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
int direction, length ;

length = nudcnb( texte );
XTextExtents( struc_police , texte , length , &direction ,
&ascent_pol , &descent_pol , &mesure ) ;
nbpxla = mesure.width ;
nbpxha = mesure.ascent + mesure.descent ;
}

void VuFermer( void )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
BUT : FERMER la fenetre Vu
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
/* XUnmapWindow( display_vu, fenetre_vu); la fenetre devient invisible */
XFreeGC( display_vu, gc_vu );
XFreeColormap( display_vu, color_map );
/* XDestroyWindow( display_vu, fenetre_vu ); */
XCloseDisplay( display_vu );
}

void VuPxFenetre( int & lapxfe, int & lhpxfe )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : RECUPERER le nombre de pixels de la largeur et hauteur de
// ----- la FENETRE ACTUELLE
//
// SORTIES :
// ---------
// lapxfe : nombre de pixels de la largeur de la fenetre
// lhpxfe : nombre de pixels de la hauteur de la fenetre
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
XWindowAttributes wattrib;

XGetWindowAttributes(display_vu, fenetre_vu, &wattrib);
lapxfe = wattrib.width;
lhpxfe = wattrib.height;
}

void MemoirePx::VuCombinerFenetreDansMemoirePx( int GX ,
XPoint xyfen, unsigned int largfen, unsigned int hautfen,//source
XPoint xympx ) //destination
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : Combiner les pixels de la fenetre_vu dans MemoirePx selon le code GX
//----- a partir de xyfen coin superieur gauche de fenetre_vu
// dans MemoirePx.mempx a partir du coin superieur gauche xympx
//
// Les pixels du pixmap mempx (src) et la fenetre_vu (dst) se combinent selon
// la valeur de GX qui peut prendre les valeurs suivantes:
//
// GXclear 0x0 <=> 0
// GXand 0x1 <=> src AND dst src comme source
// GXandReverse 0x2 <=> src AND (NOT dst) dst comme destination
// GXcopy 0x3 <=> src
// GXandInverted 0x4 <=> (NOT src) AND dst
// GXnoop 0x5 <=> dst
// GXxor 0x6 <=> src XOR dst (XOR ou exclusif) (2 fois redonne obj)
// GXor 0x7 <=> src OR dst
// GXnor 0x8 <=> (NOT src) AND (NOT dst)
// GXequiv 0x9 <=> (NOT src) XOR dst
// GXinvert 0xa <=> (NOT dst)
// GXorReverse 0xb <=> src OR (NOT dst)
// GXcopyInverted 0xc <=> (NOT src)
// GXorInverted 0xd <=> (NOT src) OR dst
// GXnand 0xe <=> (NOT src) AND (NOT dst)
// GXset 0xf <=> 1
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
// Combinaison de la fenetre_vu dans mempx
XSetFunction( display_vu, gc_vu, GX ); //activation du mode de combinaison des pixels
XCopyArea( display_vu, fenetre_vu, mempx, gc_vu,
(int) xyfen.x, (int) xyfen.y, largfen, hautfen, //source
(int) xympx.x, (int)xympx.y ); //destination
XSetFunction( display_vu, gc_vu, GXcopy ); //restauration du mode normal
}

void MemoirePx::VuCombinerMemoirePxDansFenetre( int GX,
XPoint xympx, unsigned int largmpx, unsigned int hautmpx,//source
XPoint xyfen ) //destination
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : Combiner les pixels de MemoirePx dans la fenetre_vu selon le code GX
//----- a partir de xympx coin superieur gauche de MemoirePx.mempx
// avec fenetre_vu a partir du coin superieur gauche xyfen
//
// Les pixels du pixmap mempx (src) et la fenetre_vu (dst) se combinent selon
// la valeur de GX qui peut prendre les valeurs suivantes:
//
// GXclear 0x0 <=> 0
// GXand 0x1 <=> src AND dst src comme source
// GXandReverse 0x2 <=> src AND (NOT dst) dst comme destination
// GXcopy 0x3 <=> src
// GXandInverted 0x4 <=> (NOT src) AND dst
// GXnoop 0x5 <=> dst
// GXxor 0x6 <=> src XOR dst (XOR ou exclusif) (2 fois redonne obj)
// GXor 0x7 <=> src OR dst
// GXnor 0x8 <=> (NOT src) AND (NOT dst)
// GXequiv 0x9 <=> (NOT src) XOR dst
// GXinvert 0xa <=> (NOT dst)
// GXorReverse 0xb <=> src OR (NOT dst)
// GXcopyInverted 0xc <=> (NOT src)
// GXorInverted 0xd <=> (NOT src) OR dst
// GXnand 0xe <=> (NOT src) AND (NOT dst)
// GXset 0xf <=> 1
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
XSetFunction( display_vu, gc_vu, GX ); //activation du mode de combinaison des pixels
XCopyArea( display_vu, mempx, fenetre_vu, gc_vu,
(int) xympx.x, (int) xympx.y, largmpx, hautmpx, // source
(int) xyfen.x, (int) xyfen.y ); // destination
XSetFunction( display_vu, gc_vu, GXcopy ); //restauration du mode normal
}

void MemoirePx::VuTexte( XPoint xy, char *texte )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : TRACER un texte a partir du pixel xy de la fenetre
// Attention: xy est ici le coin du TEXTE en BAS et A GAUCHE
//
// ENTREES:
// --------
// xy.x : le numero du pixel en largeur du debut de la chaine
// xy.y : le numero du pixel en hauteur du debut de la chaine
// texte : la chaine de caracteres a tracer
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
int length;

if( xy.x <= minint ) return;
if( xy.y <= minint ) return;

length = nudcnb( texte );
XDrawString(display_vu, mempx, gc_vu, xy.x, xy.y, texte, length);

/* Traitement du postscript */
if (lasopsc > 0)
{
iTe = 1 ;
if (nbrcon > 0)
{
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
}
sprintf(format,"(%%.%ds) %%6i %%6i %%4.2f %%4.2f %%4.2f 0.00 T\n",length) ;
if (lasopsc < 3)
{
fprintf(fpo,format,texte,
xy.x, ypixels-xy.y,
courgb[0],courgb[1],courgb[2]) ;
}
else
{
sprintf(&chaine[lasopsc-4][strlen(chaine[lasopsc-4])],
format,texte,
xy.x, ypixels-xy.y,
courgb[0],courgb[1],courgb[2]) ;
}
}
}

void MemoirePx::VuSymbole( XPoint xy, char *texte )
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// but : trace le symbole texte avec la couleur courante
// ----- a partir du point xy en coordonnees pixel
// la chaine est decalee d'un demi caractere vers le bas et a gauche
//
// entree :
// --------
// xy.x : abscisse objet du symbole
// xy.y : ordonnee objet du symbole
// texte : la chaine de caracteres servant de symbole
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
// Translation pour centrer le symbole en fonction de la fonte
xy.x -= nplaca/2 + 1;
xy.y += nphaca/2 - 2;

// Trace du texte
VuTexte( xy, texte );
}

void MemoirePx::VuEntier( XPoint xy, int entier )
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// but : trace les caracteres de l'entier avec la couleur nc
// ----- a partir du point xy en coordonnees pixel
//
// entree :
// --------
// xy.x : abscisse objet des caracteres de la valeur de l'entier
// xy.y : ordonnee objet des caracteres de la valeur de l'entier
// entier : entier dont la valeur doit etre tracee
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
int nbcar;
char texte[12];

// le nombre de caracteres de l'entier
itoa( entier, nbcar, texte );

// le trace de la chaine de caracteres
VuTexte( xy, texte );
}

void MemoirePx::VuReel( XPoint xy, R vR, int nbchif10 )
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// but : trace les caracteres de vR avec la couleur nc
// ----- a partir du point (x,y) en coordonnees pixel
// la transformation en pixels est assuree dans ce sp
// les autres caracteristiques du trace sont celles actuelles
//
// entrees:
// --------
// xy.x : abscisse objet des caracteres de R
// xy.y : ordonnee objet des caracteres de R
// vR : valeur Rle a tracer
// nbchif10: nombre de chiffres demandes de la partie decimale
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
int nbcar;
char texte[26];

// les caracteres finaux de vR
rtoa( vR, nbchif10, nbcar, texte );

// le trace de la chaine de caracteres
VuTexte( xy, texte );
}

void MemoirePx::VuFace( int n, XPoint *pts )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : TRACER le remplissage du polygone defini par n points pts
//
// ENTREES:
// --------
// n : nombre de sommets du polygone
// pts : coordonnees pixels des n sommets du polygone
// Si le point 0 != point n-1 alors le polygone est referme automatiquement
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
int npts, i , j;

XFillPolygon(display_vu, mempx, gc_vu, pts, n, Complex, CoordModeOrigin);

// Traitement du postscript :
// instruction ps : F
// destination : TEMPORAIRE.EPS si l'instruction est de type dessin
// : chaine si l'instruction correspond a un menu

if (lasopsc > 0){
npts = n;
iFa = 1 ;
if (nbrcon > 0){
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
}
buf[0] = '\0' ;
for (j = 0 ; j <= npts / 16 ; j++)
{
for (i = j * 16 ; i <= Min( npts-1 , (j+1) * 16 -1 ) ; i++)
sprintf(&buf[strlen(buf)], "%6i %6i " , pts[i].x , ypixels-pts[i].y) ;
if (j == npts / 16)
{
if (counb != -1)
{
sprintf(&buf[strlen(buf)],"%3i %4.2f %4.2f %4.2f %4.2f F\n",
npts,courgb[0],courgb[1],courgb[2],counb) ;
}
else
{
sprintf(&buf[strlen(buf)],"%3i %4.2f %4.2f %4.2f 1.00 F\n",
npts,courgb[0],courgb[1],courgb[2]) ;
}
}
else
{
sprintf(&buf[strlen(buf)],"\n") ;
}
if (lasopsc < 3)
{
fprintf(fpo,buf) ;
}
else
{
sprintf(&chaine[lasopsc-4][strlen(chaine[lasopsc-4])],buf) ;
}
buf[0] = '\0' ;
}
}
}

void MemoirePx::VuTrait( XPoint xy1, XPoint xy2 )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : TRACER du point (x1,y1) PIXELS au point (x2,y2) PIXELS
//
// ENTREES :
// ---------
// xy1 : coordonnees pixels du point INITIAL (ORIGINE coin superieur gauche)
// xy2 : coordonnees pixels du point FINAL (ORIGINE coin superieur gauche)
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
XDrawLine( display_vu, mempx, gc_vu, xy1.x, xy1.y, xy2.x, xy2.y );

// Traitement du postscript :
// instruction ps : S
// destination : TEMPORAIRE.EPS si l'instruction est de type dessin
// : chaine si l'instruction correspond a un menu
if (lasopsc > 0){
buf[0] = '\0' ;
if (lasopsc < 3){
/* On essaye de rendre plus compacts les traces ps de segments consecutifs
qui sont stockes dans concat. */
if (nbrcon == 0)
{
nbrcon = 1 ;
xinic = xy1.x ;
yinic = xy1.y ;
xcouc = xy2.x ;
ycouc = xy2.y ;
if (counb != -1)
{
sprintf(&concat[0],"%6i %6i %6i %6i %3i %4.2f %4.2f %4.2f %4.2f S\n",
xy1.x, ypixels-xy1.y, xy2.x, ypixels-xy2.y,
nbrcon,courgb[0],courgb[1],courgb[2],counb) ;
}
else
{
sprintf(&concat[0],"%6i %6i %6i %6i %3i %4.2f %4.2f %4.2f 0.00 S\n",
xy1.x, ypixels-xy1.y, xy2.x, ypixels-xy2.y,
nbrcon,courgb[0],courgb[1],courgb[2]) ;
}
}
else
{
if (xy1.x == xcouc && xy1.y == ycouc)
{
nbrcon++ ;
if (xy2.x == xinic && xy2.y == yinic){
iPo = 1 ;
/* la suite de segments est en fait un contour ferme */
if (counb != -1)
{
sprintf(&concat[strlen(concat)-26],"%3i %4.2f %4.2f %4.2f %4.2f P\n",
nbrcon,courgb[0],courgb[1],courgb[2],counb) ;
}
else
{
sprintf(&concat[strlen(concat)-26],"%3i %4.2f %4.2f %4.2f 0.00 P\n",
nbrcon,courgb[0],courgb[1],courgb[2]) ;
}
// ecriture de concat
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
}
else
{
if (nbrcon % 16 == 0)
/* concat est deja rempli, on le vide */
{
sprintf(&concat[strlen(concat)-26],"\n\0") ;
fprintf(fpo,concat) ;
concat[0] = '\0' ;
sprintf(&concat[0]," ") ;
}
if (counb != -1)
{
sprintf(&concat[strlen(concat)-26],"%6i %6i %3i %4.2f %4.2f %4.2f %4.2f S\n",
xy2.x, ypixels-xy2.y,nbrcon,courgb[0],courgb[1],courgb[2],counb) ;
}
else
{
sprintf(&concat[strlen(concat)-26],"%6i %6i %3i %4.2f %4.2f %4.2f 0.00 S\n",
xy2.x, ypixels-xy2.y,nbrcon,courgb[0],courgb[1],courgb[2]) ;
}
xcouc = xy2.x ;
ycouc = xy2.y ;
}
}
else
{
// ni suite, ni fermeture d'un polygone. c'est donc un nouveau segment

fprintf(fpo,concat) ;
nbrcon = 1 ;
xinic = xy1.x ;
yinic = xy1.y ;
xcouc = xy2.x ;
ycouc = xy2.y ;
if (counb != -1) {
sprintf(&concat[0],"%6i %6i %6i %6i %3i %4.2f %4.2f %4.2f %4.2f S\n",
xy1.x, ypixels-xy1.y, xy2.x, ypixels-xy2.y,
nbrcon,courgb[0],courgb[1],courgb[2],counb) ;
}
else
{
sprintf(&concat[0],"%6i %6i %6i %6i %3i %4.2f %4.2f %4.2f 0.00 S\n",
xy1.x, ypixels-xy1.y, xy2.x, ypixels-xy2.y,
nbrcon,courgb[0],courgb[1],courgb[2]) ;
}
}
}
}
else
{
// Pour les menus les segments sont traces en ps tels que, un par un
if (counb != -1)
{
sprintf(&buf[0],"%6i %6i %6i %6i %4.2f %4.2f %4.2f %4.2f S\n",
xy1.x, ypixels-xy1.y, xy2.x, ypixels-xy2.y,
courgb[0],courgb[1],courgb[2],counb) ;
}
else
{
sprintf(&buf[0],"%6i %6i %6i %6i %4.2f %4.2f %4.2f 0.00 S\n",
xy1.x, ypixels-xy1.y, xy2.x, ypixels-xy2.y,
courgb[0],courgb[1],courgb[2]) ;
}
sprintf(&chaine[lasopsc-4][strlen(chaine[lasopsc-4])],buf) ;
}
}
}

void MemoirePx::VuTraits( int nbpoints, XPoint *points )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
BUT : TRACER les segments points(i) points(i+1) pour i=1 a nbpoints-1

ENTREES :
---------
nbpoints : nombre de points sommets des traits
points : coordonnees pixels (INTEGER*2 !) des nbpoints points
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
int npts, i , j;

XDrawLines( display_vu, mempx, gc_vu, points, nbpoints, CoordModeOrigin );

/* Traitement du postscript :
instruction ps : P
destination : TEMPORAIRE.EPS si l'instruction est de type dessin
: chaine si l'instruction correspond a un menu */
if (lasopsc > 0){
iPo = 1 ;
npts = nbpoints-1;
if (nbrcon > 0){
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
}
buf[0] = '\0' ;
for (j = 0 ; j <= npts / 16 ; j++)
{
for (i = j * 16 ; i <= Min( npts-1 , (j+1) * 16 -1 ) ; i++)
sprintf(&buf[strlen(buf)], "%6i %6i " , points[i].x , ypixels-points[i].y) ;
if (j == npts / 16) {
if (counb != -1) {
sprintf(&buf[strlen(buf)],"%3i %4.2f %4.2f %4.2f %4.2f P\n",
npts,courgb[0],courgb[1],courgb[2],counb) ;
}
else {
sprintf(&buf[strlen(buf)],"%3i %4.2f %4.2f %4.2f 0.00 P\n",
npts,courgb[0],courgb[1],courgb[2]) ;
}
}
else {
sprintf(&buf[strlen(buf)],"\n") ;
}
if (lasopsc < 3) {
fprintf(fpo,buf) ;
}
else {
sprintf(&chaine[lasopsc-4][strlen(chaine[lasopsc-4])],buf) ;
}
buf[0] = '\0' ;
}
}
}

char MemoirePxInvite::lire1Caractere( void )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT: RETOURNER le caractere ASCII saisi au clavier ou
// le caractere char(27) ABANDON par clic bouton 2 de la souris
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
XEvent event;
KeySym *keysym; // incidence
int nb;
char buffer[16];

while ( 1 )
{
XNextEvent( display_vu, &event );
if(event.type == ButtonRelease) //Bouton enfonce et relache
{
if (event.xbutton.button == Button2) {return char(27);} //caractere Echappement
}
else if(event.type == KeyPress) //touche enfoncee et relachee sur le clavier
{
keysym = 0;
nb = XLookupString( &event.xkey, buffer, 15, keysym, NULL );
if ( nb != 0 ) return buffer[0]; //caractere dans la table ascii
}
}
}

void VuSouris( int & notypeevt, int & nbc, XPoint & pxy1 )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : RETOURNER le type et les caracteristiques d'un EVENEMENT
// ----- VARIANTE de Vusouris avec en plus le cas du bouton seulement enfonce
//
// SORTIES :
// ---------
// notypeevt: = 0 Si ABANDON demande par clic du bouton 2 de la souris
// ou par frappe de la touche Echappement ou @
// = 1 Si CLIC ENFONCE et RELACHE D'UN BOUTON DE LA SOURIS => pxy1
// =-1 Si CLIC SEULEMENT ENFONCE D'UN BOUTON DE LA SOURIS => pxy1
// =-2 Si le pointeur de la souris a bouge => pxy1
// = 2 Si FRAPPE D'UN CARACTERE AU CLAVIER
// nbc : seulement actif si notypeevt est non nul
// si notypeevt=1 nbc=numero du bouton
// si notypeevt=2 nbc=numero du caractere dans la table ASCII
// pxy1 : seulement actif si notypeevt=+-1
// coordonnees pixels du point clique par rapport au coin
// superieur gauche de la fenetre
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
XEvent event;
int flag;
char buffer[20];
KeySym *keysym;

notypeevt = 0;
flag = 0; //vrai

while ( !flag )
{
XNextEvent(display_vu, &event);

if( event.type == MotionNotify )
{
//Deplacement de la souris
//nombre d'evenements dans la queue
if( XEventsQueued( display_vu, QueuedAfterFlush ) <= 0 )
{
notypeevt = -2; //c'est le dernier evenement
pxy1.x = event.xbutton.x;
pxy1.y = event.xbutton.y;
if (event.xbutton.button == Button1) {nbc = 1;}
else if (event.xbutton.button == Button2) {nbc = 2;}
else {nbc = 3;}
flag=1;
}
}

else if(event.type == ButtonPress)
{
//Un bouton a ete enfonce, presse et non encore relache
//nombre d'evenements dans la queue
if( XEventsQueued( display_vu, QueuedAfterFlush ) <= 0 )
{
notypeevt = -1; //c'est le dernier evenement
pxy1.x = event.xbutton.x;
pxy1.y = event.xbutton.y;
if (event.xbutton.button == Button1) {nbc = 1;}
else if (event.xbutton.button == Button2) {nbc = 2;}
else {nbc = 3;}
flag=1;
}
}

else if(event.type == ButtonRelease) //Un bouton a ete relache
{
notypeevt = 1;
pxy1.x = event.xbutton.x;
pxy1.y = event.xbutton.y;
if (event.xbutton.button == Button1) {nbc = 1;}
else if (event.xbutton.button == Button2) {nbc = 2; notypeevt=0;}
else {nbc = 3;}
flag=1;
}

else if(event.type == KeyPress) //Une touche du clavier a ete frappee
{
notypeevt = 2;
pxy1.x = event.xkey.x;
pxy1.y = event.xkey.y;
nbc = event.xkey.keycode;
keysym = 0;
nbc = XLookupString(&event.xkey,buffer,19,keysym,NULL);
if( nbc != 0 )
{
nbc = int(buffer[0]); //codage entier du caractere
if( nbc == 27 ) {notypeevt=0;} //caractere 'Echappement' => ABANDON
if( nbc == 64 ) {notypeevt=0;} //caractere '@' => ABANDON
flag= 1;
}
}
}
}

void MemoirePxInvite::VuSourisTexte( int & notypeevt, int & nobouton, XPoint & pxy1,
char texte[] )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : RETOURNER le type et les caracteristiques d'un EVENEMENT
// ----- VARIANTE de VuSouris avec retour eventuel d'un texte ponctue par \r
//
// SORTIES :
// ---------
// notypeevt : = 0 Si ABANDON demande par clic du bouton 2 de la souris
// ou par frappe de la touche Echappement ou @
// = 1 Si CLIC ENFONCE et RELACHE D'UN BOUTON DE LA SOURIS
// =-1 Si CLIC SEULEMENT ENFONCE D'UN BOUTON DE LA SOURIS
// = 2 Si FRAPPE d'un texte fini par \r
// nobouton : seulement actif si notypeevt est non nul
// si notypeevt=1 nobouton=numero du bouton
// si notypeevt=2 nobouton=numero du caractere dans la table ASCII
// pxy1 : seulement actif si notypeevt=+-1
// coordonnees pixels du point clique par rapport au coin
// superieur gauche de la fenetre
// texte : chaine de caracteres saisie au clavier et finie par \r
// initialisee seulement si notypeevt=2
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
XEvent event;
int flag;
int nbc;
KeySym *keysym;

notypeevt = 0;
flag = 0;

while ( !flag )
{
XNextEvent(display_vu, &event);

if(event.type == MotionNotify || event.type == ButtonPress) //Un bouton a ete enfonce
{
//nombre d'evenements dans la queue
if( XEventsQueued( display_vu, QueuedAfterFlush ) <= 0 )
{
//Un bouton a ete enfonce, presse et non encore relache
notypeevt = -1;
pxy1.x = event.xbutton.x;
pxy1.y = event.xbutton.y;
if (event.xbutton.button == Button1) {nobouton = 1;}
else if (event.xbutton.button == Button2) {nobouton = 2;}
else {nobouton = 3;}
flag=1;
}
}

else if(event.type == ButtonRelease) //Un bouton a ete relache
{
notypeevt = 1;
pxy1.x = event.xbutton.x;
pxy1.y = event.xbutton.y;
if (event.xbutton.button == Button1) {nobouton = 1;}
else if (event.xbutton.button == Button2) {nobouton = 2; notypeevt=0;}
else {nobouton = 3;}
flag=1;
}

void MemoirePxInvite::VuSourisXYZ( int & notypeevt, int & nobouton, XPoint & pxy1,
R3 & XYZ )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : Retourne un point de R3 par frappe au clavier de X puis Y puis Z
// ---- ou les 2 coordonnees pixels pxy1 du point cliqué a la souris
//
// SORTIES :
// ---------
// notypeevt : = 0 Si ABANDON demande par clic du bouton 2 de la souris
// ou par frappe de la touche Echappement ou @
// = 1 Si CLIC ENFONCE et RELACHE D'UN BOUTON DE LA SOURIS en pxy1
// =-1 Si CLIC SEULEMENT ENFONCE D'UN BOUTON DE LA SOURIS en pxy1
// =-2 Si deplacement du pointeur de souris en pxy1
// = 2 Si FRAPPE des 3 coordonnees X Y Z du point
// nobouton : seulement actif si notypeevt est non nul
// si notypeevt=1 alors nobouton=numero du bouton
// si notypeevt=2 alors nobouton=numero du caractere dans la table ASCII
// pxy1 : seulement actif si notypeevt=+-1 et -2
// coordonnees pixels du point clique par rapport au coin
// superieur gauche de la fenetre
// XYZ : les 3 coordonnees du point frappees au clavier seulement si notypeevt=2
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
XEvent event;
int flag;
int nbc;
KeySym *keysym;
char texte[80];

notypeevt = 0;
flag = 0;

while ( !flag )
{
XNextEvent(display_vu, &event);

if(event.type == MotionNotify) //Le pointeur de SOURIS a ete deplace
{
//Un bouton a ete enfonce, presse et non encore relache
//nombre d'evenements dans la queue
if( XEventsQueued( display_vu, QueuedAfterFlush ) <= 0 )
{
notypeevt = -2;
pxy1.x = event.xbutton.x;
pxy1.y = event.xbutton.y;
if (event.xbutton.button == Button1) {nobouton = 1;}
else if (event.xbutton.button == Button2) {nobouton = 2;}
else {nobouton = 3;}
flag=1;
}
}
else if(event.type == ButtonPress) //Un bouton a ete enfonce
{
//Un bouton a ete enfonce, presse et non encore relache
//nombre d'evenements dans la queue
if( XEventsQueued( display_vu, QueuedAfterFlush ) <= 0 )
{
notypeevt = -1;
pxy1.x = event.xbutton.x;
pxy1.y = event.xbutton.y;
if (event.xbutton.button == Button1) {nobouton = 1;}
else if (event.xbutton.button == Button2) {nobouton = 2;}
else {nobouton = 3;}
flag=1;
}
}

//traitement du premier caractere
if( texte[0] == '@' ) {notypeevt=0; return;} //caractere '@' => ABANDON

//transformation des caracteres en R ZZ Reel = strtod( texte, endptr ); TILT
XYZ.x = atof( texte );

VuInvite( "Frapper l'ordonnee du POINT Y" );
lireR( nbc, XYZ.y );
if( nbc == -1 ) {notypeevt=0; return;} //caractere '@' => ABANDON

VuInvite( "Frapper la cote du POINT Z" );
lireR( nbc, XYZ.z );
if( nbc == -1 ) {notypeevt=0; return;} //caractere '@' => ABANDON

flag= 1;
}
}
}
}

void VuVoir(void)
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : VOIR les traces encore situes dans la memoire tampon
//
// ATTENTION: 21/1/99
// Si Vuvoir est trop souvent appele
// cela entraine un lourd trafic entre X et le fenetre manager qui doit savoir
// l'empilement des fenetres pour mettre celle de Vu au dessus
// ce qui bloque certains wm tels kde fvwm ... mais pas certains autres!
// Sur ibm dec hp sun ... et toutes les fenetres sont bloquees!!!
// Pour y remedier, tous les appels de Vuvoir ont ete supprimes
// Sur hp et PC rien ne change en execution si ce n'est que c'est plus rapide
// et SURTOUT sans blocage avec kde fvwm ... sur PC
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
XRaiseWindow ( display_vu,fenetre_vu );
XFlush( display_vu );
}

void VuPause( void )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : FAIRE une PAUSE jusqu'a l'entree d'un caractere au clavier
// ou un clic enfonce et relache de l'un des boutons de la souris
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
int notypeevt, bouton;
XPoint pxy;

notypeevt=-1;
do
{
VuSouris( notypeevt, bouton, pxy );
}while(notypeevt<=0);
}

void MemoirePx::VuBordRectangle( XPoint pxy, int width, int height )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : TRACER les aretes du contour d'un rectangle
//
// ENTREES :
// ---------
// pxy : coordonnees pixels du coin superieur gauche
// width : largeur en pixels du rectangle
// height : hauteur en pixels du rectangle
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
XDrawRectangle(display_vu, mempx, gc_vu,pxy. x, pxy.y, width, height);

// Traitement du postscript :
// instruction ps : r
// destination : TEMPORAIRE.EPS si l'instruction est de type dessin
// : chaine si l'instruction correspond a un menu
if (lasopsc > 0)
{
ire = 1 ;
if (nbrcon > 0)
{
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
}
buf[0] = '\0' ;
if (counb != -1)
{
sprintf(&buf[strlen(buf)], "%6i %6i %6i %6i %4.2f %4.2f %4.2f %4.2f r\n",
width, -height, pxy.x, ypixels-pxy.y,
courgb[0],courgb[1],courgb[2], counb) ;
}
else
{
sprintf(&buf[strlen(buf)], "%6i %6i %6i %6i %4.2f %4.2f %4.2f 0.00 r\n",
width, -height, pxy.x, ypixels-pxy.y,
courgb[0],courgb[1],courgb[2]) ;
}
if (lasopsc < 3)
{
fprintf(fpo,buf) ;
}
else
{
sprintf(&chaine[lasopsc-4][strlen(chaine[lasopsc-4])],buf) ;
}
}
}

void MemoirePx::VuRectangle( XPoint pxy, int width, int height )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : TRACER le remplissage du contour d'un rectangle
//
// ENTREES :
// pxy : coordonnees pixels du coin superieur gauche
// width : largeur en pixels du rectangle
// height : hauteur en pixels du rectangle vers le bas
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
XFillRectangle( display_vu, mempx, gc_vu,
int(pxy.x), int(pxy.y), width, height );

// Traitement du postscript :
// instruction ps : R
// destination : TEMPORAIRE.EPS si l'instruction est de type dessin
// : chaine si l'instruction correspond a un menu */
if (lasopsc > 0)
{
iRe = 1 ;
if (nbrcon > 0)
{
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
}
buf[0] = '\0' ;
if (counb != -1)
{
sprintf(&buf[strlen(buf)], "%6i %6i %6i %6i %4.2f %4.2f %4.2f %4.2f R\n",
width, -height, pxy.x, ypixels-pxy.y,courgb[0],courgb[1],courgb[2],counb) ;
}
else {
sprintf(&buf[strlen(buf)], "%6i %6i %6i %6i %4.2f %4.2f %4.2f 1.00 R\n",
width, -height, pxy.x, ypixels-pxy.y,courgb[0],courgb[1],courgb[2]) ;
}
if (lasopsc < 3){
fprintf(fpo,buf) ;
}
else{
sprintf(&chaine[lasopsc-4][strlen(chaine[lasopsc-4])],buf) ;
}
}
}

void MemoirePx::VuBordArcEllipse( XPoint pxy, int width, int height, R angle1, R angle2 )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : TRACER le bord d'un secteur d'une ellipse
//
// ENTREES :
// ---------
// pxy : coordonnees pixels du centre de l'ellipse
// width : demi-largeur en pixels de l'ellipse
// height : demi-hauteur en pixels de l'ellipse
// angle1 : angle de depart (a partir de l'axe Ox sens direct en degres )
// angle2 : angle du secteur a tracer (a partir de l'angle de depart en degres)
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
int adep , afin ;
adep = (int) (angle1 * 64) ;
afin = (int) (angle2 * 64) ;
XDrawArc(display_vu, mempx, gc_vu, pxy.x-width, pxy.y-height, width*2,
height*2, adep , afin );

// Traitement du postscript :
// instruction ps : el
// destination : TEMPORAIRE.EPS si l'instruction est de type dessin
// : chaine si l'instruction correspond a un menu
if (lasopsc > 0){
iel = 1 ;
if (nbrcon > 0){
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
}
buf[0] = '\0' ;
if (angle2 >= 0){
adep = (int) angle1 ;
afin = (int) (angle1 + angle2) ;
}
else{
afin = (int) angle1 ;
adep = (int) (angle1 + angle2) ;
}
if (counb != -1) {
sprintf(&buf[strlen(buf)], "%6i %6i %6i %6i %6i %6i %4.2f %4.2f %4.2f %4.2f el\n",
adep, afin, width, height, pxy.x, ypixels-pxy.y,
courgb[0],courgb[1],courgb[2], counb) ;
}
else {
sprintf(&buf[strlen(buf)], "%6i %6i %6i %6i %6i %6i %4.2f %4.2f %4.2f 0.00 el\n",
adep, afin, width, height, pxy.x, ypixels-pxy.y,
courgb[0],courgb[1],courgb[2]) ;
}
if (lasopsc < 3){
fprintf(fpo,buf) ;
}
else{
sprintf(&chaine[lasopsc-4][strlen(chaine[lasopsc-4])],buf) ;
}
}
}

void MemoirePx::VuArcEllipse( XPoint pxy, int width, int height, R angle1, R angle2 )
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// BUT : TRACER le remplissage d'un secteur d'une ellipse
//
// ENTREES :
// ---------
// x,y : coordonnees pixels du centre de l'ellipse
// width : demi-largeur en pixels de l'ellipse
// height : demi-hauteur en pixels de l'ellipse
// angle1 : angle de depart (a partir de l'axe Ox sens direct en degres )
// angle2 : angle du secteur a tracer (a partir de l'angle de depart en degres )
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
int adep , afin ;

adep = (int) (angle1 * 64) ;
afin = (int) (angle2 * 64) ;
XFillArc( display_vu, mempx, gc_vu, pxy.x-width, pxy.y-height, width*2,
height*2, adep, afin );

// Traitement du postscript :
// instruction ps : El
// destination : TEMPORAIRE.EPS si l'instruction est de type dessin
// : chaine si l'instruction correspond a un menu
if (lasopsc > 0)
{
iEl = 1 ;
if (nbrcon > 0)
{
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
}
buf[0] = '\0' ;
if (angle2 >= 0){
adep = (int) angle1 ;
afin = (int) (angle1+angle2) ;
}
else
{
afin = (int) angle1 ;
adep = (int) (angle1+angle2) ;
}
if (counb != -1)
{
sprintf(&buf[strlen(buf)], "%6i %6i %6i %6i %6i %6i %4.2f %4.2f %4.2f %4.2f El\n",
adep , afin , width, height, pxy.x, ypixels-pxy.y,
courgb[0],courgb[1],courgb[2], counb) ;
}
else
{
sprintf(&buf[strlen(buf)], "%6i %6i %6i %6i %6i %6i %4.2f %4.2f %4.2f 1.00 El\n",
adep , afin , width, height, pxy.x, ypixels-pxy.y,
courgb[0],courgb[1],courgb[2]) ;
}
if (lasopsc < 3)
{
fprintf(fpo,buf) ;
}
else
{
sprintf(&chaine[lasopsc-4][strlen(chaine[lasopsc-4])],buf) ;
}
}
}

void MemoirePx::VuBordTriangle( XPoint xys1, XPoint xys2, XPoint xys3 )
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Trace les 3 aretes du triangle de sommets xys
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
VuTrait( xys1, xys2 );
VuTrait( xys2, xys3 );
VuTrait( xys3, xys1 );
}

void MemoirePx::VuTriangleCouleur( XPoint xys1, XPoint xys2, XPoint xys3,
R coul1, R coul2, R coul3 )
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Trace le remplissage du triangle de sommets xys de couleurs coul
// selon les couleurs intermediaires (PALETTE 11 RECOMMANDEE)
// entrees:
//---------
// xys* : coordonnees pixels des 3 sommets
// coul* : couleur entre n1coul et ndcoul dans la palette actuelle des 3 sommets
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{
//Variables locales
static R c1, c2, c3;
static R c21, c31, c32;
static int nc, nc1, nc2, nc3, ncp1;
static XPoint xy[4];
static XPoint xyf[5];

//CORPS de la FONCTION
if ( coul1<0. || coul2<0. || coul3<0. ) return;

//LES 3 SOMMETS SONT REORDONNES SELON LES COULEURS C1<=C2<=C3
if( coul1<=coul2 && coul2<=coul3 )
{ c1=coul1; xy[1]=xys1; c2=coul2; xy[2]=xys2; c3=coul3; xy[3]=xys3; }
else if( coul2<=coul3 && coul3<=coul1 )
{ c1=coul2; xy[1]=xys2; c2=coul3; xy[2]=xys3; c3=coul1; xy[3]=xys1; }
else if( coul3<=coul1 && coul1<=coul2 )
{ c1=coul3; xy[1]=xys3; c2=coul1; xy[2]=xys1; c3=coul2; xy[3]=xys2; }
else if( coul1<=coul3 && coul3<=coul2 )
{ c1=coul1; xy[1]=xys1; c2=coul3; xy[2]=xys3; c3=coul2; xy[3]=xys2; }
else if( coul3<=coul2 && coul2<=coul1 )
{ c1=coul3; xy[1]=xys3; c2=coul2; xy[2]=xys2; c3=coul1; xy[3]=xys1; }
else if( coul2<=coul1 && coul1<=coul3 )
{ c1=coul2; xy[1]=xys2; c2=coul1; xy[2]=xys1; c3=coul3; xy[3]=xys3; }

// PARTIE ENTIERE DE LA COULEUR
nc1 = (int) c1; nc2 = (int) c2; nc3 = (int) c3;

if (nc1 == nc3)
{
// LES 3 COULEURS A TRACER SONT EGALES -> TRIANGLE MONO-COULEUR
VuCouleur( nc1 );
VuFace( 3, xy+1 );
return;
}

xyf[0] = xy[1]; // le premier sommet

//RECHERCHE DE L'ARETE P13-P12 OU LA COULEUR NC1 DEVIENT NC1+1
ncp1 = nc1 + 1;
if (nc1 != nc2)
{
c21 = 1.0 / (c2 - c1);
xyf[1].x = (int) ((xy[1].x * (c2 - ncp1) + xy[2].x * (ncp1 - c1)) * c21 + 0.5);
xyf[1].y = (int) ((xy[1].y * (c2 - ncp1) + xy[2].y * (ncp1 - c1)) * c21 + 0.5);

c31 = 1.0 / (c3 - c1);
xyf[2].x = (int) ((xy[1].x * (c3 - ncp1) + xy[3].x * (ncp1 - c1)) * c31 + 0.5);
xyf[2].y = (int) ((xy[1].y * (c3 - ncp1) + xy[3].y * (ncp1 - c1)) * c31 + 0.5);

//TRACE DU TRIANGLE SOMMET 1 - P12 - P13
VuCouleur( nc1 );
VuFace( 3, xyf );

//LES QUADRANGLES SUIVANTS
xyf[0].x = xyf[2].x;
xyf[0].y = xyf[2].y;

for (nc=nc1+1; nc<=nc2-1; nc++)
{
ncp1 = nc + 1;
xyf[2].x = (int) ((xy[1].x * (c2 - ncp1) + xy[2].x * (ncp1 - c1)) * c21 + 0.5);
xyf[2].y = (int) ((xy[1].y * (c2 - ncp1) + xy[2].y * (ncp1 - c1)) * c21 + 0.5);

xyf[3].x = (int) ((xy[1].x * (c3 - ncp1) + xy[3].x * (ncp1 - c1)) * c31 + 0.5);
xyf[3].y = (int) ((xy[1].y * (c3 - ncp1) + xy[3].y * (ncp1 - c1)) * c31 + 0.5);

//TRACE DU QUADRANGLE P13-P12-P12-P13
VuCouleur( nc );
VuFace( 4, xyf );

//3->2 ET 4->1
xyf[1].x = xyf[2].x;
xyf[1].y = xyf[2].y;

xyf[0].x = xyf[3].x;
xyf[0].y = xyf[3].y;
}

if (nc2 == nc3)
{
//IL RESTE LE QUADRANGLE P13-P12-S2-S3 */
xyf[2].x = xy[2].x;
xyf[2].y = xy[2].y;

xyf[3].x = xy[3].x;
xyf[3].y = xy[3].y;

//TRACE DU QUADRANGLE P13-P12-S2-S3 */
VuCouleur( nc2 );
VuFace( 4, xyf );
return;
}

//CAS NC1<NC2<NC3 LE PENTAGONE P13-P12-S2-P23-P13
xyf[2].x = xy[2].x;
xyf[2].y = xy[2].y;
ncp1 = nc2 + 1;
c32 = (R) 1. / (c3 - c2);
xyf[3].x = (int) ((xy[2].x * (c3 - ncp1) + xy[3].x * (ncp1 - c2)) * c32 + 0.5);
xyf[3].y = (int) ((xy[2].y * (c3 - ncp1) + xy[3].y * (ncp1 - c2)) * c32 + 0.5);

xyf[4].x = (int) ((xy[1].x * (c3 - ncp1) + xy[3].x * (ncp1 - c1)) * c31 + 0.5);
xyf[4].y = (int) ((xy[1].y * (c3 - ncp1) + xy[3].y * (ncp1 - c1)) * c31 + 0.5);

//TRACE DU PENTAGONE P13-P12-SOMMET2-P23-P13
VuCouleur( nc2 );
VuFace( 5, xyf );

//4->2 ET 5->1
xyf[1].x = xyf[3].x;
xyf[1].y = xyf[3].y;

xyf[0].x = xyf[4].x;
xyf[0].y = xyf[4].y;
goto L50;
}

//CAS : NC1=NC2<NC3 LE QUADRANGLE SOMMET1-SOMMET2-P23-P13
//xyf[0] = xy[1]; deja fait
xyf[1].x = xy[2].x;
xyf[1].y = xy[2].y;
ncp1 = nc2 + 1;
c31 = (R) 1.0 / (c3 - c1);
c32 = (R) 1.0 / (c3 - c2);
xyf[2].x = (int) ((xy[2].x * (c3 - ncp1) + xy[3].x * (ncp1 - c2)) * c32 + 0.5);
xyf[2].y = (int) ((xy[2].y * (c3 - ncp1) + xy[3].y * (ncp1 - c2)) * c32 + 0.5);

xyf[3].x = (int) ((xy[1].x * (c3 - ncp1) + xy[3].x * (ncp1 - c1)) * c31 + 0.5);
xyf[3].y = (int) ((xy[1].y * (c3 - ncp1) + xy[3].y * (ncp1 - c1)) * c31 + 0.5);

//TRACE DU QUADRANGLE SOMMET1-SOMMET2-P23-P13
VuCouleur( nc2 );
VuFace( 4, xyf );

//3->2 ET 4->1
xyf[1].x = xyf[2].x;
xyf[1].y = xyf[2].y;

xyf[0].x = xyf[3].x;
xyf[0].y = xyf[3].y;

//LES QUADRANGLES P13-P23-P23-P13
L50:
for (nc=nc2+1; nc<=nc3-1; nc++)
{
ncp1 = nc + 1;
xyf[2].x = (int) ((xy[2].x * (c3 - ncp1) + xy[3].x * (ncp1 - c2)) * c32 + 0.5);
xyf[2].y = (int) ((xy[2].y * (c3 - ncp1) + xy[3].y * (ncp1 - c2)) * c32 + 0.5);

xyf[3].x = (int) ((xy[1].x * (c3 - ncp1) + xy[3].x * (ncp1 - c1)) * c31 + 0.5);
xyf[3].y = (int) ((xy[1].y * (c3 - ncp1) + xy[3].y * (ncp1 - c1)) * c31 + 0.5);

//TRACE DU QUADRANGLE P13-P23-P23-P13
VuCouleur( nc );
VuFace( 4, xyf );
//3->2 ET 4->1
xyf[1].x = xyf[2].x;
xyf[1].y = xyf[2].y;

xyf[0].x = xyf[3].x;
xyf[0].y = xyf[3].y;
}

//LE TRIANGLE P13-P12-SOMMET 3
xyf[2].x = xy[3].x;
xyf[2].y = xy[3].y;

//TRACE DU TRIANGLE P13-P23-SOMMET 3
VuCouleur( nc3 );
VuFace( 3, xyf );
}

void VuInitierps( int modeps )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
BUT : INITIALISER le POSTSCRIPT

ENTREE :
---------
modeps : 0 mode standard bibliotheque Vu
1 mode Mefisto
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AUTEUR : DOURSAT CHRISTOPHE UPMC ANALYSE NUMERIQUE PARIS JUIN 1994
12345X7..........................................................012345678*/
{
int lasops ;
lasopsc = 0;
modepsc = modeps ;
icolorm = ndcoul + 1 ;
counb = 0.0 ;
courgb[0] = 0.0 ; courgb[1] = 0.0 ; courgb[2] = 0.0 ;
/* initialisation des pointeurs et variables postscript */
fpi = NULL ;
fpo = NULL ;
menu = 0 ;
if ( modepsc != 0 ){
/* Initialisation des tailles des chaines-tampons des menus
Nombre de caracteres a reserver par instruction PS
1 rectangle = 35
1 segment = 35
1 changement epaisseur trait = 10
1 chaine texte = 24 + long chaine
Par menu il y a :
2 rectangles (un fond et un contour)
2 segments de bordure
3 changements d'epaisseur (maximum)
n chaines de caracteres
(n-1) segments entre les chaines de caracteres
+ 50 de securite */

/* Documentation */
longchaine[0] = 2*35 + 2*35 + 3*10 + MXLGDO*(NBCADO+24) + (MXLGDO-1) * 35 + 50 ;
/* Historique */
longchaine[1] = 2*35 + 2*35 + 3*10 + MXLGHI*(NBCAHI+24) + (MXLGHI-1) * 35 + 50 ;
/* Menu */
longchaine[2] = 2*35 + 2*35 + 3*10 + MXLGME*(NBCAME+24) + (MXLGME-1) * 35 + 50 ;
/* Lignes lues */
longchaine[3] = 2*35 + 2*35 + 3*10 + MXKLG *(NBCALI+24) + 50 ;
/* Invite */
longchaine[4] = 2*35 + 2*35 + 3*10 + MXLGIN*(NBCAIN+24) + (MXLGIN-1) * 35 + 50 ;
/* Ligne de saisie */
longchaine[5] = 2*35 + 2*35 + 3*10 + MXLGSA*(NBCALG+24) + (MXLGSA-1) * 35 + 50 ;
/* Erreur */
longchaine[6] = 2*35 + 2*35 + 3*10 + MXLGER*(NBCAER+24) + (MXLGER-1) * 35 + 50 ;
/* Histogrammes et Qualites : 1+32 rectangles et chaines de caracters de 72 */
longchaine[7] = 35 +32*35 + 32*( 72 +24) + 50 ;
}
/* effacement si necessaire du fichier ps */
lasops = 0 ;
VuPostscript(lasops) ;
/* ouverture du futur fichier ps */
lasops = 1 ;
VuPostscript(lasops) ;
}

void VuImprimerps( char nomfichier[] )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
BUT: IMPRIMER nomfichier.eps

ENTREE:
-------
nomfichier: CHAINE DE CARACTERE
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AUTEUR : DOURSAT CHRISTOPHE UPMC ANALYSE NUMERIQUE PARIS JUIN 1994
12345X7..........................................................012345678*/
{
int nbc, length ;

length = nudcnb( nomfichier );
buf[0] = '\0' ;
nbc = length ;
sprintf(format,"%%.%ds.eps", nbc) ;
sprintf(buf,format,nomfichier) ;
/* changement du titre si possible */
/* if ((fpi = fopen(buf,"r+"))!=NULL) {
rewind(fpi) ;
for (i=1 ; i<9 ; i++) { fgets(buf,255,fpi) ; }
buf[0] = '\0' ;
sprintf(format,"%%.%ds.eps) /titre exch def\n",nbc) ;
sprintf(buf,format,nomfichier) ;
fprintf(fpi,"(%s",buf) ;
fclose(fpi) ;
} */

// ******************************** ATTENTION **************************************
// ORDRE D'IMPRESSION DEPENDANT TYPE IMPRIMANTE ET SYSTEME
// ******************************** ATTENTION **************************************
sprintf(format,"lpr -Ppastis %%.%ds.eps",nbc) ;/* ATTENTION ici LINUX PC LAN */

/* sprintf(format,"lp -dlaserhp %%.%ds.eps",nbc) ; */ /* ATTENTION ici HP */
/* sprintf(format,"lpr %%.%ds.eps",nbc) ; */ /* ajouter -Plaser ? */
/* sprintf(format,"/bin/prf -trans %%.%ds.eps",nbc) ; */ /* Apollo LaserWriterII */

// ******************************** ATTENTION **************************************
sprintf(buf,format,nomfichier) ;
nbc = system(buf) ;
}

void VuSauverps( char nomfichier[], int & length )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
BUT : CONCATENER LES DONNEES DE DESSIN PS CONTENUES DANS TEMPORAIRE.EPS
----- AVEC LES PROCEDURES PS ET LES DIVERS MENUS EVENTUELS
DANS nomfichier.eps

ENTREE :
--------
nomfichier: CHAINE DE CARACTERES

SORTIE:
-------
length : <0 si erreur rencontree, 0 sinon
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AUTEUR : DOURSAT CHRISTOPHE UPMC ANALYSE NUMERIQUE PARIS JUIN 1994
12345X7..........................................................012345678*/
{ int i;
char cpwd[100];
char *ligne, *car;
int an, mo, jo;

/* verification des fichiers */
length = nudcnb( nomfichier );
fprintf(fpo,concat) ;
nbrcon = 0 ;
concat[0] = '\0' ;
i = 0 ;
if (fpi != NULL)
{
fclose(fpi) ;
fpi = NULL ;
}
sprintf(format,"%%.%ds.eps",length) ;
sprintf(buf,format,nomfichier) ;
if ((fpi = fopen(buf,"w"))==NULL)
{
printf ("Erreur de creation de fichier\n") ;
i = 1 ;
length = -2 ;
}

if ( i == 0 )
{
if (fpo != NULL)
{
fclose(fpo) ;
}
fpo = fpi ;
i = 0 ;
fpi = NULL ;
if ((fpi = fopen("TEMPORAIRE.EPS","r"))==NULL)
{
printf ("Erreur d'ouverture de fichier\n") ;
i = 1 ;
length = -2 ;
}
}

if ( i == 0 )
{
lasopsc = 0 ;
/* ecriture du dictionnaire de procedures PS utilisees */
fprintf(fpo,"%%!PS-Adobe\n") ;
if ( modepsc == 0 )
{
fprintf(fpo,"%%%%Creator: Vu\n") ;
}
else
{
fprintf(fpo,"%%%%Creator: Mefisto\n") ;
sprintf(buf,"LOGNAME") ;
i = 100 ;
ValVarEnv( buf, &i, cpwd, &an) ; // dans Util.cpp
sprintf(format,"%%%%%%%%User: %%.%ds\n",an) ;
for (i=0 ; (i<an) && (*(cpwd+i)!='.') ; i++) ;
sprintf(format,"%%%%%%%%User: %%.%ds\n",i) ;
fprintf(fpo,format,cpwd) ;
}
sprintf(format,"%%%%%%%%Title: %%.%ds",length) ;
sprintf(buf,format,nomfichier) ;
fprintf(fpo,"%s\n",buf) ;
LaDate(&an,&mo,&jo) ; // dans Util.cpp
fprintf(fpo,"%%%%CreationDate: %2i/%2i/%2i\n",jo,mo,an) ;
fprintf(fpo,"%%%%BoundingBox: 0 0 %5i %5i\n",xpixels,ypixels) ;
fprintf(fpo,"%%%%EndComments\n\n") ;
fprintf(fpo,"%%=======================================================================\n") ;
fprintf(fpo,"%% A NE PAS CHANGER\n") ;
fprintf(fpo,"%%=======================================================================\n") ;
fprintf(fpo," mark\n") ;
fprintf(fpo," /tex where { pop /texval true def }{ /texval false def } ifelse\n") ;
fprintf(fpo," /texdvips where { pop /texdvipsval true def /texval true def }\n") ;
fprintf(fpo," { /texdvipsval false def } ifelse\n") ;
fprintf(fpo," /ptcm 28.3464566929134 def /cm {ptcm mul} def\n") ;
fprintf(fpo,"%%=======================================================================\n") ;
fprintf(fpo,"%% OPTIONS UTILISATEURS\n") ;
fprintf(fpo,"%%=======================================================================\n") ;
fprintf(fpo,"%% OPTION COULEUR\n") ;
fprintf(fpo,"%%=======================================================================\n") ;
fprintf(fpo," %% trace couleur (true) ou n&b = palette gris (false)\n") ;
fprintf(fpo,"true /couleur exch def %% remis systematiquement a true si le fichier est envoye sur\n") ;
fprintf(fpo," %% une imprimante couleur referencee (cf. Options Imprim.)\n\n") ;
fprintf(fpo," %% couleur de fond : true = noir false = blanc\n") ;
fprintf(fpo,"false /fondcou exch def %% remis systematiquement a false si couleur = false\n") ;
fprintf(fpo," %% sauf si imprimante couleur referencee\n\n") ;
fprintf(fpo,"%% RECADRAGE\n") ;
fprintf(fpo,"%%=======================================================================\n") ;
fprintf(fpo," 0 /zoomxmin exch def %% \n") ;
fprintf(fpo,"%5i /zoomxmax exch def %% definition du rectangle de zoom choisi\n",xpixels) ;
fprintf(fpo," 0 /zoomymin exch def %% a utiliser pour recadrer la figure\n") ;
fprintf(fpo,"%5i /zoomymax exch def %%\n\n",ypixels) ;
fprintf(fpo," %% encadrement automatique des zones de trace\n") ;
fprintf(fpo,"false /autoreca exch def %% taper dans le fichier autoreca pour definir la limite\n") ;
fprintf(fpo," %% entre deux zones a encadrer\n\n") ;
fprintf(fpo,"%% OPTIONS DE TRACE\n") ;
fprintf(fpo,"%%=======================================================================\n") ;
fprintf(fpo," %% largeur du trait de trace ]0,+oo[, 1 etant la norme.\n") ;
fprintf(fpo," -1 /lartrait exch def %% le code -1 (valeur par defaut) permet de conserver la meme\n") ;
fprintf(fpo," %% largeur de trait et d'ecriture quelque soit le zoom.\n\n") ;
if ( modepsc != 0 ){
fprintf(fpo," %% option de trace que maillage : 0\n") ;
if ( menu ){
fprintf(fpo," 2 /tracemen exch def %% avec legende qualite : 1\n") ;
} else {
if ( strlen(chaine[7]) != 0 ){
fprintf(fpo," 1 /tracemen exch def %% avec legende qualite : 1\n") ;
} else {
fprintf(fpo," 0 /tracemen exch def %% avec legende qualite : 1\n") ;
}
}
fprintf(fpo," %% avec menus : 2\n") ;
fprintf(fpo," %% par defaut : si il y a un menu 2\n") ;
fprintf(fpo," %% sinon : si qualite 1, 0 sinon\n\n") ;
}
fprintf(fpo," %% option de trace des facettes 0 fil de fer\n") ;
fprintf(fpo," 2 /tracecou exch def %% 1 faces blanches\n") ;
fprintf(fpo," %% 2 faces de couleur\n\n") ;
fprintf(fpo," true /traceecr exch def %% option de trace des chaines de caracteres\n\n") ;
fprintf(fpo,"%% OPTIONS DE MISE EN PAGE\n") ;
fprintf(fpo,"%%=======================================================================\n") ;
fprintf(fpo," true /tracecad exch def %% trace d'un cadre true ou false\n") ;
fprintf(fpo," %% \n") ;
fprintf(fpo," 4 /epcadre exch def %% epaisseur du cadre\n\n") ;
if ( modepsc != 0 ){
if ( menu ){
fprintf(fpo,"false /tracelog exch def %% trace du logo Mefisto : par defaut false si menu true sinon\n") ;
} else {
fprintf(fpo," true /tracelog exch def %% trace du logo Mefisto : par defaut false si menu true sinon\n") ;
}
}
fprintf(fpo," 1 /xpolog exch def %% position horizontale du logo Mefisto -1 gauche 1 droite\n") ;
fprintf(fpo," -1 /ypolog exch def %% position verticale du logo Mefisto -1 bas 1 haut\n") ;
fprintf(fpo," %% position par defaut 1 -1 coin bas droit\n\n") ;

/* *********************************** ATTENTION ***********************************************************
DONNEES DEPENDANTES TYPE IMPRIMANTE
*********************************** ATTENTION ******************************************************** */

fprintf(fpo,"%% OPTIONS DEPENDANTES DE L'IMPRIMANTE\n") ;
fprintf(fpo,"%%=======================================================================\n") ;
fprintf(fpo,"texval not {\n") ;
fprintf(fpo," 27.0 cm /vsize exch def %% hauteur max de la zone de trace sur A4 < 29.7cm\n") ;
fprintf(fpo," 19.0 cm /hsize exch def %% largeur max de la zone de trace sur A4 < 21.0cm\n") ;
fprintf(fpo,"} if\n\n") ;
fprintf(fpo,"version (2010.113) eq { %% palette grise pour LaserWriter II (salle apollo)\n") ;
fprintf(fpo," 0.0 /gsefo exch def %% niveau du gris le plus fonce pour segment 0 = noir\n") ;
fprintf(fpo," 0.8 /gsecl exch def %% clair 1 = blanc\n") ;
fprintf(fpo," 0.1 /gfafo exch def %% niveau du gris le plus fonce pour faces 0 = noir\n") ;
fprintf(fpo," 1.0 /gfacl exch def %% clair 1 = blanc\n") ;
fprintf(fpo,"}{\n") ;
fprintf(fpo,"version (2011.110) eq { %% palette grise pour LaserJet4 (salle HP)\n") ;
fprintf(fpo," 0.1 /gsefo exch def %% niveau du gris le plus fonce pour segment 0 = noir\n") ;
fprintf(fpo," 0.9 /gsecl exch def %% clair 1 = blanc\n") ;
fprintf(fpo," 0.5 /gfafo exch def %% niveau du gris le plus fonce pour faces 0 = noir\n") ;
fprintf(fpo," 1.0 /gfacl exch def %% clair 1 = blanc\n") ;
fprintf(fpo,"}{\n") ;
fprintf(fpo,"version (xxxx.xxx) eq { %% palette grise pour LaserWriterII (salle Mac)\n") ;
fprintf(fpo," 0.1 /gsefo exch def %% niveau du gris le plus fonce pour segment 0 = noir\n") ;
fprintf(fpo," 0.9 /gsecl exch def %% clair 1 = blanc\n") ;
fprintf(fpo," 0.5 /gfafo exch def %% niveau du gris le plus fonce pour faces 0 = noir\n") ;
fprintf(fpo," 1.0 /gfacl exch def %% clair 1 = blanc\n") ;
fprintf(fpo,"}{\n") ;
fprintf(fpo,"version (2013.104) eq { %% couleur pour jet d'encre couleur\n") ;
fprintf(fpo," /couleur true def\n") ;
fprintf(fpo,"}{ %% palette grise par defaut\n") ;
fprintf(fpo," 0.0 /gsefo exch def %% niveau du gris le plus fonce pour segment 0 = noir\n") ;
fprintf(fpo," 0.9 /gsecl exch def %% clair 1 = blanc\n") ;
fprintf(fpo," 0.5 /gfafo exch def %% niveau du gris le plus fonce pour faces 0 = noir\n") ;
fprintf(fpo," 1.0 /gfacl exch def %% clair 1 = blanc\n") ;
fprintf(fpo,"} ifelse } ifelse } ifelse } ifelse\n\n") ;
/* ******************************** ATTENTION **************************************** */
fprintf(fpo,"%% OPTION FONTES\n") ;
fprintf(fpo,"%%=======================================================================\n") ;
fprintf(fpo," %% fontes par defaut (a mettre sous la forme par ex\n") ;
fprintf(fpo,"/Courier /fontm0 exch def %% de /Courier-BoldItalic /Helvetica ...)\n") ;
fprintf(fpo,"/Helvetica /fontp0 exch def %% * /fontm0 est la fonte monospaced\n") ;
fprintf(fpo," %% * /fontp0 est la fonte proportional\n\n") ;
fprintf(fpo," %% de /Courier-BoldItalic /Helvetica ...)\n\n") ;
fprintf(fpo,"false /bavard exch def %% bavard a true indique les chaines de caracteres\n") ;
fprintf(fpo," %% ou la police choisie n'existe pas\n\n") ;
fprintf(fpo,"%%=======================================================================\n\n") ;
fprintf(fpo,"%%%%BeginProcSet \n") ;
fprintf(fpo,"%%%%\n") ;
fprintf(fpo,"%%%% Auto-encadrement\n") ;
fprintf(fpo,"autoreca{ %% definition des macros servant a l'auto-encadrement\n") ;
fprintf(fpo," /nbrcad 0 def\n") ;
fprintf(fpo," /c@rli {currentlinewidth} def\n") ;
fprintf(fpo," /initcad{/nbrcad nbrcad 1 add def /xmin{dup}def /ymin{dup}def /xmax{dup}def /ymax{dup}def}def\n") ;
fprintf(fpo," initcad\n") ;
fprintf(fpo," /t@stxy{2 copy 2 copy /n c@rli 2 div def\n") ;
fprintf(fpo," n sub dup ymin le{/ymin exch def}{pop}ifelse n sub dup xmin le{/xmin exch def}{pop}ifelse\n") ;
fprintf(fpo," n add dup ymax ge{/ymax exch def}{pop}ifelse n add dup xmax ge{/xmax exch def}{pop}ifelse}def\n") ;
fprintf(fpo," /t@stx@{2 copy dup ymin le{/ymin exch def}{pop}ifelse dup xmin le{/xmin exch def}{pop}ifelse\n") ;
fprintf(fpo," dup ymax ge{/ymax exch def}{pop}ifelse dup xmax ge{/xmax exch def}{pop}ifelse}def\n") ;
fprintf(fpo," /m@veto {t@stxy moveto}def\n") ;
fprintf(fpo," /m@v@to {2 copy t@stx@ moveto}def\n") ;
fprintf(fpo," /m@v@t@ {2 copy 2 copy 2 copy tfont add t@stx@ t@stx@ moveto}def\n") ;
fprintf(fpo," /sh@w {3 2 roll dup show stringwidth 3 2 roll add 3 1 roll add exch t@stx@}def\n") ;
fprintf(fpo," /l@neto {t@stxy lineto}def\n") ;
fprintf(fpo," /l@n@to {2 copy t@stx@ lineto}def\n") ;
fprintf(fpo," /rl@neto{2 copy currentpoint 3 2 roll add 3 1 roll add exch t@stxy pop pop rlineto}def\n") ;
fprintf(fpo," /rl@n@to{2 copy currentpoint 3 2 roll add 3 1 roll add exch t@stx@ rlineto}def\n") ;
fprintf(fpo," /t@stel{6 copy /ycent exch def /xcent exch def /hautel exch def /largel exch def\n") ;
fprintf(fpo," 2 copy exch dup truncate 0 ge{90 idiv 1 add}{90 idiv}ifelse\n") ;
fprintf(fpo," exch dup truncate 0 ge{90 idiv}{90 idiv 1 sub}ifelse\n") ;
fprintf(fpo," 2 copy exch sub 1 add 3 1 roll 1 exch {90 mul exch} for\n") ;
fprintf(fpo," 2 add {dup cos largel mul xcent add exch sin hautel mul ycent add t@stxy pop pop} repeat}def\n") ;
fprintf(fpo," /t@st@l{6 copy /ycent exch def /xcent exch def /hautel exch def /largel exch def\n") ;
fprintf(fpo," 2 copy exch dup truncate 0 ge{90 idiv 1 add}{90 idiv}ifelse\n") ;
fprintf(fpo," exch dup truncate 0 ge{90 idiv}{90 idiv 1 sub}ifelse\n") ;
fprintf(fpo," 2 copy exch sub 1 add 3 1 roll 1 exch {90 mul exch} for\n") ;
fprintf(fpo," 2 add {dup cos largel mul xcent add exch sin hautel mul ycent add t@stx@} repeat}def\n") ;
fprintf(fpo," /autoreca{xmin xmax ymin ymax initcad}def\n") ;
fprintf(fpo," /encadre {xmin xmax ymin ymax 1 epais\n") ;
fprintf(fpo," /font0 /Courier-Bold findfont [15 0 0 17 0 0] makefont definefont pop\n") ;
fprintf(fpo," lartrait -1 eq {/font0 /font0 findfont reduc scalefont definefont pop} if\n") ;
fprintf(fpo," /taillefonte{ dup /tfont exch 17 div 14 mul reduc mul def 14.0 div /font0 findfont exch scalefont setfont } bind def\n") ;
fprintf(fpo," 17 taillefonte /hsi (1234567890) stringwidth pop def\n") ;
fprintf(fpo," /tab {hsi 0 rmoveto dup stringwidth pop neg 0 rmoveto show} def\n") ;
fprintf(fpo," /hsize hsi 4 mul (1 : ) stringwidth pop add def\n") ;
fprintf(fpo," /vsize tfont nbrcad 1 add mul 1.2 mul def /angle 0 def\n") ;
fprintf(fpo," texval {\n") ;
fprintf(fpo," /xorig zoomxmin tracecad{epcadre sub}if def /yorig zoomymin tracecad{epcadre sub}if def\n") ;
fprintf(fpo," /cadrepath{newpath\n") ;
fprintf(fpo," xorig yorig vsize sub moveto zoomxmax tracecad{epcadre add}if yorig vsize sub lineto\n") ;
fprintf(fpo," zoomxmax tracecad{epcadre add}if zoomymax tracecad{epcadre add}if lineto\n") ;
fprintf(fpo," xorig zoomymax tracecad{epcadre add}if lineto\n") ;
fprintf(fpo," closepath} def cadrepath clip\n") ;
fprintf(fpo," }{ nbrcad 4 mul copy\n") ;
fprintf(fpo," /xxmin{dup}def /yymin{dup}def /xxmax{dup}def /yymax{dup}def\n") ;
fprintf(fpo," /t@stx@{ dup yymax ge{/yymax exch def}{pop}ifelse dup yymin le{/yymin exch def}{pop}ifelse\n") ;
fprintf(fpo," dup xxmax ge{/xxmax exch def}{pop}ifelse dup xxmin le{/xxmin exch def}{pop}ifelse}def\n") ;
fprintf(fpo," nbrcad { t@stx@ } repeat 14 taillefonte\n")