#include "LesFichiers.h"
#include "Surface.h"
#include "PLSV.h" //dans cet ordre!
#include "Vu.h"

//Les Memoires de Pixels pour les differents traces
//=================================================
//la declaration ci dessous est necessaire ici pour que l'editeur
//de liens retrouve les MemoirePx definis en extern dans PLSV.h

//Creation de la MemoirePx3d de la fenetre de trace dans l'ecran
MemoirePx3d fenetrecran; //construction par defaut sans le Pixmap
//car le Drawable sera ici la fenetre_vu

//Sauvegarde des pixels de fenetrecran dans mpxPLSV MemoirePx3d
MemoirePx3d mpxPLSV; //construction de la MemoirePx sans le pixmap

//Construction de la Memoire de Pixels des traces des modifications de PLSV
MemoirePx3d mpxModif; //construction de la MemoirePx sans le pixmap

//Construction de la Memoire de Pixels pour l'invite
MemoirePxInvite mpxInvite; //construction de la MemoirePx sans le pixmap

//Construction de la Memoire de Pixels pour les menus
MemoirePxMenu mpxMenu; //construction de la MemoirePx sans le pixmap

//Construction de la Memoire de Pixels pour le carre d'accrochage des points
MemoirePxAccroche mpxAccroche; //construction de la MemoirePx sans le pixmap

extern R3 PtMIN, PtMAX; //points extremes du domaine

extern int TraceTg; //Trace (1) ou non (0) des tangentes aux noeuds des courbes
extern int TraceNormales; //Trace (1) ou non (0) des normales et binormales aux noeuds des courbes

//====================================================================

int main()
{
cout << endl;
cout << "========================================\n";
cout << "Saisie et tracé des courbes NURBS\n";
cout << "========================================\n";

// Initialisation du Display, de l'Ecran X, des couleurs et autres variables
// =====================================================================
VuInitier();
// Recuperation du nombre de pixels en largeur et hauteur de l'ecran
int lapxec, lhpxec; //definition pixels de l'ecran
VuPxEcran( lapxec, lhpxec );

// Creation ouverture de la fenetre_vu
// avec son titre, sa largeur et hauteur en pixels
// et la hauteur en pixels des caracteres la plus proche de 20 pixels
// et de preference grasse et 'courier'
int lapxfe, lhpxfe; //definition pixels de la fenetre
lapxfe = lapxec-50;
lhpxfe = lhpxec-50;
VuOuvrir( "Tracé des NURBS", lapxfe, lhpxfe, hauttexte );
//A partir d'ici seulement les couleurs ... sont initialisees

VuPaletteCouleurs( 1 ); //la palette des couleurs est chargee
VuCouleurFond( Beige ); //la couleur du fond de la fenetre

//mise a jour de la MemoirePx a partir de fenetre_vu qui vient d'etre creee
fenetrecran.mempx = fenetre_vu; //la fenetre est ici le Drawable
fenetrecran.largeurpx = lapxfe; //largeur en pixels
fenetrecran.hauteurpx = lhpxfe; //hauteur en pixels
XPoint pxy0={0,0}, pxy1, pxy2, pxy3, pxy4; //XPoint auxiliaires
fenetrecran.pxcsgdf=pxy0; //pixel du coin superieur gauche
int largpx, hautpx;

//Sauvegarde des pixels de fenetrecran dans mpxPLSV MemoirePx3d
mpxPLSV.VuCreerPixmap( lapxfe, lhpxfe, pxy0 ); //creation du pixmap

//Memoire de Pixels des traces des modifications de PLSV
mpxModif.VuCreerPixmap( lapxfe, lhpxfe, pxy0 ); //creation du pixmap

//Memoire de Pixels pour l'invite
XPoint pxyinvite={0,lhpxfe-hautbouton+1};
mpxInvite.VuCreerPixmap( lapxfe, hautbouton, pxyinvite ); //creation du pixmap

//Memoire de Pixels pour les menus
mpxMenu.VuCreerPixmap( lapxfe, lhpxfe, pxy0 ); //creation du pixmap

//Memoire de Pixels pour le carre d'accrochage des points sous forme d'un petit carre
mpxAccroche.VuCreerPixmap( 15, 15 );

//Les donnees des MENUS
//=====================
Drawable fenoupix; //fenetre ou pixmap

//Les donnees du Menu0 racine de l'arborescence des Menus
const int nbboutonMenu0=7;
char *texteboutonMenu0[ nbboutonMenu0]=
{ "Gérer", "Point", "Ligne", "Surface","Volume", "Objet", "Tracer" };
const int couleurboutonMenu0=Rose;
XPoint pxyMenu0={0,0};
int largMenu0, hautMenu0, nobouton0;

//Les donnees du bouton Gerer
const int nbboutonGerer=4;
char *texteboutonGerer[nbboutonGerer]={ "Limites", "Taille", "Scu", "Quitter" };
int couleurboutonGerer=Turquoise;
XPoint pxyGerer={0,hautbouton};
int largGerer, hautGerer, noboutonGerer;

//Les donnees du bouton Point
const int nbboutonPoint=2;
char *texteboutonPoint[nbboutonPoint]={ "X,y,z", "Modifier" };
int couleurboutonPoint=Turquoise;
XPoint pxyPoint={largbouton,hautbouton};
int largPoint, hautPoint, noboutonPoint;

//Les donnees du bouton Ligne
const int nbboutonLigne=5;
char *texteboutonLigne[nbboutonLigne]={ "Droite", "Cercle", "NURBS", "BEZIER", "Modifier" };
int couleurboutonLigne=Turquoise;
XPoint pxyLigne={largbouton*2,hautbouton};
int largLigne, hautLigne, noboutonLigne;

//Les donnees du bouton Surface
const int nbboutonSurface=6;
char *texteboutonSurface[nbboutonSurface]={ "Classiques", "Speciales", "NURBS", "BEZIER", "Ombrage", "Modifier" };
int couleurboutonSurface=Turquoise;
XPoint pxySurface={largbouton*3,hautbouton};
int largSurface, hautSurface, noboutonSurface;

//Les donnees du bouton Tracer Dernier bouton actuel de Menu0
const int nbboutonTracer=12;
char *texteboutonTracer[nbboutonTracer]=
{ "Zoom+", "zOOm-", "Min Max", "Translater", "Vue 3d", "Tout",
"Points", "Lignes", "Surfaces", "Volumes",
"Tangentes", "Normales" };
int couleurboutonTracer=Turquoise;
XPoint pxyTracer={largbouton*6,hautbouton};
int largTracer, hautTracer, noboutonTracer;

//Les donnees du bouton Surfaces->Surfaces classiques
const int nbboutonSurfaceClassique=4;
char *texteboutonSurfaceClassique[nbboutonSurfaceClassique]={ "Sphere", "Tore", "Cone", "Cylindre"};
int couleurboutonSurfaceClassique=Jaune;
XPoint pxySurfaceClassique={pxySurface.x+largbouton,pxySurface.y+3};
int largSurfaceClassique, hautSurfaceClassique, noboutonSurfaceClassique;

//Les donnees du bouton Surfaces->Surfaces particulières
const int nbboutonSurfaceParticuliere=5;
char *texteboutonSurfaceParticuliere[nbboutonSurfaceParticuliere]={ "Bilineaire", "Extrudee", "Gauche", "Reglee", "Revolution" };
int couleurboutonSurfaceParticuliere=Jaune;
XPoint pxySurfaceParticuliere={pxySurface.x+largbouton,2*pxySurface.y+3};
int largSurfaceParticuliere, hautSurfaceParticuliere, noboutonSurfaceParticuliere;

//Les donnees du bouton Surface->Ombrage
const int nbboutonSurfaceOmbrage=3;
char *texteboutonSurfaceOmbrage[nbboutonSurfaceOmbrage]={"Filaire", "Gouraud","Combine"};
int couleurboutonSurfaceOmbrage=Jaune;
XPoint pxySurfaceOmbrage={pxySurface.x+largbouton,5*pxySurface.y+3};
int largSurfaceOmbrage, hautSurfaceOmbrage, noboutonSurfaceOmbrage;

//Les donnees du bouton Surface->Modifier
const int nbboutonSurfaceModifier=2;
char *texteboutonSurfaceModifier[nbboutonSurfaceModifier]=
{ "Nom", "Supprimer" };
int couleurboutonSurfaceModifier=Jaune;
XPoint pxySurfaceModifier;
int largSurfaceModifier, hautSurfaceModifier, noboutonSurfaceModifier;

//Les donnees du bouton Gerer>Limites
const int nbboutonGererLim=6;
char *texteboutonGererLim[nbboutonGererLim]=
{ "Xminimum", "xMaximum", "Yminimum", "ymAximum", "Zminimum", "zmaxImum" };
int couleurboutonGererLim=Jaune;
XPoint pxyGererLim={pxyGerer.x+largbouton,pxyGerer.y+3};
int largGererLim, hautGererLim, noboutonGererLim;

//Les donnees du bouton Gerer>Scu
const int nbboutonGererScu=10;
char *texteboutonGererScu[nbboutonGererScu]=
{ "Accrocher", "SCG", "Classiques", "Hauteur Z", "Origine",
"Pas en XY", "Translation", "Rotation", "3 Points", "Couleur" };
int couleurboutonGererScu=Jaune;
XPoint pxyGererScu={pxyGerer.x+largbouton,pxyGerer.y+2*hautbouton+3};
int largGererScu, hautGererScu, noboutonGererScu;

//Les donnees du bouton Gerer>Scu>Classique
const int nbboutonGererScuClassique=6;
char *texteboutonGererScuClassique[nbboutonGererScuClassique]=
{ "Haut", "Bas", "Droite", "Gauche", "Avant", "arrIere" };
int couleurboutonGererScuClassique=Saumon;
XPoint pxyGererScuClassique={pxyGererScu.x+largbouton,pxyGererScu.y+2*hautbouton+3};
int largGererScuClassique, hautGererScuClassique, noboutonGererScuClassique;

//Les donnees du bouton Gerer>Scu>Translation
const int nbboutonGererScuTranslation=2;
char *texteboutonGererScuTranslation[nbboutonGererScuTranslation]={ "Vecteur", "2 Points" };
int couleurboutonGererScuTranslation=Saumon;
XPoint pxyGererScuTranslation={pxyGererScu.x+largbouton,pxyGererScu.y+6*hautbouton+3};
int largGererScuTranslation, hautGererScuTranslation, noboutonGererScuTranslation;

//Les donnees du bouton Gerer>Scu>Rotation
const int nbboutonGererScuRotation=3;
char *texteboutonGererScuRotation[nbboutonGererScuRotation]={ "axe X", "axe Y", "axe Z" };
int couleurboutonGererScuRotation=Saumon;
XPoint pxyGererScuRotation={pxyGererScu.x+largbouton,pxyGererScu.y+7*hautbouton+3};
int largGererScuRotation, hautGererScuRotation, noboutonGererScuRotation;

//Les donnees du bouton Point>Modifier
const int nbboutonPointModifier=2;
char *texteboutonPointModifier[nbboutonPointModifier]={ "Nom", "Xyz" };
int couleurboutonPointModifier=Jaune;
XPoint pxyPointModifier;
int largPointModifier, hautPointModifier, noboutonPointModifier;

//Les donnees du bouton Ligne>Modifier
const int nbboutonLigneModifier=5;
char *texteboutonLigneModifier[nbboutonLigneModifier]=
{ "Nom", "Degre+", "noEud+", "Xyz", "Poids" };
int couleurboutonLigneModifier=Jaune;
XPoint pxyLigneModifier;
int largLigneModifier, hautLigneModifier, noboutonLigneModifier;

//Les donnees du bouton Tracer>Vue3d
const int nbboutonTracerVue3d=5;
char *texteboutonTracerVue3d[nbboutonTracerVue3d]=
{ "Min Max", "Longitude", "PointVu", "Oeil", "Classiques" };
int couleurboutonTracerVue3d=Jaune;
XPoint pxyTracerVue3d={pxyTracer.x+largbouton, pxyTracer.y+4*hautbouton+3};
int largTracerVue3d, hautTracerVue3d, noboutonTracerVue3d;
XPoint pxyTracerVue3dClassique={pxyTracerVue3d.x+largbouton,pxyTracerVue3d.y+4*hautbouton+3};

//les donnees generales du programme
//==================================
R axlar, axhau; //demi-largeur et demi-hauteur de la fenetre en 3d
R axarr=0; //distance arriere et avant de troncage de l'hexaedre
R axava=0;
R3 axptv, axeil;
R longitude=35, latitude=25; //en degres
R3 SCU0[4]; //Sauvegarde du Systeme de Coordonnees Utilisateur

Points *LesPoints; //Chainage des Points
Lignes *LesLignes; //Chainage des Lignes
Surfaces *LesSurfaces; //Chainage des Surfaces
Point *PPointCourant;
Ligne *PLigneCourante;
Surface *PSurfaceCourante;

R3 Pt, Pt0, Pt1, Pt2;
XPoint pxy;
Z Zprotection;
R Rprotection;
R ex, ey;
int ncvals;
Nom nomPLSV;
char texte[1+25];
int notyev, nbc;
int nbpxlat, nbpxhat;

XPoint T;
int t,res;

// declaration des Points et Lignes
// ================================
LesPoints = new Points(); // construction dynamique des POINTS
LesLignes = new Lignes(); // construction dynamique des LIGNES
LesSurfaces = new Surfaces(); // construction dynamique des SURFACES

// definition de l'axonometrie
// ===========================
Axonometrie:
VuEffacer(); //fenetrecran est couleur du fond
mpxPLSV.VuEffacerMemoirePx(); //mpxPLSV est aussi couleur du fond

//Mise en ordre eventuelle des MIN et MAX
if( PtMAX.x < PtMIN.x ) { Echange(PtMAX.x, PtMIN.x); }
if( PtMAX.y < PtMIN.y ) { Echange(PtMAX.y, PtMIN.y); }
if( PtMAX.z < PtMIN.z ) { Echange(PtMAX.z, PtMIN.z); }

//Definition de la visee dans mpxPLSV
//en 2d du rectangle, en 3d de l'hexaedre entre PtMIN et PtMAX
mpxPLSV.VuHexaedre( PtMIN, PtMAX );

//Trace des Surfaces dans mpxPLSV
LesSurfaces->TracerSurfaces( mpxPLSV, LesPoints ); // ??? ou LesPoints

//Trace des lignes dans mpxPLSV
LesLignes->TracerLignes( mpxPLSV, LesPoints );

//Trace des points dans mpxPLSV
LesPoints->TracerPoints( mpxPLSV );

//le trace du Menu0 horizontal et recuperation du nobouton0 active par l'utilisateur
//=========================================================
Menu0:
mpxPLSV.VuCombinerMemoirePxDansFenetre( GXcopy, //Restauration de mpxPLSV dans fenetrecran
pxy0, mpxPLSV.largeurpx, mpxPLSV.hauteurpx,
pxy0 );
Menu1:
mpxMenu.VuMenuHorizontal( nbboutonMenu0, texteboutonMenu0,
largbouton, couleurboutonMenu0, pxyMenu0,
largMenu0, hautMenu0, nobouton0 );
// nobouton0: numero du bouton choisi par l'utilisateur
// =-1 => demande d'abandon de l'entree d'un bouton
// >=0 => numero du bouton choisi

switch( nobouton0 ) //traitement du bouton actif du Menu0
{
case -1: //ABANDON demande
goto Menu1;

case 0: //bouton Gerer -----------------------------------------------------
mpxMenu.VuMenuVertical( nbboutonGerer, texteboutonGerer,
largbouton, couleurboutonGerer, pxyGerer,
largGerer, hautGerer, noboutonGerer );
// noboutonGerer: numero du bouton choisi par l'utilisateur
// =-1 => demande d'abandon de l'entree d'un bouton
// >=0 => numero du bouton choisi

switch( noboutonGerer ) //traitement du bouton actif du bouton Gerer
{
case -1: //ABANDON demande
goto Menu0;

case 0: //bouton Gerer>Limites

//lecture des limites de l'hexaedre englobant
mpxMenu.VuMenuVertical( nbboutonGererLim, texteboutonGererLim,
largbouton, couleurboutonGererLim, pxyGererLim,
largGererLim, hautGererLim, noboutonGererLim );
// noboutonGererLim: numero du bouton choisi par l'utilisateur
// =-1 => demande d'abandon de l'entree d'un bouton
// >=0 => numero du bouton choisi
//restauration de la fenetre_vu sans le menu
mpxPLSV.VuCombinerMemoirePxDansFenetre( GXcopy,
pxy0, mpxPLSV.largeurpx, mpxPLSV.hauteurpx,
pxy0 );
switch( noboutonGererLim ) //traitement du bouton actif du bouton Gerer
{
case -1: //ABANDON demande
goto Menu0;

case 0: //bouton Gerer>Limites>Xminimum
Rprotection = 1e100;
while ( Rprotection==1e100 )
{
mpxInvite.VuInvite( "Frapper le X MINIMUM des Points" );
mpxInvite.lireR( ncvals, Rprotection );
if(ncvals==-1) goto Menu0;
}
PtMIN.x = Rprotection;
mpxPLSV.visee=0;
goto Axonometrie;

case 1: //bouton Gerer>Limites>xMaximum
Rprotection = 1e100;
while ( Rprotection==1e100 )
{
mpxInvite.VuInvite( "Frapper le X MAXIMUM des Points" );
mpxInvite.lireR( ncvals, Rprotection );
if(ncvals==-1) goto Menu0;
}
PtMAX.x = Rprotection;
mpxPLSV.visee=0;
goto Axonometrie;

case 2: //bouton Gerer>Limites>Yminimum
Rprotection = 1e100;
while ( Rprotection==1e100 )
{
mpxInvite.VuInvite( "Frapper le Y MINIMUM des Points" );
mpxInvite.lireR( ncvals, Rprotection );
if(ncvals==-1) goto Menu0;
}
PtMIN.y = Rprotection;
mpxPLSV.visee=0;
goto Axonometrie;

case 3: //bouton Gerer>Limites>ymAximum
Rprotection = 1e100;
while ( Rprotection==1e100 )
{
mpxInvite.VuInvite( "Frapper le Y MAXIMUM des Points" );
mpxInvite.lireR( ncvals, Rprotection );
if(ncvals==-1) goto Menu0;
}
PtMAX.y = Rprotection;
mpxPLSV.visee=0;
goto Axonometrie;

case 4: //bouton Gerer>Limites>Zminimum
Rprotection = 1e100;
while ( Rprotection==1e100 )
{
mpxInvite.VuInvite( "Frapper le Z MINIMUM des Points" );
mpxInvite.lireR( ncvals, Rprotection );
if(ncvals==-1) goto Menu0;
}
PtMIN.z = Rprotection;
mpxPLSV.visee=0;
goto Axonometrie;

case 5: //bouton Gerer>Limites>zmaxImum
Rprotection = 1e100;
while ( Rprotection==1e100 )
{
mpxInvite.VuInvite( "Frapper le Z MAXIMUM des Points" );
mpxInvite.lireR( ncvals, Rprotection );
if(ncvals==-1) goto Menu0;
}
PtMAX.z = Rprotection;
mpxPLSV.visee=0;
goto Axonometrie;

default : goto Menu0;
}

case 1: //bouton Gerer>Tailler
Rprotection=0;
while ( Rprotection==0 )
{
mpxInvite.VuInvite( "Frapper la Taille des ARETES des maillages" );
mpxInvite.lireR( ncvals, Rprotection );
if(ncvals==-1) goto Menu0;
}
TailleArete = Rprotection;
goto Menu0;

case 2: //bouton Gerer>Scu
mpxMenu.VuMenuVertical( nbboutonGererScu, texteboutonGererScu,
largbouton, couleurboutonGererScu, pxyGererScu,
largGererScu, hautGererScu, noboutonGererScu );
switch( noboutonGererScu ) //traitement du bouton actif du bouton Gerer>Scu
{
case -1: //ABANDON demande
goto Menu0;

case 0: //bouton Gerer>Scu>Accrocher
if( AccrocherGrilleSCU == 0 )
{
AccrocherGrilleSCU=1; //Mode Accrocher demande
//char *c=strstrtab( texteboutonGerer, 4, "Ac" );
//s pointe sur le premier caractere de Accrocher
//cout << "accrocherGrille=" << mpxPLSV.accrocherGrille
// << " c=" << c << " *c=" << *c << endl;
//strcpy(c,"Decrocher"); // TILT c est const
//*c = 'D'; c++; *c='e'; // TILT c est const Accrocher => Decrocher
}
else
{
AccrocherGrilleSCU=0; //Mode Accrocher supprime
//char *c=strstrtab( texteboutonGerer, 4, "De" );
//strcpy(c,"Accrocher"); // TILT c est const
//*(c++) = 'A'; *c='c'; // TILT c est const //Decrocher => Accrocher
}
goto Menu0;

case 1: //bouton Gerer>Scu>Scg
SCU = SCG;
goto Axonometrie;

case 2: //bouton Gerer>Scu>Classique
mpxMenu.VuMenuVertical( nbboutonGererScuClassique, texteboutonGererScuClassique,
largbouton, couleurboutonGererScuClassique,
pxyGererScuClassique,
largGererScuClassique, hautGererScuClassique,
noboutonGererScuClassique );
switch( noboutonGererScuClassique ) //traitement du bouton Gerer>Scu>Classique
{
case -1: //ABANDON demande
goto Menu0;

case 0: //bouton Gerer>Scu>Classique>Haut
SCU = SCG;
SCU[0].x = PtMIN.x;
SCU[0].y = PtMIN.y;
SCU[0].z = PtMAX.z;
goto Axonometrie;

case 1: //bouton Gerer>Scu>Classique>Bas
SCU = SCG;
SCU[0].x = PtMIN.x;
SCU[0].y = PtMIN.y;
SCU[0].z = PtMIN.z;
goto Axonometrie;

case 2: //bouton Gerer>Scu>Classique>Droite
SCU[0].x = PtMIN.x;
SCU[0].y = PtMAX.y;
SCU[0].z = PtMIN.z;
SCU[1] = SCG[3]; // Axe X du SCU = Z du SCG
SCU[2] = SCG[1]; // Axe Y du SCU = X du SCG
SCU[3] = SCG[2]; // Axe Z du SCU = Y du SCG
goto Axonometrie;

case 3: //bouton Gerer>Scu>Classique>Gauche
SCU[0].x = PtMIN.x;
SCU[0].y = PtMIN.y;
SCU[0].z = PtMIN.z;
SCU[1] = SCG[3]; // Axe X du SCU = Z du SCG
SCU[2] = SCG[1]; // Axe Y du SCU = X du SCG
SCU[3] = SCG[2]; // Axe Z du SCU = Y du SCG
goto Axonometrie;

case 4: //bouton Gerer>Scu>Classique>Avant
SCU[0].x = PtMAX.x;
SCU[0].y = PtMIN.y;
SCU[0].z = PtMIN.z;
SCU[1] = SCG[2]; // Axe X du SCU = Y du SCG
SCU[2] = SCG[3]; // Axe Y du SCU = Z du SCG
SCU[3] = SCG[1]; // Axe Z du SCU = X du SCG
goto Axonometrie;

case 5: //bouton Gerer>Scu>Classique>arrIere
SCU = SCG;
SCU[0].x = PtMIN.x;
SCU[0].y = PtMIN.y;
SCU[0].z = PtMIN.z;
SCU[1] = SCG[2]; // Axe X du SCU = Y du SCG
SCU[2] = SCG[3]; // Axe Y du SCU = Z du SCG
SCU[3] = SCG[1]; // Axe Z du SCU = X du SCG
goto Axonometrie;
}

case 3: //bouton Gerer>Scu>Hauteur Z (du SCU!)
Rprotection = 1e100;
while ( Rprotection==1e100 )
{
mpxInvite.VuInvite( "Frapper la HAUTEUR de TRANSLATION en Z du SCU" );
mpxInvite.lireR( ncvals, Rprotection );
if(ncvals==-1) goto Menu0;
}
SCU[0] = SCU[0] + Rprotection * SCU[3];
goto Axonometrie;

case 4: //bouton Gerer>Scu>Origine dans SCG
mpxInvite.VuInvite( "Frapper les X Y Z dans le SCG du point ORIGINE du SCU" );
mpxInvite.lireXYZ( ncvals, Pt0 );
if( ncvals < 0 ) goto Menu0;
SCU[0] = Pt0;
goto Axonometrie;

case 5: //bouton Gerer>Scu>Pas en X Y
Rprotection=0;
while ( Rprotection==0 )
{
mpxInvite.VuInvite( "Frapper le PAS en X de la grille du SCU" );
mpxInvite.lireR( ncvals, Rprotection );
if(ncvals==-1) goto Menu0;
}
PasGrilleSCU.x = Rprotection;

Rprotection=0;
while ( Rprotection==0 )
{
mpxInvite.VuInvite( "Frapper le PAS en Y de la grille du SCU" );
mpxInvite.lireR( ncvals, Rprotection );
if(ncvals==-1) goto Menu0;
}
PasGrilleSCU.y = Rprotection;
goto Axonometrie;

case 6: //bouton Gerer>Scu>Translation
mpxMenu.VuMenuVertical( nbboutonGererScuTranslation, texteboutonGererScuTranslation,
largbouton, couleurboutonGererScuTranslation,
pxyGererScuTranslation,
largGererScuTranslation, hautGererScuTranslation,
noboutonGererScuTranslation );
switch( noboutonGererScuTranslation ) //traitement du bouton Gerer>Scu>Translation
{
case -1: //ABANDON demande
goto Menu0;

case 0: //bouton Gerer>Scu>Translation>Vecteur
mpxInvite.VuInvite( "Frapper les X Y Z du VECTEUR de TRANSLATION du SCU" );
mpxInvite.lireXYZ( ncvals, Pt0 );
if( ncvals < 0 ) goto Menu0;
SCU[0] = SCU[0] + Pt0;
goto Axonometrie;

case 1: //bouton Gerer>Scu>Translation>2 Points
mpxInvite.VuInvite( "Cliquer le POINT INITIAL de la TRANSLATION du SCUou frapper son NOM" );
PPointCourant = LesPoints->Points::CliquerPoint();
if( PPointCourant == NULL ) { goto Menu0; } //ABANDON
Pt0 = PPointCourant->XyzSommet[0]; //sauvegarde des coordonnees du point
mpxInvite.VuInvite( "Cliquer le POINT FINAL de la TRANSLATION du SCU ou frapper son NOM" );
PPointCourant = LesPoints->Points::CliquerPoint();
if( PPointCourant == NULL ) { goto Menu0; } //ABANDON
SCU[0] = SCU[0] + PPointCourant->XyzSommet[0] - Pt0;
goto Axonometrie;
}

case 7: //bouton Gerer>Scu>Rotation
mpxMenu.VuMenuVertical( nbboutonGererScuRotation, texteboutonGererScuRotation,
largbouton, couleurboutonGererScuRotation,
pxyGererScuRotation,
largGererScuRotation, hautGererScuRotation,
noboutonGererScuRotation );
switch( noboutonGererScuRotation ) //traitement du bouton Gerer>Scu>Rotation
{
case -1: //ABANDON demande
goto Menu0;

case 0: //bouton Gerer>Scu>Rotation>axe X
case 1: //bouton Gerer>Scu>Rotation>axe Y
case 2: //bouton Gerer>Scu>Rotation>axe Z
R3 v1, v2;
R c, s;
int i1,i2;
mpxInvite.VuInvite( "Frapper l'ANGLE en degres de ROTATION" );
mpxInvite.lireR( ncvals, Rprotection );
if( ncvals < 0 ) goto Menu0;
//Transformation des degres en radians
Rprotection = Rprotection * atan(1) / 45.0;
//Rotation du SCU autour de l'axe Z du SCU!
c = cos(Rprotection);
s = sin(Rprotection);
if ( noboutonGererScuRotation==0 )
{v1 = R3(0,c,s); v2 = R3(0,-s,c); i1=2; i2=3;}
else if( noboutonGererScuRotation==1 )
{v1 = R3(s,0,c); v2 = R3(c,0,-s); i1=3; i2=1;}
else
{v1 = R3(c,s,0); v2 = R3(-s,c,0); i1=1; i2=2;}
//expression des vecteurs X et Y du SCU dans le SCG
VecteurScuScg( SCU, v1, v1 );
VecteurScuScg( SCU, v2, v2 );
//Mise a jour du SCU exprime dans le SCG
SCU[i1] = v1;
SCU[i2] = v2;
goto Axonometrie;
}

case 8: //bouton Gerer>Scu>3 Points
mpxInvite.VuInvite( "Cliquer le POINT ORIGINE du SCU ou frapper son NOM" );
PPointCourant = LesPoints->Points::CliquerPoint();
if( PPointCourant == NULL ) { goto Menu0; } //ABANDON
Pt0= PPointCourant->XyzSommet[0]; //sauvegarde des coordonnees du point

mpxInvite.VuInvite( "Cliquer le POINT de l'axe des X du SCU ou frapper son NOM" );
PPointCourant = LesPoints->Points::CliquerPoint();
if( PPointCourant == NULL ) { goto Menu0; } //ABANDON
Pt1 = PPointCourant->XyzSommet[0]; //sauvegarde des coordonnees du point

mpxInvite.VuInvite( "Cliquer le POINT du PLAN XY du SCU ou frapper son NOM" );
PPointCourant = LesPoints->Points::CliquerPoint();
if( PPointCourant == NULL ) { goto Menu0; } //ABANDON
Pt2 = PPointCourant->XyzSommet[0]; //sauvegarde des coordonnees du point

SCU0 = SCU; //Sauvegarde du SCU actuel
nbc=Point3Axe3( Pt0, Pt1, Pt2, SCU+1 ); //Les 3 points => Les 3 axes du SCU
if(nbc!=0) {SCU=SCU0; goto Menu0;}
SCU[0] = Pt0;

cout << "SCU= Origine" << SCU[0] << " s1=" << SCU[1]
<< " s2=" << SCU[2] << " s3=" << SCU[3] << endl;
goto Axonometrie;

case 9: //bouton Gerer>Scu>Couleur de la grille du SCU
Zprotection = -1111;
while ( Zprotection==-1111 )
{
mpxInvite.VuInvite( "Frapper le NO COULEUR de la grille: <O => pas de trace" );
mpxInvite.lireZ( ncvals, Zprotection );
if(ncvals==-1) goto Menu0;
}
CouleurGrilleSCU = Zprotection;
goto Axonometrie;
}

case 3: //bouton Gerer>Quitter
//cout << "Sortie du programme NURBS" << endl;
break;

default : goto Menu0;
}
break;

case 1: // bouton Point --------------------------------------------------
mpxMenu.VuMenuVertical( nbboutonPoint, texteboutonPoint,
largbouton, couleurboutonPoint, pxyPoint,
largPoint, hautPoint, noboutonPoint );
// noboutonPoint: numero du bouton choisi par l'utilisateur
// =-1 => demande d'abandon de l'entree d'un bouton
// >=0 => numero du bouton choisi
switch( noboutonPoint ) //traitement du bouton actif du bouton Point
{
case -1: //ABANDON demande
goto Menu0;

case 0: //bouton Point>X,y,z
PPointCourant = new Pointxyz(); // construction du Point
if( PPointCourant->NbSommet == 0 ) break; // ABANDON demande
LesPoints->Ajouter1Point( PPointCourant ); // ajout du Point a l'ensemble des Points
PPointCourant->TracerMaillage(mpxPLSV); // trace du maillage du Point
break;

case 1: //bouton Point>Modifier
mpxInvite.VuInvite( "Cliquer le POINT a MODIFIER ou frapper son NOM" );
PPointCourant = LesPoints->Points::CliquerPoint();
if( PPointCourant == NULL ) { goto Menu0; } //ABANDON

mpxInvite.VuEffacerMemoirePx();
pxyPointModifier.x=pxyPoint.x+largbouton;
pxyPointModifier.y=pxyPoint.y+hautbouton+3;
mpxMenu.VuMenuLateral( nbboutonPointModifier, texteboutonPointModifier,
largbouton, couleurboutonPointModifier, pxyPointModifier,
largPointModifier, hautPointModifier, noboutonPointModifier );
//restauration de la fenetre_vu sans le menu
mpxPLSV.VuCombinerMemoirePxDansFenetre( GXcopy,
pxy0, mpxPLSV.largeurpx, mpxPLSV.hauteurpx,
pxy0 );
switch( noboutonPointModifier ) //traitement du bouton actif du bouton Modifier
{
case -1: //ABANDON demande
goto Menu0;

case 0: //Modifier le Nom du Point => Renommer le Point
mpxInvite.VuInvite( "Frapper le NOUVEAU NOM du Point" );
mpxInvite.lire1LigneTexte( 0, nomPLSV );
if( nomPLSV[0] == '@' ) { goto Menu0; }
strcpy(PPointCourant->nom, nomPLSV); //Le nouveau nom du Point
goto Axonometrie;

case 1: //Modifier XYZ du Point => Deplacer le Point avec la souris
PPointCourant->Deplacer();
goto Axonometrie;
}

case 10: //bouton Point>R,angle,z
//PPointCourant = new PointCyl(); // construction du Point en coor Cyl
PPointCourant = new Pointxyz(); // saisie du Point en x y
if( PPointCourant->NbSommet == 0 ) break; // ABANDON demande
LesPoints->Ajouter1Point( PPointCourant ); // ajout du Point a l'ensemble des Points
PPointCourant->TracerMaillage(mpxPLSV); // trace du maillage du Point
break;
}
goto Menu0;

case 2: // bouton Ligne --------------------------------------------------
mpxMenu.VuMenuVertical( nbboutonLigne, texteboutonLigne,
largbouton, couleurboutonLigne, pxyLigne,
largLigne, hautLigne, noboutonLigne );
// noboutonLigne: numero du bouton choisi par l'utilisateur
// =-1 => demande d'abandon de l'entree d'un bouton
// >=0 => numero du bouton choisi
switch( noboutonLigne ) //traitement du bouton actif du bouton Ligne
{
case -1: //ABANDON demande
goto Menu0;

case 0: //bouton Ligne>Droite
PLigneCourante = new LigneDroite(LesPoints);// construction de la Ligne
if( PLigneCourante->NbSommet == 0 ) break; // ABANDON demande
LesLignes->Ajouter1Ligne( PLigneCourante ); // ajout de la Ligne a l'ensemble des Lignes
PLigneCourante->TracerMaillage(mpxPLSV); // trace du maillage de la Ligne
goto Menu0;

case 1: //bouton Ligne>Cercle
PLigneCourante = new LigneCercle(LesPoints);// construction de la Ligne
if( PLigneCourante->NbSommet == 0 ) break; // ABANDON demande
LesLignes->Ajouter1Ligne( PLigneCourante ); // ajout de la Ligne a l'ensemble des Lignes
PLigneCourante->TracerMaillage(mpxPLSV); // trace du maillage de la Ligne
goto Menu0;

case 2: //bouton Ligne>NURBS
PLigneCourante = new LigneNURBS(LesPoints); // construction de la Ligne
if( PLigneCourante->NbSommet == 0 ) break; // ABANDON demande
LesLignes->Ajouter1Ligne( PLigneCourante ); // ajout de la Ligne a l'ensemble des Lignes
PLigneCourante->TracerMaillage(mpxPLSV); // trace du maillage de la Ligne
goto Menu0;

case 3: //bouton Ligne>BEZIER
PLigneCourante = new LigneBEZIER(LesPoints); // construction de la Ligne
if( PLigneCourante->NbSommet == 0 ) break; // ABANDON demande
LesLignes->Ajouter1Ligne( PLigneCourante ); // ajout de la Ligne a l'ensemble des Lignes
PLigneCourante->TracerMaillage(mpxPLSV); // trace du maillage de la Ligne
goto Menu0;

case 4: //bouton Ligne>Modifier
mpxInvite.VuInvite( "Cliquer la LIGNE a MODIFIER ou frapper son NOM" );
PLigneCourante = LesLignes->Lignes::CliquerLigne();
if( PLigneCourante == NULL ) { goto Menu0; } //ABANDON
mpxInvite.VuEffacerMemoirePx();
pxyLigneModifier.x=pxyPoint.x+largbouton*2;
pxyLigneModifier.y=pxyPoint.y+hautbouton*4+3;
mpxMenu.VuMenuLateral( nbboutonLigneModifier, texteboutonLigneModifier,
largbouton, couleurboutonLigneModifier, pxyLigneModifier,
largLigneModifier, hautLigneModifier, noboutonLigneModifier );
//restauration de la fenetre_vu sans le menu
mpxPLSV.VuCombinerMemoirePxDansFenetre( GXcopy,
pxy0, mpxPLSV.largeurpx, mpxPLSV.hauteurpx,
pxy0 );
switch( noboutonLigneModifier ) //traitement du bouton actif du bouton Modifier
{
case -1: //ABANDON demande
goto Menu0;

case 0: //Nom de la Ligne => Renommer la Ligne
mpxInvite.VuInvite( "Frapper le NOUVEAU NOM de la Ligne" );
mpxInvite.lire1LigneTexte( 0, nomPLSV );
if( nomPLSV[0] == '@' ) { goto Menu0; }
strcpy(PLigneCourante->nom, nomPLSV); //Le nouveau nom du Ligne
goto Axonometrie;

case 1: //Degre a elever seulement si courbe de Bezier
PLigneCourante->Elevation1Degre( LesPoints );
goto Axonometrie;

case 2: //Modification des noeuds d'une courbe NURBS
mpxInvite.VuInvite( "Frapper la valeur du NOEUD a INSERER" );
mpxInvite.lireR( ncvals, Rprotection );
if(ncvals==-1) goto Menu0;
//Le noeud Rprotection est il dans l'intervalle des Noeuds?
if( Rprotection<(PLigneCourante->U[0]) ||
Rprotection>(PLigneCourante->U[PLigneCourante->nbn+1]) ) goto Menu0;

mpxInvite.VuInvite( "Frapper le NOMBRE de FOIS le NOEUD est a INSERER" );
mpxInvite.lireZ( ncvals, Zprotection );
if(ncvals==-1 || Zprotection<=0) goto Menu0;

PLigneCourante->InsererNoeudNURBS( LesPoints, Rprotection, Zprotection );
goto Axonometrie;

case 3: //XYZ de la Ligne => Deplacer un point de controle de la Ligne
PLigneCourante->DeplacerPC( LesPoints, PPointCourant );
goto Axonometrie;

case 4: //POIDS d'un point de la Ligne => Designer le point
if( PLigneCourante->Poids==NULL ) goto Menu0; //la ligne a des poids
mpxInvite.VuInvite( "Cliquer le POINT de CONTROLE de POIDS a MODIFIER ou frapper son NOM" );
PPointCourant = LesPoints->Points::CliquerPoint();
cout << "PPointCourant=" << PPointCourant
<< " PLigneCourante->nbn=" << PLigneCourante->nbn << endl;
if( PPointCourant == NULL ) { goto Menu0; } //ABANDON
for (int i=0; i<=PLigneCourante->nbn; i++)
{
if( PLigneCourante->PC[i] == PPointCourant )
{
mpxInvite.VuInvite( "Frapper la nouvelle valeur du POIDS du point" );
mpxInvite.lireR( ncvals, Rprotection );
cout << "Rprotection=" << Rprotection << endl;
if( ncvals<0 ) { goto Menu0; } //ABANDON
PLigneCourante->Poids[i] = Rprotection;
cout << "point i=" << i << " PLigneCourante->Poids[i]="
<< PLigneCourante->Poids[i] << endl;
//reconstruction du maillage
PLigneCourante->Mailler(LesPoints);
break;
}
}
goto Axonometrie;
}
}

case 3: //bouton Surface -------------------------------------------------------
mpxMenu.VuMenuVertical ( nbboutonSurface , texteboutonSurface ,
largbouton , couleurboutonSurface , pxySurface ,
largSurface , hautSurface , noboutonSurface );

switch ( noboutonSurface )
{
case -1:
goto Menu0;

case 0:
mpxMenu.VuMenuVertical( nbboutonSurfaceClassique, texteboutonSurfaceClassique,
largbouton, couleurboutonSurfaceClassique,
pxySurfaceClassique,
largSurfaceClassique, hautSurfaceClassique,
noboutonSurfaceClassique );
switch( noboutonSurfaceClassique ) //traitement du bouton Surface->SurfaceClassique
{
case -1: //ABANDON demande
goto Menu0;

case 0: //bouton Surface>Classique>Sphere
PSurfaceCourante = new SurfaceSphere (LesLignes,LesPoints);
if ( PSurfaceCourante -> NbSommet == 0 ) break; // ABANDON demande
LesSurfaces->Ajouter1Surface(PSurfaceCourante); //ajout de la surface
PSurfaceCourante->TracerMaillage(mpxPLSV);
goto Axonometrie;

case 1: //bouton Surface>Classique>Tore
PSurfaceCourante = new SurfaceTore (LesLignes,LesPoints);
if ( PSurfaceCourante -> NbSommet == 0 ) break; // ABANDON demande
LesSurfaces->Ajouter1Surface(PSurfaceCourante); //ajout de la surface
PSurfaceCourante->TracerMaillage(mpxPLSV);
goto Axonometrie;

case 2: //bouton Surface>Classique>Cone
PSurfaceCourante = new SurfaceCone (LesLignes,LesPoints);
if ( PSurfaceCourante -> NbSommet == 0 ) break; // ABANDON demande
LesSurfaces->Ajouter1Surface(PSurfaceCourante); //ajout de la surface
PSurfaceCourante->TracerMaillage(mpxPLSV);
goto Axonometrie;

case 3: //bouton Surface>Classique>Cylindre
PSurfaceCourante = new SurfaceCylindre (LesLignes,LesPoints);
if ( PSurfaceCourante -> NbSommet == 0 ) break; // ABANDON demande
LesSurfaces->Ajouter1Surface(PSurfaceCourante); //ajout de la surface
PSurfaceCourante->TracerMaillage(mpxPLSV);
goto Axonometrie;

}

case 1:
mpxMenu.VuMenuVertical( nbboutonSurfaceParticuliere, texteboutonSurfaceParticuliere,
largbouton, couleurboutonSurfaceParticuliere,
pxySurfaceParticuliere,
largSurfaceParticuliere, hautSurfaceParticuliere,
noboutonSurfaceParticuliere );
switch( noboutonSurfaceParticuliere ) //traitement du bouton Surface->SurfaceParticuliere
{
case -1: //ABANDON demande
goto Menu0;

case 0: //bouton Surface>Particuliere>Bilineaire
PSurfaceCourante = new SurfaceBilineaire (LesLignes,LesPoints);
if ( PSurfaceCourante -> NbSommet == 0 ) break; // ABANDON demande
LesSurfaces->Ajouter1Surface(PSurfaceCourante); //ajout de la surface
PSurfaceCourante->TracerMaillage(mpxPLSV);
goto Axonometrie;

case 1: //bouton Surface>Particuliere>Extrudee
PSurfaceCourante = new SurfaceExtrudee (LesLignes,LesPoints);
if ( PSurfaceCourante -> NbSommet == 0 ) break; // ABANDON demande
LesSurfaces->Ajouter1Surface(PSurfaceCourante); //ajout de la surface
PSurfaceCourante->TracerMaillage(mpxPLSV);
goto Axonometrie;

case 2: //bouton Surface>Particuliere>Gauche

PSurfaceCourante = new SurfaceGauche (LesLignes,LesPoints);
if ( PSurfaceCourante -> NbSommet == 0 ) break; // ABANDON demande
LesSurfaces->Ajouter1Surface(PSurfaceCourante); //ajout de la surface
PSurfaceCourante->TracerMaillage(mpxPLSV);

goto Axonometrie;

case 3: //bouton Surface>Particuliere>Reglee
PSurfaceCourante = new SurfaceReglee (LesLignes,LesPoints);
if ( PSurfaceCourante -> NbSommet == 0 ) goto Menu0; // ABANDON demande
LesSurfaces->Ajouter1Surface(PSurfaceCourante); //ajout de la surface
PSurfaceCourante->TracerMaillage(mpxPLSV);
goto Axonometrie;

case 4: //bouton Surface>Particuliere>Revolution
PSurfaceCourante = new SurfaceRevolution (LesLignes,LesPoints);
if ( PSurfaceCourante -> NbSommet == 0 ) break; // ABANDON demande
LesSurfaces->Ajouter1Surface(PSurfaceCourante); //ajout de la surface
PSurfaceCourante->TracerMaillage(mpxPLSV);
goto Axonometrie;

}

case 2: //bouton Surface>NURBS
PSurfaceCourante = new SurfaceNURBS (LesLignes,LesPoints);
if ( PSurfaceCourante -> NbSommet == 0 ) break; // ABANDON demande
LesSurfaces->Ajouter1Surface(PSurfaceCourante); // ajout de la surface
PSurfaceCourante->TracerMaillage(mpxPLSV);
goto Menu0;

case 3: //bouton Surface>BEZIER
PSurfaceCourante = new SurfaceBezier(LesLignes,LesPoints);
if ( PSurfaceCourante -> NbSommet == 0 ) break; // ABANDON demande
LesSurfaces->Ajouter1Surface(PSurfaceCourante); //ajout de la surface
PSurfaceCourante->TracerMaillage(mpxPLSV);

goto Menu0;

case 4:
mpxMenu.VuMenuLateral(nbboutonSurfaceOmbrage,texteboutonSurfaceOmbrage,
largbouton,couleurboutonSurfaceOmbrage,pxySurfaceOmbrage,
largSurfaceOmbrage,hautSurfaceOmbrage,noboutonSurfaceOmbrage);
//restauration de la fenetre_vu sans le menu
mpxPLSV.VuCombinerMemoirePxDansFenetre( GXcopy,
pxy0,mpxPLSV.largeurpx, mpxPLSV.hauteurpx,
pxy0 );
switch( noboutonSurfaceOmbrage ) //traitement du bouton actif du bouton Ombrage
{
case -1: //ABANDON demande
goto Menu0;

case 0:
Ombrage=0;
goto Menu0;

case 1:
Ombrage=1;
goto Menu0;

case 2:
Ombrage=2;
goto Menu0;
}

case 5:
mpxInvite.VuInvite("Cliquer la SURFACE a MODIFIER ou frapper son NOM");
PSurfaceCourante = LesSurfaces->Surfaces::CliquerSurface();
if( PSurfaceCourante == NULL ) { goto Menu0; } //ABANDON
mpxInvite.VuEffacerMemoirePx();
pxySurfaceModifier.x=pxyPoint.x+largbouton*3;
pxySurfaceModifier.y=pxyPoint.y+hautbouton*5+3;

mpxMenu.VuMenuLateral( nbboutonSurfaceModifier, texteboutonSurfaceModifier,
largbouton, couleurboutonSurfaceModifier, pxySurfaceModifier,
largSurfaceModifier, hautSurfaceModifier, noboutonSurfaceModifier );
//restauration de la fenetre Vu sans le menu
mpxPLSV.VuCombinerMemoirePxDansFenetre( GXcopy,
pxy0, mpxPLSV.largeurpx, mpxPLSV.hauteurpx,
pxy0 );
switch( noboutonSurfaceModifier ) //traitement du bouton actif du bouton Modifier
{
case -1: //ABANDON demande
goto Menu0;

case 0: //Nom de la Surface => Renommer la Surface
mpxInvite.VuInvite( "Frapper le NOUVEAU NOM de la Surface" );
mpxInvite.lire1LigneTexte( 0, nomPLSV );
if( nomPLSV[0] == '@' ) { goto Menu0; }
strcpy(PSurfaceCourante->nom, nomPLSV); //Le nouveau nom de la Surface
goto Axonometrie;

case 1: // Supprimer une courbe
// A faire
mpxInvite.VuInvite( "Fonction non encore PROGRAMME" );
do
{
VuSouris( res, t, T );
}
while (res<=0);
goto Axonometrie;

}
}

case 4: //bouton Volume -------------------------------------------------------
mpxInvite.VuInvite( "Fonction non encore PROGRAMME" );
do
{
VuSouris( res, t, T );
}
while (res<=0);
goto Menu0;

case 5: //bouton Objet ---------------------------------------------------------
mpxInvite.VuInvite( "Fonction non encore PROGRAMME" );
do
{
VuSouris( res, t, T );
}
while (res<=0);
goto Menu0;

case 6: // bouton Tracer -------------------------------------------------------
mpxMenu.VuMenuVertical( nbboutonTracer, texteboutonTracer,
largbouton, couleurboutonTracer, pxyTracer,
largTracer, hautTracer, noboutonTracer );
// noboutonTracer: numero du bouton choisi par l'utilisateur
// =-1 => demande d'abandon de l'entree d'un bouton
// >=0 => numero du bouton choisi
switch( noboutonTracer ) //traitement du bouton actif du bouton Tracer
{
case -1: ///bouton Tracer ABANDON demande
goto Menu0;

case 0: //bouton Tracer>Zoom+ => Definition a la souris d'un rectangle en pixels
case 1: //bouton Tracer>Zoom-
mpxInvite.VuInvite( "Cliquer sans relacher le bouton souris au COIN INITIAL du rectangle" );
notyev=1;
while( notyev != 0 && notyev != -1 )
{
VuSouris( notyev, nbc, pxy ); //en attente d'evenement clavier ou souris
switch( notyev )
{
case 0: //ABANDON demande
goto Menu0;

case -1: //Bouton de la souris enfonce, non relache
pxy1 = pxy; //debut du rectangle du zoom
pxy2 = pxy; //temoin de debut du rectangle du zoom
//copie de mpxPLSV dans mpxModif pour definir la visee
fenoupix = mpxModif.mempx; //protection du mempx
mpxModif = mpxPLSV; //mise a jour des donnees de fenetre et axonometrie
mpxModif.mempx = fenoupix; //restauration du mempx
break;
}
}

RectZoom:
VuSouris( notyev, nbc, pxy ); //en attente d'evenement clavier ou souris
switch( notyev )
{
case 0: //ABANDON demande
goto Menu0;

case -2: //Souris deplacee => Trace du rectangle du zoom
mpxInvite.VuInvite( "Relacher le bouton souris au COIN FINAL du rectangle" );

//Restauration de mpxPLSV dans fenetrecran => l'ancien rectangle disparait
mpxPLSV.VuCombinerMemoirePxDansFenetre( GXcopy,
pxy0, mpxPLSV.largeurpx, mpxPLSV.hauteurpx,
pxy0 );

//trace du nouveau rectangle entre pxy1 et pxy dans mpxModif
mpxModif.VuEffacerMemoirePx();
VuCouleur( Bleu );
VuEpaisseur( 0 );
pxy2.x = Min( pxy1.x, pxy.x);
pxy2.y = Min( pxy1.y, pxy.y);
largpx = Abs(pxy1.x-pxy.x);
hautpx = Abs(pxy1.y-pxy.y);
mpxModif.VuBordRectangle( pxy0, largpx, hautpx );

//combinaison de mpxPLSV dans la fenetre
mpxModif.VuCombinerMemoirePxDansFenetre( GXand,
pxy0, largpx+2, hautpx+2,
pxy2 );
break;

case 1: //Bouton de la souris enfonce et relache
//rectangle du zoom entre pxy1 et pxy
pxy2.x = Min( pxy1.x, pxy.x); //coin superieur gauche
pxy2.y = Min( pxy1.y, pxy.y);
largpx = Abs(pxy1.x-pxy.x);
hautpx = Abs(pxy1.y-pxy.y);
if( largpx<6 || hautpx<6 ) goto Axonometrie; //rectangle trop petit
int visee0 = mpxPLSV.visee;//protection
if( noboutonTracer == 0 ) //Zoom+ le Rectangle devient la Fenetre
{
mpxPLSV.VuIsoFenetre2d( mpxPLSV.Vuxob2px( pxy2.x ), mpxPLSV.Vuxob2px( pxy2.x+largpx ),
mpxPLSV.Vuyob2px( pxy2.y+hautpx ), mpxPLSV.Vuyob2px( pxy2.y ) );
}
else
{ //Zoom- la Fenetre actuelle prend la place du Rectangle
R u0,u1, v0,v1;
u0 = -lapxfe * R(pxy2.x) / largpx; //abscisse pixel du nouveau x=0
u1 = lapxfe * ( lapxfe - R(pxy2.x) ) / largpx; //abscisse pixel du nouveau x=lapxfe
v0 = -lhpxfe * R(pxy2.y) / hautpx; //ordonnee pixel du nouveau y=0
v1 = lhpxfe * ( lhpxfe - R(pxy2.y) ) / hautpx; //ordonnee pixel du nouveau y=lhpxfe
mpxPLSV.VuIsoFenetre2d( mpxPLSV.Vuxob2px(int(u0)), mpxPLSV.Vuxob2px(int(u1)),
mpxPLSV.Vuyob2px(int(v0)), mpxPLSV.Vuyob2px(int(v1)) );
}
mpxPLSV.visee = visee0; //restauration
goto Axonometrie;
}
goto RectZoom;

case 2: //bouton Tracer>MinMax
mpxPLSV.visee=0;
goto Axonometrie;

case 3: //bouton Tracer>Translater
mpxInvite.VuInvite( "Cliquer sans relacher le bouton souris au POINT INITIAL de la translation" );
notyev=1;
while( notyev != 0 && notyev != -1 )
{
VuSouris( notyev, nbc, pxy ); //en attente d'evenement clavier ou souris
switch( notyev ) //calcul du numero du bouton clique du menu horizontal
{
case 0: //ABANDON demande
goto Menu0;

case -1: //Bouton de la souris enfonce, non relache
pxy1 = pxy; //debut du vecteur de translation
//copie de mpxPLSV dans mpxModif pour definir la visee
fenoupix = mpxModif.mempx; //protection du mempx
mpxModif = mpxPLSV; //mise a jour des donnees de fenetre et axonometrie
mpxModif.mempx = fenoupix; //restauration du mempx
break;
}
}

VecTrans:
VuSouris( notyev, nbc, pxy ); //en attente d'evenement clavier ou souris
switch( notyev ) //calcul du numero du bouton clique du menu horizontal
{
case 0: //ABANDON demande
goto Menu0;

case -2: //Souris deplacee => Trace du rectangle du zoom
mpxInvite.VuInvite( "Relacher le bouton souris au POINT FINAL de la translation" );

//Restauration de mpxPLSV dans fenetrecran => l'ancien rectangle disparait
mpxPLSV.VuCombinerMemoirePxDansFenetre( GXcopy,
pxy0, mpxPLSV.largeurpx, mpxPLSV.hauteurpx,
pxy0 );

//trace du nouveau vecteur entre pxy1 et pxy dans mpxModif
mpxModif.VuEffacerMemoirePx();
pxy2.x = Min( pxy1.x, pxy.x); //coin superieur gauche du rectangle contenant le vecteur
pxy2.y = Min( pxy1.y, pxy.y);
largpx = Abs(pxy1.x-pxy.x); //largeur hauteur du rectangle contenant le vecteur
hautpx = Abs(pxy1.y-pxy.y);

pxy3.x = pxy1.x-pxy2.x; //Translation du rectangle vers (0,0)
pxy3.y = pxy1.y-pxy2.y;
pxy4.x = pxy.x-pxy2.x;
pxy4.y = pxy.y-pxy2.y;

VuCouleur( Bleu );
VuEpaisseur( 0 );
mpxModif.MemoirePx::VuTrait( pxy3, pxy4 ); //le vecteur de translation

//combinaison de mpxPLSV dans la fenetre
mpxModif.VuCombinerMemoirePxDansFenetre( GXand,
pxy0, largpx+2, hautpx+2,
pxy2 );
break;

case 1: //Bouton de la souris enfonce et relache
//translation du PtVu de pxy1 a pxy
largpx = pxy1.x - pxy.x; //-vecteur de translation en pixels
hautpx = pxy1.y - pxy.y;
//translation des coins Min Max de la fenetre
int visee0=mpxPLSV.visee; //Protection de la visee 2d ou 3d
mpxPLSV.VuIsoFenetre2d( mpxPLSV.Vuxob2px( largpx ),
mpxPLSV.Vuxob2px( largpx+lapxfe ),
mpxPLSV.Vuyob2px( hautpx ),
mpxPLSV.Vuyob2px( hautpx+lhpxfe ) );
mpxPLSV.visee= visee0; //restauration de la visee 2d ou 3d
goto Axonometrie;
}
goto VecTrans;

case 4: //bouton Tracer>Vue 3d
mpxMenu.VuMenuLateral( nbboutonTracerVue3d, texteboutonTracerVue3d,
largbouton, couleurboutonTracerVue3d, pxyTracerVue3d,
largTracerVue3d, hautTracerVue3d, noboutonTracerVue3d );
switch( noboutonTracerVue3d )
{
case -1: //bouton Tracer>Vue3d ABANDON demande
goto Menu0;

case 0: //bouton Tracer>Vue3d>MinMax
mpxPLSV.visee=0;
goto Axonometrie;

case 1: //bouton Tracer>Vue3d>Longitude
Rprotection=1e100;
while ( Rprotection==1e100 )
{
mpxInvite.VuInvite( "Frapper l'angle de LONGITUDE en degres" );
mpxInvite.lireR( ncvals, Rprotection );
if(ncvals==-1) goto Menu0;
}
longitude = Rprotection;

//lecture de la latitude
Rprotection=1e100;
while ( Rprotection==1e100 )
{
mpxInvite.VuInvite( "Frapper l'angle de LATITUDE en degres" );
mpxInvite.lireR( ncvals, Rprotection );
if(ncvals==-1) goto Menu0;
}
latitude = Rprotection;
mpxPLSV.VuLonLat( longitude, latitude );
mpxPLSV.VuAxonometrie( mpxPLSV.axoptv, mpxPLSV.axoeil,
mpxPLSV.axolar, mpxPLSV.axohau,
mpxPLSV.axoarr, mpxPLSV.axoava );
goto Axonometrie;

case 2: //bouton Tracer>Vue3d>PointVu
mpxInvite.lireXYZ( ncvals, axptv );
mpxPLSV.VuAxonometrie( axptv, mpxPLSV.axoeil,
mpxPLSV.axolar, mpxPLSV.axohau,
mpxPLSV.axoarr, mpxPLSV.axoava );
goto Axonometrie;

case 3: //bouton Tracer>Vue3d>Oeil
mpxInvite.lireXYZ( ncvals, axeil );
mpxPLSV.VuAxonometrie( mpxPLSV.axoptv, axeil,
mpxPLSV.axolar, mpxPLSV.axohau,
mpxPLSV.axoarr, mpxPLSV.axoava );
goto Axonometrie;

case 4: //bouton Tracer>Vue3d>Oeil>Classiques
mpxMenu.VuMenuVertical( nbboutonGererScuClassique, texteboutonGererScuClassique,
largbouton, couleurboutonGererScuClassique,
pxyTracerVue3dClassique,
largGererScuClassique, hautGererScuClassique,
noboutonGererScuClassique );
switch( noboutonGererScuClassique )
{
case -1: //ABANDON demande
goto Menu0;

case 0: //bouton Tracer>Vue3d>Oeil>Classiques>Haut
// initialisation des donnees membres de MemoirePx3d
mpxPLSV.axoptv.x = ( PtMIN.x + PtMAX.x ) * 0.5; //Le point Vu
mpxPLSV.axoptv.y = ( PtMIN.y + PtMAX.y ) * 0.5;
mpxPLSV.axoptv.z = PtMAX.z;

mpxPLSV.axoeil = mpxPLSV.axoptv; //L'OEIL
mpxPLSV.axoeil.z = PtMAX.z*2 - PtMIN.z;

mpxPLSV.axolar = ( PtMAX.x - PtMIN.x ) * 0.5; //La largeur/2 de la fenetre
mpxPLSV.axohau = ( PtMAX.y - PtMIN.y ) * 0.5; //La hauteur/2 de la fenetre
break;

case 1: //bouton Tracer>Vue3d>Oeil>Classiques>Bas
mpxPLSV.axoptv.x = ( PtMIN.x + PtMAX.x ) * 0.5; //Le point Vu
mpxPLSV.axoptv.y = ( PtMIN.y + PtMAX.y ) * 0.5;
mpxPLSV.axoptv.z = PtMIN.z;

mpxPLSV.axoeil = mpxPLSV.axoptv; //L'OEIL
mpxPLSV.axoeil.z = PtMIN.z*2 - PtMAX.z;

mpxPLSV.axolar = ( PtMAX.x - PtMIN.x ) * 0.5; //La largeur/2 de la fenetre
mpxPLSV.axohau = ( PtMAX.y - PtMIN.y ) * 0.5; //La hauteur/2 de la fenetre
break;

case 2: //bouton Tracer>Vue3d>Oeil>Classiques>Droite
mpxPLSV.axoptv.x = ( PtMIN.x + PtMAX.x ) * 0.5; //Le point Vu
mpxPLSV.axoptv.y = PtMAX.y;
mpxPLSV.axoptv.z = ( PtMIN.z + PtMAX.z ) * 0.5;

mpxPLSV.axoeil = mpxPLSV.axoptv; //L'OEIL
mpxPLSV.axoeil.y = PtMAX.y*2 - PtMIN.y;

mpxPLSV.axolar = ( PtMAX.x - PtMIN.x ) * 0.5; //La largeur/2 de la fenetre
mpxPLSV.axohau = ( PtMAX.z - PtMIN.z ) * 0.5; //La hauteur/2 de la fenetre
break;

case 3: //bouton Tracer>Vue3d>Oeil>Classiques>Gauche
mpxPLSV.axoptv.x = ( PtMIN.x + PtMAX.x ) * 0.5; //Le point Vu
mpxPLSV.axoptv.y = PtMIN.y;
mpxPLSV.axoptv.z = ( PtMIN.z + PtMAX.z ) * 0.5;

mpxPLSV.axoeil = mpxPLSV.axoptv; //L'OEIL
mpxPLSV.axoeil.y = PtMIN.y*2 - PtMAX.y;

mpxPLSV.axolar = ( PtMAX.x - PtMIN.x ) * 0.5; //La largeur/2 de la fenetre
mpxPLSV.axohau = ( PtMAX.z - PtMIN.z ) * 0.5; //La hauteur/2 de la fenetre
break;

case 4: //bouton Tracer>Vue3d>Oeil>Classiques>Avant
mpxPLSV.axoptv.x = PtMAX.x;
mpxPLSV.axoptv.y = ( PtMIN.y + PtMAX.y ) * 0.5;
mpxPLSV.axoptv.z = ( PtMIN.z + PtMAX.z ) * 0.5;

mpxPLSV.axoeil = mpxPLSV.axoptv; //L'OEIL
mpxPLSV.axoeil.x = PtMAX.x*2 - PtMIN.x;

mpxPLSV.axolar = ( PtMAX.y - PtMIN.y ) * 0.5; //La largeur/2 de la fenetre
mpxPLSV.axohau = ( PtMAX.z - PtMIN.z ) * 0.5; //La hauteur/2 de la fenetre
break;

case 5: //bouton Tracer>Vue3d>Oeil>Classiques>arrIere
mpxPLSV.axoptv.x = PtMIN.x;
mpxPLSV.axoptv.y = ( PtMIN.y + PtMAX.y ) * 0.5;
mpxPLSV.axoptv.z = ( PtMIN.z + PtMAX.z ) * 0.5;

mpxPLSV.axoeil = mpxPLSV.axoptv; //L'OEIL
mpxPLSV.axoeil.x = PtMIN.x*2 - PtMAX.x;

mpxPLSV.axolar = ( PtMAX.y - PtMIN.y ) * 0.5; //La largeur/2 de la fenetre
mpxPLSV.axohau = ( PtMAX.z - PtMIN.z ) * 0.5; //La hauteur/2 de la fenetre
break;
}

//Mise a jour de l'axonometrie
mpxPLSV.visee = 3;
mpxPLSV.Vumataxo(); // calcul de la matrice axomat
// definition de la fenetre en largeur et hauteur
mpxPLSV.VuIsoFenetre2d( -mpxPLSV.axolar, mpxPLSV.axolar,
-mpxPLSV.axohau, mpxPLSV.axohau );
mpxPLSV.visee = 3;//surcharge de visee=2 modifie dans VuFenetre2d
goto Axonometrie;

default:
goto Menu0;
}

case 5: //bouton Tracer>Tout
goto Axonometrie;

case 6: //bouton Tracer>Points
VuEffacer(); //fenetrecran est couleur du fond
mpxPLSV.VuEffacerMemoirePx(); //mpxPLSV est aussi couleur du fond
//Trace des axes, en 2d du rectangle, en 3d de l'hexaedre entre PtMIN et PtMAX
mpxPLSV.VuHexaedre( PtMIN, PtMAX );
//Trace des points dans mpxPLSV
LesPoints->TracerPoints( mpxPLSV );
goto Menu0;

case 7: //bouton Tracer>Lignes
VuEffacer(); //fenetrecran est couleur du fond
mpxPLSV.VuEffacerMemoirePx(); //mpxPLSV est aussi couleur du fond
//Trace des axes, en 2d du rectangle, en 3d de l'hexaedre entre PtMIN et PtMAX
mpxPLSV.VuHexaedre( PtMIN, PtMAX );
//Trace des lignes dans mpxPLSV
LesLignes->TracerLignes( mpxPLSV, LesPoints );
goto Menu0;

case 8: //bouton Tracer>Surfaces
VuEffacer(); //fenetrecran est couleur du fond
mpxPLSV.VuEffacerMemoirePx(); //mpxPLSV est aussi couleur du fond
mpxPLSV.VuHexaedre( PtMIN, PtMAX );
//Trace des Surfaces dans mpxPLSV
LesSurfaces->TracerSurfaces( mpxPLSV, LesPoints );

goto Menu0;

case 9: //bouton Tracer>Volumes
mpxInvite.VuInvite( "Fonction non encore PROGRAMME" );
do
{
VuSouris( res, t, T );
}
while (res<=0);
goto Menu0;

case 10: //bouton Tracer>Tangentes
if( TraceTg ) TraceTg=0; else TraceTg=1; //Bascule du trace des Tg
goto Menu0;

case 11: //bouton Tracer>Normales
if( TraceNormales ) TraceNormales=0; else TraceNormales=1; //Bascule du trace des Normales
goto Menu0;
}

default:
cout << "Bouton NON PROGRAMME" << endl ;
goto Menu0;
}

//Destruction des Surfaces, Lignes et Points
//================================
delete LesSurfaces;
delete LesLignes;
delete LesPoints;

// fermeture de Vu
// ===============
VuFermer();
cout << "Sortie du programme NURBS" << endl;
return 0;
}

case 9: //bouton Tracer>Volumes
mpxInvite.VuInvite( "Fonction non encore PROGRAMME" );
do
{
VuSouris( res, t, T );
}
while (res<=0);
goto Menu0;

case 10: //bouton Tracer>Tangentes
if( TraceTg ) TraceTg=0; else TraceTg=1; //Bascule du trace des Tg
goto Menu0;

case 11: //bouton Tracer>Normales
if( TraceNormales ) TraceNormales=0; else TraceNormales=1; //Bascule du trace des Normales
goto Menu0;
}

default:
cout << "Bouton NON PROGRAMME" << endl ;
goto Menu0;
}

//Destruction des Surfaces, Lignes et Points
//================================
delete LesSurfaces;
delete LesLignes;
delete LesPoints;

// fermeture de Vu
// ===============
VuFermer();
cout << "Sortie du programme NURBS" << endl;
return 0;
}