unit unit222;

{$mode objfpc}{$H+}

interface

uses
  {$ifdef windows}Windows,{$endif} Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  Menus,ExtCtrls, Buttons,printers, unit_quelobjet,Unit_commune,
  ComCtrls,clipbrd,Unit5,Unit9, PrintersDlgs,MonBitmap,MonImprimante,LResources,LCLType,Math,LCLIntf,
  Unit1_palette,UChaines,MonPostscript,MonPostScriptCanvas,Definitions;

  const
 crDebut=10;
 crFin=11;
 crPoint1=12;
   crPoint2=13;
   crFoyer=14;    crCentre=15;   crSource=16;   crDirection=17;
   crviseur=18; crdeplacement=19; crtranslation=20;  crinfo=21;
   crrotation=22; crprop=23;   crdepcentre=24; crdepfoyer=25;
   crsuivant=26;  crdupliquer=27;  crsommet=28; crtexte=29; crtaille=30;
   crsommet1=31; crsommet2=32; crcentre1=33; crcentre2=34;
   crancre=35;  crdepsommet=36;   crmarteau=37;  crgroupe=40;
   crdepla=38;  crcentreg=41;
   maxmiroirplan=500;   maxMscopa=500;   maxMscepa=500;     maxreseau=500;
   maxrayon=500;   maxlmc=500; maxlmd=500; maxmscore=500; maxmscere=500;
   maxecran=500;   maxlsr=500;   maxpolyhedre=500; maxprisme=500;
   maxpolycercle=500;  maxfleche=500;
   maxmaxsegment=500; {nombre maximal de segments pour un rayon}
   maxrayonsparsourceponctuelle=500; maxsourceponctuelle=500;
   maxrayonsparondeplane=500;  maxondeplane=500; maxsphere=500;
     maxmiroirconique=500; maxmetre=500;  maxtexte=500; maxdiaphragme=500;
     maxlec=500; maxled=500;   maxangle=500;  maxtotalsegment=10000;
     maxsurfacesondeparsource=500;   maxoeil=500;
     maxelementsgroupe=100;    maxgroupe=500;
type

arraytpoint=array[1..maxsommet+1] of tpoint;
parraytpoint=^arraytpoint;
TTypePoint=(tpcroixx,tpcroixp,tpdisque,tpcercle);

ttypepointrot=(tpa1,tpa2,tpce,tpfo,tpf1,tpf2,tpa0,tpap1,tpap2,tpso);

 ttypeprismerot=(tpa,tpb,tpc);

ttypeinterieur=(Iinterieur,Iexterieur,Ibord);

TreflechiPolyhedre=(JamaisReflechi,ToujoursReflechi,ReflechiSiRefracte,
ReflechiSiPasRefracte);


TSurface=(sur_bordure,sur_miroirplan,sur_mscopa,sur_mscepa,sur_lmc,
sur_lmd,sur_mscore,sur_mscere,sur_ecran,sur_lsr,sur_polyhedre,
sur_sphere,sur_miroirconique,sur_diaphragme,sur_lec,sur_polycercle,sur_oeil,sur_prisme,sur_reseau);



TTypeElementModif=(mdMiroirPlan,mdMscopa,mdMscepa,mdMscore,mdMscere,
mdLmc,mdLmd,mdRayon,mdSourcePonctuelle,mdOndePlane,mdecran,mdlsr,mdpolyhedre,
mdsphere,mdmiroirconique,mdtexteaffiche,mddiaphragme,mdlec,mdmetre,mdangle,
mdpolycercle,mdfleche,mdoeil,mdneant,mdgroupe,mdprisme,mdreseau);


textremite=(trien,tffleche,ttrait,trond,tcroix,tcroixx,tdisque);



  ElementGroupe=object
  typeelementgroupe:TTypeElementModif;
  indiceelement:integer;
  end;

  Groupe=object
  ListeElements:array[1..maxelementsgroupe] of elementgroupe;
  nombreelements:integer;
  isox,isoy:extended;
  procedure create;
  procedure recalculeiso;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
  procedure imprime(mc:tmyimprimante);
  procedure translate(dx,dy:extended);
   function add(typeel:TTypeElementModif; indice:integer):boolean;
  end;

  PGroupe=array of groupe;

  Oeil=object
    cx,cy,ax,ay,c2x,c2y,c1x,c1y,bx,by,anglepolaire,rayoncourbure:extended;
    couleur:tcolor;
      epaisseur:integer;
    function create(_cx,_cy,_ax,_ay:extended;
    _epaisseur:integer;_couleur:tcolor):boolean;
    function create2(_cx,_cy,_anglepolaire,_rayoncourbure:extended;
     _epaisseur:integer;_couleur:tcolor):boolean;
     procedure dessine(mc:tmonbitmap);
     procedure dessinePS(mc:TMonPostScript);
       procedure imprime(mc:tmyimprimante);
     end;

     POeil=array of Oeil;


    Diaphragme=object
    cx,cy,a1x,a1y,a2x,a2y,ap1x,ap1y,ap2x,ap2y,rint,rext,anglepolaire:extended;
    couleur:tcolor;
    epaisseur:integer;
    function create(_cx,_cy,_a1x,_a1y,_a2x,_a2y:extended;
    _couleur:tcolor; _epaisseur:integer):boolean;
    function create2(_cx,_cy,_anglepolaire,_rint,_rext:extended;
     _couleur:tcolor; _epaisseur:integer):boolean;
     procedure dessine(mc:tmonbitmap);
     procedure dessinePS(mc:TMonPostScript);
        procedure imprime(mc:tmyimprimante);
     end;

     PDiaphragme=array of diaphragme;


   TexteAffiche=object
   policename:shortstring;
   policecharset:integer;
   policecolor:tcolor;
   policesize:integer;
   policepitch:tfontpitch;
   texteluimeme:shortstring;
   policefsbold,policefsitalic,policefsunderline,policefsstrikeout:boolean;
   x,y:extended;
   function create(_texteluimeme:shortstring; _policename:shortstring; _policecharset:integer;
   _policecolor:tcolor;
   _policesize:integer;
   _policepitch:tfontpitch;_policefsbold,_policefsitalic,_policefsunderline,
   _policefsstrikeout:boolean;_x,_y:extended):boolean;
   procedure dessine(mc:tmonbitmap);
   procedure dessinePS(mc:TMonPostScript);
     procedure imprime(mc:tmyimprimante);
   end;

    PTexteAffiche= array  of texteaffiche;

  MiroirPlan=object
  a1x,a1y,a2x,a2y,cx,cy:extended;
  anglepolaire:extended;
  epaisseur:integer;
  couleur:tcolor;
  hachures:boolean;
 normalex:extended;
 normaley:extended; taille:extended;
  function create(_a1x,_a1y,_a2x,_a2y:extended; _epaisseur:integer;
  _couleur:tcolor; _hachures:boolean):boolean;
  procedure dessine(var mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
     procedure imprime(mc:tmyimprimante);
  end;

  PMiroirPlan = array of MiroirPlan;

   Reseau=object
  a1x,a1y,a2x,a2y,cx,cy:extended;
  anglepolaire:extended;
  epaisseur:integer;
  couleur:tcolor;
 pas,nombre_trait_par_mm:extended;
 ordre_min,ordre_max:integer;
 entransmission:boolean;
 hachures:boolean;
 normalex:extended;
 normaley:extended; taille:extended;
  function create(_a1x,_a1y,_a2x,_a2y:extended; _epaisseur:integer;
  _couleur:tcolor; _pas:extended; _entransmission,_hachures:boolean; _ordre_min,_ordre_max:integer):boolean;
  procedure dessine(var mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
     procedure imprime(mc:tmyimprimante);
  end;
 PReseau = array of Reseau;

  Fleche=object
  a1x,a1y,a2x,a2y,cx,cy:extended;
  anglepolaire:extended;
  epaisseur:integer;
  couleur:tcolor;
  ext1,ext2:textremite;
  taille1,taille2:integer;
  styletrait:tpenstyle;
  function create(_a1x,_a1y,_a2x,_a2y:extended; _epaisseur:integer;
  _couleur:tcolor; _ext1,_ext2:textremite; _styletrait:tpenstyle;
  _taille1,_taille2:integer):boolean;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
      procedure imprime(mc:tmyimprimante);
  end;

  PFleche = array of Fleche;



 MiroirConique=object
 a1x,a1y,a2x,a2y,fx,fy,sx,sy,excentricite,parametre,theta0,theta1,theta2:extended;
 concave:boolean;
  couleur,couleuraxe:tcolor;
  hachures,axefocal:boolean;
 function create(_fx,_fy,_sx,_sy,_a1x,_a1y,_a2x,_a2y:extended; _concave:boolean;
 _couleur,_couleuraxe:tcolor; _hachures,_axefocal:boolean):boolean;
 function create2(_fx,_fy,_theta0,_theta1,_theta2,_excentricite,_parametre:extended; _concave:boolean;
 _couleur,_couleuraxe:tcolor; _hachures,_axefocal:boolean):boolean;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
     procedure imprime(mc:tmyimprimante);
  end;

  PMiroirConique=array of MiroirConique;


  Ecran=object
   a1x,a1y,a2x,a2y,cx,cy:extended;
  anglepolaire:extended;
  epaisseur:integer;
  couleur:tcolor;
 normalex:extended;
 normaley:extended; taille:extended;
  function create(_a1x,_a1y,_a2x,_a2y:extended; _epaisseur:integer;
  _couleur:tcolor):boolean;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
      procedure imprime(mc:tmyimprimante);
  end;

  PEcran = array of Ecran;

  lsr=object
   a1x,a1y,a2x,a2y,cx,cy:extended;
  anglepolaire:extended;
  epaisseur:integer;
  couleur:tcolor;
 normalex:extended;
 normaley:extended; taille:extended;
  function create(_a1x,_a1y,_a2x,_a2y:extended; _epaisseur:integer;
  _couleur:tcolor):boolean;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
     procedure imprime(mc:tmyimprimante);
  end;

  Plsr = array of lsr;


  Angle=object
  cx,cy,a1x,a1y,a2x,a2y,dx,dy:extended;
  function create(_cx,_cy,_a1x,_a1y,_a2x,_a2y:extended):boolean;
   procedure dessine(mc:tmonbitmap);
   procedure dessinePS(mc:TMonPostScript);
    procedure dessinebis(mc:tmonbitmap);
    procedure dessinebisPS(mc:TMonPostScript);
       procedure imprime(mc:tmyimprimante);
         procedure imprimebis(mc:tmyimprimante);
  end;

  PAngle=array of angle;

   Metre=object
   a1x,a2x,a1y,a2y,cx,cy:extended;
   function create(_a1x,_a1y,_a2x,_a2y:extended):boolean;
   procedure dessine(mc:tmonbitmap);
   procedure dessinePS(mc:TMonPostScript);
      procedure imprime(mc:tmyimprimante);
  end;

  PMetre= array of metre;

  Mscopa=object
  a1x,a1y,a2x,a2y,fx,fy,sx,sy,cx,cy,t1x,t1y,t2x,t2y:extended;
  anglepolaire:extended; focale:extended;
  epaisseur:integer;
  trou:boolean;
  diametretrou:extended;
  couleur,couleuraxe:tcolor;
  hachures,axefocal:boolean;
 normalex:extended;
 normaley:extended; taille:extended;
  function create(_a1x,_a1y,_a2x,_a2y,_fx,_fy:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_trou:boolean; _diametretrou:extended):boolean;
  function create2(_a1x,_a1y,_a2x,_a2y,_focale:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_trou:boolean; _diametretrou:extended):boolean;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
     procedure imprime(mc:tmyimprimante);
  end;

  PMscopa= array of Mscopa;

  Mscore=object
  a1x,a1y,a2x,a2y,sx,sy,cx,cy:extended;
  theta1,theta2,rayoncourbure,circonference:extended;
  theta1p,theta2p:extended;
  trou:boolean;
  diametretrou:extended;
  epaisseur:integer;
  couleur,couleuraxe:tcolor;
  hachures,axefocal,aigu:boolean;
 normalex:extended;
 normaley:extended; taille:extended;
  function create(_a1x,_a1y,_a2x,_a2y,_cx,_cy:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_trou:boolean; _diametretrou:extended):boolean;
  function create2(_a1x,_a1y,_a2x,_a2y,_rayon:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_aigu,_trou:boolean; _diametretrou:extended):boolean;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
     procedure imprime(mc:tmyimprimante);
  end;

  PMscore= array of Mscore;


  Mscere=object
  a1x,a1y,a2x,a2y,sx,sy,cx,cy:extended;
  theta1,theta2,rayoncourbure,circonference:extended;
  theta1p,theta2p:extended;
  trou:boolean;
  diametretrou:extended;
  epaisseur:integer;
  couleur,couleuraxe:tcolor;
  hachures,axefocal,aigu:boolean;
 normalex:extended;
 normaley:extended; taille:extended;
  function create(_a1x,_a1y,_a2x,_a2y,_cx,_cy:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_trou:boolean; _diametretrou:extended):boolean;
  function create2(_a1x,_a1y,_a2x,_a2y,_rayon:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_aigu,_trou:boolean; _diametretrou:extended):boolean;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
     procedure imprime(mc:tmyimprimante);
  end;

 PMscere=  array of Mscere;

  Mscepa=object
  a1x,a1y,a2x,a2y,fx,fy,sx,sy,cx,cy,t1x,t1y,t2x,t2y:extended;
  anglepolaire:extended; focale:extended;
  epaisseur:integer;
  couleur,couleuraxe:tcolor;
  hachures,axefocal:boolean;
   trou:boolean;
  diametretrou:extended;
 normalex:extended;
 normaley:extended; taille:extended;
  function create(_a1x,_a1y,_a2x,_a2y,_fx,_fy:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_trou:boolean;
  _diametretrou:extended):boolean;
  function create2(_a1x,_a1y,_a2x,_a2y,_focale:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_trou:boolean;
  _diametretrou:extended):boolean;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
      procedure imprime(mc:tmyimprimante);
  end;

  PMscepa= array of Mscepa;

  lmc=object
  a1x,a1y,a2x,a2y,f1x,f1y,f2x,f2y,ox,oy:extended;
  anglepolaire:extended; focale:extended;
  epaisseur:integer;
  couleur,couleuraxe:tcolor;
  axefocal:boolean;
 normalex:extended;
 normaley:extended; taille:extended;
 rayonmonture:extended;
  function create(_a1x,_a1y,_a2x,_a2y,_fx,_fy:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _axefocal:boolean):boolean;
  function create2(_a1x,_a1y,_a2x,_a2y,_focale:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _axefocal:boolean):boolean;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
     procedure imprime(mc:tmyimprimante);
  end;

   PLmc=  array of Lmc;

  lec=object
  a1x,a1y,a2x,a2y,b1x,b1y,b2x,b2y,
  s1x,s1y,s2x,s2y,ox,oy,c1x,c1y,c2x,c2y,r1,r2,apaf:extended;
  MesSommets: TableauPointPolyhedre;
 MesCentres: TableauPointPolyhedre;
 rectiligne,rentrant,trig:tableaurectiligne; theta1,theta2:sommetsreels;
  couleurfond,couleuraxe:tcolor;
  axefocal,tronque,mince:boolean;   diametremax,diametre:extended;
  theta1_1,theta2_1,theta1_2,theta2_2:extended;
  indicerouge,indicebleu,indicevert:extended;
 ReflechiEntrant,ReflechiSortant:TReflechiPolyhedre;
 function  estou(x,y:extended):ttypeinterieur;
 function dispersif:boolean;
  function create(_s1x,_s1y,_s2x,_s2y,_r1,_r2,_diametre:extended;
  _couleurfond,_couleuraxe:tcolor; _axefocal:boolean;
  _indicerouge,_indicebleu,_indicevert:extended;
 _ReflechiEntrant,_ReflechiSortant:TReflechiPolyhedre):boolean;
   procedure dessine(mc:tmonbitmap);
   procedure dessinePS(mc:TMonPostScript);
     procedure imprime(mc:tmyimprimante);
  end;
   PLec= array of lec;


  lmd=object
  a1x,a1y,a2x,a2y,f1x,f1y,f2x,f2y,ox,oy:extended;
  anglepolaire:extended; focale:extended;
  epaisseur:integer;
  couleur,couleuraxe:tcolor;
  axefocal:boolean;
 normalex:extended;
 normaley:extended; taille:extended;
  function create(_a1x,_a1y,_a2x,_a2y,_fx,_fy:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _axefocal:boolean):boolean;
  function create2(_a1x,_a1y,_a2x,_a2y,_focale:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _axefocal:boolean):boolean;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
     procedure imprime(mc:tmyimprimante);
  end;

  PLmd=array of Lmd;

  Rayon=object
  ax,ay,bx,by:extended;
  liste_vav,liste_vaa:array[1..maxmaxsegment] of boolean;
  vav,vaa:shortstring;
  maxsegment:integer;
  kx,ky:extended;
  cx,cy:extended;
  anglepolaire:extended;
  nombresegment:integer; nombremaxenfant:integer;
  couleur:tcolor;
  epaisseur:integer;
  function create (_ax,_ay,_kx,_ky:extended; _couleur:tcolor;
  _epaisseur:integer; _vav,_vaa:shortstring;_nombremaxenfant,_maxsegment:integer):boolean;
   function createenfant (_ax,_ay,_kx,_ky:extended;
 _couleur:tcolor;
  _epaisseur:integer; _vav,_vaa:shortstring; _nombremaxenfant,_maxsegment,indicesegment:integer):boolean;

  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
  procedure dessinebis(mc:tmonbitmap;extreme:boolean);
  procedure dessinebisPS(mc:TMonPostScript;extreme:boolean);
     procedure imprime(mc:tmyimprimante);
       procedure imprimebis(mc:tmyimprimante;extreme:boolean);
  end;


  PRayon= array of Rayon;

  Segment=object
  a1x,a1y,a2x,a2y,ap:extended;
  epaisseur:integer;
  couleur:tcolor;
  virtuelavant,virtuelarriere:boolean;
  procedure create(_a1x,_a1y,_a2x,_a2y,_ap:extended; _epaisseur:integer;
  _couleur:tcolor; _virtuelavant,_virtuelarriere:boolean);
  end;

  PSegment=array of segment;



  SourcePonctuelle=object
  ray:array[1..maxrayonsparsourceponctuelle] of rayon;
  vav,vaa,listechemins:shortstring;
  listecheminsoptiques:array[1..maxsurfacesondeparsource] of extended;
  nombrecheminsoptiques:integer;
  nombrederayon,epaisseur:integer;
  maxenfantparrayon,maxsegment:integer;
  sourcevirtuelle,tracersurfacesonde:boolean; couleur:tcolor;
  sx,sy,a1x,a1y,a2x,a2y,gx,gy:extended;
  function create(_nombrederayon:integer; _sx,_sy,_a1x,_a1y,_a2x,_a2y:extended;
  _couleur:tcolor; _epaisseur:integer; _vav,_vaa:shortstring;
  _maxenfantparrayon:integer; _sourcevirtuelle,_tracersurfacesonde:boolean;
  _listechemins:shortstring;_maxsegment:integer):boolean;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
  procedure calculesegment;
     procedure imprime(mc:tmyimprimante);
  end;

  PSourcePonctuelle= array of SourcePonctuelle;

  OndePlane=object
  ray:array[1..maxrayonsparondeplane] of rayon;
  nombrederayon:integer;
  maxenfantparrayon,maxsegment:integer;
  vav,vaa,listechemins:shortstring;
  listecheminsoptiques:array[1..maxsurfacesondeparsource] of extended;
  nombrecheminsoptiques:integer;
    couleur:tcolor;   epaisseur:integer;
    tracersurfacesonde:boolean;
  sx,sy,a1x,a1y,a2x,a2y,gx,gy:extended;
  function create(_nombrederayon:integer; _sx,_sy,_a1x,_a1y,_a2x,_a2y:extended;
  _couleur:tcolor; _epaisseur:integer; _vav,_vaa:shortstring;
  _maxenfantparrayon:integer;_tracersurfacesonde:boolean;
  _listechemins:shortstring;_maxsegment:integer):boolean;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
  procedure calculesegment;
     procedure imprime(mc:tmyimprimante);
  end;

  POndePlane=array of OndePlane;





 Polyhedre=object
 nombresommet:integer;  xiso,yiso:extended;
 MesSommets: TableauPointPolyhedre;
 indicerouge,indicebleu,indicevert:extended;
 ReflechiEntrant,ReflechiSortant:TReflechiPolyhedre;
 anglepolaire,nx,ny:array[1..maxsommet+1] of extended;
   trigodirect:boolean;   couleurbord,couleurfond:tcolor;
   function dispersif:boolean;
    procedure dessine(mc:tmonbitmap);
    procedure dessinePS(mc:TMonPostScript);
 function create(_nombresommet:integer;
 _MesSommets: TableauPointPolyhedre;
 _indicerouge,_indicebleu,_indicevert:extended; _couleurbord,_couleurfond:tcolor;
 _ReflechiEntrant,_ReflechiSortant:TReflechiPolyhedre):boolean;
 function  estou(x,y:extended):ttypeinterieur;
    procedure imprime(mc:tmyimprimante);
   end;

   PPolyhedre=array of polyhedre;

   Prisme=object
 nombresommet:integer;  xiso,yiso:extended;
 MesSommets: TableauPointPolyhedre;
 gx,gy,ax,ay,bx,by,cx,cy,hauteur,angle_sommet,
 angle_axe:extended;
 indicerouge,indicebleu,indicevert:extended;
 ReflechiEntrant,ReflechiSortant:TReflechiPolyhedre;
 anglepolaire,nx,ny:array[1..maxsommet+1] of extended;
   trigodirect:boolean;   couleurbord,couleurfond:tcolor;
   function dispersif:boolean;
   procedure dessinePS(mc:TMonPostScript);
    procedure dessine(mc:tmonbitmap);
 function create(_gx,_gy,_ax,_ay,_3x,_3y:extended; _indicerouge,_indicebleu,_indicevert:extended; _couleurbord,_couleurfond:tcolor;
 _ReflechiEntrant,_ReflechiSortant:TReflechiPolyhedre):boolean;
 function  estou(x,y:extended):ttypeinterieur;
    procedure imprime(mc:tmyimprimante);
   end;

   PPrisme=array of prisme;




Polycercle=object
 nombresommet:integer;    xiso,yiso:extended;
 MesSommets,MesCentres,MesS: TableauPointPolyhedre;
 rectiligne,rentrant,listetrigodirect,aigu,agauche:tableaurectiligne;
 anglepolaire,nx,ny:sommetsreels;
 theta1,theta2,rayon,thetavrai1,thetavrai2,tpc1,tpc2:sommetsreels;
 indicerouge,indicebleu,indicevert:extended;
 ReflechiEntrant,ReflechiSortant:TReflechiPolyhedre;
 couleurbord,couleurfond:tcolor;
 trigodirect:boolean;
   function dispersif:boolean;
    procedure dessine(mc:tmonbitmap);
    procedure dessinePS(mc:TMonPostScript);
 function create(_nombresommet:integer;
 _MesSommets,_MesS: TableauPointPolyhedre; _rectiligne:tableaurectiligne;
 _indicerouge,_indicebleu,_indicevert:extended; _couleurbord,_couleurfond:tcolor;
 _ReflechiEntrant,_ReflechiSortant:TReflechiPolyhedre):boolean;
 {function create2(_nombresommet:integer;
 _MesSommets: TableauPointPolyhedre; _rayon:sommetsreels; _rectiligne,_rentrant,_aigu:tableaurectiligne;
 _indicerouge,_indicebleu,_indicevert:extended; _couleurbord,_couleurfond:tcolor;
 _ReflechiEntrant,_ReflechiSortant:TReflechiPolyhedre;_trigodirect:boolean):boolean;}
 function  estou(x,y:extended):ttypeinterieur;
     procedure imprime(mc:tmyimprimante);
   end;

   PPolycercle=array of polycercle;



 Sphere=object
 cx,cy,rayon:extended;
 indicerouge,indicebleu,indicevert:extended;
 ReflechiEntrant,ReflechiSortant:TReflechiPolyhedre;
 couleurbord,couleurfond:tcolor;
 function create(_cx,_cy,_rayon:extended;
 _indicerouge,_indicebleu,_indicevert:extended; _couleurbord,_couleurfond:tcolor;
 _ReflechiEntrant,_ReflechiSortant:TReflechiPolyhedre):boolean;
  function dispersif:boolean;
  procedure dessine(mc:tmonbitmap);
  procedure dessinePS(mc:TMonPostScript);
  function  estou(x,y:extended):ttypeinterieur;
     procedure imprime(mc:tmyimprimante);
  end;

 PSphere=array of Sphere;
 pointerextended=^extended;

   procedure CreePsphere(var TheArray : Psphere;
  NumElements : longint);
 procedure FreePsphere(var TheArray : Psphere;
  NumElements : longint);
 procedure ReTaillePsphere(var TheArray :Psphere;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Psphere(var thearray:psphere;
indice:longint; var nbelements:longint);




    procedure CreePfleche(var TheArray : Pfleche;
  NumElements : longint);
 procedure FreePfleche(var TheArray : Pfleche;
  NumElements : longint);
 procedure ReTaillePfleche(var TheArray :Pfleche;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Pfleche(var thearray:pfleche;
indice:longint; var nbelements:longint);

   procedure CreePmetre(var TheArray : Pmetre;
  NumElements : longint);
 procedure FreePmetre(var TheArray : Pmetre;
  NumElements : longint);
 procedure ReTaillePmetre(var TheArray :Pmetre;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Pmetre(var thearray:pmetre;
indice:longint; var nbelements:longint);


procedure CreePangle(var TheArray : Pangle;
  NumElements : longint);
 procedure FreePangle(var TheArray : Pangle;
  NumElements : longint);
 procedure ReTaillePangle(var TheArray :Pangle;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Pangle(var thearray:pangle;
indice:longint; var nbelements:longint);

procedure CreePMiroirplan(var TheArray : PMiroirPlan;
  NumElements : longint);
 procedure FreePMiroirPlan(var TheArray : PMiroirPlan;
  NumElements : longint);
 procedure ReTaillePMiroirPlan(var TheArray :PMiroirPlan;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1PMiroirplan(var thearray:pmiroirplan;
indice:longint; var nbelements:longint);

 procedure CreePReseau(var TheArray : PReseau;
  NumElements : longint);
 procedure FreePReseau(var TheArray : PReseau;
  NumElements : longint);
 procedure ReTaillePReseau(var TheArray :PReseau;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1PReseau(var thearray:pReseau;
indice:longint; var nbelements:longint);

procedure CreePmiroirconique(var TheArray : Pmiroirconique;
  NumElements : longint);
 procedure FreePmiroirconique(var TheArray : Pmiroirconique;
  NumElements : longint);
 procedure ReTaillePmiroirconique(var TheArray :Pmiroirconique;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Pmiroirconique(var thearray:pmiroirconique;
indice:longint; var nbelements:longint);



procedure CreePEcran(var TheArray : PEcran;
  NumElements : longint);
 procedure FreePEcran(var TheArray : PEcran;
  NumElements : longint);
 procedure ReTaillePEcran(var TheArray :PEcran;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1PEcran(var thearray:pEcran;
indice:longint; var nbelements:longint);

procedure CreePgroupe(var TheArray : Pgroupe;
  NumElements : longint);
 procedure FreePgroupe(var TheArray : Pgroupe;
  NumElements : longint);
 procedure ReTaillePgroupe(var TheArray :Pgroupe;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Pgroupe(var thearray:pgroupe;
indice:longint; var nbelements:longint);

procedure CreePoeil(var TheArray : Poeil;
  NumElements : longint);
 procedure FreePoeil(var TheArray : Poeil;
  NumElements : longint);
 procedure ReTaillePoeil(var TheArray :Poeil;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Poeil(var thearray:poeil;
indice:longint; var nbelements:longint);



procedure CreePdiaphragme(var TheArray : Pdiaphragme;
  NumElements : longint);
 procedure FreePdiaphragme(var TheArray : Pdiaphragme;
  NumElements : longint);
 procedure ReTaillePdiaphragme(var TheArray :Pdiaphragme;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Pdiaphragme(var thearray:pdiaphragme;
indice:longint; var nbelements:longint);


procedure CreePlsr(var TheArray : Plsr;
  NumElements : longint);
 procedure FreePlsr(var TheArray : Plsr;
  NumElements : longint);
 procedure ReTaillePlsr(var TheArray :Plsr;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Plsr(var thearray:plsr;
indice:longint; var nbelements:longint);

  procedure CreePsegment(var TheArray : Psegment;
  NumElements : longint);
 procedure FreePsegment(var TheArray : Psegment;
  NumElements : longint);
 procedure ReTaillePsegment(var TheArray :Psegment;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Psegment(var thearray:psegment;
indice:longint; var nbelements:longint);


  procedure CreePmscopa(var TheArray : Pmscopa;
  NumElements : longint);
 procedure FreePmscopa(var TheArray : Pmscopa;
  NumElements : longint);
 procedure ReTaillePmscopa(var TheArray :Pmscopa;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Pmscopa(var thearray:pmscopa;
indice:longint; var nbelements:longint);


  procedure CreePmscepa(var TheArray : Pmscepa;
  NumElements : longint);
 procedure FreePmscepa(var TheArray : Pmscepa;
  NumElements : longint);
 procedure ReTaillePmscepa(var TheArray :Pmscepa;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Pmscepa(var thearray:pmscepa;
indice:longint; var nbelements:longint);

  procedure CreePmscore(var TheArray : Pmscore;
  NumElements : longint);
 procedure FreePmscore(var TheArray : Pmscore;
  NumElements : longint);
 procedure ReTaillePmscore(var TheArray :Pmscore;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Pmscore(var thearray:pmscore;
indice:longint; var nbelements:longint);


  procedure CreePmscere(var TheArray : Pmscere;
  NumElements : longint);
 procedure FreePmscere(var TheArray : Pmscere;
  NumElements : longint);
 procedure ReTaillePmscere(var TheArray :Pmscere;
  OldNumElements : longint;
  NewNumElements : longint);
  procedure Supprime1Pmscere(var thearray:pmscere;
indice:longint; var nbelements:longint);

  procedure CreePlmc(var TheArray : Plmc;
  NumElements : longint);
 procedure FreePlmc(var TheArray : Plmc;
  NumElements : longint);
 procedure ReTaillePlmc(var TheArray :Plmc;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Plmc(var thearray:plmc;
indice:longint; var nbelements:longint);


 procedure CreePlec(var TheArray : Plec;
  NumElements : longint);
 procedure FreePlec(var TheArray : Plec;
  NumElements : longint);
 procedure ReTaillePlec(var TheArray :Plec;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Plec(var thearray:plec;
indice:longint; var nbelements:longint);
  procedure CreePlmd(var TheArray : Plmd;
  NumElements : longint);
 procedure FreePlmd(var TheArray : Plmd;
  NumElements : longint);
 procedure ReTaillePlmd(var TheArray :Plmd;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Plmd(var thearray:plmd;
indice:longint; var nbelements:longint);

 procedure CreePpolyhedre(var TheArray : Ppolyhedre;
  NumElements : longint);
 procedure FreePpolyhedre(var TheArray : Ppolyhedre;
  NumElements : longint);
 procedure ReTaillePpolyhedre(var TheArray :Ppolyhedre;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Ppolyhedre(var thearray:ppolyhedre;
indice:longint; var nbelements:longint);


procedure CreePprisme(var TheArray : Pprisme;
  NumElements : longint);
 procedure FreePprisme(var TheArray : Pprisme;
  NumElements : longint);
 procedure ReTaillePprisme(var TheArray :Pprisme;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Pprisme(var thearray:pprisme;
indice:longint; var nbelements:longint);


procedure CreePpolycercle(var TheArray : Ppolycercle;
  NumElements : longint);
 procedure FreePpolycercle(var TheArray : Ppolycercle;
  NumElements : longint);
 procedure ReTaillePpolycercle(var TheArray :Ppolycercle;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Ppolycercle(var thearray:ppolycercle;
indice:longint; var nbelements:longint);




  procedure CreePrayon(var TheArray : Prayon;
  NumElements : longint);
 procedure FreePrayon(var TheArray : Prayon;
  NumElements : longint);
 procedure ReTaillePrayon(var TheArray :Prayon;
  OldNumElements : longint;
  NewNumElements : longint);
  procedure Supprime1Prayon(var thearray:prayon;
indice:longint; var nbelements:longint);


  procedure CreePsourceponctuelle(var TheArray : Psourceponctuelle;
  NumElements : longint);
 procedure FreePsourceponctuelle(var TheArray : Psourceponctuelle;
  NumElements : longint);
 procedure ReTaillePsourceponctuelle(var TheArray :Psourceponctuelle;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Psourceponctuelle(var thearray:psourceponctuelle;
indice:longint; var nbelements:longint);

procedure CreePtexteaffiche(var TheArray : Ptexteaffiche;
  NumElements : longint);
 procedure FreePtexteaffiche(var TheArray : Ptexteaffiche;
  NumElements : longint);
 procedure ReTaillePtexteaffiche(var TheArray :Ptexteaffiche;
  OldNumElements : longint;
  NewNumElements : longint);
 procedure Supprime1Ptexteaffiche(var thearray:ptexteaffiche;
indice:longint; var nbelements:longint);


  procedure CreePondeplane(var TheArray : Pondeplane;
  NumElements : longint);
 procedure FreePondeplane(var TheArray : Pondeplane;
  NumElements : longint);
 procedure ReTaillePondeplane(var TheArray :Pondeplane;
  OldNumElements : longint;
  NewNumElements : longint);
  procedure Supprime1Pondeplane(var thearray:pondeplane;
indice:longint; var nbelements:longint);

 procedure DessineTousLesSegments(mc:tmonbitmap);
  procedure DessineTousLesSegmentsPS(mc:tmonpostscript);
  procedure ImprimeTousLesSegments(mc:tmyimprimante);
 procedure calculesegment0(ax,ay,kx,ky,anglepolaire:extended; epaisseur:integer;
 couleur:tcolor; vav,vaa:shortstring; nombremaxenfant,maxsegment:integer);

 function unmilieudispersif:boolean;
var
bomme_hauteur_image,bonne_largeur_image:integer;
listemateriaux,listenrouge,listenbleu,listenvert:tstrings;
 policedefaut:tfont;
unitelongueur:shortstring;
ttpoly,ttsom,tts,ttc:tableaupointpolyhedre;
youri,helena,tavarich:tableaurectiligne;   nbactsommet,decimalesangles:integer;
selene:sommetsreels;

 deb:textfile;
 genrevirtuel:boolean;

  graphepresent:boolean;
  tracergrille,attractiongrille:boolean; grillex,grilley,pourcentagenormale:extended;
  signaler,fantomespresents,optionsurfacesonde,commentaire_change:boolean;
  stylepoint:ttypepoint;
  listefantomes:string;
  taillepoint,nbrecti,nbrectiact:integer;
    couleurpoint:tcolor;
    listerecti:array[1..maxsommet+1] of integer;
    cctheta1,cctheta2,tt_rayon:array[1..maxsommet+1] of extended;
    xxmin,xxmax,yymin,yymax:extended;
    tracesegment,point1fait,point2fait,point3fait,point4fait,foyerfait,
    sourcefaite,sommetfait,rectifait:boolean;
    point1x,point1y,pointrx,pointry,point2x,point2y,sourcex,sourcey,
    directionx,directiony,foyerx,foyery,point3x,point3y,point4x,point4y,interx1,interx2,intery1,intery2:extended;
    point1xi,point1yi,pointrxi,pointryi,point2xi,point2yi:integer;
    ajoutmiroirplan,ajoutreseau,ajoutrayon,ajoutMscopa,ajoutMscepa,ajoutlmc,ajoutlmd,
    ajoutmscore,ajoutmscere,ajoutsourceponctuelle,ajoutecran,ajoutlec,
    ajoutondeplane,modifencours,modemodif,modetranslation,moderotation,
    modeinfo,ajoutlsr,ajoutprisme,ajoutpoly,ajoutpolycercle,modeduplication,ajoutsphere,modedistance,modeangle,
    ajoutconiqueconcave,ajoutconiqueconvexe,ajouttexte,ajoutdiaphragme,modesuppression,ajoutfleche,
    ajoutoeil:boolean;
    couleurmiroirplan,couleurreseau,couleurrayon,couleurmscopa,couleuraxemscopa,couleurmscepa,
    couleuraxemscepa,couleurlmc,couleurlmd,couleuraxelmc,couleuraxelmd,
    couleuraxemscore,couleurmscore,couleuraxemscere,couleurmscere,
    couleursourceponctuelle,couleurondeplane,couleurpoignees,couleurfondsimulation,
    couleurecran,couleurlsr,couleursphere,couleurnormale,couleursuppression,couleurlec,
    couleurprisme,couleurpolyhedre,couleurpolycercle,couleurmiroirconique,couleurtexte,couleurdiaphragme,
    couleurfleche,couleuroeil,couleurangle,couleurmetre,couleuraxemiroirconique,
    couleuraxelec,couleurglobale,couleurglobaleaxe, couleurglobalerayon
    :tcolor;
    epaisseurmiroirplan,epaisseurreseau,epaisseurrayon,epaisseurmscopa,epaisseurmscepa,
    epaisseurlmc,epaisseurlmd,epaisseurmscere,epaisseurmscore,
    epaisseursourceponctuelle,epaisseurondeplane,epaisseurglobale,
    epaisseurecran,epaisseurlsr,epaisseursphere,epaisseurnormale,
    nombrepolycercle,maxrayonsrecherchesurfacesonde,epaisseurlec,
    epaisseurprisme,epaisseurpolyhedre,epaisseurpolycercle,epaisseurmiroirconique,taillefontetexte,
    epaisseurdiaphragme,epaisseurfleche,epaisseuroeil,epaisseurangle,epaisseurmetre:integer;
    ListeMiroirPlan:PMiroirPlan;  ListeReseau:PReseau;  ListeEcran:PEcran; ListeGroupe:pgroupe;
    ListeRayon,ListeRayonEnfant:PRayon;   ListeLsr:PLsr;
    ListeSourcePonctuelle:PSourcePonctuelle;  ListeOeil:POeil;
    ListeOndePlane:pondeplane;   ListeMiroirConique:pMiroirConique;
    ListeMscopa:PMscopa;    ListePrisme:PPrisme; ListePolyhedre:PPolyhedre; listepolycercle:ppolycercle;
    ListeMscore:PMscore;    ListeTexteAffiche:PTexteAffiche;
    ListeMscere:PMscere;   ListeDiaphragme:PDiaphragme;
    ListeMscepa:PMscepa;         listelec:plec;  listeangle,
    listeanglesatracer:pangle;    ListeFleche:pfleche;
    ListeLmc:Plmc; ListeSphere:PSphere;
    ListeLmd:Plmd;  ListeSegment,listenormale: psegment;   listemetre:pmetre;
    NombreMiroirPlan,NombreReseau,NombreRayon,nombreMscopa,nombreMscepa,nombrelmc,nombrelmd,
    nombremscere,nombremscore,nombresourceponctuelle,nombreoeil,
    nombreondeplane,nombretotalsegment,nombreecran,nombrelsr,nombreenfant,
    nombreprisme,nombrepolyhedre,nombresphere,nombremetre,nombreangle,nombremiroirconique,nombretexte,
    nombrediaphragme,nombrelec,nombrenormale,nombreanglesatracer,nombrefleche,
    nombregroupe:longint;
    modifie,bloqueaxe:boolean;
    lastxr,lastyr:extended;
    largeurinitialeimage1,hauteurinitialeimage1:integer;
    zoomfactor:integer;
    axefocal_x1,axefocal_y1,axefocal_x2,axefocal_y2,axefocal_anglepolaire,
    axefocal_normalex,axefocal_normaley,axefocal_ox,axefocal_oy,
    sommetx,sommety,co_theta0,co_rm,co_FS,co_thetaM,co_e,co_p,cheminactuelaobtenir:extended;
    typeelementmodif:Ttypeelementmodif;
    liste_typeelementmodif:array of Ttypeelementmodif;
    liste_indiceelementmodif:array of integer;
    liste_modetranslation,liste_moderotation:array of boolean;
    liste_tprot:array of  ttypepointrot;
     liste_boum:array of string;
     liste_tprirot:array of  ttypeprismerot;
     liste_lastxr,liste_lastyr:array of extended;
    liste_bloqueaxe:array of boolean;
    indiceelementmodif,indicepointdeplace,nombre_typeelementmodif:integer;
    tprot:ttypepointrot;   modegroupement:boolean;  tprirot:ttypeprismerot;
    optionnormale,optionangles,montrernumerossegments,premierpointsurfacesonde:boolean;
    nomsauvegarde:string;

   longueur_donde_red,longueur_donde_blue,longueur_donde_green:extended;


    listeparametres:tstringlist;
     couleurtrans:tcolor;   parametrelignecommande,toutjustefait:boolean;
     groupeprovisoire:groupe;
     tailleempennage,positionempennage:integer;
     lastx,lasty,lastxf,lastyf:longint;

     indice_rouge_par_defaut,indice_vert_par_defaut,indice_bleu_par_defaut:extended;
    fantomes:array[1..maxtotalsegment] of boolean;
    EnvVars:tstringlist;{liste des variables d'environnement}
     Ivarenv:integer;
     langue_linux:string;
    function partieentiere(x:extended):extended;
    function puissance(x,exposant:extended):extended;
     function maximum(a,b:extended):extended;
     function minimum(a,b:extended):extended;
     procedure affichecoordonnees(xx,yy:extended);
     procedure Traitegroupement(Sender: TObject; Shift: TShiftState; X,
  Y: Integer);
  procedure TraiteModif(Sender: TObject; Shift: TShiftState; X,
  Y: Integer);
   procedure Traitesuppression(Sender: TObject; Shift: TShiftState; X,
  Y: Integer);
  procedure effectuesuppression(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
     procedure effectuegroupement(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
      procedure FinModif(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
       procedure DebutModif(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
       procedure Info(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
        procedure Rafraichit;
  function DonneAnglePolaireDansPiPi(x,y:extended):extended;
   function DonneAnglePolaireDans02Pi(x,y:extended):extended;

  function Le_point_est_il_sur_une_droite(x,y,ax,ay,bx,by:extended; var para:extended; tol:extended):boolean;
   function Les_deux_segments_se_coupent_ils(Ax,Ay,Bx,By,Cx,Cy,Dx,Dy:extended):boolean;
function Le_segment_et_le_cercle_se_coupent_ils(Ax,Ay,Bx,By,Centrex,Centrey,Rayon,theta1,theta2:extended;
var paraseg1,paracer1,paraseg2,paracer2:extended;tolerance:extended):integer;
 function les_deux_cercles_se_coupent_ils(x0,y0,x1,y1,r0,r1,theta0_1,theta0_2,theta1_1,theta1_2:extended;
var para1,para2,para3,para4:extended):integer;

implementation
uses ray1,Unit3,Unit_imp,saisiemp, saisiemscopa, saisiemscepa, saisiemscore,
  saisiemscere, saisielmc, saisielmd, saisieray,saisiesp1,saisieop1, saisieec,
  saisielamesr, Unit6,Unit8, saisiesphere, saisiemconique, Unit10,
  saisiedia, Unit12, saisielec, Unit13, Unit14, Unit15, saisiecercle,
  saisiefle, saisief1, saisieoe,saisiepri,saisiereseau;

 function IsPointInPolygon(AX, AY: extended; poly:TableauPointPolyhedre; npoints:integer): Boolean;
var
  xnew, ynew: extended;
  xold,yold: extended;
  x1,y1: extended;
  x2,y2: extended;
  i: Integer;
  inside: boolean;
begin
  inside := False;
    if (npoints < 3) then Exit;
  xold := poly[npoints].ax;
  yold := poly[npoints].ay;
  for i := 1 to npoints do
  begin
    xnew := poly[i].aX;
    ynew := Poly[i].aY;
    if (xnew > xold) then
    begin
      x1:=xold;
      x2:=xnew;
      y1:=yold;
      y2:=ynew;
    end
    else
    begin
      x1:=xnew;
      x2:=xold;
      y1:=ynew;
      y2:=yold;
    end;
    if (((xnew < AX) = (AX <= xold))         // edge "open" at left end
      and ((AY-y1)*(x2-x1) < (y2-y1)*(AX-x1))) then
    begin
      inside := not inside;
    end;
    xold:=xnew;
    yold:=ynew;
  end;
  Result := inside ;
end;

function Le_point_est_il_sur_une_droite(x,y,ax,ay,bx,by:extended; var para:extended; tol:extended):boolean;
var distance_a_la_droite:extended; angle_AB_AM:extended;
  begin
    para:=10;
 angle_AB_AM:=abs(donneanglepolairedans02pi(x-ax,y-ay)-donneanglepolairedans02pi(bx-ax,by-ay));
  distance_a_la_droite:=sqrt(sqr(x-ax)+sqr(y-ay))*abs(sin(angle_AB_AM));
  if  distance_a_la_droite>tol*sqrt(sqr(bx-ax)+sqr(by-ay)) then begin
    result:=false;
    exit;
    end;
  result:=true;
 if bx<>ax then para:= (x-ax)/(bx-ax) else
 if by<>ay then para:= (y-ay)/(by-ay) else para:=10;

  end;

function les_deux_cercles_se_coupent_ils(x0,y0,x1,y1,r0,r1,theta0_1,theta0_2,theta1_1,theta1_2:extended;
var para1,para2,para3,para4:extended):integer;
var N,A,B,C,delta,xx,yy,xx1,yy1,xx2,yy2,theta1,theta0:extended;  nbe_sol:integer;
begin
 para1:=10; para2:=10; para3:=10; para4:=10;
  if y0<>y1 then begin
 N:=(sqr(r1)-sqr(r0)-sqr(x1)+sqr(x0)-sqr(y1)+sqr(y0))/2/(y0-y1);
 A:=sqr((x0-x1)/(y0-y1))+1;
 B:=2*y0*(x0-x1)/(y0-y1)-2*N*(x0-x1)/(y0-y1)-2*x0;
 C:=sqr(x0)+sqr(y0)+sqr(N)-sqr(r0)-2*y0*N;
 delta:=sqr(B)-4*A*C;
 if  delta<0 then begin
 result:=0;
 exit;
 end;

 if delta=0 then begin
 xx:=-B/2/A;
 yy:=N-xx*(x0-x1)/(y0-y1);

 theta0:=donneanglepolairedans02pi(xx-x0,yy-y0);
 if (theta0>=theta0_1) and (theta0<=theta0_2) then
 para1:=(theta0-theta0_1)/(theta0_2-theta0_1);
 if (theta0-2*pi>=theta0_1) and (theta0-2*pi<=theta0_2) then
 para1:=(theta0-2*pi-theta0_1)/(theta0_2-theta0_1);
 if (theta0+2*pi>=theta0_1) and (theta0+2*pi<=theta0_2) then
 para1:=(theta0+2*pi-theta0_1)/(theta0_2-theta0_1);

  theta1:=donneanglepolairedans02pi(xx-x1,yy-y1);
 if (theta1>=theta1_1) and (theta1<=theta1_2) then
  para2:=(theta1-theta1_1)/(theta1_2-theta1_1);
  if (theta1-2*pi>=theta1_1) and (theta1-2*pi<=theta1_2) then
  para2:=(theta1-2*pi-theta1_1)/(theta1_2-theta1_1);
  if (theta1+2*pi>=theta1_1) and (theta1+2*pi<=theta1_2) then
  para2:=(theta1+2*pi-theta1_1)/(theta1_2-theta1_1);

   if (para1>=0) and (para1<=1) and (para2>=0) and (para2<=1)
  then
  result:=1 else result:=0;
  exit;
 end;


if delta>0 then begin
 xx1:=(-B+sqrt(delta))/2/A;
 yy1:=N-xx1*(x0-x1)/(y0-y1);

 theta0:=donneanglepolairedans02pi(xx1-x0,yy1-y0);
 if (theta0>=theta0_1) and (theta0<=theta0_2) then
 para1:=(theta0-theta0_1)/(theta0_2-theta0_1);
 if (theta0-2*pi>=theta0_1) and (theta0-2*pi<=theta0_2) then
 para1:=(theta0-2*pi-theta0_1)/(theta0_2-theta0_1);
 if (theta0+2*pi>=theta0_1) and (theta0+2*pi<=theta0_2) then
 para1:=(theta0+2*pi-theta0_1)/(theta0_2-theta0_1);

  theta1:=donneanglepolairedans02pi(xx1-x1,yy1-y1);
 if (theta1>=theta1_1) and (theta1<=theta1_2) then
  para2:=(theta1-theta1_1)/(theta1_2-theta1_1);
  if (theta1-2*pi>=theta1_1) and (theta1-2*pi<=theta1_2) then
  para2:=(theta1-2*pi-theta1_1)/(theta1_2-theta1_1);
  if (theta1+2*pi>=theta1_1) and (theta1+2*pi<=theta1_2) then
  para2:=(theta1+2*pi-theta1_1)/(theta1_2-theta1_1);

  xx1:=(-B-sqrt(delta))/2/A;
 yy1:=N-xx1*(x0-x1)/(y0-y1);

 theta0:=donneanglepolairedans02pi(xx1-x0,yy1-y0);
 if (theta0>=theta0_1) and (theta0<=theta0_2) then
 para3:=(theta0-theta0_1)/(theta0_2-theta0_1);
 if (theta0-2*pi>=theta0_1) and (theta0-2*pi<=theta0_2) then
 para3:=(theta0-2*pi-theta0_1)/(theta0_2-theta0_1);
 if (theta0+2*pi>=theta0_1) and (theta0+2*pi<=theta0_2) then
 para3:=(theta0+2*pi-theta0_1)/(theta0_2-theta0_1);

  theta1:=donneanglepolairedans02pi(xx1-x1,yy1-y1);
 if (theta1>=theta1_1) and (theta1<=theta1_2) then
  para4:=(theta1-theta1_1)/(theta1_2-theta1_1);
  if (theta1-2*pi>=theta1_1) and (theta1-2*pi<=theta1_2) then
  para4:=(theta1-2*pi-theta1_1)/(theta1_2-theta1_1);
  if (theta1+2*pi>=theta1_1) and (theta1+2*pi<=theta1_2) then
  para4:=(theta1+2*pi-theta1_1)/(theta1_2-theta1_1);

  nbe_sol:=0;


  if (para1>=0) and (para1<=1) and (para2>=0) and (para2<=1)
  then
    inc(nbe_sol);

  if (para3>=0) and (para3<=1) and (para4>=0) and (para4<=1)
  then begin
    inc(nbe_sol);
  if nbe_sol=1 then begin
    para1:=para3;
    para2:=para4;
    end;    end;
  result:=nbe_sol;
  exit;
end;
  end;

  {si y0=y1}
  xx:=(sqr(r1)-sqr(r0)-sqr(x1)+sqr(x0))/2/(x0-x1);
  A:=1; B:=-2*y1; C:=sqr(x1)+sqr(xx)-2*x1*xx+sqr(y1)-sqr(r1);
    delta:=sqr(B)-4*A*C;
 if  delta<0 then begin
 result:=0;
 exit;
 end;

 if delta=0 then begin
 xx:=-B/2/A;
 yy:=N-xx*(x0-x1)/(y0-y1);

 theta0:=donneanglepolairedans02pi(xx-x0,yy-y0);
 if (theta0>=theta0_1) and (theta0<=theta0_2) then
 para1:=(theta0-theta0_1)/(theta0_2-theta0_1);
 if (theta0-2*pi>=theta0_1) and (theta0-2*pi<=theta0_2) then
 para1:=(theta0-2*pi-theta0_1)/(theta0_2-theta0_1);
 if (theta0+2*pi>=theta0_1) and (theta0+2*pi<=theta0_2) then
 para1:=(theta0+2*pi-theta0_1)/(theta0_2-theta0_1);

  theta1:=donneanglepolairedans02pi(xx-x1,yy-y1);
 if (theta1>=theta1_1) and (theta1<=theta1_2) then
  para2:=(theta1-theta1_1)/(theta1_2-theta1_1);
  if (theta1-2*pi>=theta1_1) and (theta1-2*pi<=theta1_2) then
  para2:=(theta1-2*pi-theta1_1)/(theta1_2-theta1_1);
  if (theta1+2*pi>=theta1_1) and (theta1+2*pi<=theta1_2) then
  para2:=(theta1+2*pi-theta1_1)/(theta1_2-theta1_1);
    if (para1>=0) and (para1<=1) and (para2>=0) and (para2<=1)
  then
  result:=1 else result:=0;
  exit;
 end;


if delta>0 then begin
 xx1:=(-B+sqrt(delta))/2/A;
 yy1:=N-xx1*(x0-x1)/(y0-y1);

 theta0:=donneanglepolairedans02pi(xx1-x0,yy1-y0);
 if (theta0>=theta0_1) and (theta0<=theta0_2) then
 para1:=(theta0-theta0_1)/(theta0_2-theta0_1);
 if (theta0-2*pi>=theta0_1) and (theta0-2*pi<=theta0_2) then
 para1:=(theta0-2*pi-theta0_1)/(theta0_2-theta0_1);
 if (theta0+2*pi>=theta0_1) and (theta0+2*pi<=theta0_2) then
 para1:=(theta0+2*pi-theta0_1)/(theta0_2-theta0_1);

  theta1:=donneanglepolairedans02pi(xx1-x1,yy1-y1);
 if (theta1>=theta1_1) and (theta1<=theta1_2) then
  para2:=(theta1-theta1_1)/(theta1_2-theta1_1);
  if (theta1-2*pi>=theta1_1) and (theta1-2*pi<=theta1_2) then
  para2:=(theta1-2*pi-theta1_1)/(theta1_2-theta1_1);
  if (theta1+2*pi>=theta1_1) and (theta1+2*pi<=theta1_2) then
  para2:=(theta1+2*pi-theta1_1)/(theta1_2-theta1_1);

  xx1:=(-B-sqrt(delta))/2/A;
 yy1:=N-xx1*(x0-x1)/(y0-y1);

 theta0:=donneanglepolairedans02pi(xx1-x0,yy1-y0);
 if (theta0>=theta0_1) and (theta0<=theta0_2) then
 para3:=(theta0-theta0_1)/(theta0_2-theta0_1);
 if (theta0-2*pi>=theta0_1) and (theta0-2*pi<=theta0_2) then
 para3:=(theta0-2*pi-theta0_1)/(theta0_2-theta0_1);
 if (theta0+2*pi>=theta0_1) and (theta0+2*pi<=theta0_2) then
 para3:=(theta0+2*pi-theta0_1)/(theta0_2-theta0_1);

  theta1:=donneanglepolairedans02pi(xx1-x1,yy1-y1);
 if (theta1>=theta1_1) and (theta1<=theta1_2) then
  para4:=(theta1-theta1_1)/(theta1_2-theta1_1);
  if (theta1-2*pi>=theta1_1) and (theta1-2*pi<=theta1_2) then
  para4:=(theta1-2*pi-theta1_1)/(theta1_2-theta1_1);
  if (theta1+2*pi>=theta1_1) and (theta1+2*pi<=theta1_2) then
  para4:=(theta1+2*pi-theta1_1)/(theta1_2-theta1_1);

  nbe_sol:=0;


  if (para1>=0) and (para1<=1) and (para2>=0) and (para2<=1)
  then
    inc(nbe_sol);

  if (para3>=0) and (para3<=1) and (para4>=0) and (para4<=1)
  then begin
    inc(nbe_sol);
    if nbe_sol=1 then begin
      para3:=para1;
      para2:=para4;
    end;
  end;
  result:=nbe_sol;
  exit;
end;
end;

function Le_segment_et_le_cercle_se_coupent_ils(Ax,Ay,Bx,By,Centrex,Centrey,Rayon,theta1,theta2:extended;
var paraseg1,paracer1,paraseg2,paracer2:extended;tolerance:extended):integer;
var a,b,c,delta,t,t1,t2,xi,yi,ap,xi1,yi1,xi2,yi2,ap1,ap2:extended;   nbe_sol:integer;
    begin

    paraseg1:=10; paracer1:=10; paraseg2:=10; paracer2:=10;
 a:=sqr(bx-ax)+sqr(by-ay);
 b:=2*((ax-centrex)*(bx-ax)+(ay-centrey)*(by-ay));
 c:=sqr(ax-centrex)+sqr(ay-centrey)-sqr(rayon);
 delta:=sqr(b)-4*a*c;

 result:=0;

 if delta<-tolerance then begin
 {pas d'intersection entre cercle et droite}
  exit;
 end;

 if abs(delta)<tolerance then begin
 t:=-b/2/a;
 paraseg1:=t;
 if (t<-tolerance) or (t>1+tolerance) then begin
  {intersection en dehors du segment}
 result:=0;
 exit;
 end;

 {intersection sur segment}
 xi:=ax+t*(bx-ax);
 yi:=ay+t*(by-ay);

 ap:=donneanglepolairedans02pi(xi-centrex,yi-centrey);

 if
 ((ap>=theta1-tolerance) and (ap<=theta2+tolerance))
 then paracer1:=(ap-theta1)/(theta2-theta1);
 if ((ap+2*pi>=theta1-tolerance) and (ap+2*pi<=theta2+tolerance))
 then paracer1:=(ap+2*pi-theta1)/(theta2-theta1);
 if ((ap-2*pi>=theta1-tolerance) and (ap-2*pi<=theta2+tolerance))
 then paracer1:=(ap-2*pi-theta1)/(theta2-theta1);
  if (paraseg1>=-tolerance) and (paraseg1<=1+tolerance) and (paracer1>=-tolerance) and (paracer1<=1+tolerance)
  then
  result:=1 else result:=0;
  exit;
 end; {du cas delta=0}


 {delta>0, 2 pts d'intersection entre droite et cercle}
  t1:=(-b+sqrt(delta))/2/a;
  t2:=(-b-sqrt(delta))/2/a;

if ((t1<-tolerance) or (t1>1+tolerance)) and ((t2<-tolerance) or (t2>1+tolerance))
then begin
result:=0;
exit;
end;

nbe_sol:=0;

if ((t1>=-tolerance) and (t1<=1+tolerance)) then begin
paraseg1:=t1;
xi1:=ax+t1*(bx-ax);
yi1:=ay+t1*(by-ay);
ap1:=donneanglepolairedans02pi(xi1-centrex,yi1-centrey);
if  ((ap1>=theta1-tolerance) and (ap1<=theta2+tolerance))
then paracer1:=(ap1-theta1)/(theta2-theta1);
 if  ((ap1+2*pi>=theta1-tolerance) and (ap1+2*pi<=theta2+tolerance))
 then paracer1:=(ap1+2*pi-theta1)/(theta2-theta1);
 if ((ap1-2*pi>=theta1-tolerance) and (ap1-2*pi<=theta2+tolerance))
 then paracer1:=(ap1-2*pi-theta1)/(theta2-theta1);
  if (paraseg1>=-tolerance) and (paraseg1<=1+tolerance) and (paracer1>=-tolerance) and (paracer1<=1+tolerance)
  then  inc(nbe_sol);
     end;

      if ((t2>=-tolerance) and (t2<=1+tolerance)) then begin
      paraseg2:=t2;
      xi2:=ax+t2*(bx-ax);
      yi2:=ay+t2*(by-ay);
      ap2:=donneanglepolairedans02pi(xi2-centrex,yi2-centrey);
      if  ((ap2>=theta1-tolerance) and (ap2<=theta2+tolerance))
then paracer2:=(ap2-theta1)/(theta2-theta1);
 if  ((ap2+2*pi>=theta1-tolerance) and (ap2+2*pi<=theta2+tolerance))
 then paracer2:=(ap2+2*pi-theta1)/(theta2-theta1);
 if ((ap2-2*pi>=theta1-tolerance) and (ap2-2*pi<=theta2+tolerance))
 then paracer2:=(ap2-2*pi-theta1)/(theta2-theta1);
  if (paraseg2>=-tolerance) and (paraseg2<=1+tolerance) and (paracer2>=-tolerance) and (paracer2<=1+tolerance)
  then  begin
  inc(nbe_sol);
  if nbe_sol=1 then begin
  paracer1:=paracer2;
  paraseg1:=paraseg2;
       end;
        end; end;

     result:=nbe_sol;


    end;





function Les_deux_segments_se_coupent_ils(Ax,Ay,Bx,By,Cx,Cy,Dx,Dy:extended):boolean;
var denom, num1,num2,s,r:extended;
    begin
  denom:=(bx-ax)*(dy-cy)-(by-ay)*(dx-cx);
  num1:=(ay-cy)*(dx-cx)-(ax-cx)*(dy-cy);
  num2:=(ay-cy)*(bx-ax)-(ax-cx)*(by-ay);

      if (denom=0) and (num1<>0) then begin
  {segments paralleles mais non colineaires}
  result:=false;
  exit;
      end;

  if (denom=0) and (num1=0) then begin
    {segments colineaires}
    result:=not((min(cx,dx)>max(ax,bx)) or (max(cx,dx)>min(ax,bx)));
    exit;
    end;

  r:=num1/denom;
  s:=num2/denom;

  result:=(r>=0) and (r<=1) and (s>=0) and (s<=1);
    end;

   function maximum(a,b:extended):extended;
  begin
  if a>b then maximum:=a else maximum:=b;
  end;

  function minimum(a,b:extended):extended;
  begin
   if a<b then minimum:=a else minimum:=b;
  end;



function partieentiere(x:extended):extended;
begin
if x>=0 then  begin
partieentiere:=int(x);
exit;
end;
if frac(x)=0 then begin
partieentiere:=x;
exit;
end;
{cas ou x est <0 et non entier}
partieentiere:=int(x)-1;
end;


function puissance(x,exposant:extended):extended;
begin
if exposant=0 then begin
puissance:=1;
exit;
end;
if x>0 then begin
puissance:=exp(exposant*ln(x));
exit;
end;
puissance:=0;
end;

procedure affichecoordonnees(xx,yy:extended);
var incertitudex,incertitudey:extended;
begin




if xxmax=xxmin then exit;
incertitudex:=0.5/form1.image1.width*(xxmax-xxmin)/zoomfactor;
incertitudex:=int(incertitudex/puissance(10,partieentiere(log10(incertitudex))))*
puissance(10,partieentiere(log10(incertitudex)));
 incertitudey:=0.5/form1.image1.height*(yymax-yymin)/zoomfactor;
 incertitudey:=int(incertitudey/puissance(10,partieentiere(log10(incertitudey))))*
puissance(10,partieentiere(log10(incertitudey)));

if xx<>0 then form1.statusbar1.panels[0].Text:='X='+floattostrf(xx,ffgeneral,
1+trunc(log10(abs(xx))-log10(abs(puissance(10,partieentiere(log10(incertitudex)))))),0)+'±'
+floattostrf(incertitudex,ffgeneral,1,0)+unitelongueur;
if yy<>0 then  form1.statusbar1.panels[1].text:='Y='+floattostrf(yy,ffgeneral,
1+trunc(log10(abs(yy))-log10(abs(puissance(10,partieentiere(log10(incertitudey)))))),0)+'±'
+floattostrf(incertitudey,ffgeneral,1,0)+unitelongueur;
form1.StatusBar1.Update;

  end;


function DonneAnglePolaireDansPiPi(x,y:extended):extended;
 var toto:extended;
 begin
 if ((x=0) and (y=0)) then begin
  DonneAnglePolaireDansPiPi:=0;
  exit;
  end;

  if (x=0) then
  if (y>0) then begin
  DonneAnglePolaireDansPiPi:=Pi/2;
  exit;
  end else begin
  DonneAnglePolaireDansPiPi:=-Pi/2;
  exit;
  end;

  if (y=0) then
  if (x>0) then begin
  DonneAnglePolaireDansPiPi:=0;
  exit;
  end else begin
  DonneAnglePolaireDansPiPi:=Pi;
  exit;
  end;

  try
  toto:=arctan(y/x);
  except
  if (((x>0) and (y>0)) or ((x<0) and (y<0))) then
  toto:=pi/2 else toto:=-pi/2;
  end;

  if (x<0) then toto:=toto+Pi;
  if toto>Pi then    toto:=toto-2*Pi;
  if toto<-Pi then toto:=toto+2*pi;
   DonneAnglePolaireDansPiPi:=toto;
  end;


   function DonneAnglePolaireDans02Pi(x,y:extended):extended;
     var toto:extended;
     begin
    toto:=DonneAnglePolaireDansPiPi(x,y);
     if toto<0 then toto:=toto+2*Pi;
     DonneAnglePolaireDans02Pi:=toto;
     end;

     function groupe.add(typeel:TTypeElementModif; indice:integer):boolean;
     var xd,yd:extended;
     sommex,sommey:extended;
     j:integer;
      begin
      if nombreelements=maxelementsgroupe then begin
      add:=false;
      exit;
      end;
      for j:=1 to nombreelements do
      if  (listeelements[nombreelements].typeelementgroupe=typeel) and
        (listeelements[nombreelements].indiceelement=indice) then
        {lelement fait deja partie du groupe}
        begin
        add:=false;
        exit;
        end;

        if  typeel=mdneant then
             begin
        add:=false;
        exit;
        end;

      add:=true;
      inc(nombreelements);  xd:=0; yd:=0;
        listeelements[nombreelements].typeelementgroupe:=typeel;
        listeelements[nombreelements].indiceelement:=indice;
        case typeel of
         mdoeil: begin
    xd:=listeoeil[-1+indice].cx;
    yd:=listeoeil[-1+indice].cy;  end;

    mdmiroirplan:  begin
    xd:=listemiroirplan[-1+indice].cx;
    yd:=listemiroirplan[-1+indice].cy;  end;

     mdreseau:  begin
    xd:=listereseau[-1+indice].cx;
    yd:=listereseau[-1+indice].cy;  end;

    mddiaphragme: begin
    xd:=listediaphragme[-1+indice].cx;
    yd:=listediaphragme[-1+indice].cy;   end;

     mdecran: begin
xd:=listeecran[-1+indice].cx;
    yd:= listeecran[-1+indice].cy;   end;

     mdtexteaffiche: begin
     xd:=listetexteaffiche[-1+indice].x;
     yd:=listetexteaffiche[-1+indice].y;    end;

    mdfleche: begin
    xd:=listefleche[-1+indice].cx;
    yd:=listefleche[-1+indice].cy; end;

     mdmiroirconique: begin
     xd:=     listemiroirconique[-1+indice].sx;
     yd:=listemiroirconique[-1+indice].sy; end;

     mdlsr: begin
     xd:=listelsr[-1+indice].cx;
     yd:=listelsr[-1+indice].cy; end;

     mdangle: begin
     xd:=listeangle[-1+indice].cx;
     yd:=listeangle[-1+indice].cy; end;


      mdmetre: begin
     xd:=listemetre[-1+indice].cx ;
     yd:=listemetre[-1+indice].cy;    end;

        mdmscopa: begin
     xd:=listemscopa[-1+indice].sx;
     yd:=listemscopa[-1+indice].sy; end;


      mdmscepa: begin
     xd:=listemscepa[-1+indice].sx;
     yd:=listemscepa[-1+indice].sy; end;


     mdmscore: begin
     xd:=listemscore[-1+indice].sx;
     yd:=listemscore[-1+indice].sy; end;

     mdmscere: begin
     xd:=listemscere[-1+indice].sx;
     yd:=listemscere[-1+indice].sy; end;


     mdlmc: begin
     xd:=listelmc[-1+indice].ox;
     yd:=listelmc[-1+indice].oy; end;


      mdlmd:  begin
     xd:=listelmd[-1+indice].ox;
     yd:=listelmd[-1+indice].oy; end;


       mdlec: begin
     xd:=listelec[-1+indice].ox;
     yd:=listelec[-1+indice].oy;    end;

        mdrayon:  begin
     xd:=listerayon[-1+indice].cx;
     yd:=listerayon[-1+indice].cy; end;


      mdsourceponctuelle: begin
       xd:=listesourceponctuelle[-1+indice].sx;
        yd:=listesourceponctuelle[-1+indice].sy; end;


    mdondeplane: begin
       xd:=listeondeplane[-1+indice].sx;
        yd:=listeondeplane[-1+indice].sy;   end;

        mdprisme: begin
       xd:=listeprisme[-1+indice].gx;
        yd:=listeprisme[-1+indice].gy;   end;

   mdpolyhedre: begin
   sommex:=0;  sommey:=0;
      for j:=1 to listepolyhedre[-1+indice].nombresommet do
begin
sommex:=sommex+listepolyhedre[-1+indice].messommets[j].ax;
 sommey:=sommey+listepolyhedre[-1+indice].messommets[j].ay;
end;
xd:=sommex/listepolyhedre[-1+indice].nombresommet;
yd:=sommey/listepolyhedre[-1+indice].nombresommet;
        end;

        mdpolycercle: begin
        sommex:=0;  sommey:=0;
      for j:=1 to listepolycercle[-1+indice].nombresommet do
begin
sommex:=sommex+listepolycercle[-1+indice].messommets[j].ax;
 sommey:=sommey+listepolycercle[-1+indice].messommets[j].ay;
end;
xd:=sommex/listepolycercle[-1+indice].nombresommet;
yd:=sommey/listepolycercle[-1+indice].nombresommet;
        end;

   mdsphere:  begin
         xd:=listesphere[-1+indice].cx;
          yd:=listesphere[-1+indice].cy;   end;




               end; {du case}

        isox:=(isox*(nombreelements-1)+xd)/nombreelements;
         isoy:=(isoy*(nombreelements-1)+yd)/nombreelements;

        end;


        procedure groupe.recalculeiso;
        var indice,j:integer;
        xd,yd:extended;
        begin
           isox:=0; isoy:=0;
        for indice:=1 to nombreelements do begin
            xd:=0; yd:=0;
         case listeelements[indice].typeelementgroupe of
         mdoeil: begin
    xd:=listeoeil[-1+listeelements[indice].indiceelement].cx;
    yd:=listeoeil[-1+listeelements[indice].indiceelement].cy;  end;

    mdmiroirplan:  begin
    xd:=listemiroirplan[-1+listeelements[indice].indiceelement].cx;
    yd:=listemiroirplan[-1+listeelements[indice].indiceelement].cy;  end;

     mdreseau:  begin
    xd:=listereseau[-1+listeelements[indice].indiceelement].cx;
    yd:=listereseau[-1+listeelements[indice].indiceelement].cy;  end;



    mddiaphragme: begin
    xd:=listediaphragme[-1+listeelements[indice].indiceelement].cx;
    yd:=listediaphragme[-1+listeelements[indice].indiceelement].cy;   end;

     mdecran: begin
xd:=listeecran[-1+listeelements[indice].indiceelement].cx;
    yd:= listeecran[-1+listeelements[indice].indiceelement].cy;   end;

     mdtexteaffiche: begin
     xd:=listetexteaffiche[-1+listeelements[indice].indiceelement].x;
     yd:=listetexteaffiche[-1+listeelements[indice].indiceelement].y;    end;

    mdfleche: begin
    xd:=listefleche[-1+listeelements[indice].indiceelement].cx;
    yd:=listefleche[-1+listeelements[indice].indiceelement].cy; end;

     mdmiroirconique: begin
     xd:=     listemiroirconique[-1+listeelements[indice].indiceelement].sx;
     yd:=listemiroirconique[-1+listeelements[indice].indiceelement].sy; end;

     mdlsr: begin
     xd:=listelsr[-1+listeelements[indice].indiceelement].cx;
     yd:=listelsr[-1+listeelements[indice].indiceelement].cy; end;

     mdangle: begin
     xd:=listeangle[-1+listeelements[indice].indiceelement].cx;
     yd:=listeangle[-1+listeelements[indice].indiceelement].cy; end;


      mdmetre: begin
     xd:=listemetre[-1+listeelements[indice].indiceelement].cx ;
     yd:=listemetre[-1+listeelements[indice].indiceelement].cy;    end;

        mdmscopa: begin
     xd:=listemscopa[-1+listeelements[indice].indiceelement].sx;
     yd:=listemscopa[-1+listeelements[indice].indiceelement].sy; end;


      mdmscepa: begin
     xd:=listemscepa[-1+listeelements[indice].indiceelement].sx;
     yd:=listemscepa[-1+listeelements[indice].indiceelement].sy; end;


     mdmscore: begin
     xd:=listemscore[-1+listeelements[indice].indiceelement].sx;
     yd:=listemscore[-1+listeelements[indice].indiceelement].sy; end;

     mdmscere: begin
     xd:=listemscere[-1+listeelements[indice].indiceelement].sx;
     yd:=listemscere[-1+listeelements[indice].indiceelement].sy; end;


     mdlmc: begin
     xd:=listelmc[-1+listeelements[indice].indiceelement].ox;
     yd:=listelmc[-1+listeelements[indice].indiceelement].oy; end;


      mdlmd:  begin
     xd:=listelmd[-1+listeelements[indice].indiceelement].ox;
     yd:=listelmd[-1+listeelements[indice].indiceelement].oy; end;


       mdlec: begin
     xd:=listelec[-1+listeelements[indice].indiceelement].ox;
     yd:=listelec[-1+listeelements[indice].indiceelement].oy;    end;

        mdrayon:  begin
     xd:=listerayon[-1+listeelements[indice].indiceelement].cx;
     yd:=listerayon[-1+listeelements[indice].indiceelement].cy; end;


      mdsourceponctuelle: begin
       xd:=listesourceponctuelle[-1+listeelements[indice].indiceelement].sx;
        yd:=listesourceponctuelle[-1+listeelements[indice].indiceelement].sy; end;


    mdondeplane: begin
       xd:=listeondeplane[-1+listeelements[indice].indiceelement].sx;
        yd:=listeondeplane[-1+listeelements[indice].indiceelement].sy;   end;


        mdprisme: begin

xd:=listeprisme[-1+listeelements[indice].indiceelement].xiso;
yd:=listeprisme[-1+listeelements[indice].indiceelement].yiso;
        end;

   mdpolyhedre: begin

xd:=listepolyhedre[-1+listeelements[indice].indiceelement].xiso;
yd:=listepolyhedre[-1+listeelements[indice].indiceelement].yiso;
        end;

        mdpolycercle: begin
        xd:=listepolycercle[-1+listeelements[indice].indiceelement].xiso;
yd:=listepolycercle[-1+listeelements[indice].indiceelement].yiso;
        end;

   mdsphere:  begin
         xd:=listesphere[-1+listeelements[indice].indiceelement].cx;
          yd:=listesphere[-1+listeelements[indice].indiceelement].cy;   end;

          mdneant: begin
          xd:=0;
          yd:=0;
          end;

               end; {du case}

        isox:=isox+xd;
        isoy:=isoy+yd;
        end; { de la boucle des elements}
        isox:=isox/nombreelements; isoy:=isoy/nombreelements;
         end;

        procedure groupe.create;
        var i:integer;
        begin
        isox:=0;  nombreelements:=0;
        isoy:=0;
        for i:=1 to maxelementsgroupe do begin
        listeelements[i].typeelementgroupe:=mdneant;
         listeelements[i].indiceelement:=0;
         end;
         modifie:=true;
        end;

       procedure groupe.imprime(mc:tmyimprimante);
       begin
       if nombreelements=0 then exit;

       if ((modemodif ) and (not(modeduplication))) then begin
mc.croixx(isox,isoy,3, 2,couleurtrans,pmcopy,true);
mc.ecrire(isox, isoy, rsGr, true, policedefaut);
end;
if modesuppression  then begin
mc.cercle(isox,isoy,3,
1,couleursuppression,pmcopy,true);
mc.ecrire(isox, isoy, rsGr, true, policedefaut);   end;
       end;

        procedure groupe.dessine(mc:tmonbitmap);
       begin
       if nombreelements=0 then exit;

       if ((modemodif ) and (not(modeduplication))) then begin
mc.croixx(isox,isoy,3, 2,couleurtrans,pmcopy,true);
mc.ecrire(isox, isoy, rsGr, true, policedefaut);
end;
if modesuppression  then begin
mc.cercle(isox,isoy,3,
1,couleursuppression,pmcopy,true);
mc.ecrire(isox, isoy, rsGr, true, policedefaut);   end;
       end;

          procedure groupe.dessinePS(mc:tmonpostscript);
       begin
       if nombreelements=0 then exit;

       if ((modemodif ) and (not(modeduplication))) then begin
mc.croixx(isox,isoy,3, 2,couleurtrans,pmcopy,true);
mc.ecrire(isox, isoy, rsGr, true, policedefaut);
end;
if modesuppression  then begin
mc.cercle(isox,isoy,3,
1,couleursuppression,pmcopy,true);
mc.ecrire(isox, isoy, rsGr, true, policedefaut);   end;
       end;

  procedure groupe.translate(dx,dy:extended);
  var oo:oeil; mp:miroirplan; dia:diaphragme; ec:ecran; ta:texteaffiche;
  fe:fleche; mc:miroirconique; ls:lsr; an:angle;   mt:metre; mo:mscopa;
  mor:mscore; me:mscere; mep: mscepa; lc:lmc; ld:lmd; le:lec; ra:rayon;
  sp:sourceponctuelle; op:ondeplane; ph:polyhedre; pc:polycercle; sh:sphere;pr:prisme;
   i,j:integer;   re:reseau;
   ttpoly,ttsom:tableaupointpolyhedre;
   begin
    for i:=1 to nombreelements do case listeelements[i].typeelementgroupe of
    mdoeil: if not oo.create(listeoeil[-1+listeelements[i].indiceelement].cx+dx,
    listeoeil[-1+listeelements[i].indiceelement].cy+dy,
    listeoeil[-1+listeelements[i].indiceelement].ax+dx,
    listeoeil[-1+listeelements[i].indiceelement].ay+dy,
    listeoeil[-1+listeelements[i].indiceelement].epaisseur,
    listeoeil[-1+listeelements[i].indiceelement].couleur) then exit;
    mdmiroirplan: if not
    mp.create(listemiroirplan[-1+listeelements[i].indiceelement].a1x+dx,
    listemiroirplan[-1+listeelements[i].indiceelement].a1y+dy,
    listemiroirplan[-1+listeelements[i].indiceelement].a2x+dx,
    listemiroirplan[-1+listeelements[i].indiceelement].a2y+dy,
    listemiroirplan[-1+listeelements[i].indiceelement].epaisseur,
    listemiroirplan[-1+listeelements[i].indiceelement].couleur,
    listemiroirplan[-1+listeelements[i].indiceelement].hachures) then exit;
     mdreseau: if not
    re.create(listereseau[-1+listeelements[i].indiceelement].a1x+dx,
    listereseau[-1+listeelements[i].indiceelement].a1y+dy,
    listereseau[-1+listeelements[i].indiceelement].a2x+dx,
    listereseau[-1+listeelements[i].indiceelement].a2y+dy,
    listereseau[-1+listeelements[i].indiceelement].epaisseur,
    listereseau[-1+listeelements[i].indiceelement].couleur,
    listereseau[-1+listeelements[i].indiceelement].pas,
    listereseau[-1+listeelements[i].indiceelement].entransmission,
    listereseau[-1+listeelements[i].indiceelement].hachures,
    listereseau[-1+listeelements[i].indiceelement].ordre_min,
    listereseau[-1+listeelements[i].indiceelement].ordre_max)
     then exit;
    mddiaphragme: if not dia
    .create2(listediaphragme[-1+listeelements[i].indiceelement].cx+dx,
    listediaphragme[-1+listeelements[i].indiceelement].cy+dy,
    listediaphragme[-1+listeelements[i].indiceelement].anglepolaire,
    listediaphragme[-1+listeelements[i].indiceelement].rint,
    listediaphragme[-1+listeelements[i].indiceelement].rext,
     listediaphragme[-1+listeelements[i].indiceelement].couleur,
     listediaphragme[-1+listeelements[i].indiceelement].epaisseur) then exit;
     mdecran: if not ec.create(listeecran[-1+listeelements[i].indiceelement].a1x+dx,
     listeecran[-1+listeelements[i].indiceelement].a1y+dy,
     listeecran[-1+listeelements[i].indiceelement].a2x+dx,
     listeecran[-1+listeelements[i].indiceelement].a2y+dy,
     listeecran[-1+listeelements[i].indiceelement].couleur,
     listeecran[-1+listeelements[i].indiceelement].epaisseur) then exit;
     mdtexteaffiche: if not ta.create(listetexteaffiche[-1+listeelements[i].indiceelement].texteluimeme,
     listetexteaffiche[-1+listeelements[i].indiceelement].policename,
     listetexteaffiche[-1+listeelements[i].indiceelement].policecharset,
       listetexteaffiche[-1+listeelements[i].indiceelement].policecolor,
       listetexteaffiche[-1+listeelements[i].indiceelement].policesize,
       listetexteaffiche[-1+listeelements[i].indiceelement].policepitch,
       listetexteaffiche[-1+listeelements[i].indiceelement].policefsbold,
       listetexteaffiche[-1+listeelements[i].indiceelement].policefsitalic,
       listetexteaffiche[-1+listeelements[i].indiceelement].policefsunderline,
       listetexteaffiche[-1+listeelements[i].indiceelement].policefsstrikeout,
       listetexteaffiche[-1+listeelements[i].indiceelement].x+dx,
       listetexteaffiche[-1+listeelements[i].indiceelement].y+dy) then exit;
    mdfleche: if not fe.create(listefleche[-1+listeelements[i].indiceelement].a1x+dx,
    listefleche[-1+listeelements[i].indiceelement].a1y+dy,
    listefleche[-1+listeelements[i].indiceelement].a2x+dx,
    listefleche[-1+listeelements[i].indiceelement].a2y+dy,
    listefleche[-1+listeelements[i].indiceelement].epaisseur,
    listefleche[-1+listeelements[i].indiceelement].couleur,
    listefleche[-1+listeelements[i].indiceelement].ext1,
       listefleche[-1+listeelements[i].indiceelement].ext2,
       listefleche[-1+listeelements[i].indiceelement].styletrait,
       listefleche[-1+listeelements[i].indiceelement].taille1,
       listefleche[-1+listeelements[i].indiceelement].taille2) then exit;
     mdmiroirconique: if not mc.create2(listemiroirconique[-1+listeelements[i].indiceelement].fx+dx,
     listemiroirconique[-1+listeelements[i].indiceelement].fy+dy,
     listemiroirconique[-1+listeelements[i].indiceelement].theta0,
     listemiroirconique[-1+listeelements[i].indiceelement].theta1,
     listemiroirconique[-1+listeelements[i].indiceelement].theta2,
       listemiroirconique[-1+listeelements[i].indiceelement].excentricite,
       listemiroirconique[-1+listeelements[i].indiceelement].parametre,
       listemiroirconique[-1+listeelements[i].indiceelement].concave,
       listemiroirconique[-1+listeelements[i].indiceelement].couleur,
       listemiroirconique[-1+listeelements[i].indiceelement].couleuraxe,
       listemiroirconique[-1+listeelements[i].indiceelement].hachures,
       listemiroirconique[-1+listeelements[i].indiceelement].axefocal) then exit;
     mdlsr: if not ls.create(listelsr[-1+listeelements[i].indiceelement].a1x+dx,
     listelsr[-1+listeelements[i].indiceelement].a1y+dy,
     listelsr[-1+listeelements[i].indiceelement].a2x+dx,
     listelsr[-1+listeelements[i].indiceelement].a2y+dy,
     listelsr[-1+listeelements[i].indiceelement].couleur,
     listelsr[-1+listeelements[i].indiceelement].epaisseur) then exit;
     mdangle: if not an.create(listeangle[-1+listeelements[i].indiceelement].cx+dx,
     listeangle[-1+listeelements[i].indiceelement].cy+dy,
     listeangle[-1+listeelements[i].indiceelement].a1x+dx,
     listeangle[-1+listeelements[i].indiceelement].a1y+dy,
     listeangle[-1+listeelements[i].indiceelement].a2x+dx,
     listeangle[-1+listeelements[i].indiceelement].a2y+dy) then exit;
      mdmetre: if not mt.create(
     listemetre[-1+listeelements[i].indiceelement].a1x+dx,
     listemetre[-1+listeelements[i].indiceelement].a1y+dy,
     listemetre[-1+listeelements[i].indiceelement].a2x+dx,
     listemetre[-1+listeelements[i].indiceelement].a2y+dy) then exit;
        mdmscopa: if not mo.create2(
     listemscopa[-1+listeelements[i].indiceelement].a1x+dx,
     listemscopa[-1+listeelements[i].indiceelement].a1y+dy,
     listemscopa[-1+listeelements[i].indiceelement].a2x+dx,
     listemscopa[-1+listeelements[i].indiceelement].a2y+dy,
     listemscopa[-1+listeelements[i].indiceelement].focale,
     listemscopa[-1+listeelements[i].indiceelement].epaisseur,
     listemscopa[-1+listeelements[i].indiceelement].couleur,
     listemscopa[-1+listeelements[i].indiceelement].couleuraxe,
     listemscopa[-1+listeelements[i].indiceelement].hachures,
     listemscopa[-1+listeelements[i].indiceelement].axefocal,
     listemscopa[-1+listeelements[i].indiceelement].trou,
     listemscopa[-1+listeelements[i].indiceelement].diametretrou) then exit;
      mdmscepa: if not mep.create2(
     listemscepa[-1+listeelements[i].indiceelement].a1x+dx,
     listemscepa[-1+listeelements[i].indiceelement].a1y+dy,
     listemscepa[-1+listeelements[i].indiceelement].a2x+dx,
     listemscepa[-1+listeelements[i].indiceelement].a2y+dy,
     listemscepa[-1+listeelements[i].indiceelement].focale,
     listemscepa[-1+listeelements[i].indiceelement].epaisseur,
     listemscepa[-1+listeelements[i].indiceelement].couleur,
     listemscepa[-1+listeelements[i].indiceelement].couleuraxe,
     listemscepa[-1+listeelements[i].indiceelement].hachures,
     listemscepa[-1+listeelements[i].indiceelement].axefocal,
     listemscepa[-1+listeelements[i].indiceelement].trou,
     listemscepa[-1+listeelements[i].indiceelement].diametretrou) then exit;
     mdmscore: if not mor.create2(
     listemscore[-1+listeelements[i].indiceelement].a1x+dx,
     listemscore[-1+listeelements[i].indiceelement].a1y+dy,
     listemscore[-1+listeelements[i].indiceelement].a2x+dx,
     listemscore[-1+listeelements[i].indiceelement].a2y+dy,
     listemscore[-1+listeelements[i].indiceelement].rayoncourbure,
     listemscore[-1+listeelements[i].indiceelement].epaisseur,
     listemscore[-1+listeelements[i].indiceelement].couleur,
     listemscore[-1+listeelements[i].indiceelement].couleuraxe,
     listemscore[-1+listeelements[i].indiceelement].hachures,
     listemscore[-1+listeelements[i].indiceelement].axefocal,
     listemscore[-1+listeelements[i].indiceelement].aigu,
     listemscore[-1+listeelements[i].indiceelement].trou,
     listemscore[-1+listeelements[i].indiceelement].diametretrou) then exit;
     mdmscere: if not me.create2(
     listemscere[-1+listeelements[i].indiceelement].a1x+dx,
     listemscere[-1+listeelements[i].indiceelement].a1y+dy,
     listemscere[-1+listeelements[i].indiceelement].a2x+dx,
     listemscere[-1+listeelements[i].indiceelement].a2y+dy,
     listemscere[-1+listeelements[i].indiceelement].rayoncourbure,
     listemscere[-1+listeelements[i].indiceelement].epaisseur,
     listemscere[-1+listeelements[i].indiceelement].couleur,
     listemscere[-1+listeelements[i].indiceelement].couleuraxe,
     listemscere[-1+listeelements[i].indiceelement].hachures,
     listemscere[-1+listeelements[i].indiceelement].axefocal,
     listemscere[-1+listeelements[i].indiceelement].aigu,
     listemscere[-1+listeelements[i].indiceelement].trou,
     listemscere[-1+listeelements[i].indiceelement].diametretrou) then exit;
     mdlmc: if not lc.create2(
     listelmc[-1+listeelements[i].indiceelement].a1x+dx,
     listelmc[-1+listeelements[i].indiceelement].a1y+dy,
     listelmc[-1+listeelements[i].indiceelement].a2x+dx,
     listelmc[-1+listeelements[i].indiceelement].a2y+dy,
     listelmc[-1+listeelements[i].indiceelement].focale,
     listelmc[-1+listeelements[i].indiceelement].epaisseur,
     listelmc[-1+listeelements[i].indiceelement].couleur,
     listelmc[-1+listeelements[i].indiceelement].couleuraxe,
     listelmc[-1+listeelements[i].indiceelement].axefocal) then exit;
      mdlmd: if not ld.create2(
     listelmd[-1+listeelements[i].indiceelement].a1x+dx,
     listelmd[-1+listeelements[i].indiceelement].a1y+dy,
     listelmd[-1+listeelements[i].indiceelement].a2x+dx,
     listelmd[-1+listeelements[i].indiceelement].a2y+dy,
     listelmd[-1+listeelements[i].indiceelement].focale,
     listelmd[-1+listeelements[i].indiceelement].epaisseur,
     listelmd[-1+listeelements[i].indiceelement].couleur,
     listelmd[-1+listeelements[i].indiceelement].couleuraxe,
     listelmd[-1+listeelements[i].indiceelement].axefocal) then exit;
       mdlec: if not le.create(
     listelec[-1+listeelements[i].indiceelement].s1x+dx,
     listelec[-1+listeelements[i].indiceelement].s1y+dy,
     listelec[-1+listeelements[i].indiceelement].s2x+dx,
     listelec[-1+listeelements[i].indiceelement].s2y+dy,
     listelec[-1+listeelements[i].indiceelement].r1,
      listelec[-1+listeelements[i].indiceelement].r2,
       listelec[-1+listeelements[i].indiceelement].diametre,
        listelec[-1+listeelements[i].indiceelement].couleurfond,
     listelec[-1+listeelements[i].indiceelement].couleuraxe,
     listelec[-1+listeelements[i].indiceelement].axefocal,
      listelec[-1+listeelements[i].indiceelement].indicerouge,
       listelec[-1+listeelements[i].indiceelement].indicebleu,
        listelec[-1+listeelements[i].indiceelement].indicevert,
         listelec[-1+listeelements[i].indiceelement].reflechientrant,
          listelec[-1+listeelements[i].indiceelement].reflechisortant) then exit;
        mdrayon: if not ra.create(
     listerayon[-1+listeelements[i].indiceelement].ax+dx,
     listerayon[-1+listeelements[i].indiceelement].ay+dy,
     listerayon[-1+listeelements[i].indiceelement].kx,
     listerayon[-1+listeelements[i].indiceelement].ky,
     listerayon[-1+listeelements[i].indiceelement].couleur,
     listerayon[-1+listeelements[i].indiceelement].epaisseur,
     listerayon[-1+listeelements[i].indiceelement].vav,
     listerayon[-1+listeelements[i].indiceelement].vaa,
     listerayon[-1+listeelements[i].indiceelement].nombremaxenfant,
      listerayon[-1+listeelements[i].indiceelement].maxsegment) then exit;
      mdsourceponctuelle: if not sp.create(
       listesourceponctuelle[-1+listeelements[i].indiceelement].nombrederayon,
        listesourceponctuelle[-1+listeelements[i].indiceelement].sx+dx,
         listesourceponctuelle[-1+listeelements[i].indiceelement].sy+dy,
     listesourceponctuelle[-1+listeelements[i].indiceelement].a1x+dx,
     listesourceponctuelle[-1+listeelements[i].indiceelement].a1y+dy,
     listesourceponctuelle[-1+listeelements[i].indiceelement].a2x+dx,
     listesourceponctuelle[-1+listeelements[i].indiceelement].a2y+dy,
     listesourceponctuelle[-1+listeelements[i].indiceelement].couleur,
     listesourceponctuelle[-1+listeelements[i].indiceelement].epaisseur,
     listesourceponctuelle[-1+listeelements[i].indiceelement].vav,
     listesourceponctuelle[-1+listeelements[i].indiceelement].vaa,
     listesourceponctuelle[-1+listeelements[i].indiceelement].maxenfantparrayon,
      listesourceponctuelle[-1+listeelements[i].indiceelement].sourcevirtuelle,
       listesourceponctuelle[-1+listeelements[i].indiceelement].tracersurfacesonde,
        listesourceponctuelle[-1+listeelements[i].indiceelement].listechemins,
         listesourceponctuelle[-1+listeelements[i].indiceelement].maxsegment) then exit;

    mdondeplane: if not op.create(
       listeondeplane[-1+listeelements[i].indiceelement].nombrederayon,
        listeondeplane[-1+listeelements[i].indiceelement].sx+dx,
         listeondeplane[-1+listeelements[i].indiceelement].sy+dy,
     listeondeplane[-1+listeelements[i].indiceelement].a1x+dx,
     listeondeplane[-1+listeelements[i].indiceelement].a1y+dy,
     listeondeplane[-1+listeelements[i].indiceelement].a2x+dx,
     listeondeplane[-1+listeelements[i].indiceelement].a2y+dy,
     listeondeplane[-1+listeelements[i].indiceelement].couleur,
     listeondeplane[-1+listeelements[i].indiceelement].epaisseur,
     listeondeplane[-1+listeelements[i].indiceelement].vav,
     listeondeplane[-1+listeelements[i].indiceelement].vaa,
     listeondeplane[-1+listeelements[i].indiceelement].maxenfantparrayon,
       listeondeplane[-1+listeelements[i].indiceelement].tracersurfacesonde,
        listeondeplane[-1+listeelements[i].indiceelement].listechemins,
        listeondeplane[-1+listeelements[i].indiceelement].maxsegment) then exit;

        mdprisme: if not pr.create(
     listeprisme[-1+listeelements[i].indiceelement].gx+dx,
     listeprisme[-1+listeelements[i].indiceelement].gy+dy,
     listeprisme[-1+listeelements[i].indiceelement].ax+dx,
     listeprisme[-1+listeelements[i].indiceelement].ay+dy,
     listeprisme[-1+listeelements[i].indiceelement].bx+dx,
     listeprisme[-1+listeelements[i].indiceelement].by+dy,
     listeprisme[-1+listeelements[i].indiceelement].indicerouge,
     listeprisme[-1+listeelements[i].indiceelement].indicebleu,
     listeprisme[-1+listeelements[i].indiceelement].indicevert,
     listeprisme[-1+listeelements[i].indiceelement].couleurbord,
      listeprisme[-1+listeelements[i].indiceelement].couleurfond,
       listeprisme[-1+listeelements[i].indiceelement].reflechientrant,
     listeprisme[-1+listeelements[i].indiceelement].reflechisortant) then exit;




   mdpolyhedre: begin
      for j:=1 to listepolyhedre[-1+listeelements[i].indiceelement].nombresommet do
begin
ttpoly[j].ax:=listepolyhedre[-1+listeelements[i].indiceelement].messommets[j].ax+dx;
ttpoly[j].ay:=listepolyhedre[-1+listeelements[i].indiceelement].messommets[j].ay+dy;
end;
   if not ph.create(
       listepolyhedre[-1+listeelements[i].indiceelement].nombresommet,
        ttpoly,
         listepolyhedre[-1+listeelements[i].indiceelement].indicerouge,
     listepolyhedre[-1+listeelements[i].indiceelement].indicebleu,
     listepolyhedre[-1+listeelements[i].indiceelement].indicevert,
     listepolyhedre[-1+listeelements[i].indiceelement].couleurbord,
     listepolyhedre[-1+listeelements[i].indiceelement].couleurfond,
     listepolyhedre[-1+listeelements[i].indiceelement].reflechientrant,
     listepolyhedre[-1+listeelements[i].indiceelement].reflechisortant) then exit;
        end;

        mdpolycercle: begin
      for j:=1 to listepolycercle[-1+listeelements[i].indiceelement].nombresommet do
begin
ttpoly[j].ax:=listepolycercle[-1+listeelements[i].indiceelement].messommets[j].ax+dx;
ttpoly[j].ay:=listepolycercle[-1+listeelements[i].indiceelement].messommets[j].ay+dy;
ttsom[j].ay:=listepolycercle[-1+listeelements[i].indiceelement].MesS[j].ay+dy;
ttsom[j].ax:=listepolycercle[-1+listeelements[i].indiceelement].MesS[j].ax+dx;
end;

      if not pc.create(listepolycercle[-1+listeelements[i].indiceelement].nombresommet,
      ttpoly,ttsom,listepolycercle[-1+listeelements[i].indiceelement].rectiligne,
      listepolycercle[-1+listeelements[i].indiceelement].indicerouge,
     listepolycercle[-1+listeelements[i].indiceelement].indicebleu,
     listepolycercle[-1+listeelements[i].indiceelement].indicevert,
      listepolycercle[-1+listeelements[i].indiceelement].couleurbord,
     listepolycercle[-1+listeelements[i].indiceelement].couleurfond,
     listepolycercle[-1+listeelements[i].indiceelement].reflechientrant,
     listepolycercle[-1+listeelements[i].indiceelement].reflechisortant) then exit;
  { if not pc.create2(
       listepolycercle[-1+listeelements[i].indiceelement].nombresommet,
        ttpoly,
         listepolycercle[-1+listeelements[i].indiceelement].rayon,
          listepolycercle[-1+listeelements[i].indiceelement].rectiligne,
           listepolycercle[-1+listeelements[i].indiceelement].rentrant,
           listepolycercle[-1+listeelements[i].indiceelement].aigu,
         listepolycercle[-1+listeelements[i].indiceelement].indicerouge,
     listepolycercle[-1+listeelements[i].indiceelement].indicebleu,
     listepolycercle[-1+listeelements[i].indiceelement].indicevert,
     listepolycercle[-1+listeelements[i].indiceelement].couleurbord,
     listepolycercle[-1+listeelements[i].indiceelement].couleurfond,
     listepolycercle[-1+listeelements[i].indiceelement].reflechientrant,
     listepolycercle[-1+listeelements[i].indiceelement].reflechisortant,
     listepolycercle[-1+listeelements[i].indiceelement].trigodirect) then exit;}
        end;

   mdsphere:    if not sh.create(
         listesphere[-1+listeelements[i].indiceelement].cx+dx,
          listesphere[-1+listeelements[i].indiceelement].cy+dy,
          listesphere[-1+listeelements[i].indiceelement].rayon,
         listesphere[-1+listeelements[i].indiceelement].indicerouge,
     listesphere[-1+listeelements[i].indiceelement].indicebleu,
     listesphere[-1+listeelements[i].indiceelement].indicevert,
     listesphere[-1+listeelements[i].indiceelement].couleurbord,
     listesphere[-1+listeelements[i].indiceelement].couleurfond,
     listesphere[-1+listeelements[i].indiceelement].reflechientrant,
     listesphere[-1+listeelements[i].indiceelement].reflechisortant) then exit;



     end; {du case et de la boucle}

    {et maintenant, puisque c'est bon, on translate}

    for i:=1 to nombreelements do case listeelements[i].typeelementgroupe of
    mdoeil: listeoeil[-1+listeelements[i].indiceelement].create(listeoeil[-1+listeelements[i].indiceelement].cx+dx,
    listeoeil[-1+listeelements[i].indiceelement].cy+dy,
    listeoeil[-1+listeelements[i].indiceelement].ax+dx,
    listeoeil[-1+listeelements[i].indiceelement].ay+dy,
    listeoeil[-1+listeelements[i].indiceelement].epaisseur,
    listeoeil[-1+listeelements[i].indiceelement].couleur) ;
    mdmiroirplan:
    listemiroirplan[-1+listeelements[i].indiceelement].create(listemiroirplan[-1+listeelements[i].indiceelement].a1x+dx,
    listemiroirplan[-1+listeelements[i].indiceelement].a1y+dy,
    listemiroirplan[-1+listeelements[i].indiceelement].a2x+dx,
    listemiroirplan[-1+listeelements[i].indiceelement].a2y+dy,
    listemiroirplan[-1+listeelements[i].indiceelement].epaisseur,
    listemiroirplan[-1+listeelements[i].indiceelement].couleur,
    listemiroirplan[-1+listeelements[i].indiceelement].hachures);

     mdreseau:
    listereseau[-1+listeelements[i].indiceelement].create(listereseau[-1+listeelements[i].indiceelement].a1x+dx,
    listereseau[-1+listeelements[i].indiceelement].a1y+dy,
    listereseau[-1+listeelements[i].indiceelement].a2x+dx,
    listereseau[-1+listeelements[i].indiceelement].a2y+dy,
    listereseau[-1+listeelements[i].indiceelement].epaisseur,
    listereseau[-1+listeelements[i].indiceelement].couleur,
    listereseau[-1+listeelements[i].indiceelement].pas,
    listereseau[-1+listeelements[i].indiceelement].entransmission,
    listereseau[-1+listeelements[i].indiceelement].hachures,
    listereseau[-1+listeelements[i].indiceelement].ordre_min,
    listereseau[-1+listeelements[i].indiceelement].ordre_max);

    mddiaphragme: listediaphragme[-1+listeelements[i].indiceelement]
    .create2(listediaphragme[-1+listeelements[i].indiceelement].cx+dx,
    listediaphragme[-1+listeelements[i].indiceelement].cy+dy,
    listediaphragme[-1+listeelements[i].indiceelement].anglepolaire,
    listediaphragme[-1+listeelements[i].indiceelement].rint,
    listediaphragme[-1+listeelements[i].indiceelement].rext,
     listediaphragme[-1+listeelements[i].indiceelement].couleur,
     listediaphragme[-1+listeelements[i].indiceelement].epaisseur);
     mdecran:  listeecran[-1+listeelements[i].indiceelement]
     .create(listeecran[-1+listeelements[i].indiceelement].a1x+dx,
     listeecran[-1+listeelements[i].indiceelement].a1y+dy,
     listeecran[-1+listeelements[i].indiceelement].a2x+dx,
     listeecran[-1+listeelements[i].indiceelement].a2y+dy,
     listeecran[-1+listeelements[i].indiceelement].couleur,
     listeecran[-1+listeelements[i].indiceelement].epaisseur);
     mdtexteaffiche: listetexteaffiche[-1+listeelements[i].indiceelement]
     .create(listetexteaffiche[-1+listeelements[i].indiceelement].texteluimeme,
     listetexteaffiche[-1+listeelements[i].indiceelement].policename,
     listetexteaffiche[-1+listeelements[i].indiceelement].policecharset,
       listetexteaffiche[-1+listeelements[i].indiceelement].policecolor,
       listetexteaffiche[-1+listeelements[i].indiceelement].policesize,
       listetexteaffiche[-1+listeelements[i].indiceelement].policepitch,
       listetexteaffiche[-1+listeelements[i].indiceelement].policefsbold,
       listetexteaffiche[-1+listeelements[i].indiceelement].policefsitalic,
       listetexteaffiche[-1+listeelements[i].indiceelement].policefsunderline,
       listetexteaffiche[-1+listeelements[i].indiceelement].policefsstrikeout,
       listetexteaffiche[-1+listeelements[i].indiceelement].x+dx,
       listetexteaffiche[-1+listeelements[i].indiceelement].y+dy);
    mdfleche: listefleche[-1+listeelements[i].indiceelement]
    .create(listefleche[-1+listeelements[i].indiceelement].a1x+dx,
    listefleche[-1+listeelements[i].indiceelement].a1y+dy,
    listefleche[-1+listeelements[i].indiceelement].a2x+dx,
    listefleche[-1+listeelements[i].indiceelement].a2y+dy,
    listefleche[-1+listeelements[i].indiceelement].epaisseur,
    listefleche[-1+listeelements[i].indiceelement].couleur,
    listefleche[-1+listeelements[i].indiceelement].ext1,
       listefleche[-1+listeelements[i].indiceelement].ext2,
       listefleche[-1+listeelements[i].indiceelement].styletrait,
       listefleche[-1+listeelements[i].indiceelement].taille1,
       listefleche[-1+listeelements[i].indiceelement].taille2);
     mdmiroirconique: listemiroirconique[-1+listeelements[i].indiceelement]
     .create2(listemiroirconique[-1+listeelements[i].indiceelement].fx+dx,
     listemiroirconique[-1+listeelements[i].indiceelement].fy+dy,
     listemiroirconique[-1+listeelements[i].indiceelement].theta0,
     listemiroirconique[-1+listeelements[i].indiceelement].theta1,
     listemiroirconique[-1+listeelements[i].indiceelement].theta2,
       listemiroirconique[-1+listeelements[i].indiceelement].excentricite,
       listemiroirconique[-1+listeelements[i].indiceelement].parametre,
       listemiroirconique[-1+listeelements[i].indiceelement].concave,
       listemiroirconique[-1+listeelements[i].indiceelement].couleur,
       listemiroirconique[-1+listeelements[i].indiceelement].couleuraxe,
       listemiroirconique[-1+listeelements[i].indiceelement].hachures,
       listemiroirconique[-1+listeelements[i].indiceelement].axefocal);
     mdlsr: listelsr[-1+listeelements[i].indiceelement]
     .create(listelsr[-1+listeelements[i].indiceelement].a1x+dx,
     listelsr[-1+listeelements[i].indiceelement].a1y+dy,
     listelsr[-1+listeelements[i].indiceelement].a2x+dx,
     listelsr[-1+listeelements[i].indiceelement].a2y+dy,
     listelsr[-1+listeelements[i].indiceelement].couleur,
     listelsr[-1+listeelements[i].indiceelement].epaisseur);
     mdangle: listeangle[-1+listeelements[i].indiceelement]
     .create(listeangle[-1+listeelements[i].indiceelement].cx+dx,
     listeangle[-1+listeelements[i].indiceelement].cy+dy,
     listeangle[-1+listeelements[i].indiceelement].a1x+dx,
     listeangle[-1+listeelements[i].indiceelement].a1y+dy,
     listeangle[-1+listeelements[i].indiceelement].a2x+dx,
     listeangle[-1+listeelements[i].indiceelement].a2y+dy);
      mdmetre: listemetre[-1+listeelements[i].indiceelement].create(
     listemetre[-1+listeelements[i].indiceelement].a1x+dx,
     listemetre[-1+listeelements[i].indiceelement].a1y+dy,
     listemetre[-1+listeelements[i].indiceelement].a2x+dx,
     listemetre[-1+listeelements[i].indiceelement].a2y+dy);
        mdmscopa: listemscopa[-1+listeelements[i].indiceelement].create2(
     listemscopa[-1+listeelements[i].indiceelement].a1x+dx,
     listemscopa[-1+listeelements[i].indiceelement].a1y+dy,
     listemscopa[-1+listeelements[i].indiceelement].a2x+dx,
     listemscopa[-1+listeelements[i].indiceelement].a2y+dy,
     listemscopa[-1+listeelements[i].indiceelement].focale,
     listemscopa[-1+listeelements[i].indiceelement].epaisseur,
     listemscopa[-1+listeelements[i].indiceelement].couleur,
     listemscopa[-1+listeelements[i].indiceelement].couleuraxe,
     listemscopa[-1+listeelements[i].indiceelement].hachures,
     listemscopa[-1+listeelements[i].indiceelement].axefocal,
     listemscopa[-1+listeelements[i].indiceelement].trou,
     listemscopa[-1+listeelements[i].indiceelement].diametretrou);
      mdmscepa: listemscepa[-1+listeelements[i].indiceelement].create2(
     listemscepa[-1+listeelements[i].indiceelement].a1x+dx,
     listemscepa[-1+listeelements[i].indiceelement].a1y+dy,
     listemscepa[-1+listeelements[i].indiceelement].a2x+dx,
     listemscepa[-1+listeelements[i].indiceelement].a2y+dy,
     listemscepa[-1+listeelements[i].indiceelement].focale,
     listemscepa[-1+listeelements[i].indiceelement].epaisseur,
     listemscepa[-1+listeelements[i].indiceelement].couleur,
     listemscepa[-1+listeelements[i].indiceelement].couleuraxe,
     listemscepa[-1+listeelements[i].indiceelement].hachures,
     listemscepa[-1+listeelements[i].indiceelement].axefocal,
     listemscepa[-1+listeelements[i].indiceelement].trou,
     listemscepa[-1+listeelements[i].indiceelement].diametretrou);
     mdmscore: listemscore[-1+listeelements[i].indiceelement].create2(
     listemscore[-1+listeelements[i].indiceelement].a1x+dx,
     listemscore[-1+listeelements[i].indiceelement].a1y+dy,
     listemscore[-1+listeelements[i].indiceelement].a2x+dx,
     listemscore[-1+listeelements[i].indiceelement].a2y+dy,
     listemscore[-1+listeelements[i].indiceelement].rayoncourbure,
     listemscore[-1+listeelements[i].indiceelement].epaisseur,
     listemscore[-1+listeelements[i].indiceelement].couleur,
     listemscore[-1+listeelements[i].indiceelement].couleuraxe,
     listemscore[-1+listeelements[i].indiceelement].hachures,
     listemscore[-1+listeelements[i].indiceelement].axefocal,
     listemscore[-1+listeelements[i].indiceelement].aigu,
     listemscore[-1+listeelements[i].indiceelement].trou,
     listemscore[-1+listeelements[i].indiceelement].diametretrou);
     mdmscere: listemscere[-1+listeelements[i].indiceelement].create2(
     listemscere[-1+listeelements[i].indiceelement].a1x+dx,
     listemscere[-1+listeelements[i].indiceelement].a1y+dy,
     listemscere[-1+listeelements[i].indiceelement].a2x+dx,
     listemscere[-1+listeelements[i].indiceelement].a2y+dy,
     listemscere[-1+listeelements[i].indiceelement].rayoncourbure,
     listemscere[-1+listeelements[i].indiceelement].epaisseur,
     listemscere[-1+listeelements[i].indiceelement].couleur,
     listemscere[-1+listeelements[i].indiceelement].couleuraxe,
     listemscere[-1+listeelements[i].indiceelement].hachures,
     listemscere[-1+listeelements[i].indiceelement].axefocal,
     listemscere[-1+listeelements[i].indiceelement].aigu,
     listemscere[-1+listeelements[i].indiceelement].trou,
     listemscere[-1+listeelements[i].indiceelement].diametretrou);
     mdlmc: listelmc[-1+listeelements[i].indiceelement].create2(
     listelmc[-1+listeelements[i].indiceelement].a1x+dx,
     listelmc[-1+listeelements[i].indiceelement].a1y+dy,
     listelmc[-1+listeelements[i].indiceelement].a2x+dx,
     listelmc[-1+listeelements[i].indiceelement].a2y+dy,
     listelmc[-1+listeelements[i].indiceelement].focale,
     listelmc[-1+listeelements[i].indiceelement].epaisseur,
     listelmc[-1+listeelements[i].indiceelement].couleur,
     listelmc[-1+listeelements[i].indiceelement].couleuraxe,
     listelmc[-1+listeelements[i].indiceelement].axefocal);
      mdlmd:  listelmd[-1+listeelements[i].indiceelement].create2(
     listelmd[-1+listeelements[i].indiceelement].a1x+dx,
     listelmd[-1+listeelements[i].indiceelement].a1y+dy,
     listelmd[-1+listeelements[i].indiceelement].a2x+dx,
     listelmd[-1+listeelements[i].indiceelement].a2y+dy,
     listelmd[-1+listeelements[i].indiceelement].focale,
     listelmd[-1+listeelements[i].indiceelement].epaisseur,
     listelmd[-1+listeelements[i].indiceelement].couleur,
     listelmd[-1+listeelements[i].indiceelement].couleuraxe,
     listelmd[-1+listeelements[i].indiceelement].axefocal);
       mdlec: listelec[-1+listeelements[i].indiceelement].create(
     listelec[-1+listeelements[i].indiceelement].s1x+dx,
     listelec[-1+listeelements[i].indiceelement].s1y+dy,
     listelec[-1+listeelements[i].indiceelement].s2x+dx,
     listelec[-1+listeelements[i].indiceelement].s2y+dy,
     listelec[-1+listeelements[i].indiceelement].r1,
      listelec[-1+listeelements[i].indiceelement].r2,
       listelec[-1+listeelements[i].indiceelement].diametre,
        listelec[-1+listeelements[i].indiceelement].couleurfond,
     listelec[-1+listeelements[i].indiceelement].couleuraxe,
     listelec[-1+listeelements[i].indiceelement].axefocal,
      listelec[-1+listeelements[i].indiceelement].indicerouge,
       listelec[-1+listeelements[i].indiceelement].indicebleu,
        listelec[-1+listeelements[i].indiceelement].indicevert,
         listelec[-1+listeelements[i].indiceelement].reflechientrant,
          listelec[-1+listeelements[i].indiceelement].reflechisortant);
        mdrayon:  listerayon[-1+listeelements[i].indiceelement].create(
     listerayon[-1+listeelements[i].indiceelement].ax+dx,
     listerayon[-1+listeelements[i].indiceelement].ay+dy,
     listerayon[-1+listeelements[i].indiceelement].kx,
     listerayon[-1+listeelements[i].indiceelement].ky,
     listerayon[-1+listeelements[i].indiceelement].couleur,
     listerayon[-1+listeelements[i].indiceelement].epaisseur,
     listerayon[-1+listeelements[i].indiceelement].vav,
     listerayon[-1+listeelements[i].indiceelement].vaa,
     listerayon[-1+listeelements[i].indiceelement].nombremaxenfant,
     listerayon[-1+listeelements[i].indiceelement].maxsegment);
      mdsourceponctuelle: listesourceponctuelle[-1+listeelements[i].indiceelement].create(
       listesourceponctuelle[-1+listeelements[i].indiceelement].nombrederayon,
        listesourceponctuelle[-1+listeelements[i].indiceelement].sx+dx,
         listesourceponctuelle[-1+listeelements[i].indiceelement].sy+dy,
     listesourceponctuelle[-1+listeelements[i].indiceelement].a1x+dx,
     listesourceponctuelle[-1+listeelements[i].indiceelement].a1y+dy,
     listesourceponctuelle[-1+listeelements[i].indiceelement].a2x+dx,
     listesourceponctuelle[-1+listeelements[i].indiceelement].a2y+dy,
     listesourceponctuelle[-1+listeelements[i].indiceelement].couleur,
     listesourceponctuelle[-1+listeelements[i].indiceelement].epaisseur,
     listesourceponctuelle[-1+listeelements[i].indiceelement].vav,
     listesourceponctuelle[-1+listeelements[i].indiceelement].vaa,
     listesourceponctuelle[-1+listeelements[i].indiceelement].maxenfantparrayon,
      listesourceponctuelle[-1+listeelements[i].indiceelement].sourcevirtuelle,
       listesourceponctuelle[-1+listeelements[i].indiceelement].tracersurfacesonde,
        listesourceponctuelle[-1+listeelements[i].indiceelement].listechemins,
        listesourceponctuelle[-1+listeelements[i].indiceelement].maxsegment) ;

    mdondeplane: listeondeplane[-1+listeelements[i].indiceelement].create(
       listeondeplane[-1+listeelements[i].indiceelement].nombrederayon,
        listeondeplane[-1+listeelements[i].indiceelement].sx+dx,
         listeondeplane[-1+listeelements[i].indiceelement].sy+dy,
     listeondeplane[-1+listeelements[i].indiceelement].a1x+dx,
     listeondeplane[-1+listeelements[i].indiceelement].a1y+dy,
     listeondeplane[-1+listeelements[i].indiceelement].a2x+dx,
     listeondeplane[-1+listeelements[i].indiceelement].a2y+dy,
     listeondeplane[-1+listeelements[i].indiceelement].couleur,
     listeondeplane[-1+listeelements[i].indiceelement].epaisseur,
     listeondeplane[-1+listeelements[i].indiceelement].vav,
     listeondeplane[-1+listeelements[i].indiceelement].vaa,
     listeondeplane[-1+listeelements[i].indiceelement].maxenfantparrayon,
       listeondeplane[-1+listeelements[i].indiceelement].tracersurfacesonde,
        listeondeplane[-1+listeelements[i].indiceelement].listechemins,
        listeondeplane[-1+listeelements[i].indiceelement].maxsegment) ;

   mdpolyhedre: begin
      for j:=1 to listepolyhedre[-1+listeelements[i].indiceelement].nombresommet do
begin
ttpoly[j].ax:=listepolyhedre[-1+listeelements[i].indiceelement].messommets[j].ax+dx;
ttpoly[j].ay:=listepolyhedre[-1+listeelements[i].indiceelement].messommets[j].ay+dy;
end;
   listepolyhedre[-1+listeelements[i].indiceelement].create(
       listepolyhedre[-1+listeelements[i].indiceelement].nombresommet,
        ttpoly,
         listepolyhedre[-1+listeelements[i].indiceelement].indicerouge,
     listepolyhedre[-1+listeelements[i].indiceelement].indicebleu,
     listepolyhedre[-1+listeelements[i].indiceelement].indicevert,
     listepolyhedre[-1+listeelements[i].indiceelement].couleurbord,
     listepolyhedre[-1+listeelements[i].indiceelement].couleurfond,
     listepolyhedre[-1+listeelements[i].indiceelement].reflechientrant,
     listepolyhedre[-1+listeelements[i].indiceelement].reflechisortant);
        end;

        mdpolycercle: begin
      for j:=1 to listepolycercle[-1+listeelements[i].indiceelement].nombresommet do
begin
ttpoly[j].ax:=listepolycercle[-1+listeelements[i].indiceelement].messommets[j].ax+dx;
ttpoly[j].ay:=listepolycercle[-1+listeelements[i].indiceelement].messommets[j].ay+dy;
ttsom[j].ax:=listepolycercle[-1+listeelements[i].indiceelement].mess[j].ax+dx;
ttsom[j].ay:=listepolycercle[-1+listeelements[i].indiceelement].mess[j].ay+dy;
end;
    listepolycercle[-1+listeelements[i].indiceelement].create(
       listepolycercle[-1+listeelements[i].indiceelement].nombresommet,
        ttpoly,ttsom,
          listepolycercle[-1+listeelements[i].indiceelement].rectiligne,
         listepolycercle[-1+listeelements[i].indiceelement].indicerouge,
     listepolycercle[-1+listeelements[i].indiceelement].indicebleu,
     listepolycercle[-1+listeelements[i].indiceelement].indicevert,
     listepolycercle[-1+listeelements[i].indiceelement].couleurbord,
     listepolycercle[-1+listeelements[i].indiceelement].couleurfond,
     listepolycercle[-1+listeelements[i].indiceelement].reflechientrant,
     listepolycercle[-1+listeelements[i].indiceelement].reflechisortant) ;
        end;

   mdsphere:   listesphere[-1+listeelements[i].indiceelement].create(
         listesphere[-1+listeelements[i].indiceelement].cx+dx,
          listesphere[-1+listeelements[i].indiceelement].cy+dy,
          listesphere[-1+listeelements[i].indiceelement].rayon,
         listesphere[-1+listeelements[i].indiceelement].indicerouge,
     listesphere[-1+listeelements[i].indiceelement].indicebleu,
     listesphere[-1+listeelements[i].indiceelement].indicevert,
     listesphere[-1+listeelements[i].indiceelement].couleurbord,
     listesphere[-1+listeelements[i].indiceelement].couleurfond,
     listesphere[-1+listeelements[i].indiceelement].reflechientrant,
     listesphere[-1+listeelements[i].indiceelement].reflechisortant);

  mdprisme: listeprisme[-1+listeelements[i].indiceelement].create(
     listeprisme[-1+listeelements[i].indiceelement].gx+dx,
     listeprisme[-1+listeelements[i].indiceelement].gy+dy,
     listeprisme[-1+listeelements[i].indiceelement].ax+dx,
     listeprisme[-1+listeelements[i].indiceelement].ay+dy,
     listeprisme[-1+listeelements[i].indiceelement].bx+dx,
     listeprisme[-1+listeelements[i].indiceelement].by+dy,
     listeprisme[-1+listeelements[i].indiceelement].indicerouge,
     listeprisme[-1+listeelements[i].indiceelement].indicebleu,
     listeprisme[-1+listeelements[i].indiceelement].indicevert,
     listeprisme[-1+listeelements[i].indiceelement].couleurbord,
      listeprisme[-1+listeelements[i].indiceelement].couleurfond,
       listeprisme[-1+listeelements[i].indiceelement].reflechientrant,
     listeprisme[-1+listeelements[i].indiceelement].reflechisortant);

     end; {du case et de la boucle}
     recalculeiso;

  end;


function diaphragme.create(_cx,_cy,_a1x,_a1y,_a2x,_a2y:extended;
    _couleur:tcolor; _epaisseur:integer):boolean;
 begin

 cx:=_cx; cy:=_cy; a1x:=_a1x; a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
 rint:=sqrt(sqr(a1x-cx)+sqr(a1y-cy));
  rext:=sqrt(sqr(a2x-cx)+sqr(a2y-cy));
  anglepolaire:=donneanglepolairedanspipi(a1x-cx,a1y-cy);
  a2x:=cx+rext*cos(anglepolaire);
  a2y:=cy+rext*sin(anglepolaire); {on les recalcule en cas de pbe d'alignement}
 couleur:=_couleur; epaisseur:=_epaisseur;
 ap1x:=2*cx-a1x; ap2x:=2*cx-a2x;
 ap1y:=2*cy-a1y; ap2y:=2*cy-a2y;
 if (  (a1x>xxmax) or (a1x<xxmin) or (a1y>yymax) or (a1y<yymin) or
  (ap1x>xxmax) or (ap1x<xxmin) or (ap1y>yymax) or (ap1y<yymin) or
  (a2x>xxmax) or (a2x<xxmin) or (a2y>yymax) or (a2y<yymin) or
  (ap2x>xxmax) or (ap2x<xxmin) or (ap2y>yymax) or (ap2y<yymin) or
  (rint<form1.taillemini) or (rint>rext) or (abs(rint-rext)<form1.taillemini))  then begin
  create:=false;
  exit;
  end;
   create:=true;
      modifie:=true;
  end;





   function oeil.create(_cx,_cy,_ax,_ay:extended;
    _epaisseur:integer;_couleur:tcolor):boolean;
    begin
    cx:=_cx; cy:=_cy; ax:=_ax; ay:=_ay; couleur:=_couleur;
    epaisseur:=_epaisseur;
    rayoncourbure:=sqrt(sqr(ax-cx)+sqr(ay-cy));
    anglepolaire:=donneanglepolairedans02pi(ax-cx,ay-cy);
    c1x:=cx-rayoncourbure*sin(anglepolaire);
    c1y:=cy+rayoncourbure*cos(anglepolaire);
     c2x:=cx+rayoncourbure*sin(anglepolaire);
    c2y:=cy-rayoncourbure*cos(anglepolaire);
      bx:=cx+rayoncourbure*cos(anglepolaire)*9/8;
        by:=cy+rayoncourbure*sin(anglepolaire)*9/8;
        if ({  (ax>xxmax) or (ax<xxmin) or (ay>yymax) or (ay<yymin) or
  (cx>xxmax) or (cx<xxmin) or (cy>yymax) or (cy<yymin)
  or
  (c1x>xxmax) or (c1x<xxmin) or (c1y>yymax) or (c1y<yymin)
  or
  (c2x>xxmax) or (c2x<xxmin) or (c2y>yymax) or (c2y<yymin)or }
  (rayoncourbure<form1.taillemini) )  then begin
  create:=false;
  exit;
  end;
   create:=true;
      modifie:=true;
  end;

    function oeil.create2(_cx,_cy,_anglepolaire,_rayoncourbure:extended;
    _epaisseur:integer;     _couleur:tcolor):boolean;
     begin
    cx:=_cx; cy:=_cy; anglepolaire:=_anglepolaire; couleur:=_couleur;
    epaisseur:=_epaisseur;
    rayoncourbure:=abs(_rayoncourbure);
    ax:=cx+rayoncourbure*cos(anglepolaire);
    ay:=cy+rayoncourbure*sin(anglepolaire);
    c1x:=cx-rayoncourbure*sin(anglepolaire);
    c1y:=cy+rayoncourbure*cos(anglepolaire);
     c2x:=cx+rayoncourbure*sin(anglepolaire);
    c2y:=cy-rayoncourbure*cos(anglepolaire);
      bx:=cx+rayoncourbure*cos(anglepolaire)*9/8;
        by:=cy+rayoncourbure*sin(anglepolaire)*9/8;
        if ( { (ax>xxmax) or (ax<xxmin) or (ay>yymax) or (ay<yymin) or
  (cx>xxmax) or (cx<xxmin) or (cy>yymax) or (cy<yymin) or

  (c1x>xxmax) or (c1x<xxmin) or (c1y>yymax) or (c1y<yymin)
  or
  (c2x>xxmax) or (c2x<xxmin) or (c2y>yymax) or (c2y<yymin)or}
  (rayoncourbure<form1.taillemini) )  then begin
  create2:=false;
  exit;
  end;
   create2:=true;
    modifie:=true;
    end;


   procedure oeil.dessine(mc:tmonbitmap);
   var old_pencolor:tcolor;
old_penmode:tpenmode;
 old_penstyle:tpenstyle;
 old_penwidth:integer;
 old_brushcolor:tcolor;
 old_brushstyle:tbrushstyle;
 e1x,e1y,e2x,e2y,e3x,e3y,e4x,e4y:integer;
       begin
       mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,anglepolaire-Pi/6,
       anglepolaire+Pi/6,clblack,pmcopy,pssolid,true);
       mc.arcdecercle(c1x,c1y,rayoncourbure,self.epaisseur,anglepolaire-Pi/2,
       anglepolaire-Pi/2+Pi/3+Pi/20,clblack,pmcopy,pssolid,true);
        mc.arcdecercle(c2x,c2y,rayoncourbure,self.epaisseur,anglepolaire+Pi/2
        -Pi/3-Pi/20,
       anglepolaire+Pi/2,clblack,pmcopy,pssolid,true);
        mc.arcdecercle(bx,by,rayoncourbure/4,self.epaisseur,anglepolaire+Pi-
        arccos(21/36),
       anglepolaire+Pi+arccos(21/36),clblack,pmcopy,pssolid,true);
      // mc.traceintercercles(cx,cy,rayoncourbure,bx,by,rayoncourbure/4,self.couleur,true);
      // mc.traceintercercles(cx,cy,rayoncourbure,bx,by,rayoncourbure/16*3,clblack,true);
       old_pencolor:=form1.image1.Picture.Bitmap.Canvas.Pen.Color;
old_penmode:=form1.image1.Picture.Bitmap.Canvas.Pen.Mode;
 old_penstyle:=form1.image1.Picture.Bitmap.Canvas.Pen.Style;
 old_penwidth:=form1.image1.Picture.Bitmap.Canvas.Pen.Width;
 old_brushcolor:=form1.image1.Picture.Bitmap.Canvas.Brush.Color;
 old_brushstyle:=form1.image1.Picture.Bitmap.Canvas.Brush.Style;
   form1.image1.Picture.Bitmap.Canvas.Pen.Style:=psclear;
   form1.image1.Picture.Bitmap.Canvas.Pen.mode:=pmcopy;
   form1.image1.Picture.Bitmap.Canvas.Pen.color:=self.couleur;
   form1.image1.Picture.Bitmap.Canvas.brush.Style:=bssolid;
    form1.image1.Picture.Bitmap.Canvas.brush.Color:=self.couleur;
    mc.invconvert(e1x,e1y,bx-rayoncourbure/4,by+rayoncourbure/4,true);
    mc.invconvert(e2x,e2y,bx+rayoncourbure/4,by-rayoncourbure/4,true);
    mc.invconvert(e3x,e3y,bx+rayoncourbure/4*cos(anglepolaire+Pi-
        arccos(21/36)),by+rayoncourbure/4*sin(anglepolaire+Pi-
        arccos(21/36)),true);
     mc.invconvert(e4x,e4y,bx+rayoncourbure/4*cos(anglepolaire+Pi+
        arccos(21/36)),by+rayoncourbure/4*sin(anglepolaire+Pi+
        arccos(21/36)),true);
    form1.image1.Picture.Bitmap.Canvas.Chord(e1x,e1y,e2x,e2y,e3x,e3y,e4x,e4y);
     mc.invconvert(e1x,e1y,cx-rayoncourbure,cy+rayoncourbure,true);
    mc.invconvert(e2x,e2y,cx+rayoncourbure,cy-rayoncourbure,true);
      form1.image1.Picture.Bitmap.Canvas.Chord(e1x,e1y,e2x,e2y,e4x,e4y,e3x,e3y);


   form1.image1.Picture.Bitmap.Canvas.Pen.Color:=old_pencolor;
form1.image1.Picture.Bitmap.Canvas.Pen.Mode:=old_penmode;
 form1.image1.Picture.Bitmap.Canvas.Pen.Style:=old_penstyle;
 form1.image1.Picture.Bitmap.Canvas.Pen.Width:=old_penwidth;
 form1.image1.Picture.Bitmap.Canvas.Brush.Color:=old_brushcolor;
 form1.image1.Picture.Bitmap.Canvas.Brush.Style:=old_brushstyle;



       if not(modeduplication) then
 if (modemodif or modeinfo) then begin
mc.cercle(ax,ay,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;
 if (modesuppression) then begin
mc.cercle(ax,ay,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
if modeduplication then
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
       end;

  procedure oeil.dessinePS(mc:tmonpostscript);
   var old_pencolor:tcolor;
old_penmode:tpenmode;
 old_penstyle:tpenstyle;
 old_penwidth:integer;
 old_brushcolor:tcolor;
 old_brushstyle:tbrushstyle;
 e1x,e1y,e2x,e2y,e3x,e3y,e4x,e4y:integer;
       begin
       mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,anglepolaire-Pi/6,
       anglepolaire+Pi/6,clblack,pmcopy,pssolid,true);
       mc.arcdecercle(c1x,c1y,rayoncourbure,self.epaisseur,anglepolaire-Pi/2,
       anglepolaire-Pi/2+Pi/3+Pi/20,clblack,pmcopy,pssolid,true);
        mc.arcdecercle(c2x,c2y,rayoncourbure,self.epaisseur,anglepolaire+Pi/2
        -Pi/3-Pi/20,
       anglepolaire+Pi/2,clblack,pmcopy,pssolid,true);
        mc.arcdecercle(bx,by,rayoncourbure/4,self.epaisseur,anglepolaire+Pi-
        arccos(21/36),
       anglepolaire+Pi+arccos(21/36),clblack,pmcopy,pssolid,true);



       old_pencolor:=ps.Pen.Color;
old_penmode:=ps.Pen.Mode;
 old_penstyle:=ps.pen.Style;
 old_penwidth:=ps.Pen.Width;
 old_brushcolor:=ps.Brush.Color;
 old_brushstyle:=ps.Brush.Style;
   ps.Pen.Style:=psclear;
   ps.Pen.mode:=pmcopy;
   ps.Pen.color:=self.couleur;
   ps.brush.Style:=bssolid;
    ps.brush.Color:=self.couleur;
    mc.invconvert(e1x,e1y,bx-rayoncourbure/4,by+rayoncourbure/4,true);
    mc.invconvert(e2x,e2y,bx+rayoncourbure/4,by-rayoncourbure/4,true);



    ps.Chord(e1x,e1y,e2x,e2y,trunc((anglepolaire+Pi-
        arccos(21/36))/pi*180*16),trunc((anglepolaire+Pi+
        arccos(21/36))*180/pi*16));
     mc.invconvert(e1x,e1y,cx-rayoncourbure,cy+rayoncourbure,true);
    mc.invconvert(e2x,e2y,cx+rayoncourbure,cy-rayoncourbure,true);
      ps.Chord(e1x,e1y,e2x,e2y,trunc((anglepolaire-arcsin(1/4*sin(arccos(21/36))))*180/pi*16),
      trunc((anglepolaire+arcsin(1/4*sin(arccos(21/36))))*180/pi*16));


   ps.Pen.Color:=old_pencolor;
ps.Pen.Mode:=old_penmode;
 ps.Pen.Style:=old_penstyle;
 ps.Pen.Width:=old_penwidth;
 ps.Brush.Color:=old_brushcolor;
 ps.Brush.Style:=old_brushstyle;



       if not(modeduplication) then
 if (modemodif or modeinfo) then begin
mc.cercle(ax,ay,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;
 if (modesuppression) then begin
mc.cercle(ax,ay,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
if modeduplication then
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
       end;


  procedure oeil.imprime(mc:tmyimprimante);
   var old_pencolor:tcolor;
old_penmode:tpenmode;
 old_penstyle:tpenstyle;
 old_penwidth:integer;
 old_brushcolor:tcolor;
 old_brushstyle:tbrushstyle;
 e1x,e1y,e2x,e2y,e3x,e3y,e4x,e4y:integer;
       begin
       mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,anglepolaire-Pi/6,
       anglepolaire+Pi/6,clblack,pmcopy,pssolid,true);
       mc.arcdecercle(c1x,c1y,rayoncourbure,self.epaisseur,anglepolaire-Pi/2,
       anglepolaire-Pi/2+Pi/3+Pi/20,clblack,pmcopy,pssolid,true);
        mc.arcdecercle(c2x,c2y,rayoncourbure,self.epaisseur,anglepolaire+Pi/2
        -Pi/3-Pi/20,
       anglepolaire+Pi/2,clblack,pmcopy,pssolid,true);
        mc.arcdecercle(bx,by,rayoncourbure/4,self.epaisseur,anglepolaire+Pi-
        arccos(21/36),
       anglepolaire+Pi+arccos(21/36),clblack,pmcopy,pssolid,true);
      // mc.traceintercercles(cx,cy,rayoncourbure,bx,by,rayoncourbure/4,self.couleur,true);
      // mc.traceintercercles(cx,cy,rayoncourbure,bx,by,rayoncourbure/16*3,clblack,true);

      old_pencolor:=imprimante.Canvas.Pen.Color;
old_penmode:=imprimante.Canvas.Pen.Mode;
 old_penstyle:=imprimante.Canvas.Pen.Style;
 old_penwidth:=imprimante.Canvas.Pen.Width;
 old_brushcolor:=imprimante.Canvas.Brush.Color;
 old_brushstyle:=imprimante.Canvas.Brush.Style;
   imprimante.Canvas.Pen.Style:=psclear;
   imprimante.Canvas.Pen.mode:=pmcopy;
   imprimante.Canvas.Pen.color:=self.couleur;
   imprimante.Canvas.brush.Style:=bssolid;
    imprimante.Canvas.brush.Color:=self.couleur;
    mc.invconvert(e1x,e1y,bx-rayoncourbure/4,by+rayoncourbure/4,true);
    mc.invconvert(e2x,e2y,bx+rayoncourbure/4,by-rayoncourbure/4,true);
    mc.invconvert(e3x,e3y,bx+rayoncourbure/4*cos(anglepolaire+Pi-
        arccos(21/36)),by+rayoncourbure/4*sin(anglepolaire+Pi-
        arccos(21/36)),true);
     mc.invconvert(e4x,e4y,bx+rayoncourbure/4*cos(anglepolaire+Pi+
        arccos(21/36)),by+rayoncourbure/4*sin(anglepolaire+Pi+
        arccos(21/36)),true);
    imprimante.Canvas.Chord(e1x,e1y,e2x,e2y,e3x,e3y,e4x,e4y);
     mc.invconvert(e1x,e1y,cx-rayoncourbure,cy+rayoncourbure,true);
    mc.invconvert(e2x,e2y,cx+rayoncourbure,cy-rayoncourbure,true);
      imprimante.Canvas.Chord(e1x,e1y,e2x,e2y,e4x,e4y,e3x,e3y);


   imprimante.Canvas.Pen.Color:=old_pencolor;
imprimante.Canvas.Pen.Mode:=old_penmode;
 imprimante.Canvas.Pen.Style:=old_penstyle;
 imprimante.Canvas.Pen.Width:=old_penwidth;
 imprimante.Canvas.Brush.Color:=old_brushcolor;
 imprimante.Canvas.Brush.Style:=old_brushstyle;


       if not(modeduplication) then
 if (modemodif or modeinfo) then begin
mc.cercle(ax,ay,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;
 if (modesuppression) then begin
mc.cercle(ax,ay,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
if modeduplication then
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
       end;

function diaphragme.create2(_cx,_cy,_anglepolaire,_rint,_rext:extended;
     _couleur:tcolor; _epaisseur:integer):boolean;
     begin
  cx:=_cx; cy:=_cy; anglepolaire:=_anglepolaire;
  rint:=_rint;   rext:=_rext;   couleur:=_couleur; epaisseur:=_epaisseur;
  a1x:=cx+rint*cos(anglepolaire);
  a1y:=cy+rint*sin(anglepolaire);
   a2x:=cx+rext*cos(anglepolaire);
  a2y:=cy+rext*sin(anglepolaire);
  ap1x:=cx-rint*cos(anglepolaire);
  ap1y:=cy-rint*sin(anglepolaire);
  ap2x:=cx-rext*cos(anglepolaire);
  ap2y:=cy-rext*sin(anglepolaire);
  if (  (a1x>xxmax) or (a1x<xxmin) or (a1y>yymax) or (a1y<yymin) or
  (ap1x>xxmax) or (ap1x<xxmin) or (ap1y>yymax) or (ap1y<yymin) or
  (a2x>xxmax) or (a2x<xxmin) or (a2y>yymax) or (a2y<yymin) or
  (ap2x>xxmax) or (ap2x<xxmin) or (ap2y>yymax) or (ap2y<yymin) or
  (rint<form1.taillemini) or (rint>rext) or (abs(rint-rext)<form1.taillemini) )  then begin
  create2:=false;
  exit;
  end;
   create2:=true;
    modifie:=true;
   end;

   procedure diaphragme.dessine(mc:tmonbitmap);
   begin
   mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
   mc.trait(ap1x,ap1y,ap2x,ap2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
   mc.trait(ap1x,ap1y,a1x,a1y,1,self.couleur,psdot,pmcopy,true);
   if (modeduplication) then
   mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
   if ((modeinfo and not(modeduplication)) or modemodif) then begin
   if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
     mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
     if modemodif then
mc.croixx(a1x,a1y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
      mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
       mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
       if modemodif then
mc.croixx(ap1x,ap1y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
        mc.cercle(ap1x,ap1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);

         mc.cercle(ap2x,ap2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
         end;
         if (modesuppression) then begin
     mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
      mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
       mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
        mc.cercle(ap1x,ap1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
         mc.cercle(ap2x,ap2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
         end;
         if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
          end;


    procedure diaphragme.dessinePS(mc:tmonpostscript);
   begin
   mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
   mc.trait(ap1x,ap1y,ap2x,ap2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
   mc.trait(ap1x,ap1y,a1x,a1y,1,self.couleur,psdot,pmcopy,true);
   if (modeduplication) then
   mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
   if ((modeinfo and not(modeduplication)) or modemodif) then begin
   if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
     mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
     if modemodif then
mc.croixx(a1x,a1y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
      mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
       mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
       if modemodif then
mc.croixx(ap1x,ap1y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
        mc.cercle(ap1x,ap1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);

         mc.cercle(ap2x,ap2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
         end;
         if (modesuppression) then begin
     mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
      mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
       mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
        mc.cercle(ap1x,ap1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
         mc.cercle(ap2x,ap2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
         end;
         if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
          end;

           procedure diaphragme.imprime(mc:tmyimprimante);
   begin
   mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
   mc.trait(ap1x,ap1y,ap2x,ap2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
   mc.trait(ap1x,ap1y,a1x,a1y,1,self.couleur,psdot,pmcopy,true);
   if (modeduplication) then
   mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
   if ((modeinfo and not(modeduplication)) or modemodif) then begin
   if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
     mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
     if modemodif then
mc.croixx(a1x,a1y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
      mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
       mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
       if modemodif then
mc.croixx(ap1x,ap1y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
        mc.cercle(ap1x,ap1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);

         mc.cercle(ap2x,ap2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
         end;
         if (modesuppression) then begin
     mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
      mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
       mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
        mc.cercle(ap1x,ap1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
         mc.cercle(ap2x,ap2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
         end;
         if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
          end;

function texteaffiche.create(_texteluimeme:shortstring; _policename:shortstring; _policecharset:integer;
   _policecolor:tcolor;
   _policesize:integer;
   _policepitch:tfontpitch;_policefsbold,_policefsitalic,_policefsunderline,
   _policefsstrikeout:boolean;_x,_y:extended):boolean;

begin

texteluimeme:=_texteluimeme;
x:=_x;  y:=_y;
if ((x>xxmax) or (x<xxmin) or (y>yymax) or (y<yymin)) then begin
create:=false;
exit;
end;
create:=true;
 modifie:=true;
policename:=_policename;
policecharset:=_policecharset;
policecolor:=_policecolor;
policesize:=_policesize;
policepitch:=_policepitch;
policefsbold:=_policefsbold;
policefsitalic:=_policefsitalic;
policefsunderline:=_policefsunderline;
policefsstrikeout:=_policefsstrikeout;

end;

procedure texteaffiche.dessine(mc:tmonbitmap);
var xi,yi:integer;
begin
form1.image1.Picture.Bitmap.Canvas.font.name:=policename;
form1.image1.Picture.Bitmap.Canvas.font.Size:=policesize;
form1.image1.Picture.Bitmap.Canvas.font.Charset:=policecharset;
form1.image1.Picture.Bitmap.Canvas.font.Pitch:=policepitch;
form1.image1.Picture.Bitmap.Canvas.font.color:=policecolor;
form1.image1.Picture.Bitmap.Canvas.font.Style:=[];
if policefsbold then form1.image1.Picture.Bitmap.Canvas.font.Style:=form1.image1.Picture.Bitmap.Canvas.font.Style+[fsbold];
if policefsitalic then form1.image1.Picture.Bitmap.Canvas.font.Style:=form1.image1.Picture.Bitmap.Canvas.font.Style+[fsitalic];
if policefsunderline then form1.image1.Picture.Bitmap.Canvas.font.Style:=form1.image1.Picture.Bitmap.Canvas.font.Style+[fsunderline];
if policefsstrikeout then form1.image1.Picture.Bitmap.Canvas.font.Style:=form1.image1.Picture.Bitmap.Canvas.font.Style+[fsstrikeout];
mc.invconvert(xi,yi,x,y,true);
mc.ecrireI(xi,yi,texteluimeme,form1.image1.Picture.Bitmap.Canvas.font);
if (modeinfo or modeduplication or modemodif) then
if modemodif then
 mc.croixx(x,y,3,2,couleurtrans,pmcopy,true) else
mc.cercle(x,y,3,1,couleurpoignees,pmcopy,true);
if (modesuppression) then
mc.cercle(x,y,3,1,couleursuppression,pmcopy,true);
if modegroupement then
mc.croixx(x,y,3,
2,clpurple,pmcopy,true);
end;

procedure texteaffiche.dessinePS(mc:tmonpostscript);
var xi,yi:integer;
begin
form1.image1.Picture.Bitmap.Canvas.font.name:=policename;
form1.image1.Picture.Bitmap.Canvas.font.Size:=policesize;
form1.image1.Picture.Bitmap.Canvas.font.Charset:=policecharset;
form1.image1.Picture.Bitmap.Canvas.font.Pitch:=policepitch;
form1.image1.Picture.Bitmap.Canvas.font.color:=policecolor;
form1.image1.Picture.Bitmap.Canvas.font.Style:=[];
if policefsbold then form1.image1.Picture.Bitmap.Canvas.font.Style:=form1.image1.Picture.Bitmap.Canvas.font.Style+[fsbold];
if policefsitalic then form1.image1.Picture.Bitmap.Canvas.font.Style:=form1.image1.Picture.Bitmap.Canvas.font.Style+[fsitalic];
if policefsunderline then form1.image1.Picture.Bitmap.Canvas.font.Style:=form1.image1.Picture.Bitmap.Canvas.font.Style+[fsunderline];
if policefsstrikeout then form1.image1.Picture.Bitmap.Canvas.font.Style:=form1.image1.Picture.Bitmap.Canvas.font.Style+[fsstrikeout];
mc.invconvert(xi,yi,x,y,true);
mc.ecrireI(xi,yi,texteluimeme,form1.image1.Picture.Bitmap.Canvas.font);
if (modeinfo or modeduplication or modemodif) then
if modemodif then
 mc.croixx(x,y,3,2,couleurtrans,pmcopy,true) else
mc.cercle(x,y,3,1,couleurpoignees,pmcopy,true);
if (modesuppression) then
mc.cercle(x,y,3,1,couleursuppression,pmcopy,true);
if modegroupement then
mc.croixx(x,y,3,
2,clpurple,pmcopy,true);
end;

procedure texteaffiche.imprime(mc:tmyimprimante);
var xi,yi:integer;
begin
imprimante.canvas.font.name:=policename;
imprimante.canvas.font.Size:=policesize;
imprimante.canvas.font.Charset:=policecharset;
imprimante.canvas.font.Pitch:=policepitch;
imprimante.canvas.font.color:=policecolor;
imprimante.canvas.font.Style:=[];
if policefsbold then imprimante.canvas.font.Style:=imprimante.canvas.font.Style+[fsbold];
if policefsitalic then imprimante.canvas.font.Style:=imprimante.canvas.font.Style+[fsitalic];
if policefsunderline then imprimante.canvas.font.Style:=imprimante.canvas.font.Style+[fsunderline];
if policefsstrikeout then imprimante.canvas.font.Style:=imprimante.canvas.font.Style+[fsstrikeout];
mc.invconvert(xi,yi,x,y,true);
mc.ecrireI(xi,yi,texteluimeme,imprimante.Canvas.font);
if (modeinfo or modeduplication or modemodif) then
if modemodif then
 mc.croixx(x,y,3,2,couleurtrans,pmcopy,true) else
mc.cercle(x,y,3,1,couleurpoignees,pmcopy,true);
if (modesuppression) then
mc.cercle(x,y,3,1,couleursuppression,pmcopy,true);
if modegroupement then
mc.croixx(x,y,3,
2,clpurple,pmcopy,true);
end;



 function arccos(x:extended):extended;
 begin
 if abs(x)>1 then begin
 arccos:=0;
 exit;
 end;
 if x=0 then begin
 arccos:=Pi/2; exit; end;
 if x>0 then  begin
 arccos:=arctan(sqrt(1-sqr(x))/x); exit; end;
 if x<0 then begin
 arccos:=arctan(sqrt(1-sqr(x))/x)+pi; exit; end;
 end;





     function MiroirConique.create2(_fx,_fy,_theta0,_theta1,_theta2,_excentricite,_parametre:extended; _concave:boolean;
 _couleur,_couleuraxe:tcolor; _hachures,_axefocal:boolean):boolean;
     var toto:extended;
     monmax_x,monmax_y,monmin_x,monmin_y:extended;
 jj:integer;
     begin
     couleuraxe:=_couleuraxe;
     couleur:=_couleur;
     hachures:=_hachures;
     axefocal:=_axefocal;
     fx:=_fx; fy:=_fy; theta0:=_theta0; theta1:=_theta1; theta2:=_theta2;
     excentricite:=abs(_excentricite);
     if theta1<0 then theta1:=theta1+2*Pi*(int(-theta1/2/Pi)+1);
     if theta2<0 then theta2:=theta2+2*Pi*(int(-theta2/2/Pi)+1);
     theta1:=frac(theta1/2/pi)*2*pi;
     theta2:=frac(theta2/2/pi)*2*pi;
     if theta1>=theta2 then theta2:=theta2+2*pi;
     parametre:=abs(_parametre); concave:=_concave;
     sx:=fx+parametre/(1+excentricite)*cos(theta0);
      sy:=fy+parametre/(1+excentricite)*sin(theta0);
      if ((fx>xxmax) or (fx<xxmin) or (fy>yymax) or (fy<yymin)) then begin
      create2:=false;
      exit;
      end;

       if excentricite>1 then begin
      toto:=theta1-theta0;
      if toto<-pi then toto:=toto+2*pi;
      if toto>pi then toto:=toto-2*pi;
      if ((toto>arccos(-1/excentricite)) or (toto<-arccos(-1/excentricite)))
      then begin
      create2:=false;
      exit;
      end;
      toto:=theta2-theta0;
      if toto<-pi then toto:=toto+2*pi;
      if toto>pi then toto:=toto-2*pi;
      if ((toto>arccos(-1/excentricite)) or (toto<-arccos(-1/excentricite)))
      then begin
      create2:=false;
      exit;
      end;

      end;

     a1x:=fx+cos(theta1)*parametre/(1+excentricite*cos(theta1-theta0));
      a1y:=fy+sin(theta1)*parametre/(1+excentricite*cos(theta1-theta0));
      a2x:=fx+cos(theta2)*parametre/(1+excentricite*cos(theta2-theta0));
      a2y:=fy+sin(theta2)*parametre/(1+excentricite*cos(theta2-theta0));
      sx:=fx+cos(theta0)*parametre/(1+excentricite);
      sy:=fy+sin(theta0)*parametre/(1+excentricite);
       monmax_x:=fx+cos(theta1)*parametre/(1+excentricite*cos(theta1-theta0));
 monmax_y:=fy+sin(theta1)*parametre/(1+excentricite*cos(theta1-theta0));
  monmin_x:=monmax_x; monmin_y:=monmax_y;
  for jj:=1 to 200 do begin
      monmax_x:=maximum(fx+cos(theta1+(theta2-theta1)*jj/200)*parametre/(1+excentricite*cos(theta1+(theta2-theta1)*jj/200-theta0)),monmax_x);
  monmin_x:=minimum(fx+cos(theta1+(theta2-theta1)*jj/200)*parametre/(1+excentricite*cos(theta1+(theta2-theta1)*jj/200-theta0)),monmin_x);
  monmax_y:=maximum(fy+sin(theta1+(theta2-theta1)*jj/200)*parametre/(1+excentricite*cos(theta1+(theta2-theta1)*jj/200-theta0)),monmax_y);
  monmin_y:=minimum(fy+sin(theta1+(theta2-theta1)*jj/200)*parametre/(1+excentricite*cos(theta1+(theta2-theta1)*jj/200-theta0)),monmin_y);
  end;
  if ((monmin_x<xxmin) or (monmax_x>xxmax) or (monmin_y<yymin) or
 (monmax_y>yymax) ) then
 begin
 create2:=false;
 exit;
 end;
  create2:=true;
      modifie:=true;
     end;



 function MiroirConique.create(_fx,_fy,_sx,_sy,_a1x,_a1y,_a2x,_a2y:extended; _concave:boolean;
 _couleur,_couleuraxe:tcolor; _hachures,_axefocal:boolean):boolean;
  var fs,fm:extended;
   monmax_x,monmax_y,monmin_x,monmin_y:extended;
 jj:integer;
  label 159;
  begin
   couleuraxe:=_couleuraxe;
     couleur:=_couleur;
     hachures:=_hachures;
     axefocal:=_axefocal;
  a1x:=_a1x; a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
  fx:=_fx; fy:=_fy; sx:=_sx; sy:=_sy; concave:=_concave;
  if ( (a1x>xxmax) or (a1x<xxmin) or (a2x>xxmax) or (a2x<xxmin) or
  (a1y>yymax) or (a1y<yymin) or (a2y>yymax) or (a2y<yymin)) then begin
   create:=false;
   exit;
   end;


  theta0:=DonneAnglePolaireDans02Pi(sx-fx,sy-fy);
   fs:=sqrt(sqr(sx-fx)+sqr(sy-fy));
   fm:=sqrt(sqr(a1x-fx)+sqr(a1y-fy));
   theta1:=DonneAnglePolaireDans02Pi(a1x-fx,a1y-fy);
   theta2:=DonneAnglePolaireDans02Pi(a2x-fx,a2y-fy);
   if theta2<theta1 then theta2:=theta2+2*Pi;
   if fs=fm then begin
   excentricite:=0;
   parametre:=fs;
   goto 159;

   end;

   if (cos(theta1-theta0)=fs/fm) then begin
   create:=false;
   exit;
   end;

   excentricite:=(fs/fm-1)/(cos(theta1-theta0)-fs/fm);
   if excentricite<0 then begin
    create:=false;
   exit;
   end;

   parametre:=fs*(1+excentricite);
    a2x:=fx+cos(theta2)*parametre/(1+excentricite*cos(theta2-theta0));
      a2y:=fy+sin(theta2)*parametre/(1+excentricite*cos(theta2-theta0));

      159: monmax_x:=fx+cos(theta1)*parametre/(1+excentricite*cos(theta1-theta0));
 monmax_y:=fy+sin(theta1)*parametre/(1+excentricite*cos(theta1-theta0));
  monmin_x:=monmax_x; monmin_y:=monmax_y;
  for jj:=1 to 200 do begin
      monmax_x:=maximum(fx+cos(theta1+(theta2-theta1)*jj/200)*parametre/(1+excentricite*cos(theta1+(theta2-theta1)*jj/200-theta0)),monmax_x);
  monmin_x:=minimum(fx+cos(theta1+(theta2-theta1)*jj/200)*parametre/(1+excentricite*cos(theta1+(theta2-theta1)*jj/200-theta0)),monmin_x);
  monmax_y:=maximum(fy+sin(theta1+(theta2-theta1)*jj/200)*parametre/(1+excentricite*cos(theta1+(theta2-theta1)*jj/200-theta0)),monmax_y);
  monmin_y:=minimum(fy+sin(theta1+(theta2-theta1)*jj/200)*parametre/(1+excentricite*cos(theta1+(theta2-theta1)*jj/200-theta0)),monmin_y);
  end;
  if ((monmin_x<xxmin) or (monmax_x>xxmax) or (monmin_y<yymin) or
 (monmax_y>yymax) ) then
 begin
 create:=false;
 exit;
 end;


   create:=true;
    modifie:=true;
   end;

   procedure miroirconique.dessine(mc:tmonbitmap);
   var pas,theta,r,r1,ract,thetaact,nx,ny,ttai:extended;
   nombrepas,i:integer;
   begin


   ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
   ract:=parametre/(1+excentricite*cos(theta1-theta0));
   thetaact:=theta1;  theta:=theta1;
   //pas:=ttai/200/ract/zoomfactor;
  pas:=abs(theta2-theta1)/180;
  while (theta<theta2) do begin
   theta:=thetaact+pas;
   r:=parametre/(1+excentricite*cos(theta-theta0));
   //pas:=ttai/100/r/zoomfactor;
    if theta<theta2 then begin
    mc.trait(fx+ract*cos(thetaact),fy+ract*sin(thetaact),fx+r*cos(theta),fy+r*sin(theta),
   1,self.couleur,pssolid,pmcopy,true);
   thetaact:=theta;
   ract:=r; end;
    end;
    theta:=theta2;
   r:=parametre/(1+excentricite*cos(theta-theta0));
  mc.trait(fx+ract*cos(thetaact),fy+ract*sin(thetaact),fx+r*cos(theta),fy+r*sin(theta),
   1,self.couleur,pssolid,pmcopy,true);

   if hachures then begin
   ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
   r1:=parametre/(1+excentricite*cos(theta1-theta0));
   theta:=theta1;
   pas:=ttai/100/r1/zoomfactor;
  while (theta<=theta2) do begin
   theta:=theta+pas;
   r:=parametre/(1+excentricite*cos(theta-theta0));
   pas:=ttai/100/r/zoomfactor;
   nx:=1/sqrt(1+sqr(excentricite)+2*excentricite*cos(theta-theta0))*
   (-excentricite*sin(theta-theta0)*sin(theta)-(1+excentricite*cos(theta-theta0))*cos(theta));
    ny:=1/sqrt(1+sqr(excentricite)+2*excentricite*cos(theta-theta0))*
   (excentricite*sin(theta-theta0)*cos(theta)-(1+excentricite*cos(theta-theta0))*sin(theta));
   if (theta<=theta2) then
   if (concave ) then
   mc.trait(fx+r*cos(theta),fy+r*sin(theta),fx+r*cos(theta)-nx*ttai/100/zoomfactor,
   fy+r*sin(theta)-ny*ttai/100/zoomfactor,1,self.couleur,pssolid,pmcopy,true) else
   mc.trait(fx+r*cos(theta),fy+r*sin(theta),fx+r*cos(theta)+nx*ttai/100/zoomfactor,
   fy+r*sin(theta)+ny*ttai/100/zoomfactor,1,self.couleur,pssolid,pmcopy,true);
   end;
   end;

   if axefocal then begin
   mc.trait(fx,fy,sx,sy,1,couleuraxe,psdashdot,pmcopy,true);
   mc.cercle(fx,fy,2,1,couleuraxe,pmcopy,true);
   mc.cercle(sx,sy,2,1,couleuraxe,pmcopy,true);
   end;

  if ((modemodif or modeinfo) and (not(modeduplication))) then begin
mc.cercle(a1x,a1y,3,
1,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3,
1,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(sx,sy,3,
2,couleurtrans,pmcopy,true) else
mc.cercle(sx,sy,3,
1,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(fx,fy,3,
2,claqua,pmcopy,true) else
mc.cercle(fx,fy,3,
1,couleurpoignees,pmcopy,true);
end;

 if (modesuppression) then begin
mc.cercle(a1x,a1y,3,
1,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3,
1,couleursuppression,pmcopy,true);
mc.cercle(sx,sy,3,
1,couleursuppression,pmcopy,true);
mc.cercle(fx,fy,3,
1,couleursuppression,pmcopy,true);
end;

 if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);
if modeduplication then  mc.cercle(sx,sy,3,
1,couleurpoignees,pmcopy,true);
  end;


    procedure miroirconique.dessinePS(mc:tmonpostscript);
   var pas,theta,r,r1,ract,thetaact,nx,ny,ttai:extended;
   nombrepas,i:integer;
   begin


   ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
   ract:=parametre/(1+excentricite*cos(theta1-theta0));
   thetaact:=theta1;  theta:=theta1;
  // pas:=ttai/200/ract/zoomfactor;
   pas:=abs(theta2-theta1)/180;

  while (theta<theta2) do begin
   theta:=thetaact+pas;
   r:=parametre/(1+excentricite*cos(theta-theta0));
   //pas:=ttai/100/r/zoomfactor;
    if theta<theta2 then begin
    mc.trait(fx+ract*cos(thetaact),fy+ract*sin(thetaact),fx+r*cos(theta),fy+r*sin(theta),
   1,self.couleur,pssolid,pmcopy,true);
   thetaact:=theta;
   ract:=r; end;
    end;
    theta:=theta2;
   r:=parametre/(1+excentricite*cos(theta-theta0));
  mc.trait(fx+ract*cos(thetaact),fy+ract*sin(thetaact),fx+r*cos(theta),fy+r*sin(theta),
   1,self.couleur,pssolid,pmcopy,true);

   if hachures then begin
   ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
   r1:=parametre/(1+excentricite*cos(theta1-theta0));
   theta:=theta1;
   pas:=ttai/100/r1/zoomfactor;
  while (theta<=theta2) do begin
   theta:=theta+pas;
   r:=parametre/(1+excentricite*cos(theta-theta0));
   pas:=ttai/100/r/zoomfactor;
   nx:=1/sqrt(1+sqr(excentricite)+2*excentricite*cos(theta-theta0))*
   (-excentricite*sin(theta-theta0)*sin(theta)-(1+excentricite*cos(theta-theta0))*cos(theta));
    ny:=1/sqrt(1+sqr(excentricite)+2*excentricite*cos(theta-theta0))*
   (excentricite*sin(theta-theta0)*cos(theta)-(1+excentricite*cos(theta-theta0))*sin(theta));
   if (theta<=theta2) then
   if (concave ) then
   mc.trait(fx+r*cos(theta),fy+r*sin(theta),fx+r*cos(theta)-nx*ttai/100/zoomfactor,
   fy+r*sin(theta)-ny*ttai/100/zoomfactor,1,self.couleur,pssolid,pmcopy,true) else
   mc.trait(fx+r*cos(theta),fy+r*sin(theta),fx+r*cos(theta)+nx*ttai/100/zoomfactor,
   fy+r*sin(theta)+ny*ttai/100/zoomfactor,1,self.couleur,pssolid,pmcopy,true);
   end;
   end;

   if axefocal then begin
   mc.trait(fx,fy,sx,sy,1,couleuraxe,psdashdot,pmcopy,true);
   mc.cercle(fx,fy,2,1,couleuraxe,pmcopy,true);
   mc.cercle(sx,sy,2,1,couleuraxe,pmcopy,true);
   end;

  if ((modemodif or modeinfo) and (not(modeduplication))) then begin
mc.cercle(a1x,a1y,3,
1,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3,
1,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(sx,sy,3,
2,couleurtrans,pmcopy,true) else
mc.cercle(sx,sy,3,
1,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(fx,fy,3,
2,claqua,pmcopy,true) else
mc.cercle(fx,fy,3,
1,couleurpoignees,pmcopy,true);
end;

 if (modesuppression) then begin
mc.cercle(a1x,a1y,3,
1,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3,
1,couleursuppression,pmcopy,true);
mc.cercle(sx,sy,3,
1,couleursuppression,pmcopy,true);
mc.cercle(fx,fy,3,
1,couleursuppression,pmcopy,true);
end;

 if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);
if modeduplication then  mc.cercle(sx,sy,3,
1,couleurpoignees,pmcopy,true);
  end;



  procedure miroirconique.imprime(mc:tmyimprimante);
   var pas,theta,r,r1,ract,thetaact,nx,ny,ttai:extended;
   nombrepas,i:integer;
   begin


   ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
   ract:=parametre/(1+excentricite*cos(theta1-theta0));
   thetaact:=theta1;  theta:=theta1;
   pas:=ttai/200/ract/zoomfactor;
  while (theta<theta2) do begin
   theta:=thetaact+pas;
   r:=parametre/(1+excentricite*cos(theta-theta0));
   pas:=ttai/100/r/zoomfactor;
    if theta<theta2 then begin
    mc.trait(fx+ract*cos(thetaact),fy+ract*sin(thetaact),fx+r*cos(theta),fy+r*sin(theta),
   1,self.couleur,pssolid,pmcopy,true);
   thetaact:=theta;
   ract:=r; end;
    end;
    theta:=theta2;
   r:=parametre/(1+excentricite*cos(theta-theta0));
  mc.trait(fx+ract*cos(thetaact),fy+ract*sin(thetaact),fx+r*cos(theta),fy+r*sin(theta),
   1,self.couleur,pssolid,pmcopy,true);

   if hachures then begin
   ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
   r1:=parametre/(1+excentricite*cos(theta1-theta0));
   theta:=theta1;
   pas:=ttai/100/r1/zoomfactor;
  while (theta<=theta2) do begin
   theta:=theta+pas;
   r:=parametre/(1+excentricite*cos(theta-theta0));
   pas:=ttai/100/r/zoomfactor;
   nx:=1/sqrt(1+sqr(excentricite)+2*excentricite*cos(theta-theta0))*
   (-excentricite*sin(theta-theta0)*sin(theta)-(1+excentricite*cos(theta-theta0))*cos(theta));
    ny:=1/sqrt(1+sqr(excentricite)+2*excentricite*cos(theta-theta0))*
   (excentricite*sin(theta-theta0)*cos(theta)-(1+excentricite*cos(theta-theta0))*sin(theta));
   if (theta<=theta2) then
   if (concave ) then
   mc.trait(fx+r*cos(theta),fy+r*sin(theta),fx+r*cos(theta)-nx*ttai/100/zoomfactor,
   fy+r*sin(theta)-ny*ttai/100/zoomfactor,1,self.couleur,pssolid,pmcopy,true) else
   mc.trait(fx+r*cos(theta),fy+r*sin(theta),fx+r*cos(theta)+nx*ttai/100/zoomfactor,
   fy+r*sin(theta)+ny*ttai/100/zoomfactor,1,self.couleur,pssolid,pmcopy,true);
   end;
   end;

   if axefocal then begin
   mc.trait(fx,fy,sx,sy,1,couleuraxe,psdashdot,pmcopy,true);
   mc.cercle(fx,fy,2,1,couleuraxe,pmcopy,true);
   mc.cercle(sx,sy,2,1,couleuraxe,pmcopy,true);
   end;

  if ((modemodif or modeinfo) and (not(modeduplication))) then begin
mc.cercle(a1x,a1y,3,
1,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3,
1,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(sx,sy,3,
2,couleurtrans,pmcopy,true) else
mc.cercle(sx,sy,3,
1,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(fx,fy,3,
2,claqua,pmcopy,true) else
mc.cercle(fx,fy,3,
1,couleurpoignees,pmcopy,true);
end;

 if (modesuppression) then begin
mc.cercle(a1x,a1y,3,
1,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3,
1,couleursuppression,pmcopy,true);
mc.cercle(sx,sy,3,
1,couleursuppression,pmcopy,true);
mc.cercle(fx,fy,3,
1,couleursuppression,pmcopy,true);
end;

 if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);
if modeduplication then  mc.cercle(sx,sy,3,
1,couleurpoignees,pmcopy,true);
  end;


function unmilieudispersif:boolean;
var i:integer;
begin
unmilieudispersif:=false;
if nombrepolyhedre>0 then for i:=1 to nombrepolyhedre do
if listepolyhedre[-1+i].dispersif then  unmilieudispersif:=true;
if nombrepolycercle>0 then for i:=1 to nombrepolycercle do
if listepolycercle[-1+i].dispersif then  unmilieudispersif:=true;
if nombresphere>0 then for i:=1 to nombresphere do
if listesphere[-1+i].dispersif then  unmilieudispersif:=true;
if nombrelec>0 then for i:=1 to nombrelec do
if listelec[-1+i].dispersif then  unmilieudispersif:=true;
if nombreprisme>0 then for i:=1 to nombreprisme do
if listeprisme[-1+i].dispersif then  unmilieudispersif:=true;
end;


procedure Rafraichit;
  var
 i,j,iii,n1,n2:integer;
 tt1,tt2,rra:extended;
 label 3012,628;
begin
  optionsurfacesonde:=false;
retaillepsegment(listesegment,nombretotalsegment,0);
retaillepsegment(listenormale,nombrenormale,0);

   if nombreanglesatracer>0 then begin
 retaillepangle(listeanglesatracer,nombreanglesatracer,0);
 nombreanglesatracer:=0;
 end;
  nombretotalsegment:=0; nombreenfant:=0;   nombrenormale:=0;
  creeprayon(listerayonenfant,0);
  if nombrerayon>0 then for i:=1 to nombrerayon do
  if not( (listerayon[-1+i].couleur=clblack) and (unmilieudispersif or (nombrereseau>0))) then calculesegment0(listerayon[-1+i].ax,
  listerayon[-1+i].ay,listerayon[-1+i].kx,listerayon[-1+i].ky,listerayon[-1+i].anglepolaire,listerayon[-1+i].epaisseur,
  listerayon[-1+i].couleur,listerayon[-1+i].vav,
  listerayon[-1+i].vaa,listerayon[-1+i].nombremaxenfant,listerayon[-1+i].maxsegment) else
   begin
   retailleprayon(listerayonenfant,nombreenfant,nombreenfant+1);
   inc(nombreenfant);
  listerayonenfant[-1+nombreenfant].createenfant(listerayon[-1+i].ax,listerayon[-1+i].ay
  ,listerayon[-1+i].kx,listerayon[-1+i].ky,clred,listerayon[-1+i].epaisseur,
    listerayon[-1+i].vav,listerayon[-1+i].vaa,listerayon[-1+i].nombremaxenfant,listerayon[-1+i].maxsegment,0);
   retailleprayon(listerayonenfant,nombreenfant,nombreenfant+1);
   inc(nombreenfant);
  listerayonenfant[-1+nombreenfant].createenfant(listerayon[-1+i].ax,listerayon[-1+i].ay
  ,listerayon[-1+i].kx,listerayon[-1+i].ky,clgreen,listerayon[-1+i].epaisseur,
    listerayon[-1+i].vav,listerayon[-1+i].vaa,listerayon[-1+i].nombremaxenfant,listerayon[-1+i].maxsegment,0);
    retailleprayon(listerayonenfant,nombreenfant,nombreenfant+1);
   inc(nombreenfant);
  listerayonenfant[-1+nombreenfant].createenfant(listerayon[-1+i].ax,listerayon[-1+i].ay
  ,listerayon[-1+i].kx,listerayon[-1+i].ky,clblue,listerayon[-1+i].epaisseur,
    listerayon[-1+i].vav,listerayon[-1+i].vaa,listerayon[-1+i].nombremaxenfant,listerayon[-1+i].maxsegment,0);
  end;

  if nombresourceponctuelle>0 then for i:=1 to nombresourceponctuelle do
  listesourceponctuelle[-1+i].calculesegment;
  if nombreondeplane>0 then for i:=1 to nombreondeplane do listeondeplane[-1+i].calculesegment;
  if nombreenfant=0 then goto 3012;
  i:=0;
    628:   inc(i);
  calculesegment0(listerayonenfant[-1+i].ax,
  listerayonenfant[-1+i].ay,listerayonenfant[-1+i].kx,listerayonenfant[-1+i].ky,listerayonenfant[-1+i].anglepolaire,
  listerayonenfant[-1+i].epaisseur,
  listerayonenfant[-1+i].couleur,listerayonenfant[-1+i].vav,
  listerayonenfant[-1+i].vaa,listerayonenfant[-1+i].nombremaxenfant,listerayonenfant[-1+i].maxsegment);
  if i<nombreenfant then goto 628;
 3012: freeprayon(listerayonenfant,nombreenfant);
   nombreenfant:=0;   n1:=nombretotalsegment;
  form1.retaille_image1;


 try

 BIBI.LimitesEtAxes(xxmin,xxmax,yymin,yymax,yymin,yymax,form1.image1.width,
form1.image1.height,'',policedefaut,true,clwhite,false,0,clblack,false,0,0,clblack,
policedefaut,false,false,{grillex,grilley,}1,clblack,clblack,'','','','','','',false,false,false);
BIBI.background(couleurfondsimulation);
if tracergrille then BIBI.dessinergrille(grillex,grilley);
if nombregroupe>0 then for i:=1 to nombregroupe do listegroupe[-1+i].recalculeiso;
if nombrepolycercle>0 then for i:=1 to nombrepolycercle do
listepolycercle[-1+i].dessine(BIBI);
if nombrepolyhedre>0 then for i:=1 to nombrepolyhedre do
listepolyhedre[-1+i].dessine(BIBI);
 if nombresphere>0 then for i:=1 to nombresphere do
listesphere[-1+i].dessine(BIBI);
 if nombreprisme>0 then for i:=1 to nombreprisme do
 listeprisme[-1+i].dessine(BIBI);
if nombrelec>0 then for i:=1 to nombrelec do
listelec[-1+i].dessine(BIBI);
if nombremiroirplan>0 then for i:=1 to nombremiroirplan do
ListeMiroirPlan[-1+i].dessine(BIBI);
 if nombrereseau>0 then for i:=1 to nombrereseau do
 Listereseau[-1+i].dessine(BIBI);
if nombrefleche>0 then for i:=1 to nombrefleche do
ListeFleche[-1+i].dessine(BIBI);
if nombremiroirconique>0 then for i:=1 to nombremiroirconique do
ListeMiroirconique[-1+i].dessine(BIBI);
if nombrerayon>0 then for i:=1 to nombrerayon do
listerayon[-1+i].dessine(BIBI);
if nombresourceponctuelle>0 then for i:=1 to nombresourceponctuelle do
listesourceponctuelle[-1+i].dessine(BIBI);
if nombreondeplane>0 then for i:=1 to nombreondeplane do
listeondeplane[-1+i].dessine(BIBI);
if nombremscopa>0 then for i:=1 to nombremscopa do
listemscopa[-1+i].dessine(BIBI);
if nombremscore>0 then for i:=1 to nombremscore do
listemscore[-1+i].dessine(BIBI);
if nombremscere>0 then for i:=1 to nombremscere do
listemscere[-1+i].dessine(BIBI);
if nombremscepa>0 then for i:=1 to nombremscepa do
listemscepa[-1+i].dessine(BIBI);
if nombrelmc>0 then for i:=1 to nombrelmc do
listelmc[-1+i].dessine(BIBI);
if nombrelmd>0 then for i:=1 to nombrelmd do
listelmd[-1+i].dessine(BIBI);
if nombreecran>0 then for i:=1 to nombreecran do
listeecran[-1+i].dessine(BIBI);
if nombreoeil>0 then for i:=1 to nombreoeil do
listeoeil[-1+i].dessine(BIBI);
if nombrediaphragme>0 then for i:=1 to nombrediaphragme do
listediaphragme[-1+i].dessine(BIBI);
if nombrelsr>0 then for i:=1 to nombrelsr do
listelsr[-1+i].dessine(BIBI);
if nombremetre>0 then for i:=1 to nombremetre do
listemetre[-1+i].dessine(BIBI);
if nombreangle>0 then for i:=1 to nombreangle do
listeangle[-1+i].dessine(BIBI);
if nombretexte>0 then for i:=1 to nombretexte do
listetexteaffiche[-1+i].dessine(BIBI);
if nombreanglesatracer>0 then for i:=1 to nombreanglesatracer do
listeanglesatracer[-1+i].dessinebis(BIBI);
 if nombregroupe>0 then for i:=1 to nombregroupe do
 listegroupe[-1+i].dessine(BIBI);

  if (nombrelmc+nombrelmd+nombremscopa+nombremscepa=0) then
 for i:=1 to nombresourceponctuelle do
 if listesourceponctuelle[-1+i].tracersurfacesonde then
 if not(listesourceponctuelle[-1+i].sourcevirtuelle) then
 if  listesourceponctuelle[-1+i].nombrecheminsoptiques>0 then
 begin
   tt1:=listesourceponctuelle[-1+i].ray[1].anglepolaire;
        tt2:=listesourceponctuelle[-1+i].ray[listesourceponctuelle[-1+i].nombrederayon].anglepolaire;
       if tt2<tt1 then tt2:=tt2+2*Pi;
  if tt2<tt1 then tt2:=tt2+2*Pi;
       rra:=sqrt(sqr(listesourceponctuelle[-1+i].a1x-listesourceponctuelle[-1+i].sx)
       +sqr(listesourceponctuelle[-1+i].a1y-listesourceponctuelle[-1+i].sy));
  if (sqrt(sqr(listesourceponctuelle[-1+i].a2x-listesourceponctuelle[-1+i].sx)
  +sqr(listesourceponctuelle[-1+i].a2y-listesourceponctuelle[-1+i].sy))<rra) then
  rra:=sqrt(sqr(listesourceponctuelle[-1+i].a2x-listesourceponctuelle[-1+i].sx)
  +sqr(listesourceponctuelle[-1+i].a2y-listesourceponctuelle[-1+i].sy));

 for j:=1 to   listesourceponctuelle[-1+i].nombrecheminsoptiques do
 begin

        optionsurfacesonde:=true;
         premierpointsurfacesonde:=true;
        cheminactuelaobtenir:=listesourceponctuelle[-1+i].listecheminsoptiques[j];

       for iii:=1 to maxrayonsrecherchesurfacesonde do  begin
       calculesegment0(listesourceponctuelle[-1+i].sx,listesourceponctuelle[-1+i].sy,
    rra*cos(tt1+(iii-1)*(tt2-tt1)/(maxrayonsrecherchesurfacesonde-1)),
  rra*sin(tt1+(iii-1)*(tt2-tt1)/(maxrayonsrecherchesurfacesonde-1)),tt1+(iii-1)*(tt2-tt1)/
  (maxrayonsrecherchesurfacesonde-1)
  ,1,listesourceponctuelle[-1+i].couleur,'','',0,listesourceponctuelle[-1+i].maxsegment);
     BIBI.trait(listesegment[-1+nombretotalsegment].a1x,
     listesegment[-1+nombretotalsegment].a1y,
     listesegment[-1+nombretotalsegment].a2x,
 listesegment[-1+nombretotalsegment].a2y,1,
 listesegment[-1+nombretotalsegment].couleur,psdot,pmcopy,true);
                end;
 end;  end;

    if (nombrelmc+nombrelmd+nombremscopa+nombremscepa=0) then
 for i:=1 to nombreondeplane do
 if listeondeplane[-1+i].tracersurfacesonde then
 if  listeondeplane[-1+i].nombrecheminsoptiques>0 then
  begin
 for j:=1 to   listeondeplane[-1+i].nombrecheminsoptiques do
 begin

        optionsurfacesonde:=true;
         premierpointsurfacesonde:=true;
        cheminactuelaobtenir:=listeondeplane[-1+i].listecheminsoptiques[j];

       for iii:=1 to maxrayonsrecherchesurfacesonde do  begin
       calculesegment0(listeondeplane[-1+i].a1x+
       (iii-1)*(listeondeplane[-1+i].a2x-listeondeplane[-1+i].a1x)/
       (maxrayonsrecherchesurfacesonde-1),
       listeondeplane[-1+i].a1y+
       (iii-1)*(listeondeplane[-1+i].a2y-listeondeplane[-1+i].a1y)/
       (maxrayonsrecherchesurfacesonde-1),
    listeondeplane[-1+i].ray[1].kx,
  listeondeplane[-1+i].ray[1].ky,
  listeondeplane[-1+i].ray[1].anglepolaire
  ,1,listeondeplane[-1+i].couleur,'','',0,listeondeplane[-1+i].maxsegment);
     BIBI.trait(listesegment[-1+nombretotalsegment].a1x,
     listesegment[-1+nombretotalsegment].a1y,
     listesegment[-1+nombretotalsegment].a2x,
 listesegment[-1+nombretotalsegment].a2y,1,
 listesegment[-1+nombretotalsegment].couleur,psdot,pmcopy,true);
                end;
 end;  end;
  n2:=nombretotalsegment;
  nombretotalsegment:=n1;
 DessineTousLesSegments(BIBI);


finally {//form1.monimage1.free;} end;
//form1.image1.Picture.Assign(bibi);

form1.ScrollBox1.Refresh;
  form1.Image1.Refresh;

    {bibi.free;
  BIBI:=tmonbitmap.Create;
     BIBI.LimitesEtAxes(xxmin,xxmax,yymin,yymax,yymin,yymax,form1.image1.width,
form1.image1.height,'',policedefaut,true,clwhite,false,0,clblack,false,0,0,clblack,
policedefaut,false,false,{grillex,grilley,}1,clblack,clblack,'','','','','','',false,false,false);
BIBI.background(couleurfondsimulation);
     }

       nombretotalsegment:=n2;
end;





 procedure Traitegroupement(Sender: TObject; Shift: TShiftState; X,
  Y: Integer);
  var

     x1,y1,tx,ty,distance,lambda,xx1,yy1,dtheta,AiAj,ux,uy:extended;
 i,j:integer;    boum:string;
 label 314;
  begin

graphepresent:=true;
    BIBI.convert(x,y,x1,y1,true);
   BIBI.convert(3,form1.image1.height-3,tx,ty,true);
     tx:=tx-xxmin; ty:=ty-yymin;

     affichecoordonnees(x1,y1);

     distance:=sqrt(sqr(xxmax-xxmin)+sqr(yymin-yymax));
    {on recherche si le curseur est proche d'un centre}


 if nombretexte>0 then
 for i:=1 to nombretexte do
   if ((abs(listetexteaffiche[-1+i].x-x1)<=tx*1.1) and
    (abs(listetexteaffiche[-1+i].y-y1)<=ty*1.1)) then begin
    boum:=rsCeTexte;
    goto 314;
    end;


 if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1)) then begin
    boum:=rsCetteSphRe;
    goto 314;
    end;

    if nombreprisme>0 then
 for i:=1 to nombreprisme do
   if ((abs(listeprisme[-1+i].gx-x1)<=tx*1.1) and
    (abs(listeprisme[-1+i].gy-y1)<=ty*1.1)) then begin
    boum:=rsCePrisme;
    goto 314;
    end;


     if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].cx-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].cy-y1)<=ty*1.1)) then begin
    boum:=rsCeTrait;
    goto 314;
    end;




    if nombreoeil>0 then
 for i:=1 to nombreoeil do
   if ((abs(listeoeil[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeoeil[-1+i].cy-y1)<=ty*1.1)) then begin
    boum:=rsCetOeil;
    goto 314;
    end;





 if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].cy-y1)<=ty*1.1)) then begin
    boum:=rsCeMiroirPlan;
    goto 314;
    end;


 if nombrereseau>0 then
 for i:=1 to nombrereseau do
   if ((abs(listereseau[-1+i].cx-x1)<=tx*1.1) and
    (abs(listereseau[-1+i].cy-y1)<=ty*1.1)) then begin
    boum:=rsCeReSeau;
    goto 314;
    end;


 if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].sy-y1)<=ty*1.1)) then begin
    boum:=rsCeMiroirConi;
    goto 314;
    end;





     if nombrepolyhedre>0 then
 for i:=1 to nombrepolyhedre do
   if ((abs(listepolyhedre[-1+i].xiso-x1)<=tx*1.1) and
    (abs(listepolyhedre[-1+i].yiso-y1)<=ty*1.1))
    then begin
    boum:=rsCePolygone;
    goto 314;
    end;





     if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do

   if ((abs(listepolycercle[-1+i].xiso-x1)<=tx*1.1) and
    (abs(listepolycercle[-1+i].yiso-y1)<=ty*1.1))
    then begin
    boum:=rsCePolycercle;
    goto 314;
    end;



    for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].cy-y1)<=ty*1.1)) then begin
    boum:=rsCetCran;
    goto 314;
    end;





     for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].cx-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].cy-y1)<=ty*1.1)) then begin
    boum:=rsCeDiaphragme;
    goto 314;
    end;





     for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].cx-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].cy-y1)<=ty*1.1)) then begin
    boum:=rsCetteLameSem;
    goto 314;
    end;



    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].sy-y1)<=ty*1.1)) then begin
    boum:=rsCeMiroirConc;
    goto 314;
    end;



    if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].sy-y1)<=ty*1.1)) then begin
    boum:=rsCeMiroirConv;
    goto 314;
    end;




    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].sy-y1)<=ty*1.1)) then begin
    boum:=rsCeMiroirSphR;
    goto 314;
    end;




    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].sy-y1)<=ty*1.1)) then begin
    boum:=rsCeMiroirSphR2;
    goto 314;
    end;




    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].oy-y1)<=ty*1.1)) then begin
    boum:=rsCetteLentill;
    goto 314;
    end;




     if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelec[-1+i].oy-y1)<=ty*1.1)) then begin
    boum:=rsCetteLentill2;
    goto 314;
    end;





    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].oy-y1)<=ty*1.1)) then begin
    boum:=rsCetteLentill3;
    goto 314;
    end;





    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].cx-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].cy-y1)<=ty*1.1)) then begin
    boum:=rsCeRayonLumin;
    goto 314;
    end;



     if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].gx-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].gy-y1)<=ty*1.1)) then begin
    boum:=rsCetteSourceP;
    goto 314;
    end;




 if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].sx-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].sy-y1)<=ty*1.1)) then begin
    boum:=rsCetteOndePla;
    goto 314;
    end;



     if nombreangle>0 then
    for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].cy-y1)<=ty*1.1)) then begin
    boum:=rsCetAngle;
    goto 314;
    end;




     if nombremetre>0 then
    for i:=1 to nombremetre do
   if ((abs(listemetre[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemetre[-1+i].cy-y1)<=ty*1.1)) then begin
    boum:=rsCetteMesureD;
    goto 314;
    end;


  form1.image1.Cursor:=crdefault;
  form1.StatusBar1.Panels[2].text:=rsFaitesPasser;
  exit;
 314: form1.image1.Cursor:=crgroupe;
 form1.StatusBar1.Panels[2].text:=Format(rsClicGauchePo, [boum]);
  exit;


end;



 procedure TraiteModif(Sender: TObject; Shift: TShiftState; X,
  Y: Integer);
  var

     x1,y1,tx,ty,distance,lambda,xx1,yy1,dtheta,AiAj,ux,uy,hx,hy,dAB,dIS:extended;
 i,j:integer;
 label 314, 315,316,317,319,320,321;
  begin


graphepresent:=true;
    BIBI.convert(x,y,x1,y1,true);
    if bloqueaxe then begin
      if (ssalt in shift) then  x1:=lastxr;
if (ssctrl in shift)  then  y1:=lastyr;
end;
    BIBI.convert(3,form1.image1.height-3,tx,ty,true);
     tx:=tx-xxmin; ty:=ty-yymin;

     affichecoordonnees(x1,y1);

     distance:=sqrt(sqr(xxmax-xxmin)+sqr(yymin-yymax));
    {on recherche si le curseur est proche d'un centre}
 if not(modifencours) then begin

 if nombretexte>0 then
 for i:=1 to nombretexte do
   if ((abs(listetexteaffiche[-1+i].x-x1)<=tx*1.1) and
    (abs(listetexteaffiche[-1+i].y-y1)<=ty*1.1)) then goto 314;


 if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1)) then goto 314;

     if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].cx-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].cy-y1)<=ty*1.1)) then goto 314;

    if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

     if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].a2y-y1)<=ty*1.1)) then goto 315;



if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx+listesphere[-1+i].rayon-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1)) then goto 315;

    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy+listesphere[-1+i].rayon-y1)<=ty*1.1)) then goto 315;

    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-listesphere[-1+i].rayon-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1)) then goto 315;

    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-listesphere[-1+i].rayon-y1)<=ty*1.1)) then goto 315;


    if nombreoeil>0 then
 for i:=1 to nombreoeil do
   if ((abs(listeoeil[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeoeil[-1+i].cy-y1)<=ty*1.1)) then goto 314;

    if nombreoeil>0 then
 for i:=1 to nombreoeil do
   if ((abs(listeoeil[-1+i].ax-x1)<=tx*1.1) and
    (abs(listeoeil[-1+i].ay-y1)<=ty*1.1)) then goto 315;


 if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].cy-y1)<=ty*1.1)) then goto 314;

    if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

    if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].a2y-y1)<=ty*1.1)) then goto 315;


     if nombrereseau>0 then
 for i:=1 to nombrereseau do
   if ((abs(listereseau[-1+i].cx-x1)<=tx*1.1) and
    (abs(listereseau[-1+i].cy-y1)<=ty*1.1)) then goto 314;

    if nombrereseau>0 then
 for i:=1 to nombrereseau do
   if ((abs(listereseau[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listereseau[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

    if nombrereseau>0 then
 for i:=1 to nombrereseau do
   if ((abs(listereseau[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listereseau[-1+i].a2y-y1)<=ty*1.1)) then goto 315;





 if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].sy-y1)<=ty*1.1)) then goto 314;

    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].a2y-y1)<=ty*1.1)) then goto 315;

    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].fy-y1)<=ty*1.1)) then goto 316;

  if nombreprisme>0 then
 for i:=1 to nombreprisme do
   if ((abs(listeprisme[-1+i].gx-x1)<=tx*1.1) and
    (abs(listeprisme[-1+i].gy-y1)<=ty*1.1))
    then goto 314;

    if nombreprisme>0 then
 for i:=1 to nombreprisme do
   if ((abs(listeprisme[-1+i].ax-x1)<=tx*1.1) and
    (abs(listeprisme[-1+i].ay-y1)<=ty*1.1))
    then goto 315;

    if nombreprisme>0 then
 for i:=1 to nombreprisme do
   if ((abs(listeprisme[-1+i].bx-x1)<=tx*1.1) and
    (abs(listeprisme[-1+i].by-y1)<=ty*1.1))
    then goto 321;

    if nombreprisme>0 then
 for i:=1 to nombreprisme do
   if ((abs(listeprisme[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeprisme[-1+i].cy-y1)<=ty*1.1))
    then goto 321;

     if nombrepolyhedre>0 then
 for i:=1 to nombrepolyhedre do
 for j:=1 to listepolyhedre[-1+i].nombresommet do
   if ((abs(listepolyhedre[-1+i].messommets[j].ax-x1)<=tx*1.1) and
    (abs(listepolyhedre[-1+i].messommets[j].ay-y1)<=ty*1.1))
    then goto 315;


    if nombrepolyhedre>0 then
 for i:=1 to nombrepolyhedre do
 for j:=1 to listepolyhedre[-1+i].nombresommet do
   if ((abs((listepolyhedre[-1+i].messommets[j].ax+listepolyhedre[-1+i].messommets[j+1].ax)/2-x1)<=tx*1.1) and
    (abs((listepolyhedre[-1+i].messommets[j].ay+listepolyhedre[-1+i].messommets[j+1].ay)/2-y1)<=ty*1.1) )
    then goto 314;


     if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
   if ((abs(listepolycercle[-1+i].messommets[j].ax-x1)<=tx*1.1) and
    (abs(listepolycercle[-1+i].messommets[j].ay-y1)<=ty*1.1))
    then goto 315;

     if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
   if ((abs((listepolycercle[-1+i].messommets[j].ax+listepolycercle[-1+i].messommets[j+1].ax)/2-x1)<=tx*1.1) and
    (abs((listepolycercle[-1+i].messommets[j].ay+listepolycercle[-1+i].messommets[j+1].ay)/2-y1)<=ty*1.1) )
    then goto 314;

     if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
 if not(listepolycercle[-1+i].rectiligne[j]) then
   if ((abs(listepolycercle[-1+i].mess[j].ax-x1)<=tx*1.1) and
    (abs(listepolycercle[-1+i].mess[j].ay-y1)<=ty*1.1))
    then goto 320;

    for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].cy-y1)<=ty*1.1)) then goto 314;

     for i:=1 to nombregroupe do
   if ((abs(listegroupe[-1+i].isox-x1)<=tx*1.1) and
    (abs(listegroupe[-1+i].isoy-y1)<=ty*1.1)) then goto 314;


    if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

    if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].a2y-y1)<=ty*1.1)) then goto 315;


     for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].cx-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].cy-y1)<=ty*1.1)) then goto 314;

    if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].a1y-y1)<=ty*1.1)) then goto 319;

    if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].a2y-y1)<=ty*1.1)) then goto 315;

  if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].ap1x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].ap1y-y1)<=ty*1.1)) then goto 319;

    if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].ap2x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].ap2y-y1)<=ty*1.1)) then goto 315;


     for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].cx-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].cy-y1)<=ty*1.1)) then goto 314;

    if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

    if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].a2y-y1)<=ty*1.1)) then goto 315;
    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].sy-y1)<=ty*1.1)) then goto 314;

    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].a2y-y1)<=ty*1.1)) then goto 315;

    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].fy-y1)<=ty*1.1)) then goto 316;


    if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].sy-y1)<=ty*1.1)) then goto 314;

     if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

     if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].a2y-y1)<=ty*1.1)) then goto 315;

     if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].fy-y1)<=ty*1.1)) then goto 316;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].sy-y1)<=ty*1.1)) then goto 314;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].a2y-y1)<=ty*1.1)) then goto 315;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].cy-y1)<=ty*1.1)) then goto 317;

    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].sy-y1)<=ty*1.1)) then goto 314;

    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].a2y-y1)<=ty*1.1)) then goto 315;

   if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].cy-y1)<=ty*1.1)) then goto 317;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].oy-y1)<=ty*1.1)) then goto 314;

     if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

     if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].a2y-y1)<=ty*1.1)) then goto 315;

     if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].f1x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].f1y-y1)<=ty*1.1)) then goto 316;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].f2x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].f2y-y1)<=ty*1.1)) then goto 316;


     if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelec[-1+i].oy-y1)<=ty*1.1)) then goto 314;

     if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].s1x-x1)<=tx*1.1) and
    (abs(listelec[-1+i].s1y-y1)<=ty*1.1)) then goto 315;

     if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].s2x-x1)<=tx*1.1) and
    (abs(listelec[-1+i].s2y-y1)<=ty*1.1)) then goto 315;


    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].oy-y1)<=ty*1.1)) then goto 314;


    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].a2y-y1)<=ty*1.1)) then goto 315;

       if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].f1x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].f1y-y1)<=ty*1.1)) then goto 316;

    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].f2x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].f2y-y1)<=ty*1.1)) then goto 316;


    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].cx-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].cy-y1)<=ty*1.1)) then goto 314;

    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].ax-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].ay-y1)<=ty*1.1)) then goto 315;

    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].bx-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].by-y1)<=ty*1.1)) then goto 315;

     if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].gx-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].gy-y1)<=ty*1.1)) then goto 314;


  if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].sx-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].sy-y1)<=ty*1.1)) then goto 315;

    if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

     if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].a2y-y1)<=ty*1.1)) then goto 315;

  if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].a1y-y1)<=ty*1.1)) then goto 314;

 if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].sx-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].sy-y1)<=ty*1.1)) then goto 315;

     if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].a2y-y1)<=ty*1.1)) then goto 315;

     if nombreangle>0 then
    for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].dx-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].dy-y1)<=ty*1.1)) then goto 314;


     if nombreangle>0 then
    for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

 if nombreangle>0 then
    for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].cy-y1)<=ty*1.1)) then goto 315;

     if nombreangle>0 then
    for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].a2y-y1)<=ty*1.1)) then goto 315;

   if nombremetre>0 then
    for i:=1 to nombremetre do
   if ((abs(listemetre[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemetre[-1+i].a1y-y1)<=ty*1.1)) then goto 315;

     if nombremetre>0 then
    for i:=1 to nombremetre do
   if ((abs(listemetre[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemetre[-1+i].a2y-y1)<=ty*1.1)) then goto 315;

     if nombremetre>0 then
    for i:=1 to nombremetre do
   if ((abs(listemetre[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemetre[-1+i].cy-y1)<=ty*1.1)) then goto 314;

  form1.image1.Cursor:=crdepla;
  form1.StatusBar1.Panels[2].text:=rsFaitesPasser2;
  exit;
 314: form1.image1.Cursor:=crTranslation;
 form1.StatusBar1.Panels[2].text:=rsClicGauchePo2;
  exit;

  315: form1.image1.Cursor:=crrotation;
 form1.StatusBar1.Panels[2].text:=rsClicGauchePo3;
  exit;

   317: form1.image1.Cursor:=crdepcentre;
 form1.StatusBar1.Panels[2].text:=rsClicGauchePo4;
  exit;

   316: form1.image1.Cursor:=crdepfoyer;
 form1.StatusBar1.Panels[2].text:=rsClicGauchePo5;
  exit;

  319:  form1.image1.Cursor:=crtaille;
  form1.StatusBar1.Panels[2].text:=rsClicGauchePo6;
  exit;

  321:  form1.image1.Cursor:=crtaille;
  form1.StatusBar1.Panels[2].text:=rsClicGauchePo7;
  exit;

   320:  form1.image1.Cursor:=crdepsommet;
  form1.StatusBar1.Panels[2].text:=rsClicGauchePo8;
  exit;
  end;

if moderotation then begin
case typeelementmodif of



mdsphere: begin
if ((x1<>listesphere[-1+indiceelementmodif].cx) or (y1<>listesphere[-1+indiceelementmodif].cy)) then begin
retaillepsphere(listesphere,nombresphere,nombresphere+1);
if listesphere[-1+nombresphere+1].create(
listesphere[-1+indiceelementmodif].cx,
listesphere[-1+indiceelementmodif].cy,
sqrt(sqr(x1-listesphere[-1+indiceelementmodif].cx)+
sqr(y1-listesphere[-1+indiceelementmodif].cy)),
listesphere[-1+indiceelementmodif].indicerouge,
listesphere[-1+indiceelementmodif].indicebleu,
listesphere[-1+indiceelementmodif].indicevert,
listesphere[-1+indiceelementmodif].couleurbord,
listesphere[-1+indiceelementmodif].couleurfond,
listesphere[-1+indiceelementmodif].reflechientrant,
listesphere[-1+indiceelementmodif].reflechisortant) then
listesphere[-1+indiceelementmodif].create(
listesphere[-1+indiceelementmodif].cx,
listesphere[-1+indiceelementmodif].cy,
sqrt(sqr(x1-listesphere[-1+indiceelementmodif].cx)+
sqr(y1-listesphere[-1+indiceelementmodif].cy)),
listesphere[-1+indiceelementmodif].indicerouge,
listesphere[-1+indiceelementmodif].indicebleu,
listesphere[-1+indiceelementmodif].indicevert,
listesphere[-1+indiceelementmodif].couleurbord,
listesphere[-1+indiceelementmodif].couleurfond,
listesphere[-1+indiceelementmodif].reflechientrant,
listesphere[-1+indiceelementmodif].reflechisortant)
 else
listesphere[-1+indiceelementmodif].create(
listesphere[-1+indiceelementmodif].cx,
listesphere[-1+indiceelementmodif].cy,
listesphere[-1+indiceelementmodif].rayon,
listesphere[-1+indiceelementmodif].indicerouge,
listesphere[-1+indiceelementmodif].indicebleu,
listesphere[-1+indiceelementmodif].indicevert,
listesphere[-1+indiceelementmodif].couleurbord,
listesphere[-1+indiceelementmodif].couleurfond,
listesphere[-1+indiceelementmodif].reflechientrant,
listesphere[-1+indiceelementmodif].reflechisortant);
 retaillepsphere(listesphere,nombresphere+1,nombresphere);
 Rafraichit;
 end;
  end;



  mdprisme: begin
if ((tprirot=tpa) and ((x1<>listeprisme[-1+indiceelementmodif].ax) or
 (y1<>listeprisme[-1+indiceelementmodif].ay))) then begin
retaillePprisme(listeprisme,nombreprisme,nombreprisme+1);
if listeprisme[-1+nombreprisme+1].create(
listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].gy,

listeprisme[-1+indiceelementmodif].gx+2/3*listeprisme[-1+indiceelementmodif].hauteur*
cos(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)),

listeprisme[-1+indiceelementmodif].gy+2/3*listeprisme[-1+indiceelementmodif].hauteur*
sin(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)) ,

listeprisme[-1+indiceelementmodif].gx+2/3*listeprisme[-1+indiceelementmodif].hauteur*
cos(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy))+
listeprisme[-1+indiceelementmodif].hauteur/cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*
cos(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)+pi+
listeprisme[-1+indiceelementmodif].angle_sommet/2),

listeprisme[-1+indiceelementmodif].gy+2/3*listeprisme[-1+indiceelementmodif].hauteur*
sin(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy))+
listeprisme[-1+indiceelementmodif].hauteur/cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*
sin(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)+pi+
listeprisme[-1+indiceelementmodif].angle_sommet/2),

listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant) then
 listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].gy,

listeprisme[-1+indiceelementmodif].gx+2/3*listeprisme[-1+indiceelementmodif].hauteur*
cos(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)),

listeprisme[-1+indiceelementmodif].gy+2/3*listeprisme[-1+indiceelementmodif].hauteur*
sin(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)) ,

listeprisme[-1+indiceelementmodif].gx+2/3*listeprisme[-1+indiceelementmodif].hauteur*
cos(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy))+
listeprisme[-1+indiceelementmodif].hauteur/cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*
cos(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)+pi+
listeprisme[-1+indiceelementmodif].angle_sommet/2),

listeprisme[-1+indiceelementmodif].gy+2/3*listeprisme[-1+indiceelementmodif].hauteur*
sin(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy))+
listeprisme[-1+indiceelementmodif].hauteur/cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*
sin(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)+pi+
listeprisme[-1+indiceelementmodif].angle_sommet/2),

listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant)
else
listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].ax,
listeprisme[-1+indiceelementmodif].ay,
listeprisme[-1+indiceelementmodif].bx,
listeprisme[-1+indiceelementmodif].by,
listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant);
retaillePprisme(listeprisme,nombreprisme+1,nombreprisme);
Rafraichit;
end;


if ((tprirot=tpc) and ((x1<>listeprisme[-1+indiceelementmodif].cx) or
 (y1<>listeprisme[-1+indiceelementmodif].cy))) then begin
 hx:=listeprisme[-1+indiceelementmodif].gx -0.5*(listeprisme[-1+indiceelementmodif].ax-listeprisme[-1+indiceelementmodif].gx);
 hy:=listeprisme[-1+indiceelementmodif].gy -0.5*(listeprisme[-1+indiceelementmodif].ay-listeprisme[-1+indiceelementmodif].gy);
 ux:=(listeprisme[-1+indiceelementmodif].ax-listeprisme[-1+indiceelementmodif].gx)/
 sqrt(sqr(listeprisme[-1+indiceelementmodif].ax-listeprisme[-1+indiceelementmodif].gx)+
 sqr(listeprisme[-1+indiceelementmodif].ay-listeprisme[-1+indiceelementmodif].gy));
uy:=(listeprisme[-1+indiceelementmodif].ay-listeprisme[-1+indiceelementmodif].gy)/
 sqrt(sqr(listeprisme[-1+indiceelementmodif].ax-listeprisme[-1+indiceelementmodif].gx)+
 sqr(listeprisme[-1+indiceelementmodif].ay-listeprisme[-1+indiceelementmodif].gy));
 lambda:=(x1-hx)*ux+(y1-hy)*uy;

retaillePprisme(listeprisme,nombreprisme,nombreprisme+1);
if listeprisme[-1+nombreprisme+1].create(
listeprisme[-1+indiceelementmodif].gx,
   listeprisme[-1+indiceelementmodif].gy,
                 listeprisme[-1+indiceelementmodif].ax,
               listeprisme[-1+indiceelementmodif].ay ,
            x1-lambda*ux,
            y1-lambda*uy,

listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant) then
 listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].gx,
   listeprisme[-1+indiceelementmodif].gy,
                 listeprisme[-1+indiceelementmodif].ax,
               listeprisme[-1+indiceelementmodif].ay ,
            x1-lambda*ux,
            y1-lambda*uy,

listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant)
else
listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].ax,
listeprisme[-1+indiceelementmodif].ay,
listeprisme[-1+indiceelementmodif].bx,
listeprisme[-1+indiceelementmodif].by,
listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant);
retaillePprisme(listeprisme,nombreprisme+1,nombreprisme);
Rafraichit;
end;



if ((tprirot=tpb) and ((x1<>listeprisme[-1+indiceelementmodif].bx) or
 (y1<>listeprisme[-1+indiceelementmodif].by))) then begin
 ux:=cos(donneanglepolairedans02pi(listeprisme[-1+indiceelementmodif].bx-listeprisme[-1+indiceelementmodif].ax,
 listeprisme[-1+indiceelementmodif].by-listeprisme[-1+indiceelementmodif].ay));
 uy:=sin(donneanglepolairedans02pi(listeprisme[-1+indiceelementmodif].bx-listeprisme[-1+indiceelementmodif].ax,
 listeprisme[-1+indiceelementmodif].by-listeprisme[-1+indiceelementmodif].ay));
 lambda:=-(x1-listeprisme[-1+indiceelementmodif].ax)*ux-(y1-listeprisme[-1+indiceelementmodif].ay)*uy;

retaillePprisme(listeprisme,nombreprisme,nombreprisme+1);
if listeprisme[-1+nombreprisme+1].create(
listeprisme[-1+indiceelementmodif].ax+2/3*abs(lambda)*
cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*cos(listeprisme[-1+indiceelementmodif].angle_axe+pi),


listeprisme[-1+indiceelementmodif].ay+2/3*
abs(lambda)*
cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*sin(listeprisme[-1+indiceelementmodif].angle_axe+pi),



listeprisme[-1+indiceelementmodif].ax,

listeprisme[-1+indiceelementmodif].ay ,

listeprisme[-1+indiceelementmodif].ax-lambda*ux,

listeprisme[-1+indiceelementmodif].ay-lambda*uy,

listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant) then
 listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].ax+2/3*abs(lambda)*
cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*cos(listeprisme[-1+indiceelementmodif].angle_axe+pi),


listeprisme[-1+indiceelementmodif].ay+2/3*
abs(lambda)*
cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*sin(listeprisme[-1+indiceelementmodif].angle_axe+pi),



listeprisme[-1+indiceelementmodif].ax,

listeprisme[-1+indiceelementmodif].ay ,

listeprisme[-1+indiceelementmodif].ax-lambda*ux,

listeprisme[-1+indiceelementmodif].ay-lambda*uy,

listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant)
else
listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].ax,
listeprisme[-1+indiceelementmodif].ay,
listeprisme[-1+indiceelementmodif].bx,
listeprisme[-1+indiceelementmodif].by,
listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant);
retaillePprisme(listeprisme,nombreprisme+1,nombreprisme);
Rafraichit;
end;

end;



mdmetre: begin
if ((tprot=tpa1) and ((x1<>listemetre[-1+indiceelementmodif].a2x) or
 (y1<>listemetre[-1+indiceelementmodif].a2y)))
 then begin
retaillePmetre(listemetre,nombremetre,nombremetre+1);
if listemetre[-1+nombremetre+1].create(
x1,y1,
 listemetre[-1+indiceelementmodif].a2x,
listemetre[-1+indiceelementmodif].a2y) then
 listemetre[-1+indiceelementmodif].create(
 x1,y1,
 listemetre[-1+indiceelementmodif].a2x,
listemetre[-1+indiceelementmodif].a2y)
else
listemetre[-1+indiceelementmodif].create(
listemetre[-1+indiceelementmodif].a1x,
listemetre[-1+indiceelementmodif].a1y,
listemetre[-1+indiceelementmodif].a2x,
listemetre[-1+indiceelementmodif].a2y);
retaillePmetre(listemetre,nombremetre+1,nombremetre);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listemetre[-1+indiceelementmodif].a1x) or
 (y1<>listemetre[-1+indiceelementmodif].a1y)))
 then begin
retaillePmetre(listemetre,nombremetre,nombremetre+1);
if listemetre[-1+nombremetre+1].create(
listemetre[-1+indiceelementmodif].a1x,
listemetre[-1+indiceelementmodif].a1y,
 x1,y1) then
 listemetre[-1+indiceelementmodif].create(
 listemetre[-1+indiceelementmodif].a1x,
listemetre[-1+indiceelementmodif].a1y,
 x1,y1)
else
listemetre[-1+indiceelementmodif].create(
listemetre[-1+indiceelementmodif].a1x,
listemetre[-1+indiceelementmodif].a1y,
listemetre[-1+indiceelementmodif].a2x,
listemetre[-1+indiceelementmodif].a2y);
Rafraichit;
end;
 end; {du cas metre}

mdfleche: begin
if ((tprot=tpa1) and ((x1<>listefleche[-1+indiceelementmodif].a2x) or
 (y1<>listefleche[-1+indiceelementmodif].a2y)))
 then begin
retaillePfleche(listefleche,nombrefleche,nombrefleche+1);
if listefleche[-1+nombrefleche+1].create(
x1,y1,
 listefleche[-1+indiceelementmodif].a2x,
listefleche[-1+indiceelementmodif].a2y,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2) then
 listefleche[-1+indiceelementmodif].create(
 x1,y1,
 listefleche[-1+indiceelementmodif].a2x,
listefleche[-1+indiceelementmodif].a2y,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2)
else
listefleche[-1+indiceelementmodif].create(
listefleche[-1+indiceelementmodif].a1x,
listefleche[-1+indiceelementmodif].a1y,
listefleche[-1+indiceelementmodif].a2x,
listefleche[-1+indiceelementmodif].a2y,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2);
retaillePfleche(listefleche,nombrefleche+1,nombrefleche);
Rafraichit;
end;
if ((tprot=tpa2) and ((x1<>listefleche[-1+indiceelementmodif].a1x) or
 (y1<>listefleche[-1+indiceelementmodif].a1y)))
 then begin
retaillePfleche(listefleche,nombrefleche,nombrefleche+1);
if listefleche[-1+nombrefleche+1].create(
 listefleche[-1+indiceelementmodif].a1x,
listefleche[-1+indiceelementmodif].a1y,x1,y1,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2) then
 listefleche[-1+indiceelementmodif].create(
 listefleche[-1+indiceelementmodif].a1x,
listefleche[-1+indiceelementmodif].a1y,x1,y1,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2)
else
listefleche[-1+indiceelementmodif].create(
listefleche[-1+indiceelementmodif].a1x,
listefleche[-1+indiceelementmodif].a1y,
listefleche[-1+indiceelementmodif].a2x,
listefleche[-1+indiceelementmodif].a2y,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2);
retaillePfleche(listefleche,nombrefleche+1,nombrefleche);
Rafraichit;
end;
end;

mdangle: begin
if ((tprot=tpa1) and ((x1<>listeangle[-1+indiceelementmodif].a2x) or
 (y1<>listeangle[-1+indiceelementmodif].a2y)))
 then begin
retaillePangle(listeangle,nombreangle,nombreangle+1);
if listeangle[-1+nombreangle+1].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
x1,y1,
 listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y) then
 listeangle[-1+indiceelementmodif].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
x1,y1,
 listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y)
else
listeangle[-1+indiceelementmodif].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y);
retaillePangle(listeangle,nombreangle+1,nombreangle);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listeangle[-1+indiceelementmodif].a1x) or
 (y1<>listeangle[-1+indiceelementmodif].a1y)))
 then begin
retaillePangle(listeangle,nombreangle,nombreangle+1);
if listeangle[-1+nombreangle+1].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
 x1,y1) then
 listeangle[-1+indiceelementmodif].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
 listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
 x1,y1)
else
listeangle[-1+indiceelementmodif].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y);
retaillePangle(listeangle,nombreangle+1,nombreangle);
Rafraichit;
end;

if ((tprot=tpce) and ((x1<>listeangle[-1+indiceelementmodif].cx) or
 (y1<>listeangle[-1+indiceelementmodif].cy)))
 then begin
retaillePangle(listeangle,nombreangle,nombreangle+1);
if listeangle[-1+nombreangle+1].create(x1,y1,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y ) then
 listeangle[-1+indiceelementmodif].create(x1,y1,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y)
else
listeangle[-1+indiceelementmodif].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y);
retaillePangle(listeangle,nombreangle+1,nombreangle);
Rafraichit;
end;
 end; {du cas angle}



mdmiroirplan: begin
if ((tprot=tpa1) and ((x1<>listemiroirplan[-1+indiceelementmodif].a2x) or
 (y1<>listemiroirplan[-1+indiceelementmodif].a2y)))
 then begin
retaillePMiroirplan(listemiroirplan,nombremiroirplan,nombremiroirplan+1);
if listemiroirplan[-1+nombremiroirplan+1].create(
x1,y1,
 listemiroirplan[-1+indiceelementmodif].a2x,
listemiroirplan[-1+indiceelementmodif].a2y,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures) then
 listemiroirplan[-1+indiceelementmodif].create(
 x1,y1,
 listemiroirplan[-1+indiceelementmodif].a2x,
listemiroirplan[-1+indiceelementmodif].a2y,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures)
else
listemiroirplan[-1+indiceelementmodif].create(
listemiroirplan[-1+indiceelementmodif].a1x,
listemiroirplan[-1+indiceelementmodif].a1y,
listemiroirplan[-1+indiceelementmodif].a2x,
listemiroirplan[-1+indiceelementmodif].a2y,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures);
retaillePMiroirplan(listemiroirplan,nombremiroirplan+1,nombremiroirplan);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listemiroirplan[-1+indiceelementmodif].a1x) or
 (y1<>listemiroirplan[-1+indiceelementmodif].a1y)))
 then begin
retaillePMiroirplan(listemiroirplan,nombremiroirplan,nombremiroirplan+1);
if listemiroirplan[-1+nombremiroirplan+1].create(
listemiroirplan[-1+indiceelementmodif].a1x,
listemiroirplan[-1+indiceelementmodif].a1y,
 x1,y1,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures) then
 listemiroirplan[-1+indiceelementmodif].create(
 listemiroirplan[-1+indiceelementmodif].a1x,
listemiroirplan[-1+indiceelementmodif].a1y,
 x1,y1,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures)
else
listemiroirplan[-1+indiceelementmodif].create(
listemiroirplan[-1+indiceelementmodif].a1x,
listemiroirplan[-1+indiceelementmodif].a1y,
listemiroirplan[-1+indiceelementmodif].a2x,
listemiroirplan[-1+indiceelementmodif].a2y,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures);
retaillePMiroirplan(listemiroirplan,nombremiroirplan+1,nombremiroirplan);
Rafraichit;
end;
 end; {du cas miroir plan}





mdreseau: begin
if ((tprot=tpa1) and ((x1<>listereseau[-1+indiceelementmodif].a2x) or
 (y1<>listeReseau[-1+indiceelementmodif].a2y)))
 then begin
retaillePReseau(listeReseau,nombreReseau,nombreReseau+1);
if listeReseau[-1+nombreReseau+1].create(
x1,y1,
 listeReseau[-1+indiceelementmodif].a2x,
listeReseau[-1+indiceelementmodif].a2y,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listereseau[-1+indiceelementmodif].entransmission,
listereseau[-1+indiceelementmodif].hachures,
listereseau[-1+indiceelementmodif].ordre_min,
listereseau[-1+indiceelementmodif].ordre_max) then
 listeReseau[-1+indiceelementmodif].create(
 x1,y1,
 listeReseau[-1+indiceelementmodif].a2x,
listeReseau[-1+indiceelementmodif].a2y,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listereseau[-1+indiceelementmodif].entransmission,
listereseau[-1+indiceelementmodif].hachures,
listereseau[-1+indiceelementmodif].ordre_min,
listereseau[-1+indiceelementmodif].ordre_max)
else
listeReseau[-1+indiceelementmodif].create(
listeReseau[-1+indiceelementmodif].a1x,
listeReseau[-1+indiceelementmodif].a1y,
listeReseau[-1+indiceelementmodif].a2x,
listeReseau[-1+indiceelementmodif].a2y,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listereseau[-1+indiceelementmodif].entransmission,
listereseau[-1+indiceelementmodif].hachures,
listereseau[-1+indiceelementmodif].ordre_min,
listereseau[-1+indiceelementmodif].ordre_max);
retaillePReseau(listeReseau,nombreReseau+1,nombreReseau);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listeReseau[-1+indiceelementmodif].a1x) or
 (y1<>listeReseau[-1+indiceelementmodif].a1y)))
 then begin
retaillePReseau(listeReseau,nombreReseau,nombreReseau+1);
if listeReseau[-1+nombreReseau+1].create(
listeReseau[-1+indiceelementmodif].a1x,
listeReseau[-1+indiceelementmodif].a1y,
 x1,y1,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listereseau[-1+indiceelementmodif].entransmission,
listereseau[-1+indiceelementmodif].hachures,
listereseau[-1+indiceelementmodif].ordre_min,
listereseau[-1+indiceelementmodif].ordre_max) then
 listeReseau[-1+indiceelementmodif].create(
 listeReseau[-1+indiceelementmodif].a1x,
listeReseau[-1+indiceelementmodif].a1y,
 x1,y1,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listereseau[-1+indiceelementmodif].entransmission,
listereseau[-1+indiceelementmodif].hachures,
listereseau[-1+indiceelementmodif].ordre_min,
listereseau[-1+indiceelementmodif].ordre_max)
else
listeReseau[-1+indiceelementmodif].create(
listeReseau[-1+indiceelementmodif].a1x,
listeReseau[-1+indiceelementmodif].a1y,
listeReseau[-1+indiceelementmodif].a2x,
listeReseau[-1+indiceelementmodif].a2y,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listereseau[-1+indiceelementmodif].entransmission,
listereseau[-1+indiceelementmodif].hachures,
listereseau[-1+indiceelementmodif].ordre_min,
listereseau[-1+indiceelementmodif].ordre_max);
retaillePReseau(listeReseau,nombreReseau+1,nombreReseau);
Rafraichit;
end;
 end; {du cas reseau}

mdpolyhedre:
if (  (x1<>listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace].ax) or
 (y1<>listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace].ay))
 then begin
retaillePpolyhedre(listepolyhedre,nombrepolyhedre,nombrepolyhedre+1);
for i:=1 to listepolyhedre[-1+indiceelementmodif].nombresommet do
begin
ttpoly[i].ax:=listepolyhedre[-1+indiceelementmodif].messommets[i].ax;
ttpoly[i].ay:=listepolyhedre[-1+indiceelementmodif].messommets[i].ay;
end;
ttpoly[indicepointdeplace].ax:=x1;
ttpoly[indicepointdeplace].ay:=y1;


if listepolyhedre[-1+nombrepolyhedre+1].create(
listepolyhedre[-1+indiceelementmodif].nombresommet,
ttpoly,
 listepolyhedre[-1+indiceelementmodif].indicerouge,
 listepolyhedre[-1+indiceelementmodif].indicebleu,
 listepolyhedre[-1+indiceelementmodif].indicevert,
listepolyhedre[-1+indiceelementmodif].couleurbord,
listepolyhedre[-1+indiceelementmodif].couleurfond,
listepolyhedre[-1+indiceelementmodif].reflechientrant,
listepolyhedre[-1+indiceelementmodif].reflechisortant) then
 listepolyhedre[-1+indiceelementmodif].create(
 listepolyhedre[-1+indiceelementmodif].nombresommet,
ttpoly,
 listepolyhedre[-1+indiceelementmodif].indicerouge,
 listepolyhedre[-1+indiceelementmodif].indicebleu,
 listepolyhedre[-1+indiceelementmodif].indicevert,
listepolyhedre[-1+indiceelementmodif].couleurbord,
listepolyhedre[-1+indiceelementmodif].couleurfond,
listepolyhedre[-1+indiceelementmodif].reflechientrant,
listepolyhedre[-1+indiceelementmodif].reflechisortant)
else
listepolyhedre[-1+indiceelementmodif].create(
listepolyhedre[-1+indiceelementmodif].nombresommet,
listepolyhedre[-1+indiceelementmodif].messommets,
 listepolyhedre[-1+indiceelementmodif].indicerouge,
 listepolyhedre[-1+indiceelementmodif].indicebleu,
 listepolyhedre[-1+indiceelementmodif].indicevert,
listepolyhedre[-1+indiceelementmodif].couleurbord,
listepolyhedre[-1+indiceelementmodif].couleurfond,
listepolyhedre[-1+indiceelementmodif].reflechientrant,
listepolyhedre[-1+indiceelementmodif].reflechisortant);
retaillePpolyhedre(listepolyhedre,nombrepolyhedre+1,nombrepolyhedre);
Rafraichit;
end;



mdpolycercle:   begin
if ((tprot=tpa1) and (  (x1<>listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax) or
 (y1<>listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay)))
 then begin
retaillePpolycercle(listepolycercle,nombrepolycercle,nombrepolycercle+1);
for i:=1 to listepolycercle[-1+indiceelementmodif].nombresommet do
begin
ttpoly[i].ax:=listepolycercle[-1+indiceelementmodif].messommets[i].ax;
ttpoly[i].ay:=listepolycercle[-1+indiceelementmodif].messommets[i].ay;
ttsom[i].ax:=listepolycercle[-1+indiceelementmodif].mess[i].ax;
ttsom[i].ay:=listepolycercle[-1+indiceelementmodif].mess[i].ay;
end;
ttpoly[indicepointdeplace].ax:=x1;
ttpoly[indicepointdeplace].ay:=y1;
 {si le segment précédent est un arc de cercle}
 if (indicepointdeplace>1) and
not(listepolycercle[-1+indiceelementmodif].rectiligne[indicepointdeplace-1]) then begin
dAB:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax)+
sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay));
dIS:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace-1].ax-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))+
sqr(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace-1].ay-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay)));
if  (listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax)*
(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace-1].ay-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay))-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay)*
(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace-1].ax-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))<0 then
begin
 ttsom[indicepointdeplace-1].ax:=(y1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax+x1);
 ttsom[indicepointdeplace-1].ay:=-(x1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay+y1);
end else begin
 ttsom[indicepointdeplace-1].ax:=-(y1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax+x1);
 ttsom[indicepointdeplace-1].ay:=(x1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay+y1);
 end;
end;


 {si le segment précédent est un arc de cercle}
 if (indicepointdeplace=1) and
not(listepolycercle[-1+indiceelementmodif].rectiligne[listepolycercle[-1+indiceelementmodif].nombresommet]) then begin
dAB:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax)+
sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay));
dIS:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].MesS[listepolycercle[-1+indiceelementmodif].nombresommet].ax-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))+
sqr(listepolycercle[-1+indiceelementmodif].MesS[listepolycercle[-1+indiceelementmodif].nombresommet].ay-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay)));
if  (listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax)*
(listepolycercle[-1+indiceelementmodif].MesS[listepolycercle[-1+indiceelementmodif].nombresommet].ay-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay))-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay)*
(listepolycercle[-1+indiceelementmodif].MesS[listepolycercle[-1+indiceelementmodif].nombresommet].ax-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))<0 then
begin
 ttsom[listepolycercle[-1+indiceelementmodif].nombresommet].ax:=(y1-listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax+x1);
 ttsom[listepolycercle[-1+indiceelementmodif].nombresommet].ay:=-(x1-listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay+y1);
end else begin
 ttsom[listepolycercle[-1+indiceelementmodif].nombresommet].ax:=-(y1-listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax+x1); ;
 ttsom[listepolycercle[-1+indiceelementmodif].nombresommet].ay:=(x1-listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay+y1);
 end;
end;


 {si le segment suivant est un arc de cercle}
 if (indicepointdeplace<listepolycercle[-1+indiceelementmodif].nombresommet) and
not(listepolycercle[-1+indiceelementmodif].rectiligne[indicepointdeplace]) then begin
dAB:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)+
sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay));
dIS:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ax-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))+
sqr(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ay-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay)));
if  (listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)*
(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ay-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay))-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)*
(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ax-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))<0 then
begin
 ttsom[indicepointdeplace].ax:=(y1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax+x1);
 ttsom[indicepointdeplace].ay:=-(x1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay+y1);
end else begin
 ttsom[indicepointdeplace].ax:=-(y1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax+x1);
 ttsom[indicepointdeplace].ay:=(x1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay+y1);
 end;
end;

  {si le segment suivant est un arc de cercle}
 if (indicepointdeplace=listepolycercle[-1+indiceelementmodif].nombresommet) and
not(listepolycercle[-1+indiceelementmodif].rectiligne[indicepointdeplace]) then begin
dAB:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[1].ax)+
sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[1].ay));
dIS:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ax-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[1].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))+
sqr(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ay-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[1].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay)));
if  (listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[1].ax)*
(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ay-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[1].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay))-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[1].ay)*
(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ax-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[1].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))<0 then
begin
 ttsom[indicepointdeplace].ax:=(y1-listepolycercle[-1+indiceelementmodif].messommets[1].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[1].ax+x1);
 ttsom[indicepointdeplace].ay:=-(x1-listepolycercle[-1+indiceelementmodif].messommets[1].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[1].ay+y1);
end else begin
 ttsom[indicepointdeplace].ax:=-(y1-listepolycercle[-1+indiceelementmodif].messommets[1].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[1].ax+x1);
 ttsom[indicepointdeplace].ay:=(x1-listepolycercle[-1+indiceelementmodif].messommets[1].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[1].ay+y1);
 end;
end;

if listepolycercle[-1+nombrepolycercle+1].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
ttpoly,ttsom,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant) then
 listepolycercle[-1+indiceelementmodif].create(
 listepolycercle[-1+indiceelementmodif].nombresommet,
ttpoly,ttsom,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant)
else
listepolycercle[-1+indiceelementmodif].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
listepolycercle[-1+indiceelementmodif].messommets,
listepolycercle[-1+indiceelementmodif].mess,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant);
retaillePpolycercle(listepolycercle,nombrepolycercle+1,nombrepolycercle);
Rafraichit;
end;

if ((tprot=tpso))
 then begin
retaillePpolycercle(listepolycercle,nombrepolycercle,nombrepolycercle+1);
for i:=1 to listepolycercle[-1+indiceelementmodif].nombresommet do
begin
tts[i].ax:=listepolycercle[-1+indiceelementmodif].mess[i].ax;
tts[i].ay:=listepolycercle[-1+indiceelementmodif].mess[i].ay;
end;

 AiAj:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax
 -listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)+
  sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay
  -listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay));
  ux:=(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
  listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/AiAj;
  uy:=-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax
  -listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/AiAj;
  tts[indicepointdeplace].ax:=
  (listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax+
  listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2+
(  (x1-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax
+listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2)*ux+
  (y1-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay
  +listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2)*uy
  )*ux;
  tts[indicepointdeplace].ay:=(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay
  +listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2+
(  (x1-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax
+listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2)*ux+
  (y1-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay+
  listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2)*uy
  )*uy;



if listepolycercle[-1+nombrepolycercle+1].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
listepolycercle[-1+indiceelementmodif].messommets,
tts,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant) then
 listepolycercle[-1+indiceelementmodif].create(
 listepolycercle[-1+indiceelementmodif].nombresommet,
listepolycercle[-1+indiceelementmodif].messommets,
tts,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant)
else
listepolycercle[-1+indiceelementmodif].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
listepolycercle[-1+indiceelementmodif].messommets,
listepolycercle[-1+indiceelementmodif].mess,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant);
retaillePpolycercle(listepolycercle,nombrepolycercle+1,nombrepolycercle);
Rafraichit;
end;

end;


mdoeil: begin
if (((x1<>listeoeil[-1+indiceelementmodif].cx) or
 (y1<>listeoeil[-1+indiceelementmodif].cy)))
 then begin
retaillePoeil(listeoeil,nombreoeil,nombreoeil+1);
if listeoeil[-1+nombreoeil+1].create(
listeoeil[-1+indiceelementmodif].cx,
listeoeil[-1+indiceelementmodif].cy,
x1,y1,
listeoeil[-1+indiceelementmodif].epaisseur,
listeoeil[-1+indiceelementmodif].couleur) then
 listeoeil[-1+indiceelementmodif].create(
listeoeil[-1+indiceelementmodif].cx,
listeoeil[-1+indiceelementmodif].cy,
x1,y1,
listeoeil[-1+indiceelementmodif].epaisseur,
listeoeil[-1+indiceelementmodif].couleur)
else
listeoeil[-1+indiceelementmodif].create(
listeoeil[-1+indiceelementmodif].cx,
listeoeil[-1+indiceelementmodif].cy,
listeoeil[-1+indiceelementmodif].ax,
listeoeil[-1+indiceelementmodif].ay,
listeoeil[-1+indiceelementmodif].epaisseur,
listeoeil[-1+indiceelementmodif].couleur);
retaillePoeil(listeoeil,nombreoeil+1,nombreoeil);
Rafraichit;
end;
end;


mdecran: begin
if ((tprot=tpa1) and ((x1<>listeecran[-1+indiceelementmodif].a2x) or
 (y1<>listeecran[-1+indiceelementmodif].a2y)))
 then begin
retaillePecran(listeecran,nombreecran,nombreecran+1);
if listeecran[-1+nombreecran+1].create(
x1,y1,
 listeecran[-1+indiceelementmodif].a2x,
listeecran[-1+indiceelementmodif].a2y,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur) then
 listeecran[-1+indiceelementmodif].create(
 x1,y1,
 listeecran[-1+indiceelementmodif].a2x,
listeecran[-1+indiceelementmodif].a2y,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur)
else
listeecran[-1+indiceelementmodif].create(
listeecran[-1+indiceelementmodif].a1x,
listeecran[-1+indiceelementmodif].a1y,
listeecran[-1+indiceelementmodif].a2x,
listeecran[-1+indiceelementmodif].a2y,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur);
retaillePecran(listeecran,nombreecran+1,nombreecran);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listeecran[-1+indiceelementmodif].a1x) or
 (y1<>listeecran[-1+indiceelementmodif].a1y)))
 then begin
retaillePecran(listeecran,nombreecran,nombreecran+1);
if listeecran[-1+nombreecran+1].create(
listeecran[-1+indiceelementmodif].a1x,
listeecran[-1+indiceelementmodif].a1y,
 x1,y1,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur) then
 listeecran[-1+indiceelementmodif].create(
 listeecran[-1+indiceelementmodif].a1x,
listeecran[-1+indiceelementmodif].a1y,
 x1,y1,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur)
else
listeecran[-1+indiceelementmodif].create(
listeecran[-1+indiceelementmodif].a1x,
listeecran[-1+indiceelementmodif].a1y,
listeecran[-1+indiceelementmodif].a2x,
listeecran[-1+indiceelementmodif].a2y,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur);
retaillePecran(listeecran,nombreecran+1,nombreecran);
Rafraichit;
end;
 end; {du cas ecran}



mdlsr: begin
if ((tprot=tpa1) and ((x1<>listelsr[-1+indiceelementmodif].a2x) or
 (y1<>listelsr[-1+indiceelementmodif].a2y)))
 then begin
retaillePlsr(listelsr,nombrelsr,nombrelsr+1);
if listelsr[-1+nombrelsr+1].create(
x1,y1,
 listelsr[-1+indiceelementmodif].a2x,
listelsr[-1+indiceelementmodif].a2y,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur) then
 listelsr[-1+indiceelementmodif].create(
 x1,y1,
 listelsr[-1+indiceelementmodif].a2x,
listelsr[-1+indiceelementmodif].a2y,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur)
else
listelsr[-1+indiceelementmodif].create(
listelsr[-1+indiceelementmodif].a1x,
listelsr[-1+indiceelementmodif].a1y,
listelsr[-1+indiceelementmodif].a2x,
listelsr[-1+indiceelementmodif].a2y,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur);
retaillePlsr(listelsr,nombrelsr+1,nombrelsr);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listelsr[-1+indiceelementmodif].a1x) or
 (y1<>listelsr[-1+indiceelementmodif].a1y)))
 then begin
retaillePlsr(listelsr,nombrelsr,nombrelsr+1);
if listelsr[-1+nombrelsr+1].create(
listelsr[-1+indiceelementmodif].a1x,
listelsr[-1+indiceelementmodif].a1y,
 x1,y1,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur) then
 listelsr[-1+indiceelementmodif].create(
 listelsr[-1+indiceelementmodif].a1x,
listelsr[-1+indiceelementmodif].a1y,
 x1,y1,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur)
else
listelsr[-1+indiceelementmodif].create(
listelsr[-1+indiceelementmodif].a1x,
listelsr[-1+indiceelementmodif].a1y,
listelsr[-1+indiceelementmodif].a2x,
listelsr[-1+indiceelementmodif].a2y,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur);
retaillePlsr(listelsr,nombrelsr+1,nombrelsr);
Rafraichit;
end;
 end; {du cas lsr}

 mdrayon: begin
 if ((tprot=tpa1) and ((x1<>listerayon[-1+indiceelementmodif].bx) or
 (y1<>listerayon[-1+indiceelementmodif].by)))
 then begin
retaillePrayon(listerayon,nombrerayon,nombrerayon+1);
if listerayon[-1+nombrerayon+1].create(x1,y1,
listerayon[-1+indiceelementmodif].bx-x1,
listerayon[-1+indiceelementmodif].by-y1,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment) then
 listerayon[-1+indiceelementmodif].create(x1,y1,
listerayon[-1+indiceelementmodif].bx-x1,
listerayon[-1+indiceelementmodif].by-y1,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,listerayon[-1+indiceelementmodif].vaa
,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment)
else
listerayon[-1+indiceelementmodif].create(
listerayon[-1+indiceelementmodif].ax,
listerayon[-1+indiceelementmodif].ay,
listerayon[-1+indiceelementmodif].kx,
listerayon[-1+indiceelementmodif].ky,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment);
retaillePrayon(listerayon,nombrerayon+1,nombrerayon);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listerayon[-1+indiceelementmodif].ax) or
 (y1<>listerayon[-1+indiceelementmodif].ay)))
 then begin
retaillePrayon(listerayon,nombrerayon,nombrerayon+1);
if listerayon[-1+nombrerayon+1].create(
listerayon[-1+indiceelementmodif].ax,
listerayon[-1+indiceelementmodif].ay,
-listerayon[-1+indiceelementmodif].ax+x1,
-listerayon[-1+indiceelementmodif].ay+y1,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment) then
 listerayon[-1+indiceelementmodif].create(
 listerayon[-1+indiceelementmodif].ax,
listerayon[-1+indiceelementmodif].ay,
-listerayon[-1+indiceelementmodif].ax+x1,
-listerayon[-1+indiceelementmodif].ay+y1,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment)
else
listerayon[-1+indiceelementmodif].create(
listerayon[-1+indiceelementmodif].ax,
listerayon[-1+indiceelementmodif].ay,
listerayon[-1+indiceelementmodif].kx,
listerayon[-1+indiceelementmodif].ky,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment);
retaillePrayon(listerayon,nombrerayon+1,nombrerayon);
Rafraichit;
end;
 end; {du cas rayon}



mdsourceponctuelle: begin
if ((tprot=tpa1) and ((x1<>listesourceponctuelle[-1+indiceelementmodif].sx) or
 (y1<>listesourceponctuelle[-1+indiceelementmodif].sy)))
 then begin
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle,nombresourceponctuelle+1);
if listesourceponctuelle[-1+nombresourceponctuelle+1].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,x1,y1,
 listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment) then
 listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,x1,y1,
 listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment)

else
listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,
 listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment);
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle+1,nombresourceponctuelle);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listesourceponctuelle[-1+indiceelementmodif].sx) or
 (y1<>listesourceponctuelle[-1+indiceelementmodif].sy)))
 then begin
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle,nombresourceponctuelle+1);
if listesourceponctuelle[-1+nombresourceponctuelle+1].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,x1,y1,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment) then
 listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,x1,y1,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment)

else
listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,
 listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment);
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle+1,nombresourceponctuelle);
Rafraichit;
end;


if ((tprot=tpa0) and ((x1<>listesourceponctuelle[-1+indiceelementmodif].a1x) or
 (y1<>listesourceponctuelle[-1+indiceelementmodif].a1y)) and
 ((x1<>listesourceponctuelle[-1+indiceelementmodif].a2x) or
 (y1<>listesourceponctuelle[-1+indiceelementmodif].a2y)))
 then begin
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle,nombresourceponctuelle+1);
if listesourceponctuelle[-1+nombresourceponctuelle+1].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,x1,y1,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,
listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment) then
 listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,x1,y1,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,
listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment)

else
listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,
 listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment);

retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle+1,nombresourceponctuelle);
Rafraichit;
end;
 end; {du cas sourceponctuelle}



mdondeplane: begin
if ((tprot=tpa1) and ((x1<>listeondeplane[-1+indiceelementmodif].a1x) or
 (y1<>listeondeplane[-1+indiceelementmodif].a1y)))
 then begin
retaillePondeplane(listeondeplane,nombreondeplane,nombreondeplane+1);
if listeondeplane[-1+nombreondeplane+1].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,x1,y1,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,
 listeondeplane[-1+indiceelementmodif].a2x,
listeondeplane[-1+indiceelementmodif].a2y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment) then
 listeondeplane[-1+indiceelementmodif].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,x1,y1,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,
 listeondeplane[-1+indiceelementmodif].a2x,
listeondeplane[-1+indiceelementmodif].a2y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment)

else
listeondeplane[-1+indiceelementmodif].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
  listeondeplane[-1+indiceelementmodif].sx,
listeondeplane[-1+indiceelementmodif].sy,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,
 listeondeplane[-1+indiceelementmodif].a2x,
listeondeplane[-1+indiceelementmodif].a2y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment);
retaillePondeplane(listeondeplane,nombreondeplane+1,nombreondeplane);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listeondeplane[-1+indiceelementmodif].a1x) or
 (y1<>listeondeplane[-1+indiceelementmodif].a1y)))
 then begin
retaillePondeplane(listeondeplane,nombreondeplane,nombreondeplane+1);
if listeondeplane[-1+nombreondeplane+1].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
listeondeplane[-1+indiceelementmodif].sx,
listeondeplane[-1+indiceelementmodif].sy,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,x1,y1,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment) then
 listeondeplane[-1+indiceelementmodif].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
listeondeplane[-1+indiceelementmodif].sx,
listeondeplane[-1+indiceelementmodif].sy,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,x1,y1,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment)

else
listeondeplane[-1+indiceelementmodif].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
listeondeplane[-1+indiceelementmodif].sx,
listeondeplane[-1+indiceelementmodif].sy,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,
 listeondeplane[-1+indiceelementmodif].a2x,
listeondeplane[-1+indiceelementmodif].a2y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment);
retaillePondeplane(listeondeplane,nombreondeplane+1,nombreondeplane);
Rafraichit;
end;
 end; {du cas ondeplane}

 mddiaphragme: begin
  if (( (tprot=tpa1) or (tprot=tpap1)) and ((x1<>listediaphragme[-1+indiceelementmodif].cx) or
 (y1<>listediaphragme[-1+indiceelementmodif].cy)))
 then begin
retaillePdiaphragme(listediaphragme,nombrediaphragme,nombrediaphragme+1);
if listediaphragme[-1+nombrediaphragme+1].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
listediaphragme[-1+indiceelementmodif].anglepolaire,
sqrt(sqr(x1-listediaphragme[-1+indiceelementmodif].cx)+sqr(y1-listediaphragme[-1+indiceelementmodif].cy)),
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur) then
 listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
listediaphragme[-1+indiceelementmodif].anglepolaire,
sqrt(sqr(x1-listediaphragme[-1+indiceelementmodif].cx)+sqr(y1-listediaphragme[-1+indiceelementmodif].cy)),
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur)
else
listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
listediaphragme[-1+indiceelementmodif].anglepolaire,
listediaphragme[-1+indiceelementmodif].rint,
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur);
retaillePdiaphragme(listediaphragme,nombrediaphragme+1,nombrediaphragme);
Rafraichit;
end;


   if ((tprot=tpa2) and ((x1<>listediaphragme[-1+indiceelementmodif].cx) or
 (y1<>listediaphragme[-1+indiceelementmodif].cy)))
 then begin
retaillePdiaphragme(listediaphragme,nombrediaphragme,nombrediaphragme+1);
if listediaphragme[-1+nombrediaphragme+1].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
donneanglepolairedanspipi(x1-listediaphragme[-1+indiceelementmodif].ap2x,y1-listediaphragme[-1+indiceelementmodif].ap2y),
listediaphragme[-1+indiceelementmodif].rint,
sqrt(sqr(x1-listediaphragme[-1+indiceelementmodif].ap2x)+sqr(y1-listediaphragme[-1+indiceelementmodif].ap2y))/2,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur) then
 listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
donneanglepolairedanspipi(x1-listediaphragme[-1+indiceelementmodif].ap2x,y1-listediaphragme[-1+indiceelementmodif].ap2y),
listediaphragme[-1+indiceelementmodif].rint,
sqrt(sqr(x1-listediaphragme[-1+indiceelementmodif].ap2x)+sqr(y1-listediaphragme[-1+indiceelementmodif].ap2y))/2,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur)
else
listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
listediaphragme[-1+indiceelementmodif].anglepolaire,
listediaphragme[-1+indiceelementmodif].rint,
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur);
retaillePdiaphragme(listediaphragme,nombrediaphragme+1,nombrediaphragme);
Rafraichit;
end;


  if ((tprot=tpap2) and ((x1<>listediaphragme[-1+indiceelementmodif].cx) or
 (y1<>listediaphragme[-1+indiceelementmodif].cy)))
 then begin
retaillePdiaphragme(listediaphragme,nombrediaphragme,nombrediaphragme+1);
if listediaphragme[-1+nombrediaphragme+1].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
donneanglepolairedanspipi(-x1+listediaphragme[-1+indiceelementmodif].a2x,-y1+listediaphragme[-1+indiceelementmodif].a2y),
listediaphragme[-1+indiceelementmodif].rint,
sqrt(sqr(x1-listediaphragme[-1+indiceelementmodif].a2x)+sqr(y1-listediaphragme[-1+indiceelementmodif].a2y))/2,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur) then
 listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
donneanglepolairedanspipi(-x1+listediaphragme[-1+indiceelementmodif].a2x,-y1+listediaphragme[-1+indiceelementmodif].a2y),
listediaphragme[-1+indiceelementmodif].rint,
sqrt(sqr(x1-listediaphragme[-1+indiceelementmodif].a2x)+sqr(y1-listediaphragme[-1+indiceelementmodif].a2y))/2,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur)
else
listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
listediaphragme[-1+indiceelementmodif].anglepolaire,
listediaphragme[-1+indiceelementmodif].rint,
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur);
retaillePdiaphragme(listediaphragme,nombrediaphragme+1,nombrediaphragme);
Rafraichit;
end;
      end;

 mdmscopa: begin
 if ((tprot=tpa1) and ((x1<>listemscopa[-1+indiceelementmodif].a2x) or
 (y1<>listemscopa[-1+indiceelementmodif].a2y)))
 then begin
retaillePmscopa(listemscopa,nombremscopa,nombremscopa+1);
if listemscopa[-1+nombremscopa+1].create2(
x1,y1,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou) then
 listemscopa[-1+indiceelementmodif].create2(x1,y1,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou)
else
listemscopa[-1+indiceelementmodif].create2(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou);
retaillePmscopa(listemscopa,nombremscopa+1,nombremscopa);
Rafraichit;
end;
if ((tprot=tpa2) and ((x1<>listemscopa[-1+indiceelementmodif].a1x) or
 (y1<>listemscopa[-1+indiceelementmodif].a1y)))
 then begin
retaillePmscopa(listemscopa,nombremscopa,nombremscopa+1);
if listemscopa[-1+nombremscopa+1].create2(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,x1,y1,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou) then
 listemscopa[-1+indiceelementmodif].create2(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,x1,y1,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou)
else
listemscopa[-1+indiceelementmodif].create2(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou);
retaillePmscopa(listemscopa,nombremscopa+1,nombremscopa);
Rafraichit;
 end;

 if ((tprot=tpfo) and ((x1<>listemscopa[-1+indiceelementmodif].sx) or
 (y1<>listemscopa[-1+indiceelementmodif].sy)))
 then begin
 lambda:=((x1-listemscopa[-1+indiceelementmodif].sx)*(listemscopa[-1+indiceelementmodif].cx-
 listemscopa[-1+indiceelementmodif].sx)+(y1-listemscopa[-1+indiceelementmodif].sy)*
 (listemscopa[-1+indiceelementmodif].cy-listemscopa[-1+indiceelementmodif].sy))/
 (sqr(listemscopa[-1+indiceelementmodif].cx-listemscopa[-1+indiceelementmodif].sx)+
 sqr(listemscopa[-1+indiceelementmodif].cy-listemscopa[-1+indiceelementmodif].sy));
 if lambda<0 then lambda:=0.1;
 xx1:=listemscopa[-1+indiceelementmodif].sx+lambda*(listemscopa[-1+indiceelementmodif].cx-
 listemscopa[-1+indiceelementmodif].sx);
 yy1:=listemscopa[-1+indiceelementmodif].sy+lambda*(listemscopa[-1+indiceelementmodif].cy-
 listemscopa[-1+indiceelementmodif].sy);
retaillePmscopa(listemscopa,nombremscopa,nombremscopa+1);
if listemscopa[-1+nombremscopa+1].create(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou) then
 listemscopa[-1+indiceelementmodif].create(
 listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou)
else
listemscopa[-1+indiceelementmodif].create2(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou);
retaillePmscopa(listemscopa,nombremscopa+1,nombremscopa);
Rafraichit;
end;
 end; {du cas mscopa}


 mdmscore: begin
 if ((tprot=tpa1) and ((x1<>listemscore[-1+indiceelementmodif].a2x) or
 (y1<>listemscore[-1+indiceelementmodif].a2y)))
 then begin

retaillePmscore(listemscore,nombremscore,nombremscore+1);
if listemscore[-1+nombremscore+1].create2(x1,y1,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
listemscore[-1+indiceelementmodif].trou,
listemscore[-1+indiceelementmodif].diametretrou) then
 listemscore[-1+indiceelementmodif].create2(x1,y1,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
listemscore[-1+indiceelementmodif].trou,
listemscore[-1+indiceelementmodif].diametretrou)
else
listemscore[-1+indiceelementmodif].create2(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
listemscore[-1+indiceelementmodif].trou,
listemscore[-1+indiceelementmodif].diametretrou);
retaillePmscore(listemscore,nombremscore+1,nombremscore);
Rafraichit;
end;
if ((tprot=tpa2) and ((x1<>listemscore[-1+indiceelementmodif].a1x) or
 (y1<>listemscore[-1+indiceelementmodif].a1y)))
 then begin
retaillePmscore(listemscore,nombremscore,nombremscore+1);
if listemscore[-1+nombremscore+1].create2(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,x1,y1,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
listemscore[-1+indiceelementmodif].trou,
listemscore[-1+indiceelementmodif].diametretrou) then
 listemscore[-1+indiceelementmodif].create2(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,x1,y1,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
listemscore[-1+indiceelementmodif].trou,
listemscore[-1+indiceelementmodif].diametretrou)
else
listemscore[-1+indiceelementmodif].create2(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
listemscore[-1+indiceelementmodif].trou,
listemscore[-1+indiceelementmodif].diametretrou);
retaillePmscore(listemscore,nombremscore+1,nombremscore);
Rafraichit;
 end;


 if ((tprot=tpce) and ((x1<>listemscore[-1+indiceelementmodif].sx) or
 (y1<>listemscore[-1+indiceelementmodif].sy)))
 then begin
 lambda:=((x1-listemscore[-1+indiceelementmodif].sx)*(listemscore[-1+indiceelementmodif].cx-
 listemscore[-1+indiceelementmodif].sx)+(y1-listemscore[-1+indiceelementmodif].sy)*
 (listemscore[-1+indiceelementmodif].cy-listemscore[-1+indiceelementmodif].sy))/
 (sqr(listemscore[-1+indiceelementmodif].cx-listemscore[-1+indiceelementmodif].sx)+
 sqr(listemscore[-1+indiceelementmodif].cy-listemscore[-1+indiceelementmodif].sy));
 if lambda<0 then lambda:=0.1;
 xx1:=listemscore[-1+indiceelementmodif].sx+lambda*(listemscore[-1+indiceelementmodif].cx-
 listemscore[-1+indiceelementmodif].sx);
 yy1:=listemscore[-1+indiceelementmodif].sy+lambda*(listemscore[-1+indiceelementmodif].cy-
 listemscore[-1+indiceelementmodif].sy);
retaillePmscore(listemscore,nombremscore,nombremscore+1);
if listemscore[-1+nombremscore+1].create(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].trou,
listemscore[-1+indiceelementmodif].diametretrou) then
 listemscore[-1+indiceelementmodif].create(
 listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].trou,
listemscore[-1+indiceelementmodif].diametretrou)
else
listemscore[-1+indiceelementmodif].create2(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
listemscore[-1+indiceelementmodif].trou,
listemscore[-1+indiceelementmodif].diametretrou);
retaillePmscore(listemscore,nombremscore+1,nombremscore);
Rafraichit;
end;
 end; {du cas mscore}




 mdmiroirconique: begin
 if ((tprot=tpa2) and ((x1<>listemiroirconique[-1+indiceelementmodif].a1x) or
 (y1<>listemiroirconique[-1+indiceelementmodif].a1y)))
 then begin

retaillePmiroirconique(listemiroirconique,nombremiroirconique,nombremiroirconique+1);
dtheta:=donneanglepolairedans02pi(x1-listemiroirconique[-1+indiceelementmodif].a1x,
y1-listemiroirconique[-1+indiceelementmodif].a1y)-
donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].a2x-listemiroirconique[-1+indiceelementmodif].a1x,
listemiroirconique[-1+indiceelementmodif].a2y-listemiroirconique[-1+indiceelementmodif].a1y);
if listemiroirconique[-1+nombremiroirconique+1].create2(
listemiroirconique[-1+indiceelementmodif].a1x+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a1x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a1y))*
cos(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a1x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a1y)+dtheta),

listemiroirconique[-1+indiceelementmodif].a1y+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a1x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a1y))*
sin(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a1x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a1y)+dtheta),

listemiroirconique[-1+indiceelementmodif].theta0+dtheta,
listemiroirconique[-1+indiceelementmodif].theta1+dtheta,
listemiroirconique[-1+indiceelementmodif].theta2+dtheta,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal) then
 listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].a1x+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a1x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a1y))*
cos(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a1x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a1y)+dtheta),

listemiroirconique[-1+indiceelementmodif].a1y+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a1x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a1y))*
sin(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a1x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a1y)+dtheta),

listemiroirconique[-1+indiceelementmodif].theta0+dtheta,
listemiroirconique[-1+indiceelementmodif].theta1+dtheta,
listemiroirconique[-1+indiceelementmodif].theta2+dtheta,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal)
else
listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].fx,
listemiroirconique[-1+indiceelementmodif].fy,
listemiroirconique[-1+indiceelementmodif].theta0,
listemiroirconique[-1+indiceelementmodif].theta1,
listemiroirconique[-1+indiceelementmodif].theta2,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal);
retaillePmiroirconique(listemiroirconique,nombremiroirconique+1,nombremiroirconique);
Rafraichit;
end;


 if ((tprot=tpa1) and ((x1<>listemiroirconique[-1+indiceelementmodif].a2x) or
 (y1<>listemiroirconique[-1+indiceelementmodif].a2y)))
 then begin

retaillePmiroirconique(listemiroirconique,nombremiroirconique,nombremiroirconique+1);
dtheta:=donneanglepolairedans02pi(x1-listemiroirconique[-1+indiceelementmodif].a2x,
y1-listemiroirconique[-1+indiceelementmodif].a2y)-
donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].a1x-listemiroirconique[-1+indiceelementmodif].a2x,
listemiroirconique[-1+indiceelementmodif].a1y-listemiroirconique[-1+indiceelementmodif].a2y);
if listemiroirconique[-1+nombremiroirconique+1].create2(
listemiroirconique[-1+indiceelementmodif].a2x+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a2x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a2y))*
cos(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a2x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a2y)+dtheta),

listemiroirconique[-1+indiceelementmodif].a2y+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a2x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a2y))*
sin(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a2x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a2y)+dtheta),

listemiroirconique[-1+indiceelementmodif].theta0+dtheta,
listemiroirconique[-1+indiceelementmodif].theta1+dtheta,
listemiroirconique[-1+indiceelementmodif].theta2+dtheta,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal) then
 listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].a2x+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a2x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a2y))*
cos(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a2x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a2y)+dtheta),

listemiroirconique[-1+indiceelementmodif].a2y+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a2x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a2y))*
sin(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a2x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a2y)+dtheta),

listemiroirconique[-1+indiceelementmodif].theta0+dtheta,
listemiroirconique[-1+indiceelementmodif].theta1+dtheta,
listemiroirconique[-1+indiceelementmodif].theta2+dtheta,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal)
else
listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].fx,
listemiroirconique[-1+indiceelementmodif].fy,
listemiroirconique[-1+indiceelementmodif].theta0,
listemiroirconique[-1+indiceelementmodif].theta1,
listemiroirconique[-1+indiceelementmodif].theta2,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal);
retaillePmiroirconique(listemiroirconique,nombremiroirconique+1,nombremiroirconique);
Rafraichit;
end;

 if ((tprot=tpfo) and ((x1<>listemiroirconique[-1+indiceelementmodif].sx) or
 (y1<>listemiroirconique[-1+indiceelementmodif].sy)))
 then begin
 lambda:=((x1-listemiroirconique[-1+indiceelementmodif].sx)*(listemiroirconique[-1+indiceelementmodif].fx-
 listemiroirconique[-1+indiceelementmodif].sx)+(y1-listemiroirconique[-1+indiceelementmodif].sy)*
 (listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].sy))/
 (sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].sx)+
 sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].sy));
 if lambda<0 then lambda:=0.1;
 xx1:=listemiroirconique[-1+indiceelementmodif].sx+lambda*(listemiroirconique[-1+indiceelementmodif].fx-
 listemiroirconique[-1+indiceelementmodif].sx);
 yy1:=listemiroirconique[-1+indiceelementmodif].sy+lambda*(listemiroirconique[-1+indiceelementmodif].fy-
 listemiroirconique[-1+indiceelementmodif].sy);
retaillePmiroirconique(listemiroirconique,nombremiroirconique,nombremiroirconique+1);
if listemiroirconique[-1+nombremiroirconique+1].create(
xx1,yy1,
listemiroirconique[-1+indiceelementmodif].sx,
listemiroirconique[-1+indiceelementmodif].sy,
listemiroirconique[-1+indiceelementmodif].a1x,
listemiroirconique[-1+indiceelementmodif].a1y,
listemiroirconique[-1+indiceelementmodif].a2x,
listemiroirconique[-1+indiceelementmodif].a2y,
listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal) then
 listemiroirconique[-1+indiceelementmodif].create(
xx1,yy1,
listemiroirconique[-1+indiceelementmodif].sx,
listemiroirconique[-1+indiceelementmodif].sy,
listemiroirconique[-1+indiceelementmodif].a1x,
listemiroirconique[-1+indiceelementmodif].a1y,
listemiroirconique[-1+indiceelementmodif].a2x,
listemiroirconique[-1+indiceelementmodif].a2y,
listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal)
else
listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].fx,
listemiroirconique[-1+indiceelementmodif].fy,
listemiroirconique[-1+indiceelementmodif].theta0,
listemiroirconique[-1+indiceelementmodif].theta1,
listemiroirconique[-1+indiceelementmodif].theta2,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal);
retaillePmiroirconique(listemiroirconique,nombremiroirconique+1,nombremiroirconique);
Rafraichit;
end;
 end; {du cas miroirconique}



 mdmscepa: begin
 if ((tprot=tpa1) and ((x1<>listemscepa[-1+indiceelementmodif].a2x) or
 (y1<>listemscepa[-1+indiceelementmodif].a2y)))
 then begin
retaillePmscepa(listemscepa,nombremscepa,nombremscepa+1);
if listemscepa[-1+nombremscepa+1].create2(
x1,y1,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou) then
 listemscepa[-1+indiceelementmodif].create2(x1,y1,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou)
else
listemscepa[-1+indiceelementmodif].create2(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou);
retaillePmscepa(listemscepa,nombremscepa+1,nombremscepa);
Rafraichit;
end;
if ((tprot=tpa2) and ((x1<>listemscepa[-1+indiceelementmodif].a1x) or
 (y1<>listemscepa[-1+indiceelementmodif].a1y)))
 then begin
retaillePmscepa(listemscepa,nombremscepa,nombremscepa+1);
if listemscepa[-1+nombremscepa+1].create2(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,x1,y1,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou) then
 listemscepa[-1+indiceelementmodif].create2(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,x1,y1,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou)
else
listemscepa[-1+indiceelementmodif].create2(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou);
retaillePmscepa(listemscepa,nombremscepa+1,nombremscepa);
Rafraichit;
 end;

  if ((tprot=tpfo) and ((x1<>listemscepa[-1+indiceelementmodif].sx) or
 (y1<>listemscepa[-1+indiceelementmodif].sy)))
 then begin
 lambda:=((x1-listemscepa[-1+indiceelementmodif].sx)*(listemscepa[-1+indiceelementmodif].cx-
 listemscepa[-1+indiceelementmodif].sx)+(y1-listemscepa[-1+indiceelementmodif].sy)*
 (listemscepa[-1+indiceelementmodif].cy-listemscepa[-1+indiceelementmodif].sy))/
 (sqr(listemscepa[-1+indiceelementmodif].cx-listemscepa[-1+indiceelementmodif].sx)+
 sqr(listemscepa[-1+indiceelementmodif].cy-listemscepa[-1+indiceelementmodif].sy));
 if lambda<0 then lambda:=0.1;
 xx1:=listemscepa[-1+indiceelementmodif].sx+lambda*(listemscepa[-1+indiceelementmodif].cx-
 listemscepa[-1+indiceelementmodif].sx);
 yy1:=listemscepa[-1+indiceelementmodif].sy+lambda*(listemscepa[-1+indiceelementmodif].cy-
 listemscepa[-1+indiceelementmodif].sy);
retaillePmscepa(listemscepa,nombremscepa,nombremscepa+1);
if listemscepa[-1+nombremscepa+1].create(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou) then
 listemscepa[-1+indiceelementmodif].create(
 listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou)
else
listemscepa[-1+indiceelementmodif].create2(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou);
retaillePmscepa(listemscepa,nombremscepa+1,nombremscepa);
Rafraichit;
end;
 end; {du cas mscepa}


  mdmscere: begin
 if ((tprot=tpa1) and ((x1<>listemscere[-1+indiceelementmodif].a2x) or
 (y1<>listemscere[-1+indiceelementmodif].a2y)))
 then begin
retaillePmscere(listemscere,nombremscere,nombremscere+1);
if listemscere[-1+nombremscere+1].create2(
x1,y1,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
listemscere[-1+indiceelementmodif].trou,
listemscere[-1+indiceelementmodif].diametretrou) then
 listemscere[-1+indiceelementmodif].create2(x1,y1,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
listemscere[-1+indiceelementmodif].trou,
listemscere[-1+indiceelementmodif].diametretrou)
else
listemscere[-1+indiceelementmodif].create2(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
listemscere[-1+indiceelementmodif].trou,
listemscere[-1+indiceelementmodif].diametretrou);
retaillePmscere(listemscere,nombremscere+1,nombremscere);
Rafraichit;
end;
if ((tprot=tpa2) and ((x1<>listemscere[-1+indiceelementmodif].a1x) or
 (y1<>listemscere[-1+indiceelementmodif].a1y)))
 then begin
retaillePmscere(listemscere,nombremscere,nombremscere+1);
if listemscere[-1+nombremscere+1].create2(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,x1,y1,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
listemscere[-1+indiceelementmodif].trou,
listemscere[-1+indiceelementmodif].diametretrou) then
 listemscere[-1+indiceelementmodif].create2(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,x1,y1,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
listemscere[-1+indiceelementmodif].trou,
listemscere[-1+indiceelementmodif].diametretrou)
else
listemscere[-1+indiceelementmodif].create2(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
listemscere[-1+indiceelementmodif].trou,
listemscere[-1+indiceelementmodif].diametretrou);
retaillePmscere(listemscere,nombremscere+1,nombremscere);
Rafraichit;
 end;



 if ((tprot=tpce) and ((x1<>listemscere[-1+indiceelementmodif].sx) or
 (y1<>listemscere[-1+indiceelementmodif].sy)))
 then begin
 lambda:=((x1-listemscere[-1+indiceelementmodif].sx)*(listemscere[-1+indiceelementmodif].cx-
 listemscere[-1+indiceelementmodif].sx)+(y1-listemscere[-1+indiceelementmodif].sy)*
 (listemscere[-1+indiceelementmodif].cy-listemscere[-1+indiceelementmodif].sy))/
 (sqr(listemscere[-1+indiceelementmodif].cx-listemscere[-1+indiceelementmodif].sx)+
 sqr(listemscere[-1+indiceelementmodif].cy-listemscere[-1+indiceelementmodif].sy));
 if lambda<0 then lambda:=0.1;
 xx1:=listemscere[-1+indiceelementmodif].sx+lambda*(listemscere[-1+indiceelementmodif].cx-
 listemscere[-1+indiceelementmodif].sx);
 yy1:=listemscere[-1+indiceelementmodif].sy+lambda*(listemscere[-1+indiceelementmodif].cy-
 listemscere[-1+indiceelementmodif].sy);
retaillePmscere(listemscere,nombremscere,nombremscere+1);
if listemscere[-1+nombremscere+1].create(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].trou,
listemscere[-1+indiceelementmodif].diametretrou) then
 listemscere[-1+indiceelementmodif].create(
 listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].trou,
listemscere[-1+indiceelementmodif].diametretrou)
else
listemscere[-1+indiceelementmodif].create2(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
listemscere[-1+indiceelementmodif].trou,
listemscere[-1+indiceelementmodif].diametretrou);
retaillePmscere(listemscere,nombremscere+1,nombremscere);
Rafraichit;
end;
 end; {du cas mscere}



 mdlmc: begin
 if ((tprot=tpa1) and ((x1<>listelmc[-1+indiceelementmodif].a2x) or
 (y1<>listelmc[-1+indiceelementmodif].a2y))) then begin
retaillePlmc(listelmc,nombrelmc,nombrelmc+1);
if listelmc[-1+nombrelmc+1].create2(x1,y1,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal) then
 listelmc[-1+indiceelementmodif].create2(x1,y1,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal)
else
listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal);
retaillePlmc(listelmc,nombrelmc+1,nombrelmc);
Rafraichit;
end;

 if ((tprot=tpa2) and ((x1<>listelmc[-1+indiceelementmodif].a1x) or
 (y1<>listelmc[-1+indiceelementmodif].a1y))) then begin
retaillePlmc(listelmc,nombrelmc,nombrelmc+1);
if listelmc[-1+nombrelmc+1].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,x1,y1,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal) then
 listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,x1,y1,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal)
else
listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal);
retaillePlmc(listelmc,nombrelmc+1,nombrelmc);
Rafraichit;
end;

 if ((tprot=tpf1) and ((x1<>listelmc[-1+indiceelementmodif].ox) or
 (y1<>listelmc[-1+indiceelementmodif].oy))) then begin
lambda:=((x1-listelmc[-1+indiceelementmodif].ox)*(listelmc[-1+indiceelementmodif].f1x-
 listelmc[-1+indiceelementmodif].ox)+(y1-listelmc[-1+indiceelementmodif].oy)*
 (listelmc[-1+indiceelementmodif].f1y-listelmc[-1+indiceelementmodif].oy))/
 (sqr(listelmc[-1+indiceelementmodif].f1x-listelmc[-1+indiceelementmodif].ox)+
 sqr(listelmc[-1+indiceelementmodif].f1y-listelmc[-1+indiceelementmodif].oy));
 xx1:=listelmc[-1+indiceelementmodif].ox+lambda*(listelmc[-1+indiceelementmodif].f1x-
 listelmc[-1+indiceelementmodif].ox);
 yy1:=listelmc[-1+indiceelementmodif].oy+lambda*(listelmc[-1+indiceelementmodif].f1y-
 listelmc[-1+indiceelementmodif].oy);
 retaillePlmc(listelmc,nombrelmc,nombrelmc+1);
if listelmc[-1+nombrelmc+1].create(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal) then
 listelmc[-1+indiceelementmodif].create(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal)
else
listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal);
retaillePlmc(listelmc,nombrelmc+1,nombrelmc);
Rafraichit;
 end;


 if ((tprot=tpf2) and ((x1<>listelmc[-1+indiceelementmodif].ox) or
 (y1<>listelmc[-1+indiceelementmodif].oy))) then begin
lambda:=((x1-listelmc[-1+indiceelementmodif].ox)*(listelmc[-1+indiceelementmodif].f2x-
 listelmc[-1+indiceelementmodif].ox)+(y1-listelmc[-1+indiceelementmodif].oy)*
 (listelmc[-1+indiceelementmodif].f2y-listelmc[-1+indiceelementmodif].oy))/
 (sqr(listelmc[-1+indiceelementmodif].f2x-listelmc[-1+indiceelementmodif].ox)+
 sqr(listelmc[-1+indiceelementmodif].f2y-listelmc[-1+indiceelementmodif].oy));
 xx1:=listelmc[-1+indiceelementmodif].ox+lambda*(listelmc[-1+indiceelementmodif].f2x-
 listelmc[-1+indiceelementmodif].ox);
 yy1:=listelmc[-1+indiceelementmodif].oy+lambda*(listelmc[-1+indiceelementmodif].f2y-
 listelmc[-1+indiceelementmodif].oy);
 retaillePlmc(listelmc,nombrelmc,nombrelmc+1);
if listelmc[-1+nombrelmc+1].create(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal) then
 listelmc[-1+indiceelementmodif].create(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal)
else
listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal);
retaillePlmc(listelmc,nombrelmc+1,nombrelmc);
Rafraichit;
 end;
 end; {du cas lmc}

{cas lec}
mdlec: begin
 if ((tprot=tpa1) and ((x1<>listelec[-1+indiceelementmodif].s2x) or
 (y1<>listelec[-1+indiceelementmodif].s2y))) then begin
retaillePlec(listelec,nombrelec,nombrelec+1);
if listelec[-1+nombrelec+1].create(x1,y1,
listelec[-1+indiceelementmodif].s2x,
listelec[-1+indiceelementmodif].s2y,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant) then
 listelec[-1+indiceelementmodif].create(x1,y1,
listelec[-1+indiceelementmodif].s2x,
listelec[-1+indiceelementmodif].s2y,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant)
else
listelec[-1+indiceelementmodif].create(
listelec[-1+indiceelementmodif].s1x,
listelec[-1+indiceelementmodif].s1y,
listelec[-1+indiceelementmodif].s2x,
listelec[-1+indiceelementmodif].s2y,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant);
retaillePlec(listelec,nombrelec+1,nombrelec);
Rafraichit;
end;

 if ((tprot=tpa2) and ((x1<>listelec[-1+indiceelementmodif].s1x) or
 (y1<>listelec[-1+indiceelementmodif].s1y))) then begin
retaillePlec(listelec,nombrelec,nombrelec+1);
if listelec[-1+nombrelec+1].create(
listelec[-1+indiceelementmodif].s1x,
listelec[-1+indiceelementmodif].s1y,
x1,y1,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant) then
 listelec[-1+indiceelementmodif].create(
listelec[-1+indiceelementmodif].s1x,
listelec[-1+indiceelementmodif].s1y,
x1,y1,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant)
else
listelec[-1+indiceelementmodif].create(
listelec[-1+indiceelementmodif].s1x,
listelec[-1+indiceelementmodif].s1y,
listelec[-1+indiceelementmodif].s2x,
listelec[-1+indiceelementmodif].s2y,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant);
retaillePlec(listelec,nombrelec+1,nombrelec);
Rafraichit;
end;    end;
{fin cas lec}


 mdlmd: begin
 if ((tprot=tpa1) and ((x1<>listelmd[-1+indiceelementmodif].a2x) or
 (y1<>listelmd[-1+indiceelementmodif].a2y))) then begin
retaillePlmd(listelmd,nombrelmd,nombrelmd+1);
if listelmd[-1+nombrelmd+1].create2(x1,y1,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal) then
 listelmd[-1+indiceelementmodif].create2(x1,y1,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal)
else
listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal);
retaillePlmd(listelmd,nombrelmd+1,nombrelmd);
Rafraichit;
end;

 if ((tprot=tpa2) and ((x1<>listelmd[-1+indiceelementmodif].a1x) or
 (y1<>listelmd[-1+indiceelementmodif].a1y))) then begin
retaillePlmd(listelmd,nombrelmd,nombrelmd+1);
if listelmd[-1+nombrelmd+1].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,x1,y1,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal) then
 listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,x1,y1,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal)
else
listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal);
retaillePlmd(listelmd,nombrelmd+1,nombrelmd);
Rafraichit;
end;


 if ((tprot=tpf1) and ((x1<>listelmd[-1+indiceelementmodif].ox) or
 (y1<>listelmd[-1+indiceelementmodif].oy))) then begin
lambda:=((x1-listelmd[-1+indiceelementmodif].ox)*(listelmd[-1+indiceelementmodif].f1x-
 listelmd[-1+indiceelementmodif].ox)+(y1-listelmd[-1+indiceelementmodif].oy)*
 (listelmd[-1+indiceelementmodif].f1y-listelmd[-1+indiceelementmodif].oy))/
 (sqr(listelmd[-1+indiceelementmodif].f1x-listelmd[-1+indiceelementmodif].ox)+
 sqr(listelmd[-1+indiceelementmodif].f1y-listelmd[-1+indiceelementmodif].oy));
 xx1:=listelmd[-1+indiceelementmodif].ox+lambda*(listelmd[-1+indiceelementmodif].f1x-
 listelmd[-1+indiceelementmodif].ox);
 yy1:=listelmd[-1+indiceelementmodif].oy+lambda*(listelmd[-1+indiceelementmodif].f1y-
 listelmd[-1+indiceelementmodif].oy);
 retaillePlmd(listelmd,nombrelmd,nombrelmd+1);
if listelmd[-1+nombrelmd+1].create(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal) then
 listelmd[-1+indiceelementmodif].create(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal)
else
listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal);
retaillePlmd(listelmd,nombrelmd+1,nombrelmd);
Rafraichit;
 end;


 if ((tprot=tpf2) and ((x1<>listelmd[-1+indiceelementmodif].ox) or
 (y1<>listelmd[-1+indiceelementmodif].oy))) then begin
lambda:=((x1-listelmd[-1+indiceelementmodif].ox)*(listelmd[-1+indiceelementmodif].f2x-
 listelmd[-1+indiceelementmodif].ox)+(y1-listelmd[-1+indiceelementmodif].oy)*
 (listelmd[-1+indiceelementmodif].f2y-listelmd[-1+indiceelementmodif].oy))/
 (sqr(listelmd[-1+indiceelementmodif].f2x-listelmd[-1+indiceelementmodif].ox)+
 sqr(listelmd[-1+indiceelementmodif].f2y-listelmd[-1+indiceelementmodif].oy));
 xx1:=listelmd[-1+indiceelementmodif].ox+lambda*(listelmd[-1+indiceelementmodif].f2x-
 listelmd[-1+indiceelementmodif].ox);
 yy1:=listelmd[-1+indiceelementmodif].oy+lambda*(listelmd[-1+indiceelementmodif].f2y-
 listelmd[-1+indiceelementmodif].oy);
 retaillePlmd(listelmd,nombrelmd,nombrelmd+1);
if listelmd[-1+nombrelmd+1].create(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal) then
 listelmd[-1+indiceelementmodif].create(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal)
else
listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal);
retaillePlmd(listelmd,nombrelmd+1,nombrelmd);
Rafraichit;
 end;
 end; {du cas lmd}



end; {du case}
end;   {du moderotation}



if modetranslation then begin
case typeelementmodif of


mdprisme: begin
retaillePprisme(listeprisme,nombreprisme,nombreprisme+1);
if listeprisme[-1+nombreprisme+1].create(
x1,y1,listeprisme[-1+indiceelementmodif].ax+x1-listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].ay+y1-listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].bx+x1-listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].by+y1-listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant) then
 listeprisme[-1+indiceelementmodif].create(
x1,y1,listeprisme[-1+indiceelementmodif].ax+x1-listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].ay+y1-listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].bx+x1-listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].by+y1-listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant)
else
listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].ax,
listeprisme[-1+indiceelementmodif].ay,
listeprisme[-1+indiceelementmodif].bx,
listeprisme[-1+indiceelementmodif].by,
listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant);
retaillePprisme(listeprisme,nombreprisme+1,nombreprisme);
Rafraichit;
end;


mdoeil: begin
retaillePoeil(listeoeil,nombreoeil,nombreoeil+1);
if listeoeil[-1+nombreoeil+1].create(
x1,y1,listeoeil[-1+indiceelementmodif].ax+x1-listeoeil[-1+indiceelementmodif].cx,
listeoeil[-1+indiceelementmodif].ay+y1-listeoeil[-1+indiceelementmodif].cy,
listeoeil[-1+indiceelementmodif].epaisseur,
listeoeil[-1+indiceelementmodif].couleur) then
 listeoeil[-1+indiceelementmodif].create(
x1,y1,listeoeil[-1+indiceelementmodif].ax+x1-listeoeil[-1+indiceelementmodif].cx,
listeoeil[-1+indiceelementmodif].ay+y1-listeoeil[-1+indiceelementmodif].cy,
listeoeil[-1+indiceelementmodif].epaisseur,
listeoeil[-1+indiceelementmodif].couleur)
else
listeoeil[-1+indiceelementmodif].create(
listeoeil[-1+indiceelementmodif].cx,
listeoeil[-1+indiceelementmodif].cy,
listeoeil[-1+indiceelementmodif].ax,
listeoeil[-1+indiceelementmodif].ay,
listeoeil[-1+indiceelementmodif].epaisseur,
listeoeil[-1+indiceelementmodif].couleur);
retaillePoeil(listeoeil,nombreoeil+1,nombreoeil);
Rafraichit;
end;

mdangle: begin
retaillePangle(listeangle,nombreangle,nombreangle+1);
if listeangle[-1+nombreangle+1].create(
    listeangle[-1+indiceelementmodif].cx+x1-listeangle[-1+indiceelementmodif].dx,
listeangle[-1+indiceelementmodif].cy+y1-listeangle[-1+indiceelementmodif].dy,
 listeangle[-1+indiceelementmodif].a1x+x1-listeangle[-1+indiceelementmodif].dx,
listeangle[-1+indiceelementmodif].a1y+y1-listeangle[-1+indiceelementmodif].dy,
 listeangle[-1+indiceelementmodif].a2x+x1-listeangle[-1+indiceelementmodif].dx,
listeangle[-1+indiceelementmodif].a2y+y1-listeangle[-1+indiceelementmodif].dy) then
 listeangle[-1+indiceelementmodif].create(
    listeangle[-1+indiceelementmodif].cx+x1-listeangle[-1+indiceelementmodif].dx,
listeangle[-1+indiceelementmodif].cy+y1-listeangle[-1+indiceelementmodif].dy,
 listeangle[-1+indiceelementmodif].a1x+x1-listeangle[-1+indiceelementmodif].dx,
listeangle[-1+indiceelementmodif].a1y+y1-listeangle[-1+indiceelementmodif].dy,
 listeangle[-1+indiceelementmodif].a2x+x1-listeangle[-1+indiceelementmodif].dx,
listeangle[-1+indiceelementmodif].a2y+y1-listeangle[-1+indiceelementmodif].dy)
else
listeangle[-1+indiceelementmodif].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y);
retaillePangle(listeangle,nombreangle+1,nombreangle);
Rafraichit;
end;

mdmetre: begin
retaillePmetre(listemetre,nombremetre,nombremetre+1);
if listemetre[-1+nombremetre+1].create(
    listemetre[-1+indiceelementmodif].a1x+x1-(listemetre[-1+indiceelementmodif].a1x+
    listemetre[-1+indiceelementmodif].a2x)/2,
listemetre[-1+indiceelementmodif].a1y+y1-(listemetre[-1+indiceelementmodif].a1y+
    listemetre[-1+indiceelementmodif].a2y)/2,
 listemetre[-1+indiceelementmodif].a2x+x1-(listemetre[-1+indiceelementmodif].a1x+
    listemetre[-1+indiceelementmodif].a2x)/2,
listemetre[-1+indiceelementmodif].a2y+y1-(listemetre[-1+indiceelementmodif].a1y+
    listemetre[-1+indiceelementmodif].a2y)/2) then
 listemetre[-1+indiceelementmodif].create(
    listemetre[-1+indiceelementmodif].a1x+x1-(listemetre[-1+indiceelementmodif].a1x+
    listemetre[-1+indiceelementmodif].a2x)/2,
listemetre[-1+indiceelementmodif].a1y+y1-(listemetre[-1+indiceelementmodif].a1y+
    listemetre[-1+indiceelementmodif].a2y)/2,
 listemetre[-1+indiceelementmodif].a2x+x1-(listemetre[-1+indiceelementmodif].a1x+
    listemetre[-1+indiceelementmodif].a2x)/2,
listemetre[-1+indiceelementmodif].a2y+y1-(listemetre[-1+indiceelementmodif].a1y+
    listemetre[-1+indiceelementmodif].a2y)/2)
else
listemetre[-1+indiceelementmodif].create(
listemetre[-1+indiceelementmodif].a1x,
listemetre[-1+indiceelementmodif].a1y,
listemetre[-1+indiceelementmodif].a2x,
listemetre[-1+indiceelementmodif].a2y);
retaillePmetre(listemetre,nombremetre+1,nombremetre);
Rafraichit;
end;


mdfleche: begin
retaillePfleche(listefleche,nombrefleche,nombrefleche+1);
if listefleche[-1+nombrefleche+1].create(
    listefleche[-1+indiceelementmodif].a1x+x1-listefleche[-1+indiceelementmodif].cx,
listefleche[-1+indiceelementmodif].a1y+y1-listefleche[-1+indiceelementmodif].cy,
 listefleche[-1+indiceelementmodif].a2x+x1-listefleche[-1+indiceelementmodif].cx,
listefleche[-1+indiceelementmodif].a2y+y1-listefleche[-1+indiceelementmodif].cy,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2) then
 listefleche[-1+indiceelementmodif].create(
    listefleche[-1+indiceelementmodif].a1x+x1-listefleche[-1+indiceelementmodif].cx,
listefleche[-1+indiceelementmodif].a1y+y1-listefleche[-1+indiceelementmodif].cy,
 listefleche[-1+indiceelementmodif].a2x+x1-listefleche[-1+indiceelementmodif].cx,
listefleche[-1+indiceelementmodif].a2y+y1-listefleche[-1+indiceelementmodif].cy,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2)
else
listefleche[-1+indiceelementmodif].create(
listefleche[-1+indiceelementmodif].a1x,
listefleche[-1+indiceelementmodif].a1y,
listefleche[-1+indiceelementmodif].a2x,
listefleche[-1+indiceelementmodif].a2y,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2);
retaillePfleche(listefleche,nombrefleche+1,nombrefleche);
Rafraichit;
end;


mdsourceponctuelle: begin
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle,nombresourceponctuelle+1);
if listesourceponctuelle[-1+nombresourceponctuelle+1].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx+x1-listesourceponctuelle[-1+indiceelementmodif].gx,
listesourceponctuelle[-1+indiceelementmodif].sy+y1-listesourceponctuelle[-1+indiceelementmodif].gy,
 listesourceponctuelle[-1+indiceelementmodif].a1x+x1-listesourceponctuelle[-1+indiceelementmodif].gx,
listesourceponctuelle[-1+indiceelementmodif].a1y+y1-listesourceponctuelle[-1+indiceelementmodif].gy,
listesourceponctuelle[-1+indiceelementmodif].a2x+x1-listesourceponctuelle[-1+indiceelementmodif].gx,
listesourceponctuelle[-1+indiceelementmodif].a2y+y1-listesourceponctuelle[-1+indiceelementmodif].gy,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment) then
 listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx+x1-listesourceponctuelle[-1+indiceelementmodif].gx,
listesourceponctuelle[-1+indiceelementmodif].sy+y1-listesourceponctuelle[-1+indiceelementmodif].gy,
 listesourceponctuelle[-1+indiceelementmodif].a1x+x1-listesourceponctuelle[-1+indiceelementmodif].gx,
listesourceponctuelle[-1+indiceelementmodif].a1y+y1-listesourceponctuelle[-1+indiceelementmodif].gy,
listesourceponctuelle[-1+indiceelementmodif].a2x+x1-listesourceponctuelle[-1+indiceelementmodif].gx,
listesourceponctuelle[-1+indiceelementmodif].a2y+y1-listesourceponctuelle[-1+indiceelementmodif].gy,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment)

else
listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,
 listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment);
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle+1,nombresourceponctuelle);
Rafraichit;
end;



mdtexteaffiche: begin
if ((x1<>listetexteaffiche[-1+indiceelementmodif].x) or
(y1<>listetexteaffiche[-1+indiceelementmodif].y)) then begin
retailleptexteaffiche(listetexteaffiche,nombretexte,nombretexte+1);

 if listetexteaffiche[-1+nombretexte+1].create(listetexteaffiche[-1+indiceelementmodif].texteluimeme,
 listetexteaffiche[-1+indiceelementmodif].policename,listetexteaffiche[-1+indiceelementmodif].
 policecharset,listetexteaffiche[-1+indiceelementmodif].policecolor,
 listetexteaffiche[-1+indiceelementmodif].policesize,
 listetexteaffiche[-1+indiceelementmodif].policepitch,
 listetexteaffiche[-1+indiceelementmodif].policefsbold,
 listetexteaffiche[-1+indiceelementmodif].policefsitalic,
 listetexteaffiche[-1+indiceelementmodif].policefsunderline,
 listetexteaffiche[-1+indiceelementmodif].policefsstrikeout,
 x1,y1) then
 listetexteaffiche[-1+indiceelementmodif].create(listetexteaffiche[-1+indiceelementmodif].texteluimeme,
 listetexteaffiche[-1+indiceelementmodif].policename,listetexteaffiche[-1+indiceelementmodif].
 policecharset,listetexteaffiche[-1+indiceelementmodif].policecolor,
 listetexteaffiche[-1+indiceelementmodif].policesize,
 listetexteaffiche[-1+indiceelementmodif].policepitch,
 listetexteaffiche[-1+indiceelementmodif].policefsbold,
 listetexteaffiche[-1+indiceelementmodif].policefsitalic,
 listetexteaffiche[-1+indiceelementmodif].policefsunderline,
 listetexteaffiche[-1+indiceelementmodif].policefsstrikeout,
 x1,y1) else
 listetexteaffiche[-1+indiceelementmodif].create(listetexteaffiche[-1+indiceelementmodif].texteluimeme,
 listetexteaffiche[-1+indiceelementmodif].policename,listetexteaffiche[-1+indiceelementmodif].
 policecharset,listetexteaffiche[-1+indiceelementmodif].policecolor,
 listetexteaffiche[-1+indiceelementmodif].policesize,
 listetexteaffiche[-1+indiceelementmodif].policepitch,
 listetexteaffiche[-1+indiceelementmodif].policefsbold,
 listetexteaffiche[-1+indiceelementmodif].policefsitalic,
 listetexteaffiche[-1+indiceelementmodif].policefsunderline,
 listetexteaffiche[-1+indiceelementmodif].policefsstrikeout,
 listetexteaffiche[-1+indiceelementmodif].x,
 listetexteaffiche[-1+indiceelementmodif].y);
 retailleptexteaffiche(listetexteaffiche,nombretexte+1,nombretexte);
 Rafraichit;
end;               end;


mdsphere: begin
if ((x1<>listesphere[-1+indiceelementmodif].cx) or (y1<>listesphere[-1+indiceelementmodif].cy)) then begin
retaillepsphere(listesphere,nombresphere,nombresphere+1);
if listesphere[-1+nombresphere+1].create(
x1,y1,
listesphere[-1+indiceelementmodif].rayon,
listesphere[-1+indiceelementmodif].indicerouge,
listesphere[-1+indiceelementmodif].indicebleu,
listesphere[-1+indiceelementmodif].indicevert,
listesphere[-1+indiceelementmodif].couleurbord,
listesphere[-1+indiceelementmodif].couleurfond,
listesphere[-1+indiceelementmodif].reflechientrant,
listesphere[-1+indiceelementmodif].reflechisortant) then
listesphere[-1+indiceelementmodif].create(x1,y1,
listesphere[-1+indiceelementmodif].rayon,
listesphere[-1+indiceelementmodif].indicerouge,
listesphere[-1+indiceelementmodif].indicebleu,
listesphere[-1+indiceelementmodif].indicevert,
listesphere[-1+indiceelementmodif].couleurbord,
listesphere[-1+indiceelementmodif].couleurfond,
listesphere[-1+indiceelementmodif].reflechientrant,
listesphere[-1+indiceelementmodif].reflechisortant)
 else
listesphere[-1+indiceelementmodif].create(
listesphere[-1+indiceelementmodif].cx,
listesphere[-1+indiceelementmodif].cy,
listesphere[-1+indiceelementmodif].rayon,
listesphere[-1+indiceelementmodif].indicerouge,
listesphere[-1+indiceelementmodif].indicebleu,
listesphere[-1+indiceelementmodif].indicevert,
listesphere[-1+indiceelementmodif].couleurbord,
listesphere[-1+indiceelementmodif].couleurfond,
listesphere[-1+indiceelementmodif].reflechientrant,
listesphere[-1+indiceelementmodif].reflechisortant);
 retaillepsphere(listesphere,nombresphere+1,nombresphere);
 Rafraichit;
 end;   end;


mdpolyhedre: if (  (x1<>listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace].ax) or
 (y1<>listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace].ay))
 then begin
retaillePpolyhedre(listepolyhedre,nombrepolyhedre,nombrepolyhedre+1);
for i:=1 to listepolyhedre[-1+indiceelementmodif].nombresommet do
begin
ttpoly[i].ax:=listepolyhedre[-1+indiceelementmodif].messommets[i].ax+x1-
(listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace].ax+
listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2;
ttpoly[i].ay:=listepolyhedre[-1+indiceelementmodif].messommets[i].ay+y1-
(listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace].ay+
listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2;
end;

if listepolyhedre[-1+nombrepolyhedre+1].create(
listepolyhedre[-1+indiceelementmodif].nombresommet,
ttpoly,
 listepolyhedre[-1+indiceelementmodif].indicerouge,
 listepolyhedre[-1+indiceelementmodif].indicebleu,
 listepolyhedre[-1+indiceelementmodif].indicevert,
listepolyhedre[-1+indiceelementmodif].couleurbord,
listepolyhedre[-1+indiceelementmodif].couleurfond,
listepolyhedre[-1+indiceelementmodif].reflechientrant,
listepolyhedre[-1+indiceelementmodif].reflechisortant) then
 listepolyhedre[-1+indiceelementmodif].create(
 listepolyhedre[-1+indiceelementmodif].nombresommet,
ttpoly,
 listepolyhedre[-1+indiceelementmodif].indicerouge,
 listepolyhedre[-1+indiceelementmodif].indicebleu,
 listepolyhedre[-1+indiceelementmodif].indicevert,
listepolyhedre[-1+indiceelementmodif].couleurbord,
listepolyhedre[-1+indiceelementmodif].couleurfond,
listepolyhedre[-1+indiceelementmodif].reflechientrant,
listepolyhedre[-1+indiceelementmodif].reflechisortant)
else
listepolyhedre[-1+indiceelementmodif].create(
listepolyhedre[-1+indiceelementmodif].nombresommet,
listepolyhedre[-1+indiceelementmodif].messommets,
 listepolyhedre[-1+indiceelementmodif].indicerouge,
 listepolyhedre[-1+indiceelementmodif].indicebleu,
 listepolyhedre[-1+indiceelementmodif].indicevert,
listepolyhedre[-1+indiceelementmodif].couleurbord,
listepolyhedre[-1+indiceelementmodif].couleurfond,
listepolyhedre[-1+indiceelementmodif].reflechientrant,
listepolyhedre[-1+indiceelementmodif].reflechisortant);
retaillePpolyhedre(listepolyhedre,nombrepolyhedre+1,nombrepolyhedre);
Rafraichit;
end;


mdpolycercle: if (  (x1<>listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax) or
 (y1<>listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay))
 then begin
retaillePpolycercle(listepolycercle,nombrepolycercle,nombrepolycercle+1);
for i:=1 to listepolycercle[-1+indiceelementmodif].nombresommet do
begin
ttpoly[i].ax:=listepolycercle[-1+indiceelementmodif].messommets[i].ax+x1-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2;
ttpoly[i].ay:=listepolycercle[-1+indiceelementmodif].messommets[i].ay+y1-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2;
ttsom[i].ax:=listepolycercle[-1+indiceelementmodif].mess[i].ax+x1-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2;
ttsom[i].ay:=listepolycercle[-1+indiceelementmodif].mess[i].ay+y1-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2;
end;

if listepolycercle[-1+nombrepolycercle+1].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
ttpoly,ttsom,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant) then
 listepolycercle[-1+indiceelementmodif].create(
 listepolycercle[-1+indiceelementmodif].nombresommet,
ttpoly,ttsom,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant)
else
listepolycercle[-1+indiceelementmodif].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
listepolycercle[-1+indiceelementmodif].messommets,
listepolycercle[-1+indiceelementmodif].mess,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant);
retaillePpolycercle(listepolycercle,nombrepolycercle+1,nombrepolycercle);
Rafraichit;
end;

mdmiroirplan: begin
retaillePMiroirplan(listemiroirplan,nombremiroirplan,nombremiroirplan+1);
if listemiroirplan[-1+nombremiroirplan+1].create(
listemiroirplan[-1+indiceelementmodif].a1x+x1-
listemiroirplan[-1+indiceelementmodif].cx,
listemiroirplan[-1+indiceelementmodif].a1y+y1-
listemiroirplan[-1+indiceelementmodif].cy,
listemiroirplan[-1+indiceelementmodif].a2x+x1-
listemiroirplan[-1+indiceelementmodif].cx,
listemiroirplan[-1+indiceelementmodif].a2y+y1-
listemiroirplan[-1+indiceelementmodif].cy,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures) then
 listemiroirplan[-1+indiceelementmodif].create(
listemiroirplan[-1+indiceelementmodif].a1x+x1-
listemiroirplan[-1+indiceelementmodif].cx,
listemiroirplan[-1+indiceelementmodif].a1y+y1-
listemiroirplan[-1+indiceelementmodif].cy,
listemiroirplan[-1+indiceelementmodif].a2x+x1-
listemiroirplan[-1+indiceelementmodif].cx,
listemiroirplan[-1+indiceelementmodif].a2y+y1-
listemiroirplan[-1+indiceelementmodif].cy,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures)
else
listemiroirplan[-1+indiceelementmodif].create(
listemiroirplan[-1+indiceelementmodif].a1x,
listemiroirplan[-1+indiceelementmodif].a1y,
listemiroirplan[-1+indiceelementmodif].a2x,
listemiroirplan[-1+indiceelementmodif].a2y,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures);
retaillePMiroirplan(listemiroirplan,nombremiroirplan+1,nombremiroirplan);
Rafraichit;
 end; {du cas miroir plan}


mdReseau: begin
retaillePReseau(listeReseau,nombreReseau,nombreReseau+1);
if listeReseau[-1+nombreReseau+1].create(
listeReseau[-1+indiceelementmodif].a1x+x1-
listeReseau[-1+indiceelementmodif].cx,
listeReseau[-1+indiceelementmodif].a1y+y1-
listeReseau[-1+indiceelementmodif].cy,
listeReseau[-1+indiceelementmodif].a2x+x1-
listeReseau[-1+indiceelementmodif].cx,
listeReseau[-1+indiceelementmodif].a2y+y1-
listeReseau[-1+indiceelementmodif].cy,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listereseau[-1+indiceelementmodif].entransmission,
listereseau[-1+indiceelementmodif].hachures,
listereseau[-1+indiceelementmodif].ordre_min,
listereseau[-1+indiceelementmodif].ordre_max) then
 listeReseau[-1+indiceelementmodif].create(
listeReseau[-1+indiceelementmodif].a1x+x1-
listeReseau[-1+indiceelementmodif].cx,
listeReseau[-1+indiceelementmodif].a1y+y1-
listeReseau[-1+indiceelementmodif].cy,
listeReseau[-1+indiceelementmodif].a2x+x1-
listeReseau[-1+indiceelementmodif].cx,
listeReseau[-1+indiceelementmodif].a2y+y1-
listeReseau[-1+indiceelementmodif].cy,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listereseau[-1+indiceelementmodif].entransmission,
listereseau[-1+indiceelementmodif].hachures,
listereseau[-1+indiceelementmodif].ordre_min,
listereseau[-1+indiceelementmodif].ordre_max)
else
listeReseau[-1+indiceelementmodif].create(
listeReseau[-1+indiceelementmodif].a1x,
listeReseau[-1+indiceelementmodif].a1y,
listeReseau[-1+indiceelementmodif].a2x,
listeReseau[-1+indiceelementmodif].a2y,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listereseau[-1+indiceelementmodif].entransmission,
listereseau[-1+indiceelementmodif].hachures,
listereseau[-1+indiceelementmodif].ordre_min,
listereseau[-1+indiceelementmodif].ordre_max);
retaillePReseau(listeReseau,nombreReseau+1,nombreReseau);
Rafraichit;
 end; {du cas reseau}



mdgroupe: begin
listegroupe[-1+indiceelementmodif].translate(x1-listegroupe[-1+indiceelementmodif].isox,
y1-listegroupe[-1+indiceelementmodif].isoy);
Rafraichit;
end;

mdecran: begin
retaillePecran(listeecran,nombreecran,nombreecran+1);
if listeecran[-1+nombreecran+1].create(
listeecran[-1+indiceelementmodif].a1x+x1-
listeecran[-1+indiceelementmodif].cx,
listeecran[-1+indiceelementmodif].a1y+y1-
listeecran[-1+indiceelementmodif].cy,
listeecran[-1+indiceelementmodif].a2x+x1-
listeecran[-1+indiceelementmodif].cx,
listeecran[-1+indiceelementmodif].a2y+y1-
listeecran[-1+indiceelementmodif].cy,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur) then
 listeecran[-1+indiceelementmodif].create(
listeecran[-1+indiceelementmodif].a1x+x1-
listeecran[-1+indiceelementmodif].cx,
listeecran[-1+indiceelementmodif].a1y+y1-
listeecran[-1+indiceelementmodif].cy,
listeecran[-1+indiceelementmodif].a2x+x1-
listeecran[-1+indiceelementmodif].cx,
listeecran[-1+indiceelementmodif].a2y+y1-
listeecran[-1+indiceelementmodif].cy,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur)
else
listeecran[-1+indiceelementmodif].create(
listeecran[-1+indiceelementmodif].a1x,
listeecran[-1+indiceelementmodif].a1y,
listeecran[-1+indiceelementmodif].a2x,
listeecran[-1+indiceelementmodif].a2y,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur);
retaillePecran(listeecran,nombreecran+1,nombreecran);
Rafraichit;
 end; {du cas ecran}




mddiaphragme: begin
retaillePdiaphragme(listediaphragme,nombrediaphragme,nombrediaphragme+1);
if listediaphragme[-1+nombrediaphragme+1].create2(x1,y1,
listediaphragme[-1+indiceelementmodif].anglepolaire,
listediaphragme[-1+indiceelementmodif].rint,
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur) then
 listediaphragme[-1+indiceelementmodif].create2(x1,y1,
listediaphragme[-1+indiceelementmodif].anglepolaire,
listediaphragme[-1+indiceelementmodif].rint,
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur)
else
listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
listediaphragme[-1+indiceelementmodif].anglepolaire,
listediaphragme[-1+indiceelementmodif].rint,
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur);
retaillePdiaphragme(listediaphragme,nombrediaphragme+1,nombrediaphragme);
Rafraichit;
 end; {du cas diaphragme}


mdlsr: begin
retaillePlsr(listelsr,nombrelsr,nombrelsr+1);
if listelsr[-1+nombrelsr+1].create(
listelsr[-1+indiceelementmodif].a1x+x1-
listelsr[-1+indiceelementmodif].cx,
listelsr[-1+indiceelementmodif].a1y+y1-
listelsr[-1+indiceelementmodif].cy,
listelsr[-1+indiceelementmodif].a2x+x1-
listelsr[-1+indiceelementmodif].cx,
listelsr[-1+indiceelementmodif].a2y+y1-
listelsr[-1+indiceelementmodif].cy,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur) then
 listelsr[-1+indiceelementmodif].create(
listelsr[-1+indiceelementmodif].a1x+x1-
listelsr[-1+indiceelementmodif].cx,
listelsr[-1+indiceelementmodif].a1y+y1-
listelsr[-1+indiceelementmodif].cy,
listelsr[-1+indiceelementmodif].a2x+x1-
listelsr[-1+indiceelementmodif].cx,
listelsr[-1+indiceelementmodif].a2y+y1-
listelsr[-1+indiceelementmodif].cy,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur)
else
listelsr[-1+indiceelementmodif].create(
listelsr[-1+indiceelementmodif].a1x,
listelsr[-1+indiceelementmodif].a1y,
listelsr[-1+indiceelementmodif].a2x,
listelsr[-1+indiceelementmodif].a2y,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur);
retaillePlsr(listelsr,nombrelsr+1,nombrelsr);
Rafraichit;
 end; {du cas lsr}


 mdrayon: begin
retaillePrayon(listerayon,nombrerayon,nombrerayon+1);
if listerayon[-1+nombrerayon+1].create(
listerayon[-1+indiceelementmodif].ax+x1-
listerayon[-1+indiceelementmodif].cx,
listerayon[-1+indiceelementmodif].ay+y1-
listerayon[-1+indiceelementmodif].cy,
listerayon[-1+indiceelementmodif].kx,
listerayon[-1+indiceelementmodif].ky,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment) then
 listerayon[-1+indiceelementmodif].create(
listerayon[-1+indiceelementmodif].ax+x1-
listerayon[-1+indiceelementmodif].cx,
listerayon[-1+indiceelementmodif].ay+y1-
listerayon[-1+indiceelementmodif].cy,
listerayon[-1+indiceelementmodif].kx,
listerayon[-1+indiceelementmodif].ky,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment)
else
listerayon[-1+indiceelementmodif].create(
listerayon[-1+indiceelementmodif].ax,
listerayon[-1+indiceelementmodif].ay,
listerayon[-1+indiceelementmodif].kx,
listerayon[-1+indiceelementmodif].ky,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment);
retaillePrayon(listerayon,nombrerayon+1,nombrerayon);
Rafraichit;
 end; {du cas rayon}



mdondeplane: begin
retaillePondeplane(listeondeplane,nombreondeplane,nombreondeplane+1);
if listeondeplane[-1+nombreondeplane+1].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
listeondeplane[-1+indiceelementmodif].sx+x1-
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].sy+y1-
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].a1x+x1-
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y+y1-
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].a2x+x1-
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a2y+y1-
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment) then
 listeondeplane[-1+indiceelementmodif].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
listeondeplane[-1+indiceelementmodif].sx+x1-
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].sy+y1-
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].a1x+x1-
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y+y1-
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].a2x+x1-
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a2y+y1-
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment)

else
listeondeplane[-1+indiceelementmodif].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
listeondeplane[-1+indiceelementmodif].sx,
listeondeplane[-1+indiceelementmodif].sy,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].a2x,
listeondeplane[-1+indiceelementmodif].a2y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment);
retaillePondeplane(listeondeplane,nombreondeplane+1,nombreondeplane);
Rafraichit;
 end; {du cas ondeplane}


 mdmscopa: begin
retaillePmscopa(listemscopa,nombremscopa,nombremscopa+1);
if listemscopa[-1+nombremscopa+1].create2(
listemscopa[-1+indiceelementmodif].a1x+x1-
listemscopa[-1+indiceelementmodif].sx,
listemscopa[-1+indiceelementmodif].a1y+y1-
listemscopa[-1+indiceelementmodif].sy,
listemscopa[-1+indiceelementmodif].a2x+x1-
listemscopa[-1+indiceelementmodif].sx,
listemscopa[-1+indiceelementmodif].a2y+y1-
listemscopa[-1+indiceelementmodif].sy,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou) then
 listemscopa[-1+indiceelementmodif].create2(
listemscopa[-1+indiceelementmodif].a1x+x1-
listemscopa[-1+indiceelementmodif].sx,
listemscopa[-1+indiceelementmodif].a1y+y1-
listemscopa[-1+indiceelementmodif].sy,
listemscopa[-1+indiceelementmodif].a2x+x1-
listemscopa[-1+indiceelementmodif].sx,
listemscopa[-1+indiceelementmodif].a2y+y1-
listemscopa[-1+indiceelementmodif].sy,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou)
else
listemscopa[-1+indiceelementmodif].create2(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou);
retaillePmscopa(listemscopa,nombremscopa+1,nombremscopa);
Rafraichit;
 end; {du cas mscopa}

mdmscore: begin
retaillePmscore(listemscore,nombremscore,nombremscore+1);
if listemscore[-1+nombremscore+1].create2(
listemscore[-1+indiceelementmodif].a1x+x1-
listemscore[-1+indiceelementmodif].sx,
listemscore[-1+indiceelementmodif].a1y+y1-
listemscore[-1+indiceelementmodif].sy,
listemscore[-1+indiceelementmodif].a2x+x1-
listemscore[-1+indiceelementmodif].sx,
listemscore[-1+indiceelementmodif].a2y+y1-
listemscore[-1+indiceelementmodif].sy,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
listemscore[-1+indiceelementmodif].trou,
listemscore[-1+indiceelementmodif].diametretrou) then
 listemscore[-1+indiceelementmodif].create2(
listemscore[-1+indiceelementmodif].a1x+x1-
listemscore[-1+indiceelementmodif].sx,
listemscore[-1+indiceelementmodif].a1y+y1-
listemscore[-1+indiceelementmodif].sy,
listemscore[-1+indiceelementmodif].a2x+x1-
listemscore[-1+indiceelementmodif].sx,
listemscore[-1+indiceelementmodif].a2y+y1-
listemscore[-1+indiceelementmodif].sy,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
listemscore[-1+indiceelementmodif].trou,
listemscore[-1+indiceelementmodif].diametretrou)
else
listemscore[-1+indiceelementmodif].create2(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
listemscore[-1+indiceelementmodif].trou,
listemscore[-1+indiceelementmodif].diametretrou);
retaillePmscore(listemscore,nombremscore+1,nombremscore);
Rafraichit;
 end; {du cas mscore}



mdmiroirconique: begin
retaillePmiroirconique(listemiroirconique,nombremiroirconique,nombremiroirconique+1);
if listemiroirconique[-1+nombremiroirconique+1].create2(
listemiroirconique[-1+indiceelementmodif].fx+x1-
listemiroirconique[-1+indiceelementmodif].sx,
listemiroirconique[-1+indiceelementmodif].fy+y1-
listemiroirconique[-1+indiceelementmodif].sy,
listemiroirconique[-1+indiceelementmodif].theta0,
listemiroirconique[-1+indiceelementmodif].theta1,
listemiroirconique[-1+indiceelementmodif].theta2,
listemiroirconique[-1+indiceelementmodif].excentricite,
listemiroirconique[-1+indiceelementmodif].parametre,
listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal) then
 listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].fx+x1-
listemiroirconique[-1+indiceelementmodif].sx,
listemiroirconique[-1+indiceelementmodif].fy+y1-
listemiroirconique[-1+indiceelementmodif].sy,
listemiroirconique[-1+indiceelementmodif].theta0,
listemiroirconique[-1+indiceelementmodif].theta1,
listemiroirconique[-1+indiceelementmodif].theta2,
listemiroirconique[-1+indiceelementmodif].excentricite,
listemiroirconique[-1+indiceelementmodif].parametre,
listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal)
else
listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].fx,
listemiroirconique[-1+indiceelementmodif].fy,
listemiroirconique[-1+indiceelementmodif].theta0,
listemiroirconique[-1+indiceelementmodif].theta1,
listemiroirconique[-1+indiceelementmodif].theta2,
listemiroirconique[-1+indiceelementmodif].excentricite,
listemiroirconique[-1+indiceelementmodif].parametre,
listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal) ;
retaillePmiroirconique(listemiroirconique,nombremiroirconique+1,nombremiroirconique);
Rafraichit;
 end; {du cas miroirconique}


 mdmscepa: begin
retaillePmscepa(listemscepa,nombremscepa,nombremscepa+1);
if listemscepa[-1+nombremscepa+1].create2(
listemscepa[-1+indiceelementmodif].a1x+x1-
listemscepa[-1+indiceelementmodif].sx,
listemscepa[-1+indiceelementmodif].a1y+y1-
listemscepa[-1+indiceelementmodif].sy,
listemscepa[-1+indiceelementmodif].a2x+x1-
listemscepa[-1+indiceelementmodif].sx,
listemscepa[-1+indiceelementmodif].a2y+y1-
listemscepa[-1+indiceelementmodif].sy,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou) then
 listemscepa[-1+indiceelementmodif].create2(
listemscepa[-1+indiceelementmodif].a1x+x1-
listemscepa[-1+indiceelementmodif].sx,
listemscepa[-1+indiceelementmodif].a1y+y1-
listemscepa[-1+indiceelementmodif].sy,
listemscepa[-1+indiceelementmodif].a2x+x1-
listemscepa[-1+indiceelementmodif].sx,
listemscepa[-1+indiceelementmodif].a2y+y1-
listemscepa[-1+indiceelementmodif].sy,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou)
else
listemscepa[-1+indiceelementmodif].create2(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou);
retaillePmscepa(listemscepa,nombremscepa+1,nombremscepa);
Rafraichit;
 end; {du cas mscepa}



mdmscere: begin
retaillePmscere(listemscere,nombremscere,nombremscere+1);
if listemscere[-1+nombremscere+1].create2(
listemscere[-1+indiceelementmodif].a1x+x1-
listemscere[-1+indiceelementmodif].sx,
listemscere[-1+indiceelementmodif].a1y+y1-
listemscere[-1+indiceelementmodif].sy,
listemscere[-1+indiceelementmodif].a2x+x1-
listemscere[-1+indiceelementmodif].sx,
listemscere[-1+indiceelementmodif].a2y+y1-
listemscere[-1+indiceelementmodif].sy,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
listemscere[-1+indiceelementmodif].trou,
listemscere[-1+indiceelementmodif].diametretrou) then
 listemscere[-1+indiceelementmodif].create2(
listemscere[-1+indiceelementmodif].a1x+x1-
listemscere[-1+indiceelementmodif].sx,
listemscere[-1+indiceelementmodif].a1y+y1-
listemscere[-1+indiceelementmodif].sy,
listemscere[-1+indiceelementmodif].a2x+x1-
listemscere[-1+indiceelementmodif].sx,
listemscere[-1+indiceelementmodif].a2y+y1-
listemscere[-1+indiceelementmodif].sy,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
listemscere[-1+indiceelementmodif].trou,
listemscere[-1+indiceelementmodif].diametretrou)
else
listemscere[-1+indiceelementmodif].create2(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
listemscere[-1+indiceelementmodif].trou,
listemscere[-1+indiceelementmodif].diametretrou);
retaillePmscere(listemscere,nombremscere+1,nombremscere);
Rafraichit;
 end; {du cas mscere}


 mdlmc: begin
retaillePlmc(listelmc,nombrelmc,nombrelmc+1);
if listelmc[-1+nombrelmc+1].create2(
listelmc[-1+indiceelementmodif].a1x+x1-
listelmc[-1+indiceelementmodif].ox,
listelmc[-1+indiceelementmodif].a1y+y1-
listelmc[-1+indiceelementmodif].oy,
listelmc[-1+indiceelementmodif].a2x+x1-
listelmc[-1+indiceelementmodif].ox,
listelmc[-1+indiceelementmodif].a2y+y1-
listelmc[-1+indiceelementmodif].oy,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal) then
 listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x+x1-
listelmc[-1+indiceelementmodif].ox,
listelmc[-1+indiceelementmodif].a1y+y1-
listelmc[-1+indiceelementmodif].oy,
listelmc[-1+indiceelementmodif].a2x+x1-
listelmc[-1+indiceelementmodif].ox,
listelmc[-1+indiceelementmodif].a2y+y1-
listelmc[-1+indiceelementmodif].oy,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal)
else
listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal);
retaillePlmc(listelmc,nombrelmc+1,nombrelmc);
Rafraichit;
 end; {du cas lmc}


  mdlec: begin
retaillePlec(listelec,nombrelec,nombrelec+1);
if listelec[-1+nombrelec+1].create(
listelec[-1+indiceelementmodif].s1x+x1-
listelec[-1+indiceelementmodif].ox,
listelec[-1+indiceelementmodif].s1y+y1-
listelec[-1+indiceelementmodif].oy,
listelec[-1+indiceelementmodif].s2x+x1-
listelec[-1+indiceelementmodif].ox,
listelec[-1+indiceelementmodif].s2y+y1-
listelec[-1+indiceelementmodif].oy,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant) then
 listelec[-1+indiceelementmodif].create(
listelec[-1+indiceelementmodif].s1x+x1-
listelec[-1+indiceelementmodif].ox,
listelec[-1+indiceelementmodif].s1y+y1-
listelec[-1+indiceelementmodif].oy,
listelec[-1+indiceelementmodif].s2x+x1-
listelec[-1+indiceelementmodif].ox,
listelec[-1+indiceelementmodif].s2y+y1-
listelec[-1+indiceelementmodif].oy,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant)
else
listelec[-1+indiceelementmodif].create(
listelec[-1+indiceelementmodif].s1x,
listelec[-1+indiceelementmodif].s1y,
listelec[-1+indiceelementmodif].s2x,
listelec[-1+indiceelementmodif].s2y,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant);
retaillePlec(listelec,nombrelec+1,nombrelec);
Rafraichit;
 end; {du cas lec}

 mdlmd: begin
retaillePlmd(listelmd,nombrelmd,nombrelmd+1);
if listelmd[-1+nombrelmd+1].create2(
listelmd[-1+indiceelementmodif].a1x+x1-
listelmd[-1+indiceelementmodif].ox,
listelmd[-1+indiceelementmodif].a1y+y1-
listelmd[-1+indiceelementmodif].oy,
listelmd[-1+indiceelementmodif].a2x+x1-
listelmd[-1+indiceelementmodif].ox,
listelmd[-1+indiceelementmodif].a2y+y1-
listelmd[-1+indiceelementmodif].oy,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal) then
 listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x+x1-
listelmd[-1+indiceelementmodif].ox,
listelmd[-1+indiceelementmodif].a1y+y1-
listelmd[-1+indiceelementmodif].oy,
listelmd[-1+indiceelementmodif].a2x+x1-
listelmd[-1+indiceelementmodif].ox,
listelmd[-1+indiceelementmodif].a2y+y1-
listelmd[-1+indiceelementmodif].oy,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal)
else
listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal);
retaillePlmd(listelmd,nombrelmd+1,nombrelmd);
Rafraichit;
 end; {du cas lmd}

end; {du case}
end;   {du modetranslation}

  end;



   procedure Traitesuppression(Sender: TObject; Shift: TShiftState; X,
  Y: Integer);
  var

     x1,y1,tx,ty,distance,lambda,xx1,yy1,dtheta,AiAj,ux,uy:extended;
 i,j:integer;
 boum:string;
 label 314, 315,316,317,319,320,321;
  begin

graphepresent:=true;
    BIBI.convert(x,y,x1,y1,true);
   BIBI.convert(3,form1.image1.height-3,tx,ty,true);
     tx:=tx-xxmin; ty:=ty-yymin;

     affichecoordonnees(x1,y1);

     distance:=sqrt(sqr(xxmax-xxmin)+sqr(yymin-yymax));
    {on recherche si le curseur est proche d'un centre}


 if nombretexte>0 then
 for i:=1 to nombretexte do
   if ((abs(listetexteaffiche[-1+i].x-x1)<=tx*1.1) and
    (abs(listetexteaffiche[-1+i].y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeTexte;
    goto 314;
    end;

 if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].cx-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].cy-y1)<=ty*1.1)) then
    begin
    boum:=rsCeTrait;
    goto 314;
    end;

    if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].a1y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeTrait;
    goto 314;
    end;

    if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].a2y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeTrait;
    goto 314;
    end;



 if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1)) then begin
    boum:=rsCetteSphRe;
    goto 314;
    end;

if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx+listesphere[-1+i].rayon-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1)) then
    begin
    boum:=rsCetteSphRe;
    goto 314;
    end;

    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy+listesphere[-1+i].rayon-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteSphRe;
    goto 314;
    end;

    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-listesphere[-1+i].rayon-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteSphRe;
    goto 314;
    end;

    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-listesphere[-1+i].rayon-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteSphRe;
    goto 314;
    end;


 if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].cy-y1)<=ty*1.1)) then  begin
    boum:=rsCeMiroirPlan;
    goto 314;
    end;

    if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].a1y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeMiroirPlan;
    goto 314;
    end;

    if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].a2y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeMiroirPlan;
    goto 314;
    end;


    if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].cy-y1)<=ty*1.1)) then  begin
    boum:=rsCeReseau;
    goto 314;
    end;

    if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].a1y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeReseau;
    goto 314;
    end;

    if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].a2y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeReseau;
    goto 314;
    end;





 if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].sy-y1)<=ty*1.1)) then
    begin
    boum:=rsCeMiroirCNiq;
    goto 314;
    end;

    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].a1y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeMiroirCNiq;
    goto 314;
    end;


    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].a2y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeMiroirCNiq;
    goto 314;
    end;


    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].fy-y1)<=ty*1.1)) then
    begin
    boum:=rsCeMiroirCNiq;
    goto 314;
    end;



     if nombrepolyhedre>0 then
 for i:=1 to nombrepolyhedre do
 for j:=1 to listepolyhedre[-1+i].nombresommet do
   if ((abs(listepolyhedre[-1+i].messommets[j].ax-x1)<=tx*1.1) and
    (abs(listepolyhedre[-1+i].messommets[j].ay-y1)<=ty*1.1))
    then
    begin
    boum:=rsCePolygNe;
    goto 314;
    end;



    if nombrepolyhedre>0 then
 for i:=1 to nombrepolyhedre do
 for j:=1 to listepolyhedre[-1+i].nombresommet do
   if ((abs((listepolyhedre[-1+i].messommets[j].ax+listepolyhedre[-1+i].messommets[j+1].ax)/2-x1)<=tx*1.1) and
    (abs((listepolyhedre[-1+i].messommets[j].ay+listepolyhedre[-1+i].messommets[j+1].ay)/2-y1)<=ty*1.1) )
    then
    begin
    boum:=rsCePolygNe;
    goto 314;
    end;


     if nombreprisme>0 then
 for i:=1 to nombreprisme do
 for j:=1 to listeprisme[-1+i].nombresommet do
   if ((abs(listeprisme[-1+i].messommets[j].ax-x1)<=tx*1.1) and
    (abs(listeprisme[-1+i].messommets[j].ay-y1)<=ty*1.1))
    then
    begin
    boum:=rsCePrisme;
    goto 314;
    end;



    if nombreprisme>0 then
 for i:=1 to nombreprisme do
 for j:=1 to listeprisme[-1+i].nombresommet do
   if ((abs((listeprisme[-1+i].messommets[j].ax+listeprisme[-1+i].messommets[j+1].ax)/2-x1)<=tx*1.1) and
    (abs((listeprisme[-1+i].messommets[j].ay+listeprisme[-1+i].messommets[j+1].ay)/2-y1)<=ty*1.1) )
    then
    begin
    boum:=rsCePrisme;
    goto 314;
    end;


     if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
   if ((abs(listepolycercle[-1+i].messommets[j].ax-x1)<=tx*1.1) and
    (abs(listepolycercle[-1+i].messommets[j].ay-y1)<=ty*1.1))
    then
    begin
    boum:=rsCePolycercle;
    goto 314;
    end;

     if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
   if ((abs((listepolycercle[-1+i].messommets[j].ax+listepolycercle[-1+i].messommets[j+1].ax)/2-x1)<=tx*1.1) and
    (abs((listepolycercle[-1+i].messommets[j].ay+listepolycercle[-1+i].messommets[j+1].ay)/2-y1)<=ty*1.1) )
    then
     begin
    boum:=rsCePolycercle;
    goto 314;
    end;

     if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
 if not(listepolycercle[-1+i].rectiligne[j]) then
   if ((abs(listepolycercle[-1+i].mess[j].ax-x1)<=tx*1.1) and
    (abs(listepolycercle[-1+i].mess[j].ay-y1)<=ty*1.1))
    then
     begin
    boum:=rsCePolycercle;
    goto 314;
    end;


      if nombreoeil>0 then
    for i:=1 to nombreoeil do
   if ((abs(listeoeil[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeoeil[-1+i].cy-y1)<=ty*1.1)) then
     begin
    boum:=rsCetOeil;
    goto 314;
    end;

    if nombreoeil>0 then
 for i:=1 to nombreoeil do
   if ((abs(listeoeil[-1+i].ax-x1)<=tx*1.1) and
    (abs(listeoeil[-1+i].ay-y1)<=ty*1.1)) then
    begin
    boum:=rsCetOeil;
    goto 314;
    end;



      if nombreecran>0 then
    for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].cy-y1)<=ty*1.1)) then
     begin
    boum:=rsCetCran;
    goto 314;
    end;

     if nombregroupe>0 then
    for i:=1 to nombregroupe do
   if ((abs(listegroupe[-1+i].isox-x1)<=tx*1.1) and
    (abs(listegroupe[-1+i].isoy-y1)<=ty*1.1)) then
     begin
    boum:=rsCeGroupe;
    goto 314;
    end;



    if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].a1y-y1)<=ty*1.1)) then
    begin
    boum:=rsCetCran;
    goto 314;
    end;

    if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].a2y-y1)<=ty*1.1)) then
    begin
    boum:=rsCetCran;
    goto 314;
    end;


     for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].cx-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].cy-y1)<=ty*1.1)) then
    begin
    boum:=rsCeDiaphragme;
    goto 314;
    end;

    if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].a1y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeDiaphragme;
    goto 314;
    end;

    if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].a2y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeDiaphragme;
    goto 314;
    end;

  if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].ap1x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].ap1y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeDiaphragme;
    goto 314;
    end;

    if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].ap2x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].ap2y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeDiaphragme;
    goto 314;
    end;


     for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].cx-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].cy-y1)<=ty*1.1)) then
    begin
    boum:=rsCetteLameSem;
    goto 314;
    end;

    if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].a1y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLameSem;
    goto 314;
    end;

    if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].a2y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLameSem;
    goto 314;
    end;


    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].sy-y1)<=ty*1.1)) then
     begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].a1y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].a2y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].fy-y1)<=ty*1.1)) then
    begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;


    if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].sy-y1)<=ty*1.1)) then
    begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

     if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].a1y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

     if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].a2y-y1)<=ty*1.1)) then
    begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

     if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].fy-y1)<=ty*1.1)) then
    begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].sy-y1)<=ty*1.1)) then
     begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].a1y-y1)<=ty*1.1)) then
     begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].a2y-y1)<=ty*1.1)) then
     begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].cy-y1)<=ty*1.1)) then
     begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].sy-y1)<=ty*1.1)) then
     begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].a1y-y1)<=ty*1.1)) then
     begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].a2y-y1)<=ty*1.1)) then
     begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

   if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].cy-y1)<=ty*1.1)) then
     begin
    boum:=rsCeMiroirSphR3;
    goto 314;
    end;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].oy-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLentill4;
    goto 314;
    end;

     if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].a1y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLentill4;
    goto 314;
    end;

     if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].a2y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLentill4;
    goto 314;
    end;

     if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].f1x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].f1y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLentill4;
    goto 314;
    end;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].f2x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].f2y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLentill4;
    goto 314;
    end;


     if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelec[-1+i].oy-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLentill4;
    goto 314;
    end;

     if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].s1x-x1)<=tx*1.1) and
    (abs(listelec[-1+i].s1y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLentill4;
    goto 314;
    end;

     if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].s2x-x1)<=tx*1.1) and
    (abs(listelec[-1+i].s2y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLentill4;
    goto 314;
    end;


    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].oy-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLentill4;
    goto 314;
    end;


    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].a1y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLentill4;
    goto 314;
    end;

    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].a2y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLentill4;
    goto 314;
    end;

       if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].f1x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].f1y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLentill4;
    goto 314;
    end;

    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].f2x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].f2y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteLentill4;
    goto 314;
    end;


    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].cx-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].cy-y1)<=ty*1.1)) then
     begin
    boum:=rsCeRayon;
    goto 314;
    end;

    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].ax-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].ay-y1)<=ty*1.1)) then
     begin
    boum:=rsCeRayon;
    goto 314;
    end;

    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].bx-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].by-y1)<=ty*1.1)) then
     begin
    boum:=rsCeRayon;
    goto 314;
    end;

     if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].gx-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].gy-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteSourceP;
    goto 314;
    end;


  if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].sx-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].sy-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteSourceP;
    goto 314;
    end;

    if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].a1y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteSourceP;
    goto 314;
    end;

     if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].a2y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteSourceP;
    goto 314;
    end;

  if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].a1y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteOndePla;
    goto 314;
    end;

 if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].sx-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].sy-y1)<=ty*1.1)) then begin
    boum:=rsCetteOndePla;
    goto 314;
    end;

     if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].a2y-y1)<=ty*1.1)) then
    begin
    boum:=rsCetteOndePla;
    goto 314;
    end;

     if nombreangle>0 then
    for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].a1y-y1)<=ty*1.1)) then
    begin
    boum:=rsCetteMesureD2;
    goto 314;
    end;

 if nombreangle>0 then
    for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].cy-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteMesureD3;
    goto 314;
    end;

     if nombreangle>0 then
    for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].a2y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteMesureD4;
    goto 314;
    end;

   if nombremetre>0 then
    for i:=1 to nombremetre do
   if ((abs(listemetre[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemetre[-1+i].a1y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteMesureD;
    goto 314;
    end;

     if nombremetre>0 then
    for i:=1 to nombremetre do
   if ((abs(listemetre[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemetre[-1+i].a2y-y1)<=ty*1.1)) then
     begin
    boum:=rsCetteMesureD;
    goto 314;
    end;



  form1.image1.Cursor:=crdefault;
  form1.StatusBar1.Panels[2].text:=rsFaitesPasser3;
  exit;
 314:
  315:
   317:
   316:
  319:
   320:  form1.image1.Cursor:=crmarteau;
  form1.StatusBar1.Panels[2].text:=Format(rsClicGauchePo9, [boum]);
  exit;
  end;


  {*****************debut modif***************************************}
  procedure DebutModif(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
  var

     x1,y1,tx,ty,distance:extended;
 i,j:integer;

  begin

  modetranslation:=false;
  moderotation:=false;

graphepresent:=true;
    BIBI.convert(x,y,x1,y1,true);
    BIBI.convert(3,form1.image1.height-3,tx,ty,true);
     tx:=tx-xxmin; ty:=ty-yymin;

     distance:=sqrt(sqr(xxmax-xxmin)+sqr(yymin-yymax));
     affichecoordonnees(x1,y1);
      bloqueaxe:=false;
    {on recherche si le curseur est proche d'un centre, et si oui lequel}
  nombre_typeelementmodif:=0;      tprot:=tpa1;  tprirot:=tpa;
   lastxr:=0; lastyr:=0;
      if nombretexte>0 then
 for i:=1 to nombretexte do
   if ((abs(listetexteaffiche[-1+i].x-x1)<=tx*1.1) and
    (abs(listetexteaffiche[-1+i].y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdtexteaffiche;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listetexteaffiche[-1+i].x;
    lastyr:=listetexteaffiche[-1+i].y;
    bloqueaxe:=true;
    end;
    modetranslation:=true;   moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
       setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
         setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].sy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemiroirconique[-1+i].sx;
    lastyr:=listemiroirconique[-1+i].sy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemiroirconique[-1+i].a1x;
    lastyr:=listemiroirconique[-1+i].a1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa2;   modetranslation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemiroirconique[-1+i].a2x;
    lastyr:=listemiroirconique[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].fy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpfo;   modetranslation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemiroirconique[-1+i].fx;
    lastyr:=listemiroirconique[-1+i].fy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;



 if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listesphere[-1+i].cx;
    lastyr:=listesphere[-1+i].cy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx+listesphere[-1+i].rayon-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=false;   moderotation:=true;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listesphere[-1+i].cx+listesphere[-1+i].rayon;
    lastyr:=listesphere[-1+i].cy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-listesphere[-1+i].rayon-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=false;   moderotation:=true;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
     if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listesphere[-1+i].cx-listesphere[-1+i].rayon;
    lastyr:=listesphere[-1+i].cy;
    bloqueaxe:=true;
    end;
     setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy+listesphere[-1+i].rayon-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=false;   moderotation:=true;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
     if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listesphere[-1+i].cx;
    lastyr:=listesphere[-1+i].cy+listesphere[-1+i].rayon;
    bloqueaxe:=true;
    end;
     setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-listesphere[-1+i].rayon-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=false;   moderotation:=true;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listesphere[-1+i].cx;
    lastyr:=listesphere[-1+i].cy-listesphere[-1+i].rayon;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


   if nombreoeil>0 then
 for i:=1 to nombreoeil do
   if ((abs(listeoeil[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeoeil[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdoeil;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeoeil[-1+i].cx;
    lastyr:=listeoeil[-1+i].cy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombreoeil>0 then
 for i:=1 to nombreoeil do
   if ((abs(listeoeil[-1+i].ax-x1)<=tx*1.1) and
    (abs(listeoeil[-1+i].ay-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdoeil;
 inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeoeil[-1+i].ax;
    lastyr:=listeoeil[-1+i].ay;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


 if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirplan;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemiroirplan[-1+i].cx;
    lastyr:=listemiroirplan[-1+i].cy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirplan;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemiroirplan[-1+i].a1x;
    lastyr:=listemiroirplan[-1+i].a1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirplan;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;  tprot:=tpa2;   modetranslation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemiroirplan[-1+i].a2x;
    lastyr:=listemiroirplan[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


      if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdReseau;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeReseau[-1+i].cx;
    lastyr:=listeReseau[-1+i].cy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdReseau;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeReseau[-1+i].a1x;
    lastyr:=listeReseau[-1+i].a1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdReseau;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;  tprot:=tpa2;   modetranslation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeReseau[-1+i].a2x;
    lastyr:=listeReseau[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

   if nombreangle>0 then
 for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].dx-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].dy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdangle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeangle[-1+i].dx;
    lastyr:=listeangle[-1+i].dy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

 if nombreangle>0 then
 for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdangle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=false;   moderotation:=true;  tprot:=tpce;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
     if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeangle[-1+i].cx;
    lastyr:=listeangle[-1+i].cy;
    bloqueaxe:=true;
    end;
     setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombreangle>0 then
 for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdangle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
     if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeangle[-1+i].a1x;
    lastyr:=listeangle[-1+i].a1y;
    bloqueaxe:=true;
    end;
     setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombreangle>0 then
 for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdangle;
inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;  tprot:=tpa2;   modetranslation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
     if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeangle[-1+i].a2x;
    lastyr:=listeangle[-1+i].a2y;
    bloqueaxe:=true;
    end;
     setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


     if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdfleche;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
     if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listefleche[-1+i].a1x;
    lastyr:=listefleche[-1+i].a1y;
    bloqueaxe:=true;
    end;
     setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdfleche;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa2;   modetranslation:=false;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listefleche[-1+i].a2x;
    lastyr:=listefleche[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].cx-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdfleche;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=false;      modetranslation:=true;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listefleche[-1+i].cx;
    lastyr:=listefleche[-1+i].cy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


     if nombreprisme>0 then
 for i:=1 to nombreprisme do
   if ((abs(listeprisme[-1+i].gx-x1)<=tx*1.1) and
    (abs(listeprisme[-1+i].gy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdprisme;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=false;      modetranslation:=true;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeprisme[-1+i].gx;
    lastyr:=listeprisme[-1+i].gy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


    if nombreprisme>0 then
 for i:=1 to nombreprisme do
   if ((abs(listeprisme[-1+i].ax-x1)<=tx*1.1) and
    (abs(listeprisme[-1+i].ay-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdprisme;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;      modetranslation:=false;  tprirot:=tpa;
    setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeprisme[-1+i].ax;
    lastyr:=listeprisme[-1+i].ay;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

  if nombreprisme>0 then
 for i:=1 to nombreprisme do
   if ((abs(listeprisme[-1+i].bx-x1)<=tx*1.1) and
    (abs(listeprisme[-1+i].by-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdprisme;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;      modetranslation:=false;  tprirot:=tpb;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeprisme[-1+i].bx;
    lastyr:=listeprisme[-1+i].by;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombreprisme>0 then
 for i:=1 to nombreprisme do
   if ((abs(listeprisme[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeprisme[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdprisme;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;      modetranslation:=false;  tprirot:=tpc;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeprisme[-1+i].cx;
    lastyr:=listeprisme[-1+i].cy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;







    if nombremetre>0 then
 for i:=1 to nombremetre do
   if ((abs(listemetre[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemetre[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmetre;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemetre[-1+i].a1x;
    lastyr:=listemetre[-1+i].a1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombremetre>0 then
 for i:=1 to nombremetre do
   if ((abs(listemetre[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemetre[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmetre;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;  tprot:=tpa2;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemetre[-1+i].a2x;
    lastyr:=listemetre[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombremetre>0 then
 for i:=1 to nombremetre do
   if ((abs((listemetre[-1+i].a2x+listemetre[-1+i].a1x)/2-x1)<=tx*1.1) and
    (abs((listemetre[-1+i].a2y+listemetre[-1+i].a1y)/2-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmetre;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=false;     modetranslation:=true;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=(listemetre[-1+i].a2x+listemetre[-1+i].a1x)/2;
    lastyr:=(listemetre[-1+i].a2y+listemetre[-1+i].a1y)/2;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;




     if nombrepolyhedre>0 then
 for i:=1 to nombrepolyhedre do
 for j:=1 to listepolyhedre[-1+i].nombresommet do
   if ((abs(listepolyhedre[-1+i].messommets[j].ax-x1)<=tx*1.1) and
    (abs(listepolyhedre[-1+i].messommets[j].ay-y1)<=ty*1.1) )
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdpolyhedre;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
  moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
   setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
   if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listepolyhedre[-1+i].messommets[j].ax;
    lastyr:=listepolyhedre[-1+i].messommets[j].ay;
    bloqueaxe:=true;
    end;
   setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


    if nombrepolyhedre>0 then
 for i:=1 to nombrepolyhedre do
 for j:=1 to listepolyhedre[-1+i].nombresommet do
   if ((abs((listepolyhedre[-1+i].messommets[j].ax+listepolyhedre[-1+i].messommets[j+1].ax)/2-x1)<=tx*1.1) and
    (abs((listepolyhedre[-1+i].messommets[j].ay+listepolyhedre[-1+i].messommets[j+1].ay)/2-y1)<=ty*1.1) )
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdpolyhedre;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
  moderotation:=false;     modetranslation:=true;
   setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
  if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=(listepolyhedre[-1+i].messommets[j].ax+listepolyhedre[-1+i].messommets[j+1].ax)/2;
    lastyr:=(listepolyhedre[-1+i].messommets[j].ay+listepolyhedre[-1+i].messommets[j+1].ay)/2;
    bloqueaxe:=true;
    end;
  setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


      if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
   if ((abs(listepolycercle[-1+i].messommets[j].ax-x1)<=tx*1.1) and
    (abs(listepolycercle[-1+i].messommets[j].ay-y1)<=ty*1.1) )
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdpolycercle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
  moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
   setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
  if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listepolycercle[-1+i].messommets[j].ax;
    lastyr:=listepolycercle[-1+i].messommets[j].ay;
    bloqueaxe:=true;
    end;
  setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


     if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
   if ((abs((listepolycercle[-1+i].messommets[j].ax+listepolycercle[-1+i].messommets[j+1].ax)/2-x1)<=tx*1.1) and
    (abs((listepolycercle[-1+i].messommets[j].ay+listepolycercle[-1+i].messommets[j+1].ay)/2-y1)<=ty*1.1)
    and not((listepolycercle[-1+i].nombresommet=2) and (j=2))
    )
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdpolycercle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
  moderotation:=false;     modetranslation:=true;
   setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
  if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=(listepolycercle[-1+i].messommets[j].ax+listepolycercle[-1+i].messommets[j+1].ax)/2;
    lastyr:=(listepolycercle[-1+i].messommets[j].ay+listepolycercle[-1+i].messommets[j+1].ay)/2;
    bloqueaxe:=true;
    end;
  setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


      if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
 if not(listepolycercle[-1+i].rectiligne[j]) then
   if ((abs(listepolycercle[-1+i].mess[j].ax-x1)<=tx*1.1) and
    (abs(listepolycercle[-1+i].mess[j].ay-y1)<=ty*1.1))
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdpolycercle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
  moderotation:=true;   tprot:=tpso;   modetranslation:=false;
   setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
   if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listepolycercle[-1+i].mess[j].ax;
    lastyr:=listepolycercle[-1+i].mess[j].ay;
    bloqueaxe:=true;
    end;
   setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;



     if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].cx-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listediaphragme[-1+i].cx;
    lastyr:=listediaphragme[-1+i].cy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listediaphragme[-1+i].a1x;
    lastyr:=listediaphragme[-1+i].a1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;  tprot:=tpa2;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listediaphragme[-1+i].a2x;
    lastyr:=listediaphragme[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].ap1x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].ap1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpap1;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listediaphragme[-1+i].ap1x;
    lastyr:=listediaphragme[-1+i].ap1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].ap2x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].ap2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;  tprot:=tpap2;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
     if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listediaphragme[-1+i].ap2x;
    lastyr:=listediaphragme[-1+i].ap2y;
    bloqueaxe:=true;
    end;
     setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdecran;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
     if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeecran[-1+i].cx;
    lastyr:=listeecran[-1+i].cy;
    bloqueaxe:=true;
    end;
     setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombregroupe>0 then
 for i:=1 to nombregroupe do
   if ((abs(listegroupe[-1+i].isox-x1)<=tx*1.1) and
    (abs(listegroupe[-1+i].isoy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdgroupe;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listegroupe[-1+i].isox;
    lastyr:=listegroupe[-1+i].isoy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


    if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdecran;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeecran[-1+i].a1x;
    lastyr:=listeecran[-1+i].a1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdecran;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;  tprot:=tpa2;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeecran[-1+i].a2x;
    lastyr:=listeecran[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


     if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].cx-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlsr;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelsr[-1+i].cx;
    lastyr:=listelsr[-1+i].cy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlsr;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelsr[-1+i].a1x;
    lastyr:=listelsr[-1+i].a1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlsr;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;  tprot:=tpa2;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelsr[-1+i].a2x;
    lastyr:=listelsr[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscopa[-1+i].sx;
    lastyr:=listemscopa[-1+i].sy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
     if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscopa[-1+i].a1x;
    lastyr:=listemscopa[-1+i].a1y;
    bloqueaxe:=true;
    end;
     setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

   if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa2;    modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscopa[-1+i].a2x;
    lastyr:=listemscopa[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

      if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].fy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpfo;    modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscopa[-1+i].fx;
    lastyr:=listemscopa[-1+i].fy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


    if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscepa[-1+i].sx;
    lastyr:=listemscepa[-1+i].sy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


    if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;   tprot:=tpa1;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscepa[-1+i].a1x;
    lastyr:=listemscepa[-1+i].a1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;    tprot:=tpa2;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscepa[-1+i].a2x;
    lastyr:=listemscepa[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].fy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;    tprot:=tpfo;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscepa[-1+i].fx;
    lastyr:=listemscepa[-1+i].fy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;    moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscore[-1+i].sx;
    lastyr:=listemscore[-1+i].sy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpa1; modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
     if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscore[-1+i].a1x;
    lastyr:=listemscore[-1+i].a1y;
    bloqueaxe:=true;
    end;
     setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpa2;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
     if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscore[-1+i].a2x;
    lastyr:=listemscore[-1+i].a2y;
    bloqueaxe:=true;
    end;
     setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

   if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpce;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
     if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscore[-1+i].cx;
    lastyr:=listemscore[-1+i].cy;
    bloqueaxe:=true;
    end;
     setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;     moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
     if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscere[-1+i].sx;
    lastyr:=listemscere[-1+i].sy;
    bloqueaxe:=true;
    end;
     setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpa1;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscere[-1+i].a1x;
    lastyr:=listemscere[-1+i].a1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpa2;    modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscere[-1+i].a2x;
    lastyr:=listemscere[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpce;    modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listemscere[-1+i].cx;
    lastyr:=listemscere[-1+i].cy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].oy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;    moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelmc[-1+i].ox;
    lastyr:=listelmc[-1+i].oy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpa1;    modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelmc[-1+i].a1x;
    lastyr:=listelmc[-1+i].a1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].f1x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].f1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpf1;    modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelmc[-1+i].f1x;
    lastyr:=listelmc[-1+i].f1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpa2;  modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelmc[-1+i].a2x;
    lastyr:=listelmc[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].f2x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].f2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpf2;  modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelmc[-1+i].f2x;
    lastyr:=listelmc[-1+i].f2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;



     if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelec[-1+i].oy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlec;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;    moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelec[-1+i].ox;
    lastyr:=listelec[-1+i].oy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].s1x-x1)<=tx*1.1) and
    (abs(listelec[-1+i].s1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlec;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpa1;    modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelec[-1+i].s1x;
    lastyr:=listelec[-1+i].s1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;



    if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].s2x-x1)<=tx*1.1) and
    (abs(listelec[-1+i].s2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlec;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpa2;  modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelec[-1+i].s2x;
    lastyr:=listelec[-1+i].s2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].oy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelmd[-1+i].ox;
    lastyr:=listelmd[-1+i].oy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


     if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;    tprot:=tpa1;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelmd[-1+i].a1x;
    lastyr:=listelmd[-1+i].a1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].f1x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].f1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;    tprot:=tpf1;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelmd[-1+i].f1x;
    lastyr:=listelmd[-1+i].f1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;    tprot:=tpa2;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelmd[-1+i].a2x;
    lastyr:=listelmd[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].f2x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].f2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;    tprot:=tpf2;   modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listelmd[-1+i].f2x;
    lastyr:=listelmd[-1+i].f2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;




    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].cx-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdrayon;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;      moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listerayon[-1+i].cx;
    lastyr:=listerayon[-1+i].cy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].ax-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].ay-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdrayon;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpa1;      modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listerayon[-1+i].ax;
    lastyr:=listerayon[-1+i].ay;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].bx-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].by-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdrayon;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true; tprot:=tpa2;     modetranslation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listerayon[-1+i].bx;
    lastyr:=listerayon[-1+i].by;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


     if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].gx-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].gy-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsourceponctuelle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;      moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listesourceponctuelle[-1+i].gx;
    lastyr:=listesourceponctuelle[-1+i].gy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;


    if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].sx-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].sy-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsourceponctuelle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=false;      moderotation:=true; tprot:=tpa0;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listesourceponctuelle[-1+i].sx;
    lastyr:=listesourceponctuelle[-1+i].sy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].a1y-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsourceponctuelle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;     modetranslation:=false;  tprot:=tpa1;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listesourceponctuelle[-1+i].a1x;
    lastyr:=listesourceponctuelle[-1+i].a1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

  if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].a2y-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsourceponctuelle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;     modetranslation:=false;  tprot:=tpa2;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listesourceponctuelle[-1+i].a2x;
    lastyr:=listesourceponctuelle[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

   if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].a1y-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdondeplane;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    modetranslation:=true;   moderotation:=false;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeondeplane[-1+i].a1x;
    lastyr:=listeondeplane[-1+i].a1y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

     if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].sx-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].sy-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdondeplane;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;     modetranslation:=false;  tprot:=tpa1;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeondeplane[-1+i].sx;
    lastyr:=listeondeplane[-1+i].sy;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;

    if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].a2y-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdondeplane;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    moderotation:=true;     modetranslation:=false;  tprot:=tpa2;
     setlength(liste_modetranslation,nombre_typeelementmodif);
      setlength(liste_moderotation,nombre_typeelementmodif);
       setlength(liste_tprot,nombre_typeelementmodif);
        setlength(liste_tprirot,nombre_typeelementmodif);
           liste_tprirot[nombre_typeelementmodif-1]:=tprirot;
               liste_modetranslation[nombre_typeelementmodif-1]:=modetranslation;
            liste_moderotation[nombre_typeelementmodif-1]:=moderotation;
         liste_tprot[nombre_typeelementmodif-1]:=tprot;
    if ((ssalt in shift) or (ssctrl in shift)) then begin
    lastxr:=listeondeplane[-1+i].a2x;
    lastyr:=listeondeplane[-1+i].a2y;
    bloqueaxe:=true;
    end;
    setlength(liste_lastxr,nombre_typeelementmodif);
    setlength(liste_lastyr,nombre_typeelementmodif);
    setlength(liste_bloqueaxe,nombre_typeelementmodif);
     liste_lastxr[nombre_typeelementmodif-1]:=lastxr;
      liste_lastyr[nombre_typeelementmodif-1]:=lastyr;
       liste_bloqueaxe[nombre_typeelementmodif-1]:=bloqueaxe;
    end;



   if nombre_typeelementmodif >1 then  begin
 form_quelobjet.ComboBox1.Items.Clear;
 form_quelobjet.Caption:=rsChoixDeLObje;
 for i:=1 to  nombre_typeelementmodif do begin
 case liste_typeelementmodif[i-1]  of
 mdmetre:   form_quelobjet.ComboBox1.Items.Add(Format(rsMesureDeDist2, [inttostr
   (liste_indiceelementmodif[i-1])]));
 mdprisme:   form_quelobjet.ComboBox1.Items.Add(Format(rsPrismeN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdMiroirPlan: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirPlanN, [
   inttostr(liste_indiceelementmodif[i-1])]));

  mdreseau: form_quelobjet.ComboBox1.Items.Add(Format(rsReseauN, [
   inttostr(liste_indiceelementmodif[i-1])]));

 mdMscopa: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirConcav, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdMscepa: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirConvex, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdMscore: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirConcav2, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdMscere: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirConvex2, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdLmc: form_quelobjet.ComboBox1.Items.Add(Format(rsLentilleMinc5, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdLmd: form_quelobjet.ComboBox1.Items.Add(Format(rsLentilleMinc6, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdRayon: form_quelobjet.ComboBox1.Items.Add(Format(rsRayonN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdSourcePonctuelle: form_quelobjet.ComboBox1.Items.Add(Format(rsSourcePonctu2,
   [inttostr(liste_indiceelementmodif[i-1])]));
 mdOndePlane: form_quelobjet.ComboBox1.Items.Add(Format(rsOndePlaneN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdecran: form_quelobjet.ComboBox1.Items.Add(Format(rsEcranN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdlsr: form_quelobjet.ComboBox1.Items.Add(Format(rsLameSemiRFlC3, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdpolyhedre: form_quelobjet.ComboBox1.Items.Add(Format(rsPolyhDreRFra2, [
   inttostr(liste_indiceelementmodif[i-1])]));
 mdsphere: form_quelobjet.ComboBox1.Items.Add(Format(rsSphReRFracta2, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdmiroirconique: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirCNique2, [
   inttostr(liste_indiceelementmodif[i-1])]));
 mdtexteaffiche: form_quelobjet.ComboBox1.Items.Add(Format(rsTexteN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mddiaphragme: form_quelobjet.ComboBox1.Items.Add(Format(rsDiaphragmeN, [
   inttostr(liste_indiceelementmodif[i-1])]));
 mdlec: form_quelobjet.ComboBox1.Items.Add(Format(rsLentillePais2, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdangle: form_quelobjet.ComboBox1.Items.Add(Format(rsMesureDAngle2, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdpolycercle:   form_quelobjet.ComboBox1.Items.Add(Format(rsPolycercleRF2, [
   inttostr(liste_indiceelementmodif[i-1])]));
 mdfleche: form_quelobjet.ComboBox1.Items.Add(Format(rsFlCheN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdoeil: form_quelobjet.ComboBox1.Items.Add(Format(rsOeilN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdneant: form_quelobjet.ComboBox1.Items.Add(Format(rsNAntN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdgroupe: form_quelobjet.ComboBox1.Items.Add(Format(rsGroupeN, [inttostr(
   liste_indiceelementmodif[i-1])]));
  end;
  end;

  with form_quelobjet
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
  form_quelobjet.ShowModal;
  if  form_quelobjet.ComboBox1.ItemIndex>=0 then begin
  typeelementmodif:=liste_typeelementmodif[form_quelobjet.ComboBox1.ItemIndex];
  indiceelementmodif:=liste_indiceelementmodif[form_quelobjet.ComboBox1.ItemIndex];
  modetranslation:=liste_modetranslation[form_quelobjet.ComboBox1.ItemIndex];
   moderotation:=liste_moderotation [form_quelobjet.ComboBox1.ItemIndex];
   tprot:=liste_tprot[form_quelobjet.ComboBox1.ItemIndex];
   tprirot:=liste_tprirot[form_quelobjet.ComboBox1.ItemIndex];
   lastxr:=liste_lastxr[form_quelobjet.ComboBox1.ItemIndex];
   lastyr:=liste_lastyr[form_quelobjet.ComboBox1.ItemIndex];
   bloqueaxe:=liste_bloqueaxe[form_quelobjet.ComboBox1.ItemIndex];
  end;

     end;











    if modetranslation then   begin
    form1.image1.Cursor:=crTranslation;
    modifencours:=true;
    form1.StatusBar1.Panels[2].text:=rsDPlacerLLMen;
    form1.StatusBar1.Panels[3].text:=rsModeTranslat;
    exit;
    end;

    if (moderotation and (typeelementmodif=mddiaphragme) and ((tprot=tpa1) or (tprot=tpap1))) then begin
      form1.image1.Cursor:=crtaille;
    modifencours:=true;
    form1.StatusBar1.Panels[2].text:=rsDPlacerLeBor;
    form1.StatusBar1.Panels[3].text:=rsModeChangeme;
    exit;
    end;

 if (moderotation and (typeelementmodif=mdprisme) and ((tprirot=tpa))) then begin
      form1.image1.Cursor:=crrotation;
    modifencours:=true;
    form1.StatusBar1.Panels[2].text:=rsDPlacerLeSom;
    form1.StatusBar1.Panels[3].text:=rsModeChangeme2;
    exit;
    end;

    if (moderotation and (typeelementmodif=mdprisme) and ((tprirot=tpb) )) then begin
      form1.image1.Cursor:=crtaille;
    modifencours:=true;
    form1.StatusBar1.Panels[2].text:=rsDPlacerLeSom;
    form1.StatusBar1.Panels[3].text:=rsModeChangeme3;
    exit;
    end;

    if (moderotation and (typeelementmodif=mdprisme) and ( (tprirot=tpc))) then begin
      form1.image1.Cursor:=crtaille;
    modifencours:=true;
    form1.StatusBar1.Panels[2].text:=rsDPlacerLeSom;
    form1.StatusBar1.Panels[3].text:=rsModeChangeme4;
    exit;
    end;


     if (moderotation and ((tprot=tpfo) or (tprot=tpf1) or (tprot=tpf2))) then   begin
    form1.image1.Cursor:=crdepfoyer;
    modifencours:=true;
    form1.StatusBar1.Panels[2].text:=rsDPlacerLeFoy;
    form1.StatusBar1.Panels[3].text:=rsModeChangeme5;
    exit;
    end;

     if (moderotation and (tprot=tpce)) then   begin
    form1.image1.Cursor:=crdepcentre;
    modifencours:=true;
    form1.StatusBar1.Panels[2].text:=rsDPlacerLeCen;
    form1.StatusBar1.Panels[3].text:=rsModeChgtRayo;
    exit;
    end;

     if (moderotation and (tprot=tpso)) then   begin
    form1.image1.Cursor:=crdepsommet;
    modifencours:=true;
    form1.StatusBar1.Panels[2].text:=rsDPlacerLeSom;
    form1.StatusBar1.Panels[3].text:=rsModeChgtRayo2;
    exit;
    end;


    if moderotation then   begin
    form1.image1.Cursor:=crrotation;
    modifencours:=true;
    form1.StatusBar1.Panels[2].text:=rsDPlacerLLMen2;
    form1.StatusBar1.Panels[3].text:=rsModeRotation;
    exit;
    end;

  form1.image1.Cursor:=crdepla;
  form1.StatusBar1.Panels[2].text:=rsFaitesPasser4;
  form1.StatusBar1.Panels[3].text:=rsModeDPlaceme2;
              exit;



  end;

procedure effectuesuppression(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
  var

     x1,y1,tx,ty,distance:extended;
 i,j:integer;
   boum:string;
  begin


graphepresent:=true;
    BIBI.convert(x,y,x1,y1,true);
    BIBI.convert(3,form1.image1.height-3,tx,ty,true);

     tx:=tx-xxmin; ty:=ty-yymin;
     distance:=sqrt(sqr(xxmax-xxmin)+sqr(yymin-yymax));
     affichecoordonnees(x1,y1);

    {on recherche si le curseur est proche d'un centre, et si oui lequel}
      indiceelementmodif:=0;
       nombre_typeelementmodif:=0;
      if nombretexte>0 then
 for i:=1 to nombretexte do
   if ((abs(listetexteaffiche[-1+i].x-x1)<=tx*1.1) and
    (abs(listetexteaffiche[-1+i].y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdtexteaffiche;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeTexte;
    end;


    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].sy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirCNiq;
    end;

     if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirCNiq;
    end;


    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirCNiq;
    end;

    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].fy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirCNiq;
    end;



 if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteSphRe;
    end;

    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx+listesphere[-1+i].rayon-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteSphRe;
    end;


    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-listesphere[-1+i].rayon-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteSphRe;
    end;

    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy+listesphere[-1+i].rayon-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteSphRe;
    end;

     if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-listesphere[-1+i].rayon-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteSphRe;
    end;





 if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirplan;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirPlan;
    end;

    if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirplan;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirPlan;
    end;

     if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirplan;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirPlan;
    end;


      if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdReseau;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeReseau;
    end;

    if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdReseau;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeReseau;
    end;

     if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdReseau;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeReseau;
    end;



 if nombreangle>0 then
 for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdangle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteMesureD5;
    end;

    if nombreangle>0 then
 for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdangle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteMesureD6;
    end;

     if nombreangle>0 then
 for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdangle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteMesureD7;
    end;


    if nombremetre>0 then
 for i:=1 to nombremetre do
   if ((abs(listemetre[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemetre[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmetre;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteMesureD;
    end;

     if nombremetre>0 then
 for i:=1 to nombremetre do
   if ((abs(listemetre[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemetre[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmetre;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteMesureD;
    end;


    if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdfleche;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeTrait;
    end;

     if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdfleche;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeTrait;
    end;

    if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].cx-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdfleche;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeTrait;
    end;

     if nombrepolyhedre>0 then
 for i:=1 to nombrepolyhedre do
 for j:=1 to listepolyhedre[-1+i].nombresommet do
   if ((abs(listepolyhedre[-1+i].messommets[j].ax-x1)<=tx*1.1) and
    (abs(listepolyhedre[-1+i].messommets[j].ay-y1)<=ty*1.1))
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdpolyhedre;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCePolygNe;
    end;


    if nombrepolyhedre>0 then
 for i:=1 to nombrepolyhedre do
 for j:=1 to listepolyhedre[-1+i].nombresommet do
   if ((abs((listepolyhedre[-1+i].messommets[j].ax+listepolyhedre[-1+i].messommets[j+1].ax)/2-x1)<=tx*1.1) and
    (abs((listepolyhedre[-1+i].messommets[j].ay+listepolyhedre[-1+i].messommets[j+1].ay)/2-y1)<=ty*1.1) )
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdpolyhedre;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCePolygNe;
    end;


    if nombreprisme>0 then
 for i:=1 to nombreprisme do
 for j:=1 to listeprisme[-1+i].nombresommet do
   if ((abs(listeprisme[-1+i].messommets[j].ax-x1)<=tx*1.1) and
    (abs(listeprisme[-1+i].messommets[j].ay-y1)<=ty*1.1) )
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdprisme;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCePrisme;
    end;


    if nombreprisme>0 then
 for i:=1 to nombreprisme do
 for j:=1 to listeprisme[-1+i].nombresommet do
   if ((abs((listeprisme[-1+i].messommets[j].ax+listeprisme[-1+i].messommets[j+1].ax)/2-x1)<=tx*1.1) and
    (abs((listeprisme[-1+i].messommets[j].ay+listeprisme[-1+i].messommets[j+1].ay)/2-y1)<=ty*1.1) )
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdprisme;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCePrisme;
    end;




      if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
   if ((abs(listepolycercle[-1+i].messommets[j].ax-x1)<=tx*1.1) and
    (abs(listepolycercle[-1+i].messommets[j].ay-y1)<=ty*1.1) )
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdpolycercle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCePolycercle;
    end;


     if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
   if ((abs((listepolycercle[-1+i].messommets[j].ax+listepolycercle[-1+i].messommets[j+1].ax)/2-x1)<=tx*1.1) and
    (abs((listepolycercle[-1+i].messommets[j].ay+listepolycercle[-1+i].messommets[j+1].ay)/2-y1)<=ty*1.1)
    and not((listepolycercle[-1+i].nombresommet=2) and (j=2)))
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdpolycercle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCePolycercle;
    end;


      if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
 if not(listepolycercle[-1+i].rectiligne[j]) then
   if ((abs(listepolycercle[-1+i].mess[j].ax-x1)<=tx*1.1) and
    (abs(listepolycercle[-1+i].mess[j].ay-y1)<=ty*1.1) )
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdpolycercle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCePolycercle;
    end;



     if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].cx-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeDiaphragme;
    end;

    if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeDiaphragme;
    end;

     if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeDiaphragme;
    end;

     if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].ap1x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].ap1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeDiaphragme;
    end;

     if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].ap2x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].ap2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeDiaphragme;
    end;


    if nombreoeil>0 then
 for i:=1 to nombreoeil do
   if ((abs(listeoeil[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeoeil[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdoeil;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetOeil;
    end;

    if nombreoeil>0 then
 for i:=1 to nombreoeil do
   if ((abs(listeoeil[-1+i].ax-x1)<=tx*1.1) and
    (abs(listeoeil[-1+i].ay-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdoeil;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetOeil;
    end;


    if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdecran;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetCran;
    end;

     if nombregroupe>0 then
 for i:=1 to nombregroupe do
   if ((abs(listegroupe[-1+i].isox-x1)<=tx*1.1) and
    (abs(listegroupe[-1+i].isoy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdgroupe;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeGroupe;
    end;


    if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdecran;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetCran;
    end;

     if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdecran;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetCran;
    end;


     if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].cx-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlsr;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLameSem;
    end;

    if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlsr;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLameSem;
    end;

     if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlsr;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLameSem;
    end;


    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;

    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;

   if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;

      if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].fy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;


    if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;


    if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;

    if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;

    if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].fy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;

     if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;

   if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;


    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;

     if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;


    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;

    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeMiroirSphR4;
    end;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].oy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLentill4;
    end;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLentill4;
    end;

     if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].f1x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].f1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLentill4;
    end;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLentill4;
    end;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].f2x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].f2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLentill4;
    end;



     if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelec[-1+i].oy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlec;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLentill4;
    end;

    if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].s1x-x1)<=tx*1.1) and
    (abs(listelec[-1+i].s1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlec;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLentill4;
    end;



    if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].s2x-x1)<=tx*1.1) and
    (abs(listelec[-1+i].s2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlec;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLentill4;
    end;

    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].oy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLentill4;
    end;


     if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLentill4;
    end;

     if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].f1x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].f1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLentill4;
    end;


    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteLentill4;
    end;

    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].f2x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].f2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=pchar(rscettelentill4);
    end;




    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].cx-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdrayon;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeRayon;
    end;

     if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].ax-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].ay-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdrayon;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCeRayon;
    end;

    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].bx-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].by-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdrayon;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rscerayon;
    end;


     if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].gx-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].gy-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsourceponctuelle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteSourceP;
    end;


    if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].sx-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].sy-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsourceponctuelle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rscettesourcep;
    end;

    if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].a1y-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsourceponctuelle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rscettesourcep;
    end;

  if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].a2y-y1)<=ty*1.1))
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsourceponctuelle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rscettesourcep;
    end;

   if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].a1y-y1)<=ty*1.1))
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdondeplane;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteOndePla;
    end;

     if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].sx-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].sy-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdondeplane;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteOndePla;
    end;

    if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].a2y-y1)<=ty*1.1))
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdondeplane;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
     setlength(liste_boum,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
     liste_boum[nombre_typeelementmodif-1]:=rsCetteOndePla;
    end;

    if nombre_typeelementmodif >1 then  begin
 form_quelobjet.ComboBox1.Items.Clear;
 form_quelobjet.Caption:=rsChoisissezLO;
 for i:=1 to  nombre_typeelementmodif do begin
 case liste_typeelementmodif[i-1]  of
 mdmetre:   form_quelobjet.ComboBox1.Items.Add(Format(rsMesureDeDist2, [inttostr
   (liste_indiceelementmodif[i-1])]));
 mdprisme:   form_quelobjet.ComboBox1.Items.Add(Format(rsPrismeN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdMiroirPlan: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirPlanN, [
   inttostr(liste_indiceelementmodif[i-1])]));

  mdReseau: form_quelobjet.ComboBox1.Items.Add(Format(rsReseauN, [
   inttostr(liste_indiceelementmodif[i-1])]));


 mdMscopa: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirConcav, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdMscepa: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirConvex, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdMscore: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirConcav2, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdMscere: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirConvex2, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdLmc: form_quelobjet.ComboBox1.Items.Add(Format(rsLentilleMinc5, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdLmd: form_quelobjet.ComboBox1.Items.Add(Format(rsLentilleMinc6, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdRayon: form_quelobjet.ComboBox1.Items.Add(Format(rsRayonN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdSourcePonctuelle: form_quelobjet.ComboBox1.Items.Add(Format(rsSourcePonctu2,
   [inttostr(liste_indiceelementmodif[i-1])]));
 mdOndePlane: form_quelobjet.ComboBox1.Items.Add(Format(rsOndePlaneN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdecran: form_quelobjet.ComboBox1.Items.Add(Format(rsEcranN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdlsr: form_quelobjet.ComboBox1.Items.Add(Format(rsLameSemiRFlC3, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdpolyhedre: form_quelobjet.ComboBox1.Items.Add(Format(rsPolyhDreRFra2, [
   inttostr(liste_indiceelementmodif[i-1])]));
 mdsphere: form_quelobjet.ComboBox1.Items.Add(Format(rsSphReRFracta2, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdmiroirconique: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirCNique2, [
   inttostr(liste_indiceelementmodif[i-1])]));
 mdtexteaffiche: form_quelobjet.ComboBox1.Items.Add(Format(rsTexteN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mddiaphragme: form_quelobjet.ComboBox1.Items.Add(Format(rsDiaphragmeN, [
   inttostr(liste_indiceelementmodif[i-1])]));
 mdlec: form_quelobjet.ComboBox1.Items.Add(Format(rsLentillePais2, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdangle: form_quelobjet.ComboBox1.Items.Add(Format(rsMesureDAngle3, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdpolycercle:   form_quelobjet.ComboBox1.Items.Add(Format(rsPolycercleRF2, [
   inttostr(liste_indiceelementmodif[i-1])]));
 mdfleche: form_quelobjet.ComboBox1.Items.Add(Format(rsFlCheN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdoeil: form_quelobjet.ComboBox1.Items.Add(Format(rsOeilN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdneant: form_quelobjet.ComboBox1.Items.Add(Format(rsNAntN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdgroupe: form_quelobjet.ComboBox1.Items.Add(Format(rsGroupeN, [inttostr(
   liste_indiceelementmodif[i-1])]));
  end;
  end;

  with form_quelobjet
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
  form_quelobjet.ShowModal;
  if form_quelobjet.ComboBox1.ItemIndex>=0 then begin
  typeelementmodif:=liste_typeelementmodif[form_quelobjet.ComboBox1.ItemIndex];
  indiceelementmodif:=liste_indiceelementmodif[form_quelobjet.ComboBox1.ItemIndex];
  boum:=liste_boum[form_quelobjet.ComboBox1.ItemIndex];
     end else indiceelementmodif:=0; end;

    if indiceelementmodif=0 then exit;

  if application.messagebox(pchar(Format(rsEtesVousSurD, [boum])), pchar(
    rsattention), mb_yesno)=
   idno  then exit;

   case typeelementmodif of
   mdmiroirplan: supprime1pmiroirplan(listemiroirplan,indiceelementmodif,nombremiroirplan);
    mdReseau: supprime1pReseau(listeReseau,indiceelementmodif,nombreReseau);
   mdfleche: supprime1pfleche(listefleche,indiceelementmodif,nombrefleche);
    mdlmc: supprime1plmc(listelmc,indiceelementmodif,nombrelmc);
     mdlmd: supprime1plmd(listelmd,indiceelementmodif,nombrelmd);
     mdlsr: supprime1plsr(listelsr,indiceelementmodif,nombrelsr);
      mdmscopa: supprime1pmscopa(listemscopa,indiceelementmodif,nombremscopa);
     mdmscepa: supprime1pmscepa(listemscepa,indiceelementmodif,nombremscepa);
      mdmscore: supprime1pmscore(listemscore,indiceelementmodif,nombremscore);
   mdmscere: supprime1pmscere(listemscere,indiceelementmodif,nombremscere);
  mdmiroirconique: supprime1pmiroirconique(listemiroirconique,indiceelementmodif,nombremiroirconique);
   mdecran: supprime1pecran(listeecran,indiceelementmodif,nombreecran);
    mdgroupe: supprime1pgroupe(listegroupe,indiceelementmodif,nombregroupe);
   mdoeil: supprime1poeil(listeoeil,indiceelementmodif,nombreoeil);
    mddiaphragme: supprime1pdiaphragme(listediaphragme,indiceelementmodif,nombrediaphragme);
     mdrayon: supprime1prayon(listerayon,indiceelementmodif,nombrerayon);
    mdsourceponctuelle: supprime1psourceponctuelle(listesourceponctuelle,indiceelementmodif,nombresourceponctuelle);
     mdondeplane: supprime1pondeplane(listeondeplane,indiceelementmodif,nombreondeplane);
      mdlec: supprime1plec(listelec,indiceelementmodif,nombrelec);
       mdpolyhedre: supprime1ppolyhedre(listepolyhedre,indiceelementmodif,nombrepolyhedre);
        mdprisme: supprime1pprisme(listeprisme,indiceelementmodif,nombreprisme);
  mdpolycercle: supprime1ppolycercle(listepolycercle,indiceelementmodif,nombrepolycercle);
 mdsphere: supprime1psphere(listesphere,indiceelementmodif,nombresphere);
  mdmetre: supprime1pmetre(listemetre,indiceelementmodif,nombremetre);
   mdangle: supprime1pangle(listeangle,indiceelementmodif,nombreangle);
    mdtexteaffiche: supprime1ptexteaffiche(listetexteaffiche,indiceelementmodif,nombretexte);
   end;
   form1.activeboutons;
modesuppression:=false;
form_palette.boutonsuppression.caption:=rsSupprimer;
form1.image1.Cursor:=crDefault;
form1.StatusBar1.Panels[2].text:='';
form1.StatusBar1.Panels[3].text:='';
Rafraichit;

    end;





    procedure effectuegroupement(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
  var

     x1,y1,tx,ty,distance:extended;
 i,j:integer;
   boum:string;
  begin


graphepresent:=true;
    BIBI.convert(x,y,x1,y1,true);
   BIBI.convert(3,form1.image1.height-3,tx,ty,true);
     tx:=tx-xxmin; ty:=ty-yymin;

     distance:=sqrt(sqr(xxmax-xxmin)+sqr(yymin-yymax));
     affichecoordonnees(x1,y1);

    {on recherche si le curseur est proche d'un centre, et si oui lequel}
      indiceelementmodif:=0;

      if nombretexte>0 then
 for i:=1 to nombretexte do
   if ((abs(listetexteaffiche[-1+i].x-x1)<=tx*1.1) and
    (abs(listetexteaffiche[-1+i].y-y1)<=ty*1.1) and
    (sqrt(sqr(listetexteaffiche[-1+i].x-x1)+sqr(listetexteaffiche[-1+i].y-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdtexteaffiche;
    boum:=rsTexte;
    distance:=sqrt(sqr(listetexteaffiche[-1+i].x-x1)+sqr(listetexteaffiche[-1+i].y-y1));
    end;


    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].sy-y1)<=ty*1.1) and
    (sqrt(sqr(listemiroirconique[-1+i].sx-x1)+sqr(listemiroirconique[-1+i].sy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
     boum:=rsMiroirConiqu;
    distance:=sqrt(sqr(listemiroirconique[-1+i].sx-x1)+sqr(listemiroirconique[-1+i].sy-y1));
    end;




 if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1) and
    (sqrt(sqr(listesphere[-1+i].cx-x1)+sqr(listesphere[-1+i].cy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
     boum:=rsSphRe;
    distance:=sqrt(sqr(listesphere[-1+i].cx-x1)+sqr(listesphere[-1+i].cy-y1));

    end;


    if nombreprisme>0 then
 for i:=1 to nombreprisme do
   if ((abs(listeprisme[-1+i].gx-x1)<=tx*1.1) and
    (abs(listeprisme[-1+i].gy-y1)<=ty*1.1) and
    (sqrt(sqr(listeprisme[-1+i].gx-x1)+sqr(listeprisme[-1+i].gy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdprisme;
     boum:=rsPrisme;
    distance:=sqrt(sqr(listeprisme[-1+i].gx-x1)+sqr(listeprisme[-1+i].gy-y1));

    end;





 if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].cy-y1)<=ty*1.1) and
    (sqrt(sqr(listemiroirplan[-1+i].cx-x1)+sqr(listemiroirplan[-1+i].cy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirplan;
     boum:=rsMiroirPlan;
    distance:=sqrt(sqr(listemiroirplan[-1+i].cx-x1)+sqr(listemiroirplan[-1+i].cy-y1));
          end;


 if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].cy-y1)<=ty*1.1) and
    (sqrt(sqr(listeReseau[-1+i].cx-x1)+sqr(listeReseau[-1+i].cy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdReseau;
     boum:=rsReseau;
    distance:=sqrt(sqr(listeReseau[-1+i].cx-x1)+sqr(listeReseau[-1+i].cy-y1));
          end;





 if nombreangle>0 then
 for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].cy-y1)<=ty*1.1) and
    (sqrt(sqr(listeangle[-1+i].cx-x1)+sqr(listeangle[-1+i].cy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdangle;
     boum:=rsMesureDAngle4;
    distance:=sqrt(sqr(listeangle[-1+i].cx-x1)+sqr(listeangle[-1+i].cy-y1));
    end;



    if nombremetre>0 then
 for i:=1 to nombremetre do
   if ((abs(listemetre[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemetre[-1+i].cy-y1)<=ty*1.1) and
    (sqrt(sqr(listemetre[-1+i].cx-x1)+sqr(listemetre[-1+i].cy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmetre;
    boum:=rsMesureDeDist;
    distance:=sqrt(sqr(listemetre[-1+i].cx-x1)+sqr(listemetre[-1+i].cy-y1));
          end;


    if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].cx-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].cy-y1)<=ty*1.1) and
    (sqrt(sqr(listefleche[-1+i].cx-x1)+sqr(listefleche[-1+i].cy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdfleche;
     boum:=rsTrait;
    distance:=sqrt(sqr(listefleche[-1+i].cx-x1)+sqr(listefleche[-1+i].cy-y1));
        end;



     if nombrepolyhedre>0 then
 for i:=1 to nombrepolyhedre do

   if ((abs(listepolyhedre[-1+i].xiso-x1)<=tx*1.1) and
    (abs(listepolyhedre[-1+i].yiso-y1)<=ty*1.1) and
    (sqrt(sqr(listepolyhedre[-1+i].xiso-x1)+sqr(listepolyhedre[-1+i].yiso-y1))<distance))
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdpolyhedre;
     boum:=rsPolygone;
    distance:=sqrt(sqr(listepolyhedre[-1+i].xiso-x1)+sqr(listepolyhedre[-1+i].yiso-y1));
    end;


     if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do

   if ((abs(listepolycercle[-1+i].xiso-x1)<=tx*1.1) and
    (abs(listepolycercle[-1+i].yiso-y1)<=ty*1.1) and
    (sqrt(sqr(listepolycercle[-1+i].xiso-x1)+sqr(listepolycercle[-1+i].yiso-y1))<distance))
     then
   begin
    indiceelementmodif:=i;  indicepointdeplace:=j;
    typeelementmodif:=mdpolycercle;
     boum:=rsPolycercle;
    distance:=sqrt(sqr(listepolycercle[-1+i].xiso-x1)+sqr(listepolycercle[-1+i].yiso-y1));
    end;






     if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].cx-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].cy-y1)<=ty*1.1) and
    (sqrt(sqr(listediaphragme[-1+i].cx-x1)+sqr(listediaphragme[-1+i].cy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
     boum:=rsDiaphragme;
    distance:=sqrt(sqr(listediaphragme[-1+i].cx-x1)+sqr(listediaphragme[-1+i].cy-y1));
         end;


    if nombreoeil>0 then
 for i:=1 to nombreoeil do
   if ((abs(listeoeil[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeoeil[-1+i].cy-y1)<=ty*1.1) and
    (sqrt(sqr(listeoeil[-1+i].cx-x1)+sqr(listeoeil[-1+i].cy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
     boum:=rsOeil;
    typeelementmodif:=mdoeil;
    distance:=sqrt(sqr(listeoeil[-1+i].cx-x1)+sqr(listeoeil[-1+i].cy-y1));
         end;


    if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].cy-y1)<=ty*1.1) and
    (sqrt(sqr(listeecran[-1+i].cx-x1)+sqr(listeecran[-1+i].cy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdecran;
     boum:=rsEcran;
    distance:=sqrt(sqr(listeecran[-1+i].cx-x1)+sqr(listeecran[-1+i].cy-y1));
          end;



     if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].cx-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].cy-y1)<=ty*1.1) and
    (sqrt(sqr(listelsr[-1+i].cx-x1)+sqr(listelsr[-1+i].cy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlsr;
     boum:=rsLameSemiRFle;
    distance:=sqrt(sqr(listelsr[-1+i].cx-x1)+sqr(listelsr[-1+i].cy-y1));
        end;


    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].sy-y1)<=ty*1.1)and
    (sqrt(sqr(listemscopa[-1+i].sx-x1)+sqr(listemscopa[-1+i].sy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
     boum:=rsMiroirConcav3;
    distance:=sqrt(sqr(listemscopa[-1+i].sx-x1)+sqr(listemscopa[-1+i].sy-y1));
          end;


    if nombremscepa>0 then
    for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].sy-y1)<=ty*1.1)and
    (sqrt(sqr(listemscepa[-1+i].sx-x1)+sqr(listemscepa[-1+i].sy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
     boum:=rsMiroirConvex3;
    distance:=sqrt(sqr(listemscepa[-1+i].sx-x1)+sqr(listemscepa[-1+i].sy-y1));
        end;


    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].sy-y1)<=ty*1.1)and
    (sqrt(sqr(listemscore[-1+i].sx-x1)+sqr(listemscore[-1+i].sy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
     boum:=rsMiroirSphRiq;
    distance:=sqrt(sqr(listemscore[-1+i].sx-x1)+sqr(listemscore[-1+i].sy-y1));
         end;



    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].sy-y1)<=ty*1.1)and
    (sqrt(sqr(listemscere[-1+i].sx-x1)+sqr(listemscere[-1+i].sy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
     boum:=rsMiroirSphRiq2;
    distance:=sqrt(sqr(listemscere[-1+i].sx-x1)+sqr(listemscere[-1+i].sy-y1));
           end;





    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].oy-y1)<=ty*1.1)and
    (sqrt(sqr(listelmc[-1+i].ox-x1)+sqr(listelmc[-1+i].oy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
     boum:=rsLentilleMinc;
    distance:=sqrt(sqr(listelmc[-1+i].ox-x1)+sqr(listelmc[-1+i].oy-y1));
         end;





     if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelec[-1+i].oy-y1)<=ty*1.1)and
    (sqrt(sqr(listelec[-1+i].ox-x1)+sqr(listelec[-1+i].oy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlec;
     boum:=rsLentillePais;
    distance:=sqrt(sqr(listelec[-1+i].ox-x1)+sqr(listelec[-1+i].oy-y1));
          end;




    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].oy-y1)<=ty*1.1)and
    (sqrt(sqr(listelmd[-1+i].ox-x1)+sqr(listelmd[-1+i].oy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
     boum:=rsLentilleMinc2;
    distance:=sqrt(sqr(listelmd[-1+i].ox-x1)+sqr(listelmd[-1+i].oy-y1));
           end;






    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].cx-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].cy-y1)<=ty*1.1)and
    (sqrt(sqr(listerayon[-1+i].cx-x1)+sqr(listerayon[-1+i].cy-y1))<
    distance)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdrayon;
     boum:=rsRayon;
    distance:=sqrt(sqr(listerayon[-1+i].cx-x1)+sqr(listerayon[-1+i].cy-y1));
         end;


     if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].gx-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].gy-y1)<=ty*1.1) and
    (sqrt(sqr(listesourceponctuelle[-1+i].gx-x1)+
    sqr(listesourceponctuelle[-1+i].gy-y1))<
    distance ))
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsourceponctuelle;
     boum:=rsSourcePonctu;
    distance:=sqrt(sqr(listesourceponctuelle[-1+i].gx-x1)+
    sqr(listesourceponctuelle[-1+i].gy-y1));
          end;





     if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].sx-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].sy-y1)<=ty*1.1) and
    (sqrt(sqr(listeondeplane[-1+i].sx-x1)+
    sqr(listeondeplane[-1+i].sy-y1))<
    distance ))
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdondeplane;
     boum:=rsOndePlane;
    distance:=sqrt(sqr(listeondeplane[-1+i].sx-x1)+
    sqr(listeondeplane[-1+i].sy-y1));
         end;



    if indiceelementmodif=0 then exit;
    groupeprovisoire.add(typeelementmodif,indiceelementmodif);
     application.messagebox(pchar(Format(rsAjoutAuGroup, [boum, inttostr(
       nombregroupe+1)])), pchar(rsFait), mb_ok);
    end;{de effectue groupement}


  {*****************info en cas de clic***************************************}
  procedure Info(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
  var
     newmenuitem:tmenuitem;
     x1,y1,tx,ty,tx1,ty1,distance:extended;
 i,j:integer;        infofound:boolean;
 oldnombremiroirplan,oldnombrereseau,oldnombremscopa,oldnombremscepa,oldnombremscore,
 oldnombremscere,oldnombrelmc,oldnombrelmd,oldnombrerayon,
 oldnombresourceponctuelle,oldnombreondeplane,oldnombreecran,oldnombrepolyhedre,
 oldnombrelsr,oldnombresphere,oldnombremiroirconique,
 oldnombretexte,oldnombrediaphragme,oldnombrelec,oldnombremetre,oldnombreangle,
 oldnombrepolycercle,oldnombrefleche,oldnombreoeil,oldnombregroupe,
 oldnombreprisme:integer;
  begin
 infofound:=false;

graphepresent:=true;
    BIBI.convert(x,y,x1,y1,true);
    BIBI.convert(3,form1.image1.height-3,tx,ty,true);
     tx:=tx-xxmin; ty:=ty-yymin;

     distance:=sqrt(sqr(xxmax-xxmin)+sqr(yymin-yymax));
      affichecoordonnees(x1,y1);

    {on recherche si le curseur est proche d'un centre, et si oui lequel}
 if not(modeduplication) then begin
 nombre_typeelementmodif:=0;

  if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].cx-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdfleche;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


  if nombremetre>0 then
 for i:=1 to nombremetre do
   if ((abs(listemetre[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemetre[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmetre;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;




    if nombreangle>0 then
 for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdangle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


 if nombretexte>0 then
 for i:=1 to nombretexte do
   if ((abs(listetexteaffiche[-1+i].x-x1)<=tx*1.1) and
    (abs(listetexteaffiche[-1+i].y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdtexteaffiche;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


  if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx+listesphere[-1+i].rayon-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy+listesphere[-1+i].rayon-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-listesphere[-1+i].rayon-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-listesphere[-1+i].rayon-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

  if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].fy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

 if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirplan;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirplan;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirplan;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;



     if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdReseau;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdReseau;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdReseau;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombrepolyhedre>0 then
 for i:=1 to nombrepolyhedre do
 for j:=1 to listepolyhedre[-1+i].nombresommet do
   if ((abs(listepolyhedre[-1+i].messommets[j].ax-x1)<=tx*1.1) and
    (abs(listepolyhedre[-1+i].messommets[j].ay-y1)<=ty*1.1) )
     then
   begin
    indiceelementmodif:=i;
    typeelementmodif:=mdpolyhedre;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombreprisme>0 then
 for i:=1 to nombreprisme do
 for j:=1 to listeprisme[-1+i].nombresommet do
   if ((abs(listeprisme[-1+i].messommets[j].ax-x1)<=tx*1.1) and
    (abs(listeprisme[-1+i].messommets[j].ay-y1)<=ty*1.1) )
     then
   begin
    indiceelementmodif:=i;
    typeelementmodif:=mdprisme;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


     if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
   if ((abs(listepolycercle[-1+i].messommets[j].ax-x1)<=tx*1.1) and
    (abs(listepolycercle[-1+i].messommets[j].ay-y1)<=ty*1.1) )
     then
   begin
    indiceelementmodif:=i;
    typeelementmodif:=mdpolycercle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


     if nombreoeil>0 then
 for i:=1 to nombreoeil do
   if ((abs(listeoeil[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeoeil[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdoeil;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombreoeil>0 then
 for i:=1 to nombreoeil do
   if ((abs(listeoeil[-1+i].ax-x1)<=tx*1.1) and
    (abs(listeoeil[-1+i].ay-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdoeil;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdecran;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdecran;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdecran;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


     if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].cx-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].a2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].ap1x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].ap1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].ap2x-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].ap2y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
 inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;



    if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].cx-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlsr;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].a1y-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlsr;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlsr;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].fy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombremscepa>0 then
  for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombremscepa>0 then
  for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].fx-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].fy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombremscepa>0 then
  for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombremscepa>0 then
  for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].oy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].f1x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].f1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].f2x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].f2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


     if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelec[-1+i].oy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlec;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].s1x-x1)<=tx*1.1) and
    (abs(listelec[-1+i].s1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlec;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].s2x-x1)<=tx*1.1) and
    (abs(listelec[-1+i].s2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlec;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].oy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].f1x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].f1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].f2x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].f2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].a1y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].a2y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].cx-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdrayon;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].ax-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].ay-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdrayon;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].bx-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].by-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdrayon;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].sx-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].sy-y1)<=ty*1.1))
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsourceponctuelle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].a1y-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsourceponctuelle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs(listesourceponctuelle[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listesourceponctuelle[-1+i].a2y-y1)<=ty*1.1))
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsourceponctuelle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;

    infofound:=true;
    end;

   if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].a1y-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdondeplane;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].sx-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].sy-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdondeplane;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].a2x-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].a2y-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdondeplane;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].ray[listeondeplane[-1+i].nombrederayon].bx-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].ray[listeondeplane[-1+i].nombrederayon].by-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdondeplane;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;
       end;
       {mode duplication}
       if modeduplication then begin
       nombre_typeelementmodif:=0;
   if nombretexte>0 then
 for i:=1 to nombretexte do
   if ((abs(listetexteaffiche[-1+i].x-x1)<=tx*1.1) and
    (abs(listetexteaffiche[-1+i].y-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdtexteaffiche;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombrefleche>0 then
 for i:=1 to nombrefleche do
   if ((abs(listefleche[-1+i].cx-x1)<=tx*1.1) and
    (abs(listefleche[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdfleche;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

       if nombremetre>0 then
 for i:=1 to nombremetre do
   if ((abs(listemetre[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemetre[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmetre;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombreangle>0 then
 for i:=1 to nombreangle do
   if ((abs(listeangle[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeangle[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdangle;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


  if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx+listesphere[-1+i].rayon-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy+listesphere[-1+i].rayon-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-listesphere[-1+i].rayon-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombresphere>0 then
 for i:=1 to nombresphere do
   if ((abs(listesphere[-1+i].cx-x1)<=tx*1.1) and
    (abs(listesphere[-1+i].cy-listesphere[-1+i].rayon-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsphere;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

 if nombremiroirplan>0 then
 for i:=1 to nombremiroirplan do
   if ((abs(listemiroirplan[-1+i].cx-x1)<=tx*1.1) and
    (abs(listemiroirplan[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirplan;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

  if nombreReseau>0 then
 for i:=1 to nombreReseau do
   if ((abs(listeReseau[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeReseau[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdReseau;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

 if nombremiroirconique>0 then
 for i:=1 to nombremiroirconique do
   if ((abs(listemiroirconique[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemiroirconique[-1+i].sy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmiroirconique;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

    if nombrepolyhedre>0 then
 for i:=1 to nombrepolyhedre do
 for j:=1 to listepolyhedre[-1+i].nombresommet do
   if ((abs((listepolyhedre[-1+i].messommets[j].ax+
   listepolyhedre[-1+i].messommets[j+1].ax)/2-x1)<=tx*1.1) and
    (abs((listepolyhedre[-1+i].messommets[j].ay+listepolyhedre[-1+i].messommets[j+1].ay)/2-y1)<=ty*1.1) )
     then
   begin
    indiceelementmodif:=i; indicepointdeplace:=j;
    typeelementmodif:=mdpolyhedre;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;



    if nombreprisme>0 then
 for i:=1 to nombreprisme do
 for j:=1 to listeprisme[-1+i].nombresommet do
   if ((abs((listeprisme[-1+i].messommets[j].ax+
   listeprisme[-1+i].messommets[j+1].ax)/2-x1)<=tx*1.1) and
    (abs((listeprisme[-1+i].messommets[j].ay+listeprisme[-1+i].messommets[j+1].ay)/2-y1)<=ty*1.1) )
     then
   begin
    indiceelementmodif:=i; indicepointdeplace:=j;
    typeelementmodif:=mdprisme;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


     if nombrepolycercle>0 then
 for i:=1 to nombrepolycercle do
 for j:=1 to listepolycercle[-1+i].nombresommet do
   if ((abs((listepolycercle[-1+i].messommets[j].ax+
   listepolycercle[-1+i].messommets[j+1].ax)/2-x1)<=tx*1.1) and
    (abs((listepolycercle[-1+i].messommets[j].ay+listepolycercle[-1+i].messommets[j+1].ay)/2-y1)<=ty*1.1)
    and not((listepolycercle[-1+i].nombresommet=2) and (j=2)))
     then
   begin
    indiceelementmodif:=i; indicepointdeplace:=j;
    typeelementmodif:=mdpolycercle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;



    if nombreecran>0 then
 for i:=1 to nombreecran do
   if ((abs(listeecran[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeecran[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdecran;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

     if nombreoeil>0 then
 for i:=1 to nombreoeil do
   if ((abs(listeoeil[-1+i].cx-x1)<=tx*1.1) and
    (abs(listeoeil[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdoeil;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombrediaphragme>0 then
 for i:=1 to nombrediaphragme do
   if ((abs(listediaphragme[-1+i].cx-x1)<=tx*1.1) and
    (abs(listediaphragme[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mddiaphragme;
  inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;



    if nombrelsr>0 then
 for i:=1 to nombrelsr do
   if ((abs(listelsr[-1+i].cx-x1)<=tx*1.1) and
    (abs(listelsr[-1+i].cy-y1)<=ty*1.1) ) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlsr;
 inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;





    if nombremscopa>0 then
  for i:=1 to nombremscopa do
   if ((abs(listemscopa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscopa[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscopa;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;




    if nombremscepa>0 then
  for i:=1 to nombremscepa do
   if ((abs(listemscepa[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscepa[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscepa;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;




    if nombremscore>0 then
    for i:=1 to nombremscore do
   if ((abs(listemscore[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscore[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscore;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;



    if nombremscere>0 then
    for i:=1 to nombremscere do
   if ((abs(listemscere[-1+i].sx-x1)<=tx*1.1) and
    (abs(listemscere[-1+i].sy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdmscere;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;



    if nombrelmc>0 then
    for i:=1 to nombrelmc do
   if ((abs(listelmc[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmc[-1+i].oy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmc;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


     if nombrelec>0 then
    for i:=1 to nombrelec do
   if ((abs(listelec[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelec[-1+i].oy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlec;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;



    if nombrelmd>0 then
    for i:=1 to nombrelmd do
   if ((abs(listelmd[-1+i].ox-x1)<=tx*1.1) and
    (abs(listelmd[-1+i].oy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdlmd;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombrerayon>0 then
    for i:=1 to nombrerayon do
   if ((abs(listerayon[-1+i].cx-x1)<=tx*1.1) and
    (abs(listerayon[-1+i].cy-y1)<=ty*1.1)) then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdrayon;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;


    if nombresourceponctuelle>0 then
    for i:=1 to nombresourceponctuelle do
   if ((abs((listesourceponctuelle[-1+i].a1x+listesourceponctuelle[-1+i].a2x)/2-x1)<=tx*1.1) and
    (abs((listesourceponctuelle[-1+i].a1y+listesourceponctuelle[-1+i].a2y)/2-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdsourceponctuelle;
    inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;



   if nombreondeplane>0 then
    for i:=1 to nombreondeplane do
   if ((abs(listeondeplane[-1+i].a1x-x1)<=tx*1.1) and
    (abs(listeondeplane[-1+i].a1y-y1)<=ty*1.1) )
     then begin
    indiceelementmodif:=i;
    typeelementmodif:=mdondeplane;
   inc(nombre_typeelementmodif);
    setlength(liste_typeelementmodif,nombre_typeelementmodif);
     setlength(liste_indiceelementmodif,nombre_typeelementmodif);
      liste_typeelementmodif[nombre_typeelementmodif-1]:=typeelementmodif;
       liste_indiceelementmodif[nombre_typeelementmodif-1]:=indiceelementmodif;
    infofound:=true;
    end;

end; {du cas duplication}



    if not(infofound) then begin
    if not(modeduplication) then
    form1.image1.Cursor:=crprop else
       form1.image1.Cursor:=crdefault;
    exit;
   end;


  if nombre_typeelementmodif >1 then  begin
 form_quelobjet.ComboBox1.Items.Clear;
 if not(modeduplication) then   form_quelobjet.Caption:=rsPropriTSDeLO2 else
  form_quelobjet.Caption:=rsObjetDupliqu;
 for i:=1 to  nombre_typeelementmodif do begin
 case liste_typeelementmodif[i-1]  of
 mdmetre:   form_quelobjet.ComboBox1.Items.Add(Format(rsMesureDeDist2, [inttostr
   (liste_indiceelementmodif[i-1])]));
 mdprisme:   form_quelobjet.ComboBox1.Items.Add(Format(rsPrismeN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdMiroirPlan: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirPlanN, [
   inttostr(liste_indiceelementmodif[i-1])]));

 mdReseau: form_quelobjet.ComboBox1.Items.Add(Format(rsReseauN, [
   inttostr(liste_indiceelementmodif[i-1])]));

 mdMscopa: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirConcav, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdMscepa: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirConvex, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdMscore: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirConcav2, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdMscere: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirConvex2, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdLmc: form_quelobjet.ComboBox1.Items.Add(Format(rsLentilleMinc5, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdLmd: form_quelobjet.ComboBox1.Items.Add(Format(rsLentilleMinc6, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdRayon: form_quelobjet.ComboBox1.Items.Add(Format(rsRayonN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdSourcePonctuelle: form_quelobjet.ComboBox1.Items.Add(Format(rsSourcePonctu2,
   [inttostr(liste_indiceelementmodif[i-1])]));
 mdOndePlane: form_quelobjet.ComboBox1.Items.Add(Format(rsOndePlaneN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdecran: form_quelobjet.ComboBox1.Items.Add(Format(rsEcranN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdlsr: form_quelobjet.ComboBox1.Items.Add(Format(rsLameSemiRFlC3, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdpolyhedre: form_quelobjet.ComboBox1.Items.Add(Format(rsPolyhDreRFra2, [
   inttostr(liste_indiceelementmodif[i-1])]));
 mdsphere: form_quelobjet.ComboBox1.Items.Add(Format(rsSphReRFracta2, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdmiroirconique: form_quelobjet.ComboBox1.Items.Add(Format(rsMiroirCNique2, [
   inttostr(liste_indiceelementmodif[i-1])]));
 mdtexteaffiche: form_quelobjet.ComboBox1.Items.Add(Format(rsTexteN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mddiaphragme: form_quelobjet.ComboBox1.Items.Add(Format(rsDiaphragmeN, [
   inttostr(liste_indiceelementmodif[i-1])]));
 mdlec: form_quelobjet.ComboBox1.Items.Add(Format(rsLentillePais2, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdangle: form_quelobjet.ComboBox1.Items.Add(Format(rsMesureDAngle5, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdpolycercle:   form_quelobjet.ComboBox1.Items.Add(Format(rsPolycercleRF2, [
   inttostr(liste_indiceelementmodif[i-1])]));
 mdfleche: form_quelobjet.ComboBox1.Items.Add(Format(rsFlCheN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdoeil: form_quelobjet.ComboBox1.Items.Add(Format(rsOeilN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdneant: form_quelobjet.ComboBox1.Items.Add(Format(rsNAntN, [inttostr(
   liste_indiceelementmodif[i-1])]));
 mdgroupe: form_quelobjet.ComboBox1.Items.Add(Format(rsGroupeN, [inttostr(
   liste_indiceelementmodif[i-1])]));
  end;
  end;

  with form_quelobjet
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
showmodal;
end;
  if form_quelobjet.ComboBox1.ItemIndex>=0 then begin
  typeelementmodif:=liste_typeelementmodif[form_quelobjet.ComboBox1.ItemIndex];
  indiceelementmodif:=liste_indiceelementmodif[form_quelobjet.ComboBox1.ItemIndex];

     end else begin
     indiceelementmodif:=0;
     typeelementmodif:=mdneant;
     end;   end;


   if not(modeduplication) then

    case typeelementmodif of

    mdmetre:begin
oldnombremetre:=nombremetre;

  with saisiemetre
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
saisiemetre.Caption:=rsPropriTSDeCe23;
saisiemetre.boutonsup.enabled:=true;
saisiemetre.editx1.text:=floattostr(listemetre[-1+indiceelementmodif].a1x);
saisiemetre.editx2.text:=floattostr(listemetre[-1+indiceelementmodif].a2x);
saisiemetre.edity1.text:=floattostr(listemetre[-1+indiceelementmodif].a1y);
saisiemetre.edity2.text:=floattostr(listemetre[-1+indiceelementmodif].a2y);
saisiemetre.log1.Caption:=unitelongueur;
     saisiemetre.log2.Caption:=unitelongueur;
     saisiemetre.log3.Caption:=unitelongueur;
      saisiemetre.log4.Caption:=unitelongueur;
if saisiemetre.showmodal=mrno then  begin
 supprime1pmetre(listemetre,indiceelementmodif,nombremetre);
 sauvevirtuel; end else
 if nombremetre>oldnombremetre then begin
 listemetre[-1+indiceelementmodif].create(listemetre[-1+nombremetre].a1x,
 listemetre[-1+nombremetre].a1y,listemetre[-1+nombremetre].a2x,listemetre[-1+nombremetre].a2y);
 retaillepmetre(listemetre,nombremetre,nombremetre-1);
 dec(nombremetre);
 sauvevirtuel;
    end;
    end;


    mdfleche:begin
oldnombrefleche:=nombrefleche;

  with saisiefle1
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
saisiefle1.boutonsup.enabled:=true;
saisiefle1.caption:=rsPropriTSDeCe4;
saisiefle1.editx1.text:=floattostr(listefleche[-1+indiceelementmodif].a1x);
saisiefle1.editx2.text:=floattostr(listefleche[-1+indiceelementmodif].a2x);
saisiefle1.edity1.text:=floattostr(listefleche[-1+indiceelementmodif].a1y);
saisiefle1.edity2.text:=floattostr(listefleche[-1+indiceelementmodif].a2y);
saisiefle1.spinepaisseur.value:=listefleche[-1+indiceelementmodif].epaisseur;
saisiefle1.spintaille1.value:=listefleche[-1+indiceelementmodif].taille1;
saisiefle1.spintaille2.value:=listefleche[-1+indiceelementmodif].taille2;
case  listefleche[-1+indiceelementmodif].ext1 of
 trien: saisiefle1.radioext1.itemindex:=0;
 tffleche: saisiefle1.radioext1.itemindex:=1;
 ttrait: saisiefle1.radioext1.itemindex:=2;
 trond: saisiefle1.radioext1.itemindex:=3;
 tcroix: saisiefle1.radioext1.itemindex:=4;
 tcroixx: saisiefle1.radioext1.itemindex:=5;
 tdisque: saisiefle1.radioext1.itemindex:=6;
 end;
 case  listefleche[-1+indiceelementmodif].ext2 of
 trien: saisiefle1.radioext2.itemindex:=0;
 tffleche: saisiefle1.radioext2.itemindex:=1;
 ttrait: saisiefle1.radioext2.itemindex:=2;
 trond: saisiefle1.radioext2.itemindex:=3;
 tcroix: saisiefle1.radioext2.itemindex:=4;
 tcroixx: saisiefle1.radioext2.itemindex:=5;
 tdisque: saisiefle1.radioext2.itemindex:=6;
 end;

 case listefleche[-1+indiceelementmodif].styletrait of
 pssolid:   saisiefle1.radiostyletrait.itemindex:=0;
 psdot:   saisiefle1.radiostyletrait.itemindex:=1;
 psdash: saisiefle1.radiostyletrait.itemindex:=2;
 psdashdot: saisiefle1.radiostyletrait.itemindex:=3;
 psdashdotdot: saisiefle1.radiostyletrait.itemindex:=4;
 end;


saisiefle1.colorgrid1.selected:=(
listefleche[-1+indiceelementmodif].couleur) ;


saisiefle1.log1.Caption:=unitelongueur;
     saisiefle1.log2.Caption:=unitelongueur;
     saisiefle1.log3.Caption:=unitelongueur;
      saisiefle1.log4.Caption:=unitelongueur;
if saisiefle1.showmodal=mrno then begin
 supprime1pfleche(listefleche,indiceelementmodif,nombrefleche);
  sauvevirtuel; end else
 if nombrefleche>oldnombrefleche then begin
 listefleche[-1+indiceelementmodif].create(listefleche[-1+nombrefleche].a1x,
 listefleche[-1+nombrefleche].a1y,listefleche[-1+nombrefleche].a2x,listefleche[-1+nombrefleche].a2y,
 listefleche[-1+nombrefleche].epaisseur,listefleche[-1+nombrefleche].couleur,
 listefleche[-1+nombrefleche].ext1,listefleche[-1+nombrefleche].ext2,
 listefleche[-1+nombrefleche].styletrait,
 listefleche[-1+nombrefleche].taille1, listefleche[-1+nombrefleche].taille2);
 retaillepfleche(listefleche,nombrefleche,nombrefleche-1);
 dec(nombrefleche);
  sauvevirtuel;
    end;
    end;



    mdangle:begin
oldnombreangle:=nombreangle;

  with saisieangle
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
saisieangle.boutonsup.enabled:=true;
saisieangle.editx1.text:=floattostr(listeangle[-1+indiceelementmodif].a1x);
saisieangle.editx2.text:=floattostr(listeangle[-1+indiceelementmodif].a2x);
saisieangle.editcx.text:=floattostr(listeangle[-1+indiceelementmodif].cx);
saisieangle.editcy.text:=floattostr(listeangle[-1+indiceelementmodif].cy);
saisieangle.edity1.text:=floattostr(listeangle[-1+indiceelementmodif].a1y);
saisieangle.edity2.text:=floattostr(listeangle[-1+indiceelementmodif].a2y);
saisieangle.log1.Caption:=unitelongueur;
saisieangle.Caption:=rsPropriTSDeCe5;
     saisieangle.log2.Caption:=unitelongueur;
     saisieangle.log3.Caption:=unitelongueur;
      saisieangle.log4.Caption:=unitelongueur;
      saisieangle.log5.Caption:=unitelongueur;
      saisieangle.log6.Caption:=unitelongueur;
if saisieangle.showmodal=mrno then  begin
 supprime1pangle(listeangle,indiceelementmodif,nombreangle);
  sauvevirtuel; end else
 if nombreangle>oldnombreangle then begin
 listeangle[-1+indiceelementmodif].create(listeangle[-1+nombreangle].cx,
 listeangle[-1+nombreangle].cy,listeangle[-1+nombreangle].a1x,
 listeangle[-1+nombreangle].a1y,listeangle[-1+nombreangle].a2x,listeangle[-1+nombreangle].a2y);
 retaillepangle(listeangle,nombreangle,nombreangle-1);
 dec(nombreangle);
  sauvevirtuel;
    end;
    end;


    mdtexteaffiche: begin
    oldnombretexte:=nombretexte;

       with saisietexte2
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
     fontetexte2:=saisietexte2.edit1.Font;
  saisietexte2.fontdialog1.font:=saisietexte2.edit1.Font;
  saisietexte2.fontdialog1.font.name:=listetexteaffiche[-1+indiceelementmodif].policename;
  saisietexte2.fontdialog1.font.charset:=listetexteaffiche[-1+indiceelementmodif].policecharset;
  saisietexte2.fontdialog1.font.size:=listetexteaffiche[-1+indiceelementmodif].policesize;
  saisietexte2.fontdialog1.font.color:=listetexteaffiche[-1+indiceelementmodif].policecolor;
 saisietexte2.fontdialog1.font.pitch:=listetexteaffiche[-1+indiceelementmodif].policepitch;
  saisietexte2.fontdialog1.font.style:=[];
  if  listetexteaffiche[-1+indiceelementmodif].policefsbold then
  saisietexte2.fontdialog1.font.style:=saisietexte2.fontdialog1.font.style+[fsbold];
  if  listetexteaffiche[-1+indiceelementmodif].policefsitalic then
  saisietexte2.fontdialog1.font.style:=saisietexte2.fontdialog1.font.style+[fsitalic];
  if  listetexteaffiche[-1+indiceelementmodif].policefsunderline then
  saisietexte2.fontdialog1.font.style:=saisietexte2.fontdialog1.font.style+[fsunderline];
  if  listetexteaffiche[-1+indiceelementmodif].policefsstrikeout then
  saisietexte2.fontdialog1.font.style:=saisietexte2.fontdialog1.font.style+[fsstrikeout];
  unit10.fontetexte2:=saisietexte2.fontdialog1.font;
  saisietexte2.edit1.text:=listetexteaffiche[-1+indiceelementmodif].texteluimeme;
  saisietexte2.editx.text:=floattostr(listetexteaffiche[-1+indiceelementmodif].x);
  saisietexte2.edity.text:=floattostr(listetexteaffiche[-1+indiceelementmodif].y);
 saisietexte2.boutonsup.enabled:=true;
 saisietexte2.log2.Caption:=unitelongueur;
    saisietexte2.log1.Caption:=unitelongueur;
    saisietexte2.Caption:=rsPropriTSDeCe6;
 if saisietexte2.showmodal=mrno then begin
 supprime1ptexteaffiche(listetexteaffiche,indiceelementmodif,nombretexte);
  sauvevirtuel; end else
 if nombretexte>oldnombretexte then begin
 listetexteaffiche[-1+indiceelementmodif].create({texteaafficher2,fontetexte2.name,
 fontetexte2.charset,fontetexte2.color,fontetexte2.size,fontetexte2.pitch,
 (fsbold in fontetexte2.style),(fsitalic in fontetexte2.style),
 (fsunderline in fontetexte2.style),(fsstrikeout in fontetexte2.style),
 textex,textey}
 listetexteaffiche[-1+nombretexte].texteluimeme, listetexteaffiche[-1+nombretexte].policename,
 listetexteaffiche[-1+nombretexte].policecharset,listetexteaffiche[-1+nombretexte].policecolor,
 listetexteaffiche[-1+nombretexte].policesize,listetexteaffiche[-1+nombretexte].policepitch,
 listetexteaffiche[-1+nombretexte].policefsbold,listetexteaffiche[-1+nombretexte].policefsitalic,
 listetexteaffiche[-1+nombretexte].policefsunderline,listetexteaffiche[-1+nombretexte].policefsstrikeout,
 listetexteaffiche[-1+nombretexte].x,listetexteaffiche[-1+nombretexte].y);
 retailleptexteaffiche(listetexteaffiche,nombretexte,nombretexte-1);
 dec(nombretexte);
  sauvevirtuel;
    end;
      end;



    mdsphere: begin
    oldnombresphere:=nombresphere;

    saisiesph.combomateriaux.items:=listemateriaux;
saisiesph.combomateriaux.itemindex:=0;
      with saisiesph
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisiesph.editx.text:=floattostr(listesphere[-1+indiceelementmodif].cx);
     saisiesph.edity.text:=floattostr(listesphere[-1+indiceelementmodif].cy);
      saisiesph.editrayon.text:=floattostr(listesphere[-1+indiceelementmodif].rayon);
      saisiesph.editnrouge.text:=floattostr(listesphere[-1+indiceelementmodif].indicerouge);
       saisiesph.editnvert.text:=floattostr(listesphere[-1+indiceelementmodif].indicevert);
        saisiesph.editnbleu.text:=floattostr(listesphere[-1+indiceelementmodif].indicebleu);
     case  listesphere[-1+indiceelementmodif].reflechientrant of
       toujoursreflechi: saisiesph.radioentrant.ItemIndex:=0;
       jamaisreflechi: saisiesph.radioentrant.ItemIndex:=1;
      reflechisirefracte: saisiesph.radioentrant.ItemIndex:=2;
       reflechisipasrefracte: saisiesph.radioentrant.ItemIndex:=3;
       end;
        case  listesphere[-1+indiceelementmodif].reflechisortant of
       toujoursreflechi: saisiesph.radiosortant.ItemIndex:=0;
       jamaisreflechi: saisiesph.radiosortant.ItemIndex:=1;
      reflechisirefracte: saisiesph.radiosortant.ItemIndex:=2;
       reflechisipasrefracte: saisiesph.radiosortant.ItemIndex:=3;
       end;
       saisiesph.boutonsup.enabled:=true;

saisiesph.colorgrid1.selected:=(
listesphere[-1+indiceelementmodif].couleurfond);
    saisiesph.log1.Caption:=unitelongueur;
     saisiesph.log2.Caption:=unitelongueur;
     saisiesph.log3.Caption:=unitelongueur;
     if saisiesph.showmodal=mrno then  begin
 supprime1psphere(listesphere,indiceelementmodif,nombresphere);
  sauvevirtuel; end else
  if nombresphere>oldnombresphere then begin
 listesphere[-1+indiceelementmodif].create(
 listesphere[-1+nombresphere].cx,
 listesphere[-1+nombresphere].cy,
 listesphere[-1+nombresphere].rayon,
 listesphere[-1+nombresphere].indicerouge,
 listesphere[-1+nombresphere].indicebleu,
 listesphere[-1+nombresphere].indicevert,
 listesphere[-1+nombresphere].couleurbord,
 listesphere[-1+nombresphere].couleurfond,
 listesphere[-1+nombresphere].reflechientrant,
 listesphere[-1+nombresphere].reflechisortant);
 retaillepsphere(listesphere,nombresphere,nombresphere-1);
 dec(nombresphere);
  sauvevirtuel;
    end;
      end;



    mdpolyhedre:begin
    oldnombrepolyhedre:=nombrepolyhedre;

    saisiepolyhedre.combomateriaux.items:=listemateriaux;
saisiepolyhedre.combomateriaux.itemindex:=0;

      with saisiepolyhedre
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisiepolyhedre.ComboBox1.Items.Clear;
    nbpoly:=listepolyhedre[-1+indiceelementmodif].nombresommet;
    for i:=1 to listepolyhedre[-1+indiceelementmodif].nombresommet do  begin
    saisiepolyhedre.ComboBox1.Items.Add(Format(rsSommet, [inttostr(i)]));
    ttpoly[i].ax:=listepolyhedre[-1+indiceelementmodif].messommets[i].ax;
    ttpoly[i].ay:=listepolyhedre[-1+indiceelementmodif].messommets[i].ay;
    end;
     saisiepolyhedre.ComboBox1.Itemindex:=0;
     saisiepolyhedre.editx.text:=floattostr(ttpoly[1].ax);
     saisiepolyhedre.edity.text:=floattostr(ttpoly[1].ay);
     saisiepolyhedre.editnrouge.text:=floattostr(listepolyhedre[-1+indiceelementmodif].indicerouge);
      saisiepolyhedre.editnvert.text:=floattostr(listepolyhedre[-1+indiceelementmodif].indicevert);
       saisiepolyhedre.editnbleu.text:=floattostr(listepolyhedre[-1+indiceelementmodif].indicebleu);
       case  listepolyhedre[-1+indiceelementmodif].reflechientrant of
       toujoursreflechi: saisiepolyhedre.radioentrant.ItemIndex:=0;
       jamaisreflechi: saisiepolyhedre.radioentrant.ItemIndex:=1;
      reflechisirefracte: saisiepolyhedre.radioentrant.ItemIndex:=2;
       reflechisipasrefracte: saisiepolyhedre.radioentrant.ItemIndex:=3;
       end;
        case  listepolyhedre[-1+indiceelementmodif].reflechisortant of
       toujoursreflechi: saisiepolyhedre.radiosortant.ItemIndex:=0;
       jamaisreflechi: saisiepolyhedre.radiosortant.ItemIndex:=1;
      reflechisirefracte: saisiepolyhedre.radiosortant.ItemIndex:=2;
       reflechisipasrefracte: saisiepolyhedre.radiosortant.ItemIndex:=3;
       end;
       saisiepolyhedre.boutonsup.enabled:=true;

saisiepolyhedre.colorgrid1.selected:=(
listepolyhedre[-1+indiceelementmodif].couleurfond);
     unit6.oldindex:=0;
      saisiepolyhedre.log1.Caption:=unitelongueur;
     saisiepolyhedre.log2.Caption:=unitelongueur;

     if saisiepolyhedre.showmodal=mrno then  begin
 supprime1ppolyhedre(listepolyhedre,indiceelementmodif,nombrepolyhedre);
  sauvevirtuel; end else
  if nombrepolyhedre>oldnombrepolyhedre then begin
 listepolyhedre[-1+indiceelementmodif].create(
 listepolyhedre[-1+nombrepolyhedre].nombresommet,
 listepolyhedre[-1+nombrepolyhedre].messommets,
 listepolyhedre[-1+nombrepolyhedre].indicerouge,
 listepolyhedre[-1+nombrepolyhedre].indicebleu,
 listepolyhedre[-1+nombrepolyhedre].indicevert,
 listepolyhedre[-1+nombrepolyhedre].couleurbord,
 listepolyhedre[-1+nombrepolyhedre].couleurfond,
 listepolyhedre[-1+nombrepolyhedre].reflechientrant,
 listepolyhedre[-1+nombrepolyhedre].reflechisortant);
 retailleppolyhedre(listepolyhedre,nombrepolyhedre,nombrepolyhedre-1);
 dec(nombrepolyhedre);
  sauvevirtuel;
    end;
      end;







       mdprisme:begin
    oldnombreprisme:=nombreprisme;

    saisieprisme.combomateriaux.items:=listemateriaux;
saisieprisme.combomateriaux.itemindex:=0;

      with saisieprisme
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;

     saisieprisme.edit_gx.text:=floattostr(listeprisme[-1+indiceelementmodif].gx);
      saisieprisme.edit_gy.text:=floattostr(listeprisme[-1+indiceelementmodif].gy);
       saisieprisme.edit_hauteur.text:=floattostr(listeprisme[-1+indiceelementmodif].hauteur);
        saisieprisme.edit_angleausommet.text:=floattostr(listeprisme[-1+indiceelementmodif].angle_sommet);
         saisieprisme.edit_anglepolaire.text:=floattostr(listeprisme[-1+indiceelementmodif].angle_axe);
     saisieprisme.editnrouge.text:=floattostr(listeprisme[-1+indiceelementmodif].indicerouge);
      saisieprisme.editnvert.text:=floattostr(listeprisme[-1+indiceelementmodif].indicevert);
       saisieprisme.editnbleu.text:=floattostr(listeprisme[-1+indiceelementmodif].indicebleu);
       case  listeprisme[-1+indiceelementmodif].reflechientrant of
       toujoursreflechi: saisieprisme.radioentrant.ItemIndex:=0;
       jamaisreflechi: saisieprisme.radioentrant.ItemIndex:=1;
      reflechisirefracte: saisieprisme.radioentrant.ItemIndex:=2;
       reflechisipasrefracte: saisieprisme.radioentrant.ItemIndex:=3;
       end;
        case  listeprisme[-1+indiceelementmodif].reflechisortant of
       toujoursreflechi: saisieprisme.radiosortant.ItemIndex:=0;
       jamaisreflechi: saisieprisme.radiosortant.ItemIndex:=1;
      reflechisirefracte: saisieprisme.radiosortant.ItemIndex:=2;
       reflechisipasrefracte: saisieprisme.radiosortant.ItemIndex:=3;
       end;
       saisieprisme.boutonsup.enabled:=true;

saisieprisme.colorgrid1.selected:=(
listeprisme[-1+indiceelementmodif].couleurfond);

      saisieprisme.log1.Caption:=unitelongueur;
     saisieprisme.log2.Caption:=unitelongueur;
            saisieprisme.log3.Caption:=unitelongueur;
     if saisieprisme.showmodal=mrno then  begin
 supprime1pprisme(listeprisme,indiceelementmodif,nombreprisme);
  sauvevirtuel; end else
  if nombreprisme>oldnombreprisme then begin
 listeprisme[-1+indiceelementmodif].create(
 listeprisme[-1+nombreprisme].gx,
 listeprisme[-1+nombreprisme].gy,
 listeprisme[-1+nombreprisme].ax,
 listeprisme[-1+nombreprisme].ay,
 listeprisme[-1+nombreprisme].bx,
 listeprisme[-1+nombreprisme].by,
 listeprisme[-1+nombreprisme].indicerouge,
 listeprisme[-1+nombreprisme].indicebleu,
 listeprisme[-1+nombreprisme].indicevert,
 listeprisme[-1+nombreprisme].couleurbord,
 listeprisme[-1+nombreprisme].couleurfond,
 listeprisme[-1+nombreprisme].reflechientrant,
 listeprisme[-1+nombreprisme].reflechisortant);
 retaillepprisme(listeprisme,nombreprisme,nombreprisme-1);
 dec(nombreprisme);
  sauvevirtuel;
    end;
      end;







       mdpolycercle:begin
    oldnombrepolycercle:=nombrepolycercle;

    saisiepolycercle.combomateriaux.items:=listemateriaux;
saisiepolycercle.combomateriaux.itemindex:=0;
      with saisiepolycercle
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisiepolycercle.ComboBox1.Items.Clear;
    nbpoly:=listepolycercle[-1+indiceelementmodif].nombresommet;
    for i:=1 to listepolycercle[-1+indiceelementmodif].nombresommet do  begin
    saisiepolycercle.ComboBox1.Items.Add(Format(rsSommet, [inttostr(i)]));
    ttpoly[i].ax:=listepolycercle[-1+indiceelementmodif].messommets[i].ax;
    ttpoly[i].ay:=listepolycercle[-1+indiceelementmodif].messommets[i].ay;
    youri[i]:=listepolycercle[-1+indiceelementmodif].rectiligne[i];
    helena[i]:=listepolycercle[-1+indiceelementmodif].agauche[i];
    tavarich[i]:=listepolycercle[-1+indiceelementmodif].aigu[i];
    selene[i]:=listepolycercle[-1+indiceelementmodif].rayon[i];
    end;
    saisiecercle.trigogo:=listepolycercle[-1+indiceelementmodif].trigodirect;

     saisiepolycercle.ComboBox1.Itemindex:=0;
     saisiepolycercle.editx.text:=floattostr(ttpoly[1].ax);
     saisiepolycercle.edity.text:=floattostr(ttpoly[1].ay);
     if  youri[1] then
     saisiepolycercle.radiorectiligne.itemindex:=0 else
         saisiepolycercle.radiorectiligne.itemindex:=1;
       if  helena[1] then
     saisiepolycercle.radiorentrant.itemindex:=0 else
         saisiepolycercle.radiorentrant.itemindex:=1;
        if  tavarich[1] then
     saisiepolycercle.radiogroupaigu.itemindex:=0 else
         saisiepolycercle.radiogroupaigu.itemindex:=1;
         saisiepolycercle.editrayon.text:=floattostr(selene[1]);
     saisiepolycercle.editnrouge.text:=floattostr(listepolycercle[-1+indiceelementmodif].indicerouge);
      saisiepolycercle.editnvert.text:=floattostr(listepolycercle[-1+indiceelementmodif].indicevert);
       saisiepolycercle.editnbleu.text:=floattostr(listepolycercle[-1+indiceelementmodif].indicebleu);
       case  listepolycercle[-1+indiceelementmodif].reflechientrant of
       toujoursreflechi: saisiepolycercle.radioentrant.ItemIndex:=0;
       jamaisreflechi: saisiepolycercle.radioentrant.ItemIndex:=1;
      reflechisirefracte: saisiepolycercle.radioentrant.ItemIndex:=2;
       reflechisipasrefracte: saisiepolycercle.radioentrant.ItemIndex:=3;
       end;
        case  listepolycercle[-1+indiceelementmodif].reflechisortant of
       toujoursreflechi: saisiepolycercle.radiosortant.ItemIndex:=0;
       jamaisreflechi: saisiepolycercle.radiosortant.ItemIndex:=1;
      reflechisirefracte: saisiepolycercle.radiosortant.ItemIndex:=2;
       reflechisipasrefracte: saisiepolycercle.radiosortant.ItemIndex:=3;
       end;
       saisiepolycercle.boutonsup.enabled:=true;
     saisiecercle.oldindex:=0;

saisiepolycercle.colorgrid1.selected:=(
listepolycercle[-1+indiceelementmodif].couleurfond);
    saisiepolycercle.log1.Caption:=unitelongueur;
     saisiepolycercle.log2.Caption:=unitelongueur;
     saisiepolycercle.log3.Caption:=unitelongueur;
     if saisiepolycercle.showmodal=mrno then  begin
 supprime1ppolycercle(listepolycercle,indiceelementmodif,nombrepolycercle);
  sauvevirtuel; end else
  if nombrepolycercle>oldnombrepolycercle then begin
 listepolycercle[-1+indiceelementmodif].create(
 listepolycercle[-1+nombrepolycercle].nombresommet,
 listepolycercle[-1+nombrepolycercle].messommets,
 listepolycercle[-1+nombrepolycercle].mess,
 listepolycercle[-1+nombrepolycercle].rectiligne,
 listepolycercle[-1+nombrepolycercle].indicerouge,
 listepolycercle[-1+nombrepolycercle].indicebleu,
 listepolycercle[-1+nombrepolycercle].indicevert,
 listepolycercle[-1+nombrepolycercle].couleurbord,
 listepolycercle[-1+nombrepolycercle].couleurfond,
 listepolycercle[-1+nombrepolycercle].reflechientrant,
 listepolycercle[-1+nombrepolycercle].reflechisortant);
 retailleppolycercle(listepolycercle,nombrepolycercle,nombrepolycercle-1);
 dec(nombrepolycercle);
  sauvevirtuel;
    end;
      end;



    mdmiroirplan: begin
    oldnombremiroirplan:=nombremiroirplan;

       with saisiemiroirplan
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
     saisiemiroirplan.boutonsup.enabled:=true;
    saisiemiroirplan.editx1.text:=floattostr(listemiroirplan[-1+indiceelementmodif].a1x);
    saisiemiroirplan.editx2.text:=floattostr(listemiroirplan[-1+indiceelementmodif].a2x);
    saisiemiroirplan.edity1.text:=floattostr(listemiroirplan[-1+indiceelementmodif].a1y);
    saisiemiroirplan.edity2.text:=floattostr(listemiroirplan[-1+indiceelementmodif].a2y);
    saisiemiroirplan.cochehachures.checked:=listemiroirplan[-1+indiceelementmodif].hachures;
    saisiemiroirplan.editepaisseur.Value:=listemiroirplan[-1+indiceelementmodif].epaisseur;

saisiemiroirplan.colorgrid1.selected:=(
listemiroirplan[-1+indiceelementmodif].couleur);
    saisiemiroirplan.caption:=
    rsPropriTSDeCe7;
     saisiemiroirplan.log1.Caption:=unitelongueur;
     saisiemiroirplan.log2.Caption:=unitelongueur;
      saisiemiroirplan.log3.Caption:=unitelongueur;
       saisiemiroirplan.log4.Caption:=unitelongueur;

 if saisiemiroirplan.showmodal=mrno then begin
 supprime1pmiroirplan(listemiroirplan,indiceelementmodif,nombremiroirplan);
  sauvevirtuel; end else
  if nombremiroirplan>oldnombremiroirplan then begin
 listemiroirplan[-1+indiceelementmodif].create(
 listemiroirplan[-1+nombremiroirplan].a1x,
 listemiroirplan[-1+nombremiroirplan].a1y,
 listemiroirplan[-1+nombremiroirplan].a2x,
 listemiroirplan[-1+nombremiroirplan].a2y,
 listemiroirplan[-1+nombremiroirplan].epaisseur,
 listemiroirplan[-1+nombremiroirplan].couleur,
 listemiroirplan[-1+nombremiroirplan].hachures);
 retaillepmiroirplan(listemiroirplan,nombremiroirplan,nombremiroirplan-1);
 dec(nombremiroirplan);
   sauvevirtuel;
 end;
    end;


      mdReseau: begin
    oldnombreReseau:=nombreReseau;

       with fsaisiereseau
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
     fsaisiereseau.boutonsup.enabled:=true;
    fsaisiereseau.editx1.text:=floattostr(listeReseau[-1+indiceelementmodif].a1x);
    fsaisiereseau.editx2.text:=floattostr(listeReseau[-1+indiceelementmodif].a2x);
    fsaisiereseau.edity1.text:=floattostr(listeReseau[-1+indiceelementmodif].a1y);
    fsaisiereseau.edity2.text:=floattostr(listeReseau[-1+indiceelementmodif].a2y);
    fsaisiereseau.cochehachures.checked:=listeReseau[-1+indiceelementmodif].hachures;
    fsaisiereseau.editepaisseur.Value:=listeReseau[-1+indiceelementmodif].epaisseur;
     fsaisiereseau.spinedit_ordre_min.value:=listeReseau[-1+indiceelementmodif].ordre_min;
      fsaisiereseau.spinedit_ordre_max.value:=listeReseau[-1+indiceelementmodif].ordre_max;
      fsaisiereseau.FloatSpinEdit1.value:=listeReseau[-1+indiceelementmodif].nombre_trait_par_mm;
      if listeReseau[-1+indiceelementmodif].entransmission then
      fsaisiereseau.radiogroup1.itemindex:=0 else fsaisiereseau.radiogroup1.itemindex:=1;
fsaisiereseau.colorgrid1.selected:=(
listeReseau[-1+indiceelementmodif].couleur);
    fsaisiereseau.caption:=
    rsPropriTSDeCe24;
     fsaisiereseau.log1.Caption:=unitelongueur;
     fsaisiereseau.log2.Caption:=unitelongueur;
      fsaisiereseau.log3.Caption:=unitelongueur;
       fsaisiereseau.log4.Caption:=unitelongueur;

 if fsaisiereseau.showmodal=mrno then begin
 supprime1pReseau(listeReseau,indiceelementmodif,nombreReseau);
  sauvevirtuel; end else
  if nombreReseau>oldnombreReseau then begin
 listeReseau[-1+indiceelementmodif].create(
 listeReseau[-1+nombreReseau].a1x,
 listeReseau[-1+nombreReseau].a1y,
 listeReseau[-1+nombreReseau].a2x,
 listeReseau[-1+nombreReseau].a2y,
 listeReseau[-1+nombreReseau].epaisseur,
 listeReseau[-1+nombreReseau].couleur,
 listeReseau[-1+nombreReseau].pas,
 listeReseau[-1+nombreReseau].entransmission,
 listeReseau[-1+nombreReseau].hachures,
 listeReseau[-1+nombreReseau].ordre_min,
 listeReseau[-1+nombreReseau].ordre_max);
 retaillepReseau(listeReseau,nombreReseau,nombreReseau-1);
 dec(nombreReseau);
   sauvevirtuel;
 end;
    end;


     mdecran: begin
    oldnombreecran:=nombreecran;

       with saisieecran
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
     saisieecran.boutonsup.enabled:=true;
    saisieecran.editx1.text:=floattostr(listeecran[-1+indiceelementmodif].a1x);
    saisieecran.editx2.text:=floattostr(listeecran[-1+indiceelementmodif].a2x);
    saisieecran.edity1.text:=floattostr(listeecran[-1+indiceelementmodif].a1y);
    saisieecran.edity2.text:=floattostr(listeecran[-1+indiceelementmodif].a2y);
    saisieecran.editepaisseur.Value:=listeecran[-1+indiceelementmodif].epaisseur;

saisieecran.colorgrid1.selected:=(
listeecran[-1+indiceelementmodif].couleur) ;
    saisieecran.caption:=
    rsPropriTSDeCe8;
     saisieecran.log1.Caption:=unitelongueur;
     saisieecran.log2.Caption:=unitelongueur;
      saisieecran.log3.Caption:=unitelongueur;
      saisieecran.log4.Caption:=unitelongueur;
 if saisieecran.showmodal=mrno then begin
 supprime1pecran(listeecran,indiceelementmodif,nombreecran);
  sauvevirtuel; end else
  if nombreecran>oldnombreecran then begin
 listeecran[-1+indiceelementmodif].create(
 listeecran[-1+nombreecran].a1x,
 listeecran[-1+nombreecran].a1y,
 listeecran[-1+nombreecran].a2x,
 listeecran[-1+nombreecran].a2y,
 listeecran[-1+nombreecran].epaisseur,
 listeecran[-1+nombreecran].couleur);
 retaillepecran(listeecran,nombreecran,nombreecran-1);
 dec(nombreecran);
  sauvevirtuel;
 end;
    end;


     mdoeil: begin
    oldnombreoeil:=nombreoeil;

       with saisieoeil
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
     saisieoeil.boutonsup.enabled:=true;
    saisieoeil.editx1.text:=floattostr(listeoeil[-1+indiceelementmodif].cx);
    saisieoeil.editx2.text:=floattostr(listeoeil[-1+indiceelementmodif].ax);
    saisieoeil.edity1.text:=floattostr(listeoeil[-1+indiceelementmodif].cy);
    saisieoeil.edity2.text:=floattostr(listeoeil[-1+indiceelementmodif].ay);
    saisieoeil.editepaisseur.Value:=listeoeil[-1+indiceelementmodif].epaisseur;

saisieoeil.colorgrid1.selected:=(
listeoeil[-1+indiceelementmodif].couleur) ;
    saisieoeil.caption:=
    rsPropriTSDeCe9;
     saisieoeil.log1.Caption:=unitelongueur;
     saisieoeil.log2.Caption:=unitelongueur;
      saisieoeil.log3.Caption:=unitelongueur;
      saisieoeil.log4.Caption:=unitelongueur;
 if saisieoeil.showmodal=mrno then begin
 supprime1poeil(listeoeil,indiceelementmodif,nombreoeil);
  sauvevirtuel; end else
  if nombreoeil>oldnombreoeil then begin
 listeoeil[-1+indiceelementmodif].create(
 listeoeil[-1+nombreoeil].cx,
 listeoeil[-1+nombreoeil].cy,
 listeoeil[-1+nombreoeil].ax,
 listeoeil[-1+nombreoeil].ay,
 listeoeil[-1+nombreoeil].epaisseur,
 listeoeil[-1+nombreoeil].couleur);
 retaillepoeil(listeoeil,nombreoeil,nombreoeil-1);
 dec(nombreoeil);
  sauvevirtuel;
 end;
    end;


     mddiaphragme: begin
    oldnombrediaphragme:=nombrediaphragme;

       with saisiediaphragme
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
     saisiediaphragme.boutonsup.enabled:=true;
    saisiediaphragme.editcx.text:=floattostr(listediaphragme[-1+indiceelementmodif].cx);
    saisiediaphragme.editcy.text:=floattostr(listediaphragme[-1+indiceelementmodif].cy);
    saisiediaphragme.editt.text:=floattostr(listediaphragme[-1+indiceelementmodif].anglepolaire);
    saisiediaphragme.editrint.text:=floattostr(listediaphragme[-1+indiceelementmodif].rint);
    saisiediaphragme.editrext.text:=floattostr(listediaphragme[-1+indiceelementmodif].rext);
    saisiediaphragme.spinedit1.Value:=listediaphragme[-1+indiceelementmodif].epaisseur;
saisiediaphragme.colorgrid1.selected:=(
listediaphragme[-1+indiceelementmodif].couleur) ;
    saisiediaphragme.caption:=
    rsPropriTSDeCe10;
     saisiediaphragme.log1.Caption:=unitelongueur;
     saisiediaphragme.log2.Caption:=unitelongueur;
      saisiediaphragme.log3.Caption:=unitelongueur;
      saisiediaphragme.log4.Caption:=unitelongueur;
 if saisiediaphragme.showmodal=mrno then  begin
 supprime1pdiaphragme(listediaphragme,indiceelementmodif,nombrediaphragme);
  sauvevirtuel; end else
  if nombrediaphragme>oldnombrediaphragme then begin
 listediaphragme[-1+indiceelementmodif].create2(
 listediaphragme[-1+nombrediaphragme].cx,
 listediaphragme[-1+nombrediaphragme].cy,
 listediaphragme[-1+nombrediaphragme].anglepolaire,
 listediaphragme[-1+nombrediaphragme].rint,
 listediaphragme[-1+nombrediaphragme].rext,
  listediaphragme[-1+nombrediaphragme].couleur,
  listediaphragme[-1+nombrediaphragme].epaisseur);
 retaillepdiaphragme(listediaphragme,nombrediaphragme,nombrediaphragme-1);
 dec(nombrediaphragme);
  sauvevirtuel;
 end;
    end;


    mdlsr: begin
    oldnombrelsr:=nombrelsr;

       with saisielsr
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
     saisielsr.boutonsup.enabled:=true;
    saisielsr.editx1.text:=floattostr(listelsr[-1+indiceelementmodif].a1x);
    saisielsr.editx2.text:=floattostr(listelsr[-1+indiceelementmodif].a2x);
    saisielsr.edity1.text:=floattostr(listelsr[-1+indiceelementmodif].a1y);
    saisielsr.edity2.text:=floattostr(listelsr[-1+indiceelementmodif].a2y);
    saisielsr.editepaisseur.Value:=listelsr[-1+indiceelementmodif].epaisseur;

saisielsr.colorgrid1.selected:=(
listelsr[-1+indiceelementmodif].couleur) ;
    saisielsr.caption:=
    rsPropriTSDeCe11;
    saisielsr.log1.Caption:=unitelongueur;
     saisielsr.log2.Caption:=unitelongueur;
      saisielsr.log3.Caption:=unitelongueur;
       saisielsr.log4.Caption:=unitelongueur;
 if saisielsr.showmodal=mrno then  begin
 supprime1plsr(listelsr,indiceelementmodif,nombrelsr);
  sauvevirtuel; end else
  if nombrelsr>oldnombrelsr then begin
 listelsr[-1+indiceelementmodif].create(
 listelsr[-1+nombrelsr].a1x,
 listelsr[-1+nombrelsr].a1y,
 listelsr[-1+nombrelsr].a2x,
 listelsr[-1+nombrelsr].a2y,
 listelsr[-1+nombrelsr].epaisseur,
 listelsr[-1+nombrelsr].couleur);
 retailleplsr(listelsr,nombrelsr,nombrelsr-1);
 dec(nombrelsr);
  sauvevirtuel;
 end;
    end;

    mdrayon: begin
    oldnombrerayon:=nombrerayon;

      with saisierayon
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisierayon.boutonsup.enabled:=true;
    saisierayon.Spinmaxsegment.Value:=listerayon[-1+indiceelementmodif].maxsegment;
    saisierayon.Spinenfantmax.value:=listerayon[-1+indiceelementmodif].nombremaxenfant;
    saisierayon.editx1.text:=floattostr(listerayon[-1+indiceelementmodif].ax);
    saisierayon.editx2.text:=floattostr(listerayon[-1+indiceelementmodif].bx);
    saisierayon.edity1.text:=floattostr(listerayon[-1+indiceelementmodif].ay);
    saisierayon.edity2.text:=floattostr(listerayon[-1+indiceelementmodif].by);
     saisierayon.editvav.text:=listerayon[-1+indiceelementmodif].vav;
    saisierayon.editvaa.text:=listerayon[-1+indiceelementmodif].vaa;
    saisierayon.editepaisseur.Value:=listerayon[-1+indiceelementmodif].epaisseur;
    case listerayon[-1+indiceelementmodif].couleur of
clred:   saisierayon.radiocouleur.ItemIndex:=0;
clgreen:  saisierayon.radiocouleur.ItemIndex:=1;
clblue:   saisierayon.radiocouleur.ItemIndex:=2;
clblack:  saisierayon.radiocouleur.ItemIndex:=3;
end;
    saisierayon.caption:=
    rsPropriTSDeCe12;
    saisierayon.log1.Caption:=unitelongueur;
     saisierayon.log2.Caption:=unitelongueur;
      saisierayon.log3.Caption:=unitelongueur;
      saisierayon.log4.Caption:=unitelongueur;
if saisierayon.showmodal=mrno then  begin
supprime1prayon(listerayon,indiceelementmodif,nombrerayon);
 sauvevirtuel; end else
 if nombrerayon>oldnombrerayon then begin
 listerayon[-1+indiceelementmodif].create(
 listerayon[-1+nombrerayon].ax,
 listerayon[-1+nombrerayon].ay,
 listerayon[-1+nombrerayon].kx,
 listerayon[-1+nombrerayon].ky,
 listerayon[-1+nombrerayon].couleur,
 listerayon[-1+nombrerayon].epaisseur,
 listerayon[-1+nombrerayon].vav,
 listerayon[-1+nombrerayon].vaa,
listerayon[-1+nombrerayon].nombremaxenfant,
listerayon[-1+nombrerayon].maxsegment);
 retailleprayon(listerayon,nombrerayon,nombrerayon-1);
 dec(nombrerayon);
  sauvevirtuel;
 end;
    end;


    mdsourceponctuelle: begin
    oldnombresourceponctuelle:=nombresourceponctuelle;

      with saisiespp
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisiespp.spinmaxenfant.value:=listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon;
    saisiespp.boutonsup.enabled:=true;
    saisiespp.spinnombrerayons.Value:=listesourceponctuelle[-1+indiceelementmodif].nombrederayon;
      saisiespp.editlistechemins.text:=listesourceponctuelle[-1+indiceelementmodif].listechemins;
    saisiespp.cochesurfacesonde.checked:=listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde;
    saisiespp.editx1.text:=floattostr(listesourceponctuelle[-1+indiceelementmodif].a1x);
    saisiespp.editx2.text:=floattostr(listesourceponctuelle[-1+indiceelementmodif].a2x);
     saisiespp.edity1.text:=floattostr(listesourceponctuelle[-1+indiceelementmodif].a1y);
    saisiespp.edity2.text:=floattostr(listesourceponctuelle[-1+indiceelementmodif].a2y);
     saisiespp.editsx.text:=floattostr(listesourceponctuelle[-1+indiceelementmodif].sx);
    saisiespp.editsy.text:=floattostr(listesourceponctuelle[-1+indiceelementmodif].sy);
    saisiespp.editvaa.text:=listesourceponctuelle[-1+indiceelementmodif].vaa;
    saisiespp.editvav.text:=listesourceponctuelle[-1+indiceelementmodif].vav;
    saisiespp.editepaisseur.Value:=listesourceponctuelle[-1+indiceelementmodif].epaisseur;
    saisiespp.Spinmaxsegment.Value:=listesourceponctuelle[-1+indiceelementmodif].maxsegment;
    if  listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle then
    saisiespp.radiovirtuelle.ItemIndex:=1 else
         saisiespp.radiovirtuelle.ItemIndex:=0;
    case listesourceponctuelle[-1+indiceelementmodif].ray[1].couleur of
clred:   saisiespp.radiocouleur.ItemIndex:=0;
clgreen:  saisiespp.radiocouleur.ItemIndex:=1;
clblue:   saisiespp.radiocouleur.ItemIndex:=2;
clblack:  saisiespp.radiocouleur.ItemIndex:=3;
end;
    saisiespp.caption:=
    rsPropriTSDeCe13;
    saisiespp.log1.Caption:=unitelongueur;
     saisiespp.log2.Caption:=unitelongueur;
      saisiespp.log3.Caption:=unitelongueur;
      saisiespp.log4.Caption:=unitelongueur;
     saisiespp.log5.Caption:=unitelongueur;
      saisiespp.log6.Caption:=unitelongueur;
       if  listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle then
       begin
     saisiespp.cochesurfacesonde.enabled:=false;
     saisiespp.editlistechemins.enabled:=false;
     end;
if saisiespp.showmodal=mrno then  begin
supprime1psourceponctuelle(listesourceponctuelle,indiceelementmodif,nombresourceponctuelle);
 sauvevirtuel; end else
 if nombresourceponctuelle>oldnombresourceponctuelle then begin

listesourceponctuelle[-1+indiceelementmodif].create(
 listesourceponctuelle[-1+nombresourceponctuelle].nombrederayon,
 listesourceponctuelle[-1+nombresourceponctuelle].sx,
 listesourceponctuelle[-1+nombresourceponctuelle].sy,
 listesourceponctuelle[-1+nombresourceponctuelle].a1x,
 listesourceponctuelle[-1+nombresourceponctuelle].a1y,
 listesourceponctuelle[-1+nombresourceponctuelle].a2x,
 listesourceponctuelle[-1+nombresourceponctuelle].a2y,
 listesourceponctuelle[-1+nombresourceponctuelle].couleur,
 listesourceponctuelle[-1+nombresourceponctuelle].epaisseur,
 listesourceponctuelle[-1+nombresourceponctuelle].vav,
 listesourceponctuelle[-1+nombresourceponctuelle].vaa,
listesourceponctuelle[-1+nombresourceponctuelle].maxenfantparrayon,
listesourceponctuelle[-1+nombresourceponctuelle].sourcevirtuelle,
listesourceponctuelle[-1+nombresourceponctuelle].tracersurfacesonde,
listesourceponctuelle[-1+nombresourceponctuelle].listechemins,
listesourceponctuelle[-1+nombresourceponctuelle].maxsegment) ;
 retaillepsourceponctuelle(listesourceponctuelle,nombresourceponctuelle,nombresourceponctuelle-1);
 dec(nombresourceponctuelle);
  sauvevirtuel;
 end;
    end;

     mdondeplane: begin
    oldnombreondeplane:=nombreondeplane;

      with saisieopp
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisieopp.spinmaxenfant.value:=listeondeplane[-1+indiceelementmodif].maxenfantparrayon;
    saisieopp.boutonsup.enabled:=true;
     saisieopp.Spinmaxsegment.Value:= listeondeplane[-1+indiceelementmodif].maxsegment;
    saisieopp.spinnombrerayons.Value:=listeondeplane[-1+indiceelementmodif].nombrederayon;
    saisieopp.editx1.text:=floattostr(listeondeplane[-1+indiceelementmodif].a1x);
    saisieopp.editx2.text:=floattostr(listeondeplane[-1+indiceelementmodif].a2x);
     saisieopp.edity1.text:=floattostr(listeondeplane[-1+indiceelementmodif].a1y);
    saisieopp.edity2.text:=floattostr(listeondeplane[-1+indiceelementmodif].a2y);
     saisieopp.editsx.text:=floattostr(listeondeplane[-1+indiceelementmodif].sx);
    saisieopp.editsy.text:=floattostr(listeondeplane[-1+indiceelementmodif].sy);
     saisieopp.editvaa.text:=listeondeplane[-1+indiceelementmodif].vaa;
    saisieopp.editvav.text:=listeondeplane[-1+indiceelementmodif].vav;
    saisieopp.editepaisseur.Value:=listeondeplane[-1+indiceelementmodif].ray[1].epaisseur;
    saisieopp.cochesurfaces.Checked:=listeondeplane[-1+indiceelementmodif].tracersurfacesonde;
    saisieopp.editlistechemins.text:=listeondeplane[-1+indiceelementmodif].listechemins;
    case listeondeplane[-1+indiceelementmodif].ray[1].couleur of
clred:   saisieopp.radiocouleur.ItemIndex:=0;
clgreen:  saisieopp.radiocouleur.ItemIndex:=1;
clblue:   saisieopp.radiocouleur.ItemIndex:=2;
clblack:  saisieopp.radiocouleur.ItemIndex:=3;
end;
    saisieopp.caption:=
    rsPropriTSDeCe14;
    saisieopp.log1.Caption:=unitelongueur;
     saisieopp.log2.Caption:=unitelongueur;
      saisieopp.log3.Caption:=unitelongueur;
      saisieopp.log4.Caption:=unitelongueur;
     saisieopp.log5.Caption:=unitelongueur;
      saisieopp.log6.Caption:=unitelongueur;
if saisieopp.showmodal=mrno then  begin
supprime1pondeplane(listeondeplane,indiceelementmodif,nombreondeplane);
sauvevirtuel; end  else
 if nombreondeplane>oldnombreondeplane then begin
 listeondeplane[-1+indiceelementmodif].create(
 listeondeplane[-1+nombreondeplane].nombrederayon,
 listeondeplane[-1+nombreondeplane].sx,
 listeondeplane[-1+nombreondeplane].sy,
 listeondeplane[-1+nombreondeplane].a1x,
 listeondeplane[-1+nombreondeplane].a1y,
 listeondeplane[-1+nombreondeplane].a2x,
 listeondeplane[-1+nombreondeplane].a2y,
 listeondeplane[-1+nombreondeplane].couleur,
 listeondeplane[-1+nombreondeplane].epaisseur,
 listeondeplane[-1+nombreondeplane].vav,
 listeondeplane[-1+nombreondeplane].vaa,
listeondeplane[-1+nombreondeplane].maxenfantparrayon,
listeondeplane[-1+nombreondeplane].tracersurfacesonde,
listeondeplane[-1+nombreondeplane].listechemins,
listeondeplane[-1+nombreondeplane].maxsegment);
 retaillepondeplane(listeondeplane,nombreondeplane,nombreondeplane-1);
 dec(nombreondeplane);
  sauvevirtuel;
 end;
    end;


  mdmiroirconique: begin
    oldnombremiroirconique:=nombremiroirconique;

      with saisiemiroirconique
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisiemiroirconique.boutonsup.enabled:=true;
    saisiemiroirconique.editfx.text:=floattostr(listemiroirconique[-1+indiceelementmodif].fx);
    saisiemiroirconique.editfy.text:=floattostr(listemiroirconique[-1+indiceelementmodif].fy);
    saisiemiroirconique.edite.text:=floattostr(listemiroirconique[-1+indiceelementmodif].excentricite);
    saisiemiroirconique.editp.text:=floattostr(listemiroirconique[-1+indiceelementmodif].parametre);
    saisiemiroirconique.editt0.text:=floattostr(listemiroirconique[-1+indiceelementmodif].theta0);
    saisiemiroirconique.editt1.text:=floattostr(listemiroirconique[-1+indiceelementmodif].theta1);
    saisiemiroirconique.editt2.text:=floattostr(listemiroirconique[-1+indiceelementmodif].theta2);
    saisiemiroirconique.checkhachures.checked:=listemiroirconique[-1+indiceelementmodif].hachures;
    saisiemiroirconique.checkaxefocal.checked:=listemiroirconique[-1+indiceelementmodif].axefocal;
    saisiemiroirconique.checkconcave.checked:=listemiroirconique[-1+indiceelementmodif].concave;

saisiemiroirconique.colorgrid1.selected:=(
listemiroirconique[-1+indiceelementmodif].couleur);


saisiemiroirconique.gridaxe.selected:=(
listemiroirconique[-1+indiceelementmodif].couleuraxe) ;
if  listemiroirconique[-1+indiceelementmodif].excentricite<=0.99999999999 then  saisiemiroirconique.caption:=
    rsPropriTSDeCe15 else
    if  listemiroirconique[-1+indiceelementmodif].excentricite>=1.00000000001 then  saisiemiroirconique.caption:=
    rsPropriTSDeCe16 else
     saisiemiroirconique.caption:=
    rsPropriTSDeCe17;
   saisiemiroirconique.log1.Caption:=unitelongueur;
     saisiemiroirconique.log2.Caption:=unitelongueur;
      saisiemiroirconique.log3.Caption:=unitelongueur;

 if saisiemiroirconique.showmodal=mrno then  begin
 supprime1pmiroirconique(listemiroirconique,indiceelementmodif,nombremiroirconique);
  sauvevirtuel; end else
 if nombremiroirconique>oldnombremiroirconique then begin
 listemiroirconique[-1+indiceelementmodif].create2(
 listemiroirconique[-1+nombremiroirconique].fx,
 listemiroirconique[-1+nombremiroirconique].fy,
 listemiroirconique[-1+nombremiroirconique].theta0,
 listemiroirconique[-1+nombremiroirconique].theta1,
 listemiroirconique[-1+nombremiroirconique].theta2,
 listemiroirconique[-1+nombremiroirconique].excentricite,
 listemiroirconique[-1+nombremiroirconique].parametre,
 listemiroirconique[-1+nombremiroirconique].concave,
 listemiroirconique[-1+nombremiroirconique].couleur,
 listemiroirconique[-1+nombremiroirconique].couleuraxe,
 listemiroirconique[-1+nombremiroirconique].hachures,
 listemiroirconique[-1+nombremiroirconique].axefocal);
 retaillepmiroirconique(listemiroirconique,nombremiroirconique,nombremiroirconique-1);
 dec(nombremiroirconique);
  sauvevirtuel;
 end;
    end;

    mdmscopa: begin
    oldnombremscopa:=nombremscopa;

     with saisiemiroirscopa
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisiemiroirscopa.checktrou.checked:=listemscopa[-1+indiceelementmodif].trou;
    saisiemiroirscopa.editdiametretrou.enabled:=listemscopa[-1+indiceelementmodif].trou;
   saisiemiroirscopa.editdiametretrou.text:=floattostr(listemscopa[-1+indiceelementmodif].diametretrou);
    saisiemiroirscopa.boutonsup.enabled:=true;
    saisiemiroirscopa.editx1.text:=floattostr(listemscopa[-1+indiceelementmodif].a1x);
    saisiemiroirscopa.editx2.text:=floattostr(listemscopa[-1+indiceelementmodif].a2x);
    saisiemiroirscopa.edity1.text:=floattostr(listemscopa[-1+indiceelementmodif].a1y);
    saisiemiroirscopa.edity2.text:=floattostr(listemscopa[-1+indiceelementmodif].a2y);
    saisiemiroirscopa.editfocale.text:=floattostr(listemscopa[-1+indiceelementmodif].focale);
    saisiemiroirscopa.cochehachures.checked:=listemscopa[-1+indiceelementmodif].hachures;
    saisiemiroirscopa.cocheaxe.checked:=listemscopa[-1+indiceelementmodif].axefocal;
    saisiemiroirscopa.editepaisseur.Value:=listemscopa[-1+indiceelementmodif].epaisseur;

saisiemiroirscopa.colorgrid1.selected:=(
listemscopa[-1+indiceelementmodif].couleur) ;


saisiemiroirscopa.gridaxe.selected:=(
listemscopa[-1+indiceelementmodif].couleuraxe) ;
    saisiemiroirscopa.caption:=
    rsPropriTSDeCe18;
    saisiemiroirscopa.log1.Caption:=unitelongueur;
     saisiemiroirscopa.log2.Caption:=unitelongueur;
      saisiemiroirscopa.log3.Caption:=unitelongueur;
       saisiemiroirscopa.log4.Caption:=unitelongueur;
        saisiemiroirscopa.log5.Caption:=unitelongueur;
       saisiemiroirscopa.log6.Caption:=unitelongueur;

 if saisiemiroirscopa.showmodal=mrno then   begin
 supprime1pmscopa(listemscopa,indiceelementmodif,nombremscopa);
  sauvevirtuel; end else
 if nombremscopa>oldnombremscopa then begin
 listemscopa[-1+indiceelementmodif].create2(
 listemscopa[-1+nombremscopa].a1x,
 listemscopa[-1+nombremscopa].a1y,
 listemscopa[-1+nombremscopa].a2x,
 listemscopa[-1+nombremscopa].a2y,
 listemscopa[-1+nombremscopa].focale,
 listemscopa[-1+nombremscopa].epaisseur,
 listemscopa[-1+nombremscopa].couleur,
 listemscopa[-1+nombremscopa].couleuraxe,
 listemscopa[-1+nombremscopa].hachures,
 listemscopa[-1+nombremscopa].axefocal,
listemscopa[-1+nombremscopa].trou,
listemscopa[-1+nombremscopa].diametretrou);
 retaillepmscopa(listemscopa,nombremscopa,nombremscopa-1);
 dec(nombremscopa);
  sauvevirtuel;
 end;
    end;

    mdmscepa: begin
    oldnombremscepa:=nombremscepa;

      with saisiemiroirscepa
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisiemiroirscepa.checktrou.checked:=listemscepa[-1+indiceelementmodif].trou;
    saisiemiroirscepa.editdiametretrou.enabled:=listemscepa[-1+indiceelementmodif].trou;
   saisiemiroirscepa.editdiametretrou.text:=floattostr(listemscepa[-1+indiceelementmodif].diametretrou);
    saisiemiroirscepa.boutonsup.enabled:=true;
    saisiemiroirscepa.editx1.text:=floattostr(listemscepa[-1+indiceelementmodif].a1x);
    saisiemiroirscepa.editx2.text:=floattostr(listemscepa[-1+indiceelementmodif].a2x);
    saisiemiroirscepa.edity1.text:=floattostr(listemscepa[-1+indiceelementmodif].a1y);
    saisiemiroirscepa.edity2.text:=floattostr(listemscepa[-1+indiceelementmodif].a2y);
    saisiemiroirscepa.editfocale.text:=floattostr(listemscepa[-1+indiceelementmodif].focale);
    saisiemiroirscepa.cochehachures.checked:=listemscepa[-1+indiceelementmodif].hachures;
    saisiemiroirscepa.cocheaxe.checked:=listemscepa[-1+indiceelementmodif].axefocal;
    saisiemiroirscepa.editepaisseur.Value:=listemscepa[-1+indiceelementmodif].epaisseur;

saisiemiroirscepa.colorgrid1.selected:=(
listemscepa[-1+indiceelementmodif].couleur) ;


saisiemiroirscepa.gridaxe.selected:=(
listemscepa[-1+indiceelementmodif].couleuraxe) ;
    saisiemiroirscepa.caption:=
    rsPropriTSDeCe19;
    saisiemiroirscepa.log1.Caption:=unitelongueur;
     saisiemiroirscepa.log2.Caption:=unitelongueur;
      saisiemiroirscepa.log3.Caption:=unitelongueur;
       saisiemiroirscepa.log4.Caption:=unitelongueur;
        saisiemiroirscepa.log5.Caption:=unitelongueur;
       saisiemiroirscepa.log6.Caption:=unitelongueur;
 if saisiemiroirscepa.showmodal=mrno then begin
 supprime1pmscepa(listemscepa,indiceelementmodif,nombremscepa);
  sauvevirtuel; end else
 if nombremscepa>oldnombremscepa then begin
 listemscepa[-1+indiceelementmodif].create2(
 listemscepa[-1+nombremscepa].a1x,
 listemscepa[-1+nombremscepa].a1y,
 listemscepa[-1+nombremscepa].a2x,
 listemscepa[-1+nombremscepa].a2y,
 listemscepa[-1+nombremscepa].focale,
 listemscepa[-1+nombremscepa].epaisseur,
 listemscepa[-1+nombremscepa].couleur,
 listemscepa[-1+nombremscepa].couleuraxe,
 listemscepa[-1+nombremscepa].hachures,
 listemscepa[-1+nombremscepa].axefocal,
listemscepa[-1+nombremscepa].trou,
listemscepa[-1+nombremscepa].diametretrou);
 retaillepmscepa(listemscepa,nombremscepa,nombremscepa-1);
 dec(nombremscepa);
  sauvevirtuel;
 end;
    end;

 mdmscore: begin
    oldnombremscore:=nombremscore;

      with saisiemiroirscore
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisiemiroirscore.boutonsup.enabled:=true;
    saisiemiroirscore.checkobtu.Checked:=not(listemscore[-1+indiceelementmodif].aigu);
    saisiemiroirscore.editx1.text:=floattostr(listemscore[-1+indiceelementmodif].a1x);
    saisiemiroirscore.editx2.text:=floattostr(listemscore[-1+indiceelementmodif].a2x);
    saisiemiroirscore.edity1.text:=floattostr(listemscore[-1+indiceelementmodif].a1y);
    saisiemiroirscore.edity2.text:=floattostr(listemscore[-1+indiceelementmodif].a2y);
    saisiemiroirscore.editrayoncourbure.text:=floattostr(listemscore[-1+indiceelementmodif].rayoncourbure);
    saisiemiroirscore.cochehachures.checked:=listemscore[-1+indiceelementmodif].hachures;
    saisiemiroirscore.cocheaxe.checked:=listemscore[-1+indiceelementmodif].axefocal;
    saisiemiroirscore.editepaisseur.Value:=listemscore[-1+indiceelementmodif].epaisseur;

saisiemiroirscore.colorgrid1.selected:=(
listemscore[-1+indiceelementmodif].couleur) ;


saisiemiroirscore.gridaxe.selected:=(
listemscore[-1+indiceelementmodif].couleuraxe) ;
    saisiemiroirscore.caption:=
    rsPropriTSDeCe18;
     saisiemiroirscore.log1.Caption:=unitelongueur;
     saisiemiroirscore.log2.Caption:=unitelongueur;
      saisiemiroirscore.log3.Caption:=unitelongueur;
       saisiemiroirscore.log4.Caption:=unitelongueur;
        saisiemiroirscore.log5.Caption:=unitelongueur;

    saisiemiroirscore.cochetrou.checked:=listemscore[-1+indiceelementmodif].trou;
    if listemscore[-1+indiceelementmodif].trou then
   saisiemiroirscore.editdiametretrou.text:=floattostr(listemscore[-1+indiceelementmodif].diametretrou);
 if saisiemiroirscore.showmodal=mrno then begin
 supprime1pmscore(listemscore,indiceelementmodif,nombremscore);
  sauvevirtuel; end else
 if nombremscore>oldnombremscore then begin
 listemscore[-1+indiceelementmodif].create2(
 listemscore[-1+nombremscore].a1x,
 listemscore[-1+nombremscore].a1y,
 listemscore[-1+nombremscore].a2x,
 listemscore[-1+nombremscore].a2y,
 listemscore[-1+nombremscore].rayoncourbure,
 listemscore[-1+nombremscore].epaisseur,
 listemscore[-1+nombremscore].couleur,
 listemscore[-1+nombremscore].couleuraxe,
 listemscore[-1+nombremscore].hachures,
 listemscore[-1+nombremscore].axefocal,
 listemscore[-1+nombremscore].aigu,
listemscore[-1+nombremscore].trou,
listemscore[-1+nombremscore].diametretrou);
 retaillepmscore(listemscore,nombremscore,nombremscore-1);
 dec(nombremscore);
  sauvevirtuel;
 end;
    end;


 mdmscere: begin
    oldnombremscere:=nombremscere;

      with saisiemiroirscere
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisiemiroirscere.boutonsup.enabled:=true;
    saisiemiroirscere.checkobtu.Checked:=not(listemscere[-1+indiceelementmodif].aigu);
    saisiemiroirscere.editx1.text:=floattostr(listemscere[-1+indiceelementmodif].a1x);
    saisiemiroirscere.editx2.text:=floattostr(listemscere[-1+indiceelementmodif].a2x);
    saisiemiroirscere.edity1.text:=floattostr(listemscere[-1+indiceelementmodif].a1y);
    saisiemiroirscere.edity2.text:=floattostr(listemscere[-1+indiceelementmodif].a2y);
    saisiemiroirscere.editrayoncourbure.text:=floattostr(listemscere[-1+indiceelementmodif].rayoncourbure);
    saisiemiroirscere.cochehachures.checked:=listemscere[-1+indiceelementmodif].hachures;
    saisiemiroirscere.cocheaxe.checked:=listemscere[-1+indiceelementmodif].axefocal;
    saisiemiroirscere.editepaisseur.Value:=listemscere[-1+indiceelementmodif].epaisseur;

saisiemiroirscere.colorgrid1.selected:=(
listemscere[-1+indiceelementmodif].couleur);


saisiemiroirscere.gridaxe.selected:=(
listemscere[-1+indiceelementmodif].couleuraxe);
    saisiemiroirscere.caption:=
    rsPropriTSDeCe19;
    saisiemiroirscere.log1.Caption:=unitelongueur;
     saisiemiroirscere.log2.Caption:=unitelongueur;
      saisiemiroirscere.log3.Caption:=unitelongueur;
       saisiemiroirscere.log4.Caption:=unitelongueur;
        saisiemiroirscere.log5.Caption:=unitelongueur;
     saisiemiroirscere.cochetrou.checked:=listemscere[-1+indiceelementmodif].trou;
    if listemscere[-1+indiceelementmodif].trou then
   saisiemiroirscere.editdiametretrou.text:=floattostr(listemscere[-1+indiceelementmodif].diametretrou);
 if saisiemiroirscere.showmodal=mrno then  begin
 supprime1pmscere(listemscere,indiceelementmodif,nombremscere);
  sauvevirtuel; end else
 if nombremscere>oldnombremscere then begin
 listemscere[-1+indiceelementmodif].create2(
 listemscere[-1+nombremscere].a1x,
 listemscere[-1+nombremscere].a1y,
 listemscere[-1+nombremscere].a2x,
 listemscere[-1+nombremscere].a2y,
 listemscere[-1+nombremscere].rayoncourbure,
 listemscere[-1+nombremscere].epaisseur,
 listemscere[-1+nombremscere].couleur,
 listemscere[-1+nombremscere].couleuraxe,
 listemscere[-1+nombremscere].hachures,
 listemscere[-1+nombremscere].axefocal,
 listemscere[-1+nombremscere].aigu,
 listemscere[-1+nombremscere].trou,
 listemscere[-1+nombremscere].diametretrou);
 retaillepmscere(listemscere,nombremscere,nombremscere-1);
 dec(nombremscere);
  sauvevirtuel;
 end;
    end;

  mdlmc: begin
    oldnombrelmc:=nombrelmc;

      with saisielentillemc
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisielentillemc.boutonsup.enabled:=true;
    saisielentillemc.editx1.text:=floattostr(listelmc[-1+indiceelementmodif].a1x);
    saisielentillemc.editx2.text:=floattostr(listelmc[-1+indiceelementmodif].a2x);
    saisielentillemc.edity1.text:=floattostr(listelmc[-1+indiceelementmodif].a1y);
    saisielentillemc.edity2.text:=floattostr(listelmc[-1+indiceelementmodif].a2y);
    saisielentillemc.editfocale.text:=floattostr(listelmc[-1+indiceelementmodif].focale);
    saisielentillemc.cocheaxe.checked:=listelmc[-1+indiceelementmodif].axefocal;
    saisielentillemc.editepaisseur.Value:=listelmc[-1+indiceelementmodif].epaisseur;

saisielentillemc.colorgrid1.selected:=(
listelmc[-1+indiceelementmodif].couleur) ;


saisielentillemc.gridaxe.selected:=(
listelmc[-1+indiceelementmodif].couleuraxe) ;
    saisielentillemc.caption:=
    rsPropriTSDeCe20;
     saisielentillemc.log1.Caption:=unitelongueur;
     saisielentillemc.log2.Caption:=unitelongueur;
      saisielentillemc.log3.Caption:=unitelongueur;
       saisielentillemc.log4.Caption:=unitelongueur;
        saisielentillemc.log5.Caption:=unitelongueur;
 if saisielentillemc.showmodal=mrno then  begin
 supprime1plmc(listelmc,indiceelementmodif,nombrelmc);
  sauvevirtuel; end else
 if nombrelmc>oldnombrelmc then begin
 listelmc[-1+indiceelementmodif].create2(
 listelmc[-1+nombrelmc].a1x,
 listelmc[-1+nombrelmc].a1y,
 listelmc[-1+nombrelmc].a2x,
 listelmc[-1+nombrelmc].a2y,
 listelmc[-1+nombrelmc].focale,
 listelmc[-1+nombrelmc].epaisseur,
 listelmc[-1+nombrelmc].couleur,
 listelmc[-1+nombrelmc].couleuraxe,
 listelmc[-1+nombrelmc].axefocal);
 retailleplmc(listelmc,nombrelmc,nombrelmc-1);
 dec(nombrelmc);
  sauvevirtuel;
 end;
    end;

  mdlec: begin
    oldnombrelec:=nombrelec;

    saisielentille.combomateriaux.items:=listemateriaux;
saisielentille.combomateriaux.itemindex:=0;
      with saisielentille
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisielentille.boutonsup.enabled:=true;
    saisielentille.edits1x.text:=floattostr(listelec[-1+indiceelementmodif].s1x);
    saisielentille.edits2x.text:=floattostr(listelec[-1+indiceelementmodif].s2x);
    saisielentille.edits1y.text:=floattostr(listelec[-1+indiceelementmodif].s1y);
    saisielentille.edits2y.text:=floattostr(listelec[-1+indiceelementmodif].s2y);
    saisielentille.editr1.text:=floattostr(listelec[-1+indiceelementmodif].r1);
     saisielentille.editr2.text:=floattostr(listelec[-1+indiceelementmodif].r2);
     saisielentille.editdiametre.text:=floattostr(listelec[-1+indiceelementmodif].diametre);
     saisielentille.editnrouge.text:=floattostr(listelec[-1+indiceelementmodif].indicerouge);
     saisielentille.editnvert.text:=floattostr(listelec[-1+indiceelementmodif].indicevert);
     saisielentille.editnbleu.text:=floattostr(listelec[-1+indiceelementmodif].indicebleu);

    saisielentille.caption:=
    rsPropriTSDeCe21;

saisielentille.colorgrid1.selected:=(
listelec[-1+indiceelementmodif].couleurfond);
    saisielentille.log1.Caption:=unitelongueur;
     saisielentille.log2.Caption:=unitelongueur;
      saisielentille.log3.Caption:=unitelongueur;
       saisielentille.log4.Caption:=unitelongueur;
        saisielentille.log5.Caption:=unitelongueur;
         saisielentille.log6.Caption:=unitelongueur;
          saisielentille.log7.Caption:=unitelongueur;
 if saisielentille.showmodal=mrno then  begin
 supprime1plec(listelec,indiceelementmodif,nombrelec);
  sauvevirtuel; end else
 if nombrelec>oldnombrelec then begin
 listelec[-1+indiceelementmodif].create(
 listelec[-1+nombrelec].s1x,
 listelec[-1+nombrelec].s1y,
 listelec[-1+nombrelec].s2x,
 listelec[-1+nombrelec].s2y,
 listelec[-1+nombrelec].r1,
 listelec[-1+nombrelec].r2,
 listelec[-1+nombrelec].diametre,
 listelec[-1+nombrelec].couleurfond,
 listelec[-1+nombrelec].couleuraxe,
 listelec[-1+nombrelec].axefocal,listelec[-1+nombrelec].indicerouge,
 listelec[-1+nombrelec].indicebleu,
 listelec[-1+nombrelec].indicevert,
 listelec[-1+nombrelec].reflechientrant,
 listelec[-1+nombrelec].reflechisortant);
 retailleplec(listelec,nombrelec,nombrelec-1);
 dec(nombrelec);
  sauvevirtuel;
 end;
    end;


  mdlmd: begin
    oldnombrelmd:=nombrelmd;

      with saisielentillemd
do begin
if screen.width>width then left:=(screen.width-width) div 2 else left:=0;
if screen.height>height then top:=(screen.height-height) div 2 else top:=0;
end;
    saisielentillemd.boutonsup.enabled:=true;
    saisielentillemd.editx1.text:=floattostr(listelmd[-1+indiceelementmodif].a1x);
    saisielentillemd.editx2.text:=floattostr(listelmd[-1+indiceelementmodif].a2x);
    saisielentillemd.edity1.text:=floattostr(listelmd[-1+indiceelementmodif].a1y);
    saisielentillemd.edity2.text:=floattostr(listelmd[-1+indiceelementmodif].a2y);
    saisielentillemd.editfocale.text:=floattostr(listelmd[-1+indiceelementmodif].focale);
    saisielentillemd.cocheaxe.checked:=listelmd[-1+indiceelementmodif].axefocal;
    saisielentillemd.editepaisseur.Value:=listelmd[-1+indiceelementmodif].epaisseur;

saisielentillemd.colorgrid1.selected:=(
listelmd[-1+indiceelementmodif].couleur) ;

saisielentillemd.gridaxe.selected:=(
listelmd[-1+indiceelementmodif].couleuraxe) ;
    saisielentillemd.caption:=
    rsPropriTSDeCe22;
     saisielentillemd.log1.Caption:=unitelongueur;
     saisielentillemd.log2.Caption:=unitelongueur;
      saisielentillemd.log3.Caption:=unitelongueur;
       saisielentillemd.log4.Caption:=unitelongueur;
        saisielentillemd.log5.Caption:=unitelongueur;
if saisielentillemd.showmodal=mrno then  begin
supprime1plmd(listelmd,indiceelementmodif,nombrelmd);
 sauvevirtuel; end else
 if nombrelmd>oldnombrelmd then begin
 listelmd[-1+indiceelementmodif].create2(
 listelmd[-1+nombrelmd].a1x,
 listelmd[-1+nombrelmd].a1y,
 listelmd[-1+nombrelmd].a2x,
 listelmd[-1+nombrelmd].a2y,
 listelmd[-1+nombrelmd].focale,
 listelmd[-1+nombrelmd].epaisseur,
 listelmd[-1+nombrelmd].couleur,
 listelmd[-1+nombrelmd].couleuraxe,
 listelmd[-1+nombrelmd].axefocal);
 retailleplmd(listelmd,nombrelmd,nombrelmd-1);
 dec(nombrelmd);
  sauvevirtuel;
 end;
    end;

    end; {du case}

     if modeduplication then  begin

    case typeelementmodif of


    mdtexteaffiche:

 if nombretexte<maxtexte then begin
 retailleptexteaffiche(listetexteaffiche,nombretexte,nombretexte+1);
 inc(nombretexte);
 listetexteaffiche[-1+nombretexte].create(listetexteaffiche[-1+indiceelementmodif].texteluimeme,
 listetexteaffiche[-1+indiceelementmodif].policename,listetexteaffiche[-1+indiceelementmodif].
 policecharset,listetexteaffiche[-1+indiceelementmodif].policecolor,
 listetexteaffiche[-1+indiceelementmodif].policesize,
 listetexteaffiche[-1+indiceelementmodif].policepitch,
 listetexteaffiche[-1+indiceelementmodif].policefsbold,
 listetexteaffiche[-1+indiceelementmodif].policefsitalic,
 listetexteaffiche[-1+indiceelementmodif].policefsunderline,
 listetexteaffiche[-1+indiceelementmodif].policefsstrikeout,
 listetexteaffiche[-1+indiceelementmodif].x,
 listetexteaffiche[-1+indiceelementmodif].y);
 indiceelementmodif:=nombretexte;
    end;



   mdpolyhedre: if nombrepolyhedre<maxpolyhedre then begin
   retailleppolyhedre(listepolyhedre,nombrepolyhedre,nombrepolyhedre+1);
   inc(nombrepolyhedre);
 listepolyhedre[-1+nombrepolyhedre].create(
 listepolyhedre[-1+indiceelementmodif].nombresommet,
 listepolyhedre[-1+indiceelementmodif].messommets,
 listepolyhedre[-1+indiceelementmodif].indicerouge,
 listepolyhedre[-1+indiceelementmodif].indicebleu,
 listepolyhedre[-1+indiceelementmodif].indicevert,
 listepolyhedre[-1+indiceelementmodif].couleurbord,
 listepolyhedre[-1+indiceelementmodif].couleurfond,
 listepolyhedre[-1+indiceelementmodif].reflechientrant,
 listepolyhedre[-1+indiceelementmodif].reflechisortant);
 indiceelementmodif:=nombrepolyhedre;

      end;


      mdprisme: if nombreprisme<maxprisme then begin
   retaillepprisme(listeprisme,nombreprisme,nombreprisme+1);
   inc(nombreprisme);
 listeprisme[-1+nombreprisme].create(
 listeprisme[-1+indiceelementmodif].gx,
 listeprisme[-1+indiceelementmodif].gy,
 listeprisme[-1+indiceelementmodif].ax,
 listeprisme[-1+indiceelementmodif].ay,
 listeprisme[-1+indiceelementmodif].bx,
 listeprisme[-1+indiceelementmodif].by,
 listeprisme[-1+indiceelementmodif].indicerouge,
 listeprisme[-1+indiceelementmodif].indicebleu,
 listeprisme[-1+indiceelementmodif].indicevert,
 listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].reflechientrant,
 listeprisme[-1+indiceelementmodif].reflechisortant);
 indiceelementmodif:=nombreprisme;

      end;




        mdpolycercle: if nombrepolycercle<maxpolycercle then begin
   retailleppolycercle(listepolycercle,nombrepolycercle,nombrepolycercle+1);
   inc(nombrepolycercle);
 listepolycercle[-1+nombrepolycercle].create(
 listepolycercle[-1+indiceelementmodif].nombresommet,
 listepolycercle[-1+indiceelementmodif].messommets,
  listepolycercle[-1+indiceelementmodif].mess,
   listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
 listepolycercle[-1+indiceelementmodif].couleurbord,
 listepolycercle[-1+indiceelementmodif].couleurfond,
 listepolycercle[-1+indiceelementmodif].reflechientrant,
 listepolycercle[-1+indiceelementmodif].reflechisortant);
 indiceelementmodif:=nombrepolycercle;

      end;

      mdmiroirconique: if nombremiroirconique<maxmiroirconique then begin
   retaillepmiroirconique(listemiroirconique,nombremiroirconique,nombremiroirconique+1);
   inc(nombremiroirconique);
 listemiroirconique[-1+nombremiroirconique].create2(
 listemiroirconique[-1+indiceelementmodif].fx,
 listemiroirconique[-1+indiceelementmodif].fy,
 listemiroirconique[-1+indiceelementmodif].theta0,
 listemiroirconique[-1+indiceelementmodif].theta1,
 listemiroirconique[-1+indiceelementmodif].theta2,
 listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
 listemiroirconique[-1+indiceelementmodif].couleur,
 listemiroirconique[-1+indiceelementmodif].couleuraxe,
 listemiroirconique[-1+indiceelementmodif].hachures,
 listemiroirconique[-1+indiceelementmodif].axefocal);
 indiceelementmodif:=nombremiroirconique;

      end;


   mdsphere: if nombresphere<maxsphere then begin
   retaillepsphere(listesphere,nombresphere,nombresphere+1);
   inc(nombresphere);
 listesphere[-1+nombresphere].create(
 listesphere[-1+indiceelementmodif].cx,
 listesphere[-1+indiceelementmodif].cy,
  listesphere[-1+indiceelementmodif].rayon,
 listesphere[-1+indiceelementmodif].indicerouge,
 listesphere[-1+indiceelementmodif].indicebleu,
 listesphere[-1+indiceelementmodif].indicevert,
 listesphere[-1+indiceelementmodif].couleurbord,
 listesphere[-1+indiceelementmodif].couleurfond,
 listesphere[-1+indiceelementmodif].reflechientrant,
 listesphere[-1+indiceelementmodif].reflechisortant);
 indiceelementmodif:=nombresphere;
          end;

    mdmiroirplan: if nombremiroirplan<maxmiroirplan then begin
    retaillepmiroirplan(listemiroirplan,nombremiroirplan,nombremiroirplan+1);
    inc(nombremiroirplan);
     listemiroirplan[-1+nombremiroirplan].create(
 listemiroirplan[-1+indiceelementmodif].a1x,
 listemiroirplan[-1+indiceelementmodif].a1y,
 listemiroirplan[-1+indiceelementmodif].a2x,
 listemiroirplan[-1+indiceelementmodif].a2y,
 listemiroirplan[-1+indiceelementmodif].epaisseur,
 listemiroirplan[-1+indiceelementmodif].couleur,
 listemiroirplan[-1+indiceelementmodif].hachures);
 indiceelementmodif:=nombremiroirplan;
    end;

      mdReseau: if nombreReseau<maxReseau then begin
    retaillepReseau(listeReseau,nombreReseau,nombreReseau+1);
    inc(nombreReseau);
     listeReseau[-1+nombreReseau].create(
 listeReseau[-1+indiceelementmodif].a1x,
 listeReseau[-1+indiceelementmodif].a1y,
 listeReseau[-1+indiceelementmodif].a2x,
 listeReseau[-1+indiceelementmodif].a2y,
 listeReseau[-1+indiceelementmodif].epaisseur,
 listeReseau[-1+indiceelementmodif].couleur,
 listeReseau[-1+indiceelementmodif].pas,
 listeReseau[-1+indiceelementmodif].entransmission,
 listeReseau[-1+indiceelementmodif].hachures,
 listeReseau[-1+indiceelementmodif].ordre_min,
 listeReseau[-1+indiceelementmodif].ordre_max);
 indiceelementmodif:=nombreReseau;
    end;

    mdmetre: if nombremetre<maxmetre then begin
    retaillepmetre(listemetre,nombremetre,nombremetre+1);
    inc(nombremetre);
     listemetre[-1+nombremetre].create(
 listemetre[-1+indiceelementmodif].a1x,
 listemetre[-1+indiceelementmodif].a1y,
 listemetre[-1+indiceelementmodif].a2x,
 listemetre[-1+indiceelementmodif].a2y);
 indiceelementmodif:=nombremetre;
    end;

    mdangle: if nombreangle<maxangle then begin
    retaillepangle(listeangle,nombreangle,nombreangle+1);
    inc(nombreangle);
     listeangle[-1+nombreangle].create(
     listeangle[-1+indiceelementmodif].cx,
     listeangle[-1+indiceelementmodif].cy,
 listeangle[-1+indiceelementmodif].a1x,
 listeangle[-1+indiceelementmodif].a1y,
 listeangle[-1+indiceelementmodif].a2x,
 listeangle[-1+indiceelementmodif].a2y);
 indiceelementmodif:=nombreangle;
    end;



     mdfleche: if nombrefleche<maxfleche then begin
    retaillepfleche(listefleche,nombrefleche,nombrefleche+1);
    inc(nombrefleche);
     listefleche[-1+nombrefleche].create(
 listefleche[-1+indiceelementmodif].a1x,
 listefleche[-1+indiceelementmodif].a1y,
 listefleche[-1+indiceelementmodif].a2x,
 listefleche[-1+indiceelementmodif].a2y,
 listefleche[-1+indiceelementmodif].epaisseur,
 listefleche[-1+indiceelementmodif].couleur,
 listefleche[-1+indiceelementmodif].ext1,
 listefleche[-1+indiceelementmodif].ext2,
  listefleche[-1+indiceelementmodif].styletrait,
   listefleche[-1+indiceelementmodif].taille1,
    listefleche[-1+indiceelementmodif].taille2 );
 indiceelementmodif:=nombrefleche;
    end;



     mdecran: if nombreecran<maxecran then begin
  retaillepecran(listeecran,nombreecran,nombreecran+1);
 inc(nombreecran);
 listeecran[-1+nombreecran].create(
 listeecran[-1+indiceelementmodif].a1x,
 listeecran[-1+indiceelementmodif].a1y,
 listeecran[-1+indiceelementmodif].a2x,
 listeecran[-1+indiceelementmodif].a2y,
 listeecran[-1+indiceelementmodif].epaisseur,
 listeecran[-1+indiceelementmodif].couleur);
   indiceelementmodif:=nombreecran;
 end;


  mdoeil: if nombreoeil<maxoeil then begin
  retaillepoeil(listeoeil,nombreoeil,nombreoeil+1);
 inc(nombreoeil);
 listeoeil[-1+nombreoeil].create(
 listeoeil[-1+indiceelementmodif].cx,
 listeoeil[-1+indiceelementmodif].cy,
 listeoeil[-1+indiceelementmodif].ax,
 listeoeil[-1+indiceelementmodif].ay,
 listeoeil[-1+indiceelementmodif].epaisseur,
 listeoeil[-1+indiceelementmodif].couleur);
   indiceelementmodif:=nombreoeil;
 end;



 mddiaphragme: if nombrediaphragme<maxdiaphragme then begin
  retaillepdiaphragme(listediaphragme,nombrediaphragme,nombrediaphragme+1);
 inc(nombrediaphragme);
 listediaphragme[-1+nombrediaphragme].create2(
 listediaphragme[-1+indiceelementmodif].cx,
 listediaphragme[-1+indiceelementmodif].cy,
 listediaphragme[-1+indiceelementmodif].anglepolaire,
 listediaphragme[-1+indiceelementmodif].rint,
 listediaphragme[-1+indiceelementmodif].rext,
 listediaphragme[-1+indiceelementmodif].couleur,
 listediaphragme[-1+indiceelementmodif].epaisseur);
   indiceelementmodif:=nombrediaphragme;
 end;



mdlsr: if nombrelsr<maxlsr then begin
retailleplsr(listelsr,nombrelsr,nombrelsr+1);
 inc(nombrelsr);
 listelsr[-1+nombrelsr].create(
 listelsr[-1+indiceelementmodif].a1x,
 listelsr[-1+indiceelementmodif].a1y,
 listelsr[-1+indiceelementmodif].a2x,
 listelsr[-1+indiceelementmodif].a2y,
 listelsr[-1+indiceelementmodif].epaisseur,
 listelsr[-1+indiceelementmodif].couleur);
 indiceelementmodif:=nombrelsr;
    end;

    mdrayon:  if nombrerayon<maxrayon then begin
    retailleprayon(listerayon,nombrerayon,nombrerayon+1);
 inc(nombrerayon);
 listerayon[-1+nombrerayon].create(
 listerayon[-1+indiceelementmodif].ax,
 listerayon[-1+indiceelementmodif].ay,
 listerayon[-1+indiceelementmodif].kx,
 listerayon[-1+indiceelementmodif].ky,
 listerayon[-1+indiceelementmodif].couleur,
 listerayon[-1+indiceelementmodif].epaisseur,
 listerayon[-1+indiceelementmodif].vav,
 listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment);
indiceelementmodif:=nombrerayon;
    end;


    mdsourceponctuelle: if nombresourceponctuelle<maxsourceponctuelle then begin
     retaillepsourceponctuelle(listesourceponctuelle,nombresourceponctuelle,nombresourceponctuelle+1);
 inc(nombresourceponctuelle);
 listesourceponctuelle[-1+nombresourceponctuelle].create(
 listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
 listesourceponctuelle[-1+indiceelementmodif].sx,
 listesourceponctuelle[-1+indiceelementmodif].sy,
 listesourceponctuelle[-1+indiceelementmodif].a1x,
 listesourceponctuelle[-1+indiceelementmodif].a1y,
 listesourceponctuelle[-1+indiceelementmodif].a2x,
 listesourceponctuelle[-1+indiceelementmodif].a2y,
 listesourceponctuelle[-1+indiceelementmodif].couleur,
 listesourceponctuelle[-1+indiceelementmodif].epaisseur,
 listesourceponctuelle[-1+indiceelementmodif].vav,
 listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment);
 indiceelementmodif:=nombresourceponctuelle;
 end;


     mdondeplane: if nombreondeplane<maxondeplane then begin
    retaillepondeplane(listeondeplane,nombreondeplane,nombreondeplane+1);
 inc(nombreondeplane);
 listeondeplane[-1+nombreondeplane].create(
 listeondeplane[-1+indiceelementmodif].nombrederayon,
 listeondeplane[-1+indiceelementmodif].sx,
 listeondeplane[-1+indiceelementmodif].sy,
 listeondeplane[-1+indiceelementmodif].a1x,
 listeondeplane[-1+indiceelementmodif].a1y,
 listeondeplane[-1+indiceelementmodif].a2x,
 listeondeplane[-1+indiceelementmodif].a2y,
 listeondeplane[-1+indiceelementmodif].couleur,
 listeondeplane[-1+indiceelementmodif].epaisseur,
 listeondeplane[-1+indiceelementmodif].vav,
 listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment);
  indiceelementmodif:=nombreondeplane;
 end;



    mdmscopa: if nombremscopa<maxmscopa then begin
    retaillepmscopa(listemscopa,nombremscopa,nombremscopa+1);
 inc(nombremscopa);
 listemscopa[-1+nombremscopa].create2(
 listemscopa[-1+indiceelementmodif].a1x,
 listemscopa[-1+indiceelementmodif].a1y,
 listemscopa[-1+indiceelementmodif].a2x,
 listemscopa[-1+indiceelementmodif].a2y,
 listemscopa[-1+indiceelementmodif].focale,
 listemscopa[-1+indiceelementmodif].epaisseur,
 listemscopa[-1+indiceelementmodif].couleur,
 listemscopa[-1+indiceelementmodif].couleuraxe,
 listemscopa[-1+indiceelementmodif].hachures,
 listemscopa[-1+indiceelementmodif].axefocal,
 listemscopa[-1+indiceelementmodif].trou,
 listemscopa[-1+indiceelementmodif].diametretrou);
   indiceelementmodif:=nombremscopa;
 end;


    mdmscepa: if nombremscepa<maxmscepa then begin
    retaillepmscepa(listemscepa,nombremscepa,nombremscepa+1);
 inc(nombremscepa);
 listemscepa[-1+nombremscepa].create2(
 listemscepa[-1+indiceelementmodif].a1x,
 listemscepa[-1+indiceelementmodif].a1y,
 listemscepa[-1+indiceelementmodif].a2x,
 listemscepa[-1+indiceelementmodif].a2y,
 listemscepa[-1+indiceelementmodif].focale,
 listemscepa[-1+indiceelementmodif].epaisseur,
 listemscepa[-1+indiceelementmodif].couleur,
 listemscepa[-1+indiceelementmodif].couleuraxe,
 listemscepa[-1+indiceelementmodif].hachures,
 listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou);
   indiceelementmodif:=nombremscepa;
 end;


 mdmscore: if nombremscore<maxmscore then begin
   retaillepmscore(listemscore,nombremscore,nombremscore+1);
 inc(nombremscore);
 listemscore[-1+nombremscore].create2(
 listemscore[-1+indiceelementmodif].a1x,
 listemscore[-1+indiceelementmodif].a1y,
 listemscore[-1+indiceelementmodif].a2x,
 listemscore[-1+indiceelementmodif].a2y,
 listemscore[-1+indiceelementmodif].rayoncourbure,
 listemscore[-1+indiceelementmodif].epaisseur,
 listemscore[-1+indiceelementmodif].couleur,
 listemscore[-1+indiceelementmodif].couleuraxe,
 listemscore[-1+indiceelementmodif].hachures,
 listemscore[-1+indiceelementmodif].axefocal,
 listemscore[-1+indiceelementmodif].aigu,
 listemscore[-1+indiceelementmodif].trou,
 listemscore[-1+indiceelementmodif].diametretrou);
 indiceelementmodif:=nombremscore;
      end;


 mdmscere: if nombremscere<maxmscere then begin
  retaillepmscere(listemscere,nombremscere,nombremscere+1);
 inc(nombremscere);
 listemscere[-1+nombremscere].create2(
 listemscere[-1+indiceelementmodif].a1x,
 listemscere[-1+indiceelementmodif].a1y,
 listemscere[-1+indiceelementmodif].a2x,
 listemscere[-1+indiceelementmodif].a2y,
 listemscere[-1+indiceelementmodif].rayoncourbure,
 listemscere[-1+indiceelementmodif].epaisseur,
 listemscere[-1+indiceelementmodif].couleur,
 listemscere[-1+indiceelementmodif].couleuraxe,
 listemscere[-1+indiceelementmodif].hachures,
 listemscere[-1+indiceelementmodif].axefocal,
 listemscere[-1+indiceelementmodif].aigu,
 listemscere[-1+indiceelementmodif].trou,
 listemscere[-1+indiceelementmodif].diametretrou);
  indiceelementmodif:=nombremscere;
 end;


  mdlmc: if nombrelmc<maxlmc then begin
  retailleplmc(listelmc,nombrelmc,nombrelmc+1);
 inc(nombrelmc);
 listelmc[-1+nombrelmc].create2(
 listelmc[-1+indiceelementmodif].a1x,
 listelmc[-1+indiceelementmodif].a1y,
 listelmc[-1+indiceelementmodif].a2x,
 listelmc[-1+indiceelementmodif].a2y,
 listelmc[-1+indiceelementmodif].focale,
 listelmc[-1+indiceelementmodif].epaisseur,
 listelmc[-1+indiceelementmodif].couleur,
 listelmc[-1+indiceelementmodif].couleuraxe,
 listelmc[-1+indiceelementmodif].axefocal);
   indiceelementmodif:=nombrelmc;
 end;


 mdlec: if nombrelec<maxlec then begin
  retailleplec(listelec,nombrelec,nombrelec+1);
 inc(nombrelec);
 listelec[-1+nombrelec].create(
 listelec[-1+indiceelementmodif].s1x,
 listelec[-1+indiceelementmodif].s1y,
 listelec[-1+indiceelementmodif].s2x,
 listelec[-1+indiceelementmodif].s2y,
 listelec[-1+indiceelementmodif].r1,
 listelec[-1+indiceelementmodif].r2,
 listelec[-1+indiceelementmodif].diametre,
 listelec[-1+indiceelementmodif].couleurfond,
 listelec[-1+indiceelementmodif].couleuraxe,
 listelec[-1+indiceelementmodif].axefocal,
 listelec[-1+indiceelementmodif].indicerouge,
 listelec[-1+indiceelementmodif].indicebleu,
 listelec[-1+indiceelementmodif].indicevert,
 listelec[-1+indiceelementmodif].reflechientrant,
 listelec[-1+indiceelementmodif].reflechisortant);
   indiceelementmodif:=nombrelec;
 end;




  mdlmd: if nombrelmd<maxlmd then begin
  retailleplmd(listelmd,nombrelmd,nombrelmd+1);
 inc(nombrelmd);
 listelmd[-1+nombrelmd].create2(
 listelmd[-1+indiceelementmodif].a1x,
 listelmd[-1+indiceelementmodif].a1y,
 listelmd[-1+indiceelementmodif].a2x,
 listelmd[-1+indiceelementmodif].a2y,
 listelmd[-1+indiceelementmodif].focale,
 listelmd[-1+indiceelementmodif].epaisseur,
 listelmd[-1+indiceelementmodif].couleur,
 listelmd[-1+indiceelementmodif].couleuraxe,
 listelmd[-1+indiceelementmodif].axefocal);
   indiceelementmodif:=nombrelmd;
 end;


    end; {du case}


     modeinfo:=false; modemodif:=true; modetranslation:=true; modifencours:=true;
     form1.image1.Cursor:=crtranslation;
     traitemodif(sender,shift,x,y);
     end;


   Rafraichit;
   form1.image1.Cursor:=crdefault;
  end;




   procedure FinModif(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
  var x1,y1,rapport,lambda,xx1,yy1,dtheta,AiAj,ux,uy,hx,hy,dAB,dIS:extended;

   i:integer;

  begin if bloqueaxe then begin
  if (ssalt in shift) then  x:=lastxf;
if (ssctrl in shift)  then  y:=lastyf;
end;

graphepresent:=true;
    BIBI.convert(x,y,x1,y1,true);
   if (modetranslation and attractiongrille) then  BIBI.arronditalagrille(x1,y1,grillex,grilley);


    if bloqueaxe then begin
      if (ssalt in shift) then  x1:=lastxr;
if (ssctrl in shift)  then  y1:=lastyr;
end;


  if modetranslation then begin
case typeelementmodif of

mdoeil: begin
retaillePoeil(listeoeil,nombreoeil,nombreoeil+1);
if listeoeil[-1+nombreoeil+1].create(
x1,y1,listeoeil[-1+indiceelementmodif].ax+x1-listeoeil[-1+indiceelementmodif].cx,
listeoeil[-1+indiceelementmodif].ay+y1-listeoeil[-1+indiceelementmodif].cy,
listeoeil[-1+indiceelementmodif].epaisseur,
listeoeil[-1+indiceelementmodif].couleur) then
 listeoeil[-1+indiceelementmodif].create(
x1,y1,listeoeil[-1+indiceelementmodif].ax+x1-listeoeil[-1+indiceelementmodif].cx,
listeoeil[-1+indiceelementmodif].ay+y1-listeoeil[-1+indiceelementmodif].cy,
listeoeil[-1+indiceelementmodif].epaisseur,
listeoeil[-1+indiceelementmodif].couleur)
else
listeoeil[-1+indiceelementmodif].create(
listeoeil[-1+indiceelementmodif].cx,
listeoeil[-1+indiceelementmodif].cy,
listeoeil[-1+indiceelementmodif].ax,
listeoeil[-1+indiceelementmodif].ay,
listeoeil[-1+indiceelementmodif].epaisseur,
listeoeil[-1+indiceelementmodif].couleur);
retaillePoeil(listeoeil,nombreoeil+1,nombreoeil);
Rafraichit;
end;


mdprisme: begin
retaillePprisme(listeprisme,nombreprisme,nombreprisme+1);
if listeprisme[-1+nombreprisme+1].create(
x1,y1,listeprisme[-1+indiceelementmodif].ax+x1-listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].ay+y1-listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].bx+x1-listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].by+y1-listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant) then
 listeprisme[-1+indiceelementmodif].create(
x1,y1,listeprisme[-1+indiceelementmodif].ax+x1-listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].ay+y1-listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].bx+x1-listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].by+y1-listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant)
else
listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].ax,
listeprisme[-1+indiceelementmodif].ay,
listeprisme[-1+indiceelementmodif].bx,
listeprisme[-1+indiceelementmodif].by,
listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant);
retaillePprisme(listeprisme,nombreprisme+1,nombreprisme);
Rafraichit;
end;


mdmetre: begin
retaillePmetre(listemetre,nombremetre,nombremetre+1);
if listemetre[-1+nombremetre+1].create(
    listemetre[-1+indiceelementmodif].a1x+x1-(listemetre[-1+indiceelementmodif].a1x+
    listemetre[-1+indiceelementmodif].a2x)/2,
listemetre[-1+indiceelementmodif].a1y+y1-(listemetre[-1+indiceelementmodif].a1y+
    listemetre[-1+indiceelementmodif].a2y)/2,
 listemetre[-1+indiceelementmodif].a2x+x1-(listemetre[-1+indiceelementmodif].a1x+
    listemetre[-1+indiceelementmodif].a2x)/2,
listemetre[-1+indiceelementmodif].a2y+y1-(listemetre[-1+indiceelementmodif].a1y+
    listemetre[-1+indiceelementmodif].a2y)/2) then
 listemetre[-1+indiceelementmodif].create(
    listemetre[-1+indiceelementmodif].a1x+x1-(listemetre[-1+indiceelementmodif].a1x+
    listemetre[-1+indiceelementmodif].a2x)/2,
listemetre[-1+indiceelementmodif].a1y+y1-(listemetre[-1+indiceelementmodif].a1y+
    listemetre[-1+indiceelementmodif].a2y)/2,
 listemetre[-1+indiceelementmodif].a2x+x1-(listemetre[-1+indiceelementmodif].a1x+
    listemetre[-1+indiceelementmodif].a2x)/2,
listemetre[-1+indiceelementmodif].a2y+y1-(listemetre[-1+indiceelementmodif].a1y+
    listemetre[-1+indiceelementmodif].a2y)/2)
else
listemetre[-1+indiceelementmodif].create(
listemetre[-1+indiceelementmodif].a1x,
listemetre[-1+indiceelementmodif].a1y,
listemetre[-1+indiceelementmodif].a2x,
listemetre[-1+indiceelementmodif].a2y);
retaillePmetre(listemetre,nombremetre+1,nombremetre);
Rafraichit;
end;


mdangle: begin
retaillePangle(listeangle,nombreangle,nombreangle+1);
if listeangle[-1+nombreangle+1].create(
    listeangle[-1+indiceelementmodif].cx+x1-listeangle[-1+indiceelementmodif].dx,
listeangle[-1+indiceelementmodif].cy+y1-listeangle[-1+indiceelementmodif].dy,
 listeangle[-1+indiceelementmodif].a1x+x1-listeangle[-1+indiceelementmodif].dx,
listeangle[-1+indiceelementmodif].a1y+y1-listeangle[-1+indiceelementmodif].dy,
 listeangle[-1+indiceelementmodif].a2x+x1-listeangle[-1+indiceelementmodif].dx,
listeangle[-1+indiceelementmodif].a2y+y1-listeangle[-1+indiceelementmodif].dy) then
 listeangle[-1+indiceelementmodif].create(
    listeangle[-1+indiceelementmodif].cx+x1-listeangle[-1+indiceelementmodif].dx,
listeangle[-1+indiceelementmodif].cy+y1-listeangle[-1+indiceelementmodif].dy,
 listeangle[-1+indiceelementmodif].a1x+x1-listeangle[-1+indiceelementmodif].dx,
listeangle[-1+indiceelementmodif].a1y+y1-listeangle[-1+indiceelementmodif].dy,
 listeangle[-1+indiceelementmodif].a2x+x1-listeangle[-1+indiceelementmodif].dx,
listeangle[-1+indiceelementmodif].a2y+y1-listeangle[-1+indiceelementmodif].dy)
else
listeangle[-1+indiceelementmodif].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y);
retaillePangle(listeangle,nombreangle+1,nombreangle);
Rafraichit;
end;


mdfleche: begin
retaillePfleche(listefleche,nombrefleche,nombrefleche+1);
if listefleche[-1+nombrefleche+1].create(
    listefleche[-1+indiceelementmodif].a1x+x1-listefleche[-1+indiceelementmodif].cx,
listefleche[-1+indiceelementmodif].a1y+y1-listefleche[-1+indiceelementmodif].cy,
 listefleche[-1+indiceelementmodif].a2x+x1-listefleche[-1+indiceelementmodif].cx,
listefleche[-1+indiceelementmodif].a2y+y1-listefleche[-1+indiceelementmodif].cy,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2) then
 listefleche[-1+indiceelementmodif].create(
    listefleche[-1+indiceelementmodif].a1x+x1-listefleche[-1+indiceelementmodif].cx,
listefleche[-1+indiceelementmodif].a1y+y1-listefleche[-1+indiceelementmodif].cy,
 listefleche[-1+indiceelementmodif].a2x+x1-listefleche[-1+indiceelementmodif].cx,
listefleche[-1+indiceelementmodif].a2y+y1-listefleche[-1+indiceelementmodif].cy,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2)
else
listefleche[-1+indiceelementmodif].create(
listefleche[-1+indiceelementmodif].a1x,
listefleche[-1+indiceelementmodif].a1y,
listefleche[-1+indiceelementmodif].a2x,
listefleche[-1+indiceelementmodif].a2y,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2);
retaillePfleche(listefleche,nombrefleche+1,nombrefleche);
Rafraichit;
end;



 mdtexteaffiche: begin
if ((x1<>listetexteaffiche[-1+indiceelementmodif].x) or
(y1<>listetexteaffiche[-1+indiceelementmodif].y)) then begin
retailleptexteaffiche(listetexteaffiche,nombretexte,nombretexte+1);

 if listetexteaffiche[-1+nombretexte+1].create(listetexteaffiche[-1+indiceelementmodif].texteluimeme,
 listetexteaffiche[-1+indiceelementmodif].policename,listetexteaffiche[-1+indiceelementmodif].
 policecharset,listetexteaffiche[-1+indiceelementmodif].policecolor,
 listetexteaffiche[-1+indiceelementmodif].policesize,
 listetexteaffiche[-1+indiceelementmodif].policepitch,
 listetexteaffiche[-1+indiceelementmodif].policefsbold,
 listetexteaffiche[-1+indiceelementmodif].policefsitalic,
 listetexteaffiche[-1+indiceelementmodif].policefsunderline,
 listetexteaffiche[-1+indiceelementmodif].policefsstrikeout,
 x1,y1) then
 listetexteaffiche[-1+indiceelementmodif].create(listetexteaffiche[-1+indiceelementmodif].texteluimeme,
 listetexteaffiche[-1+indiceelementmodif].policename,listetexteaffiche[-1+indiceelementmodif].
 policecharset,listetexteaffiche[-1+indiceelementmodif].policecolor,
 listetexteaffiche[-1+indiceelementmodif].policesize,
 listetexteaffiche[-1+indiceelementmodif].policepitch,
 listetexteaffiche[-1+indiceelementmodif].policefsbold,
 listetexteaffiche[-1+indiceelementmodif].policefsitalic,
 listetexteaffiche[-1+indiceelementmodif].policefsunderline,
 listetexteaffiche[-1+indiceelementmodif].policefsstrikeout,
 x1,y1) else
 listetexteaffiche[-1+indiceelementmodif].create(listetexteaffiche[-1+indiceelementmodif].texteluimeme,
 listetexteaffiche[-1+indiceelementmodif].policename,listetexteaffiche[-1+indiceelementmodif].
 policecharset,listetexteaffiche[-1+indiceelementmodif].policecolor,
 listetexteaffiche[-1+indiceelementmodif].policesize,
 listetexteaffiche[-1+indiceelementmodif].policepitch,
 listetexteaffiche[-1+indiceelementmodif].policefsbold,
 listetexteaffiche[-1+indiceelementmodif].policefsitalic,
 listetexteaffiche[-1+indiceelementmodif].policefsunderline,
 listetexteaffiche[-1+indiceelementmodif].policefsstrikeout,
 listetexteaffiche[-1+indiceelementmodif].x,
 listetexteaffiche[-1+indiceelementmodif].y);
 retailleptexteaffiche(listetexteaffiche,nombretexte+1,nombretexte);
 Rafraichit;
end;               end;

mdsphere: begin
if ((x1<>listesphere[-1+indiceelementmodif].cx) or (y1<>listesphere[-1+indiceelementmodif].cy)) then begin
retaillepsphere(listesphere,nombresphere,nombresphere+1);
if listesphere[-1+nombresphere+1].create(
x1,y1,
listesphere[-1+indiceelementmodif].rayon,
listesphere[-1+indiceelementmodif].indicerouge,
listesphere[-1+indiceelementmodif].indicebleu,
listesphere[-1+indiceelementmodif].indicevert,
listesphere[-1+indiceelementmodif].couleurbord,
listesphere[-1+indiceelementmodif].couleurfond,
listesphere[-1+indiceelementmodif].reflechientrant,
listesphere[-1+indiceelementmodif].reflechisortant) then
listesphere[-1+indiceelementmodif].create(x1,y1,
listesphere[-1+indiceelementmodif].rayon,
listesphere[-1+indiceelementmodif].indicerouge,
listesphere[-1+indiceelementmodif].indicebleu,
listesphere[-1+indiceelementmodif].indicevert,
listesphere[-1+indiceelementmodif].couleurbord,
listesphere[-1+indiceelementmodif].couleurfond,
listesphere[-1+indiceelementmodif].reflechientrant,
listesphere[-1+indiceelementmodif].reflechisortant)
 else
listesphere[-1+indiceelementmodif].create(
listesphere[-1+indiceelementmodif].cx,
listesphere[-1+indiceelementmodif].cy,
listesphere[-1+indiceelementmodif].rayon,
listesphere[-1+indiceelementmodif].indicerouge,
listesphere[-1+indiceelementmodif].indicebleu,
listesphere[-1+indiceelementmodif].indicevert,
listesphere[-1+indiceelementmodif].couleurbord,
listesphere[-1+indiceelementmodif].couleurfond,
listesphere[-1+indiceelementmodif].reflechientrant,
listesphere[-1+indiceelementmodif].reflechisortant);
 retaillepsphere(listesphere,nombresphere+1,nombresphere);
 Rafraichit;
 end;   end;

mdmiroirplan: begin
  retaillePMiroirplan(listemiroirplan,nombremiroirplan,nombremiroirplan+1);
if listemiroirplan[-1+nombremiroirplan+1].create(
listemiroirplan[-1+indiceelementmodif].a1x+x1-
listemiroirplan[-1+indiceelementmodif].cx,
listemiroirplan[-1+indiceelementmodif].a1y+y1-
listemiroirplan[-1+indiceelementmodif].cy,
listemiroirplan[-1+indiceelementmodif].a2x+x1-
listemiroirplan[-1+indiceelementmodif].cx,
listemiroirplan[-1+indiceelementmodif].a2y+y1-
listemiroirplan[-1+indiceelementmodif].cy,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures) then
 listemiroirplan[-1+indiceelementmodif].create(
listemiroirplan[-1+indiceelementmodif].a1x+x1-
listemiroirplan[-1+indiceelementmodif].cx,
listemiroirplan[-1+indiceelementmodif].a1y+y1-
listemiroirplan[-1+indiceelementmodif].cy,
listemiroirplan[-1+indiceelementmodif].a2x+x1-
listemiroirplan[-1+indiceelementmodif].cx,
listemiroirplan[-1+indiceelementmodif].a2y+y1-
listemiroirplan[-1+indiceelementmodif].cy,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures) else
 listemiroirplan[-1+indiceelementmodif].create(
listemiroirplan[-1+indiceelementmodif].a1x,
listemiroirplan[-1+indiceelementmodif].a1y,
listemiroirplan[-1+indiceelementmodif].a2x,
listemiroirplan[-1+indiceelementmodif].a2y,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures);
retaillePMiroirplan(listemiroirplan,nombremiroirplan+1,nombremiroirplan);
Rafraichit;
end; {du cas miroir plan}


mdReseau: begin
  retaillePReseau(listeReseau,nombreReseau,nombreReseau+1);
if listeReseau[-1+nombreReseau+1].create(
listeReseau[-1+indiceelementmodif].a1x+x1-
listeReseau[-1+indiceelementmodif].cx,
listeReseau[-1+indiceelementmodif].a1y+y1-
listeReseau[-1+indiceelementmodif].cy,
listeReseau[-1+indiceelementmodif].a2x+x1-
listeReseau[-1+indiceelementmodif].cx,
listeReseau[-1+indiceelementmodif].a2y+y1-
listeReseau[-1+indiceelementmodif].cy,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listeReseau[-1+indiceelementmodif].entransmission,
listeReseau[-1+indiceelementmodif].hachures,
listeReseau[-1+indiceelementmodif].ordre_min,
listeReseau[-1+indiceelementmodif].ordre_max) then
 listeReseau[-1+indiceelementmodif].create(
listeReseau[-1+indiceelementmodif].a1x+x1-
listeReseau[-1+indiceelementmodif].cx,
listeReseau[-1+indiceelementmodif].a1y+y1-
listeReseau[-1+indiceelementmodif].cy,
listeReseau[-1+indiceelementmodif].a2x+x1-
listeReseau[-1+indiceelementmodif].cx,
listeReseau[-1+indiceelementmodif].a2y+y1-
listeReseau[-1+indiceelementmodif].cy,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listeReseau[-1+indiceelementmodif].entransmission,
listeReseau[-1+indiceelementmodif].hachures,
listeReseau[-1+indiceelementmodif].ordre_min,
listeReseau[-1+indiceelementmodif].ordre_max) else
 listeReseau[-1+indiceelementmodif].create(
listeReseau[-1+indiceelementmodif].a1x,
listeReseau[-1+indiceelementmodif].a1y,
listeReseau[-1+indiceelementmodif].a2x,
listeReseau[-1+indiceelementmodif].a2y,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listeReseau[-1+indiceelementmodif].entransmission,
listeReseau[-1+indiceelementmodif].hachures,
listeReseau[-1+indiceelementmodif].ordre_min,
listeReseau[-1+indiceelementmodif].ordre_max);
retaillePReseau(listeReseau,nombreReseau+1,nombreReseau);
Rafraichit;
end; {du cas reseau}


mdpolyhedre: if (  (x1<>listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace].ax) or
 (y1<>listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace].ay))
 then begin
retaillePpolyhedre(listepolyhedre,nombrepolyhedre,nombrepolyhedre+1);
for i:=1 to listepolyhedre[-1+indiceelementmodif].nombresommet do
begin
ttpoly[i].ax:=listepolyhedre[-1+indiceelementmodif].messommets[i].ax+x1-
(listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace].ax+
listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2;
ttpoly[i].ay:=listepolyhedre[-1+indiceelementmodif].messommets[i].ay+y1-
(listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace].ay+
listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2;
end;

if listepolyhedre[-1+nombrepolyhedre+1].create(
listepolyhedre[-1+indiceelementmodif].nombresommet,
ttpoly,
 listepolyhedre[-1+indiceelementmodif].indicerouge,
 listepolyhedre[-1+indiceelementmodif].indicebleu,
 listepolyhedre[-1+indiceelementmodif].indicevert,
listepolyhedre[-1+indiceelementmodif].couleurbord,
listepolyhedre[-1+indiceelementmodif].couleurfond,
listepolyhedre[-1+indiceelementmodif].reflechientrant,
listepolyhedre[-1+indiceelementmodif].reflechisortant) then
 listepolyhedre[-1+indiceelementmodif].create(
 listepolyhedre[-1+indiceelementmodif].nombresommet,
ttpoly,
 listepolyhedre[-1+indiceelementmodif].indicerouge,
 listepolyhedre[-1+indiceelementmodif].indicebleu,
 listepolyhedre[-1+indiceelementmodif].indicevert,
listepolyhedre[-1+indiceelementmodif].couleurbord,
listepolyhedre[-1+indiceelementmodif].couleurfond,
listepolyhedre[-1+indiceelementmodif].reflechientrant,
listepolyhedre[-1+indiceelementmodif].reflechisortant)
else
listepolyhedre[-1+indiceelementmodif].create(
listepolyhedre[-1+indiceelementmodif].nombresommet,
listepolyhedre[-1+indiceelementmodif].messommets,
 listepolyhedre[-1+indiceelementmodif].indicerouge,
 listepolyhedre[-1+indiceelementmodif].indicebleu,
 listepolyhedre[-1+indiceelementmodif].indicevert,
listepolyhedre[-1+indiceelementmodif].couleurbord,
listepolyhedre[-1+indiceelementmodif].couleurfond,
listepolyhedre[-1+indiceelementmodif].reflechientrant,
listepolyhedre[-1+indiceelementmodif].reflechisortant);
retaillePpolyhedre(listepolyhedre,nombrepolyhedre+1,nombrepolyhedre);
Rafraichit;
end;



mdpolycercle: if (  (x1<>listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax) or
 (y1<>listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay))
 then begin
retaillePpolycercle(listepolycercle,nombrepolycercle,nombrepolycercle+1);
for i:=1 to listepolycercle[-1+indiceelementmodif].nombresommet do
begin
ttpoly[i].ax:=listepolycercle[-1+indiceelementmodif].messommets[i].ax+x1-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2;
ttpoly[i].ay:=listepolycercle[-1+indiceelementmodif].messommets[i].ay+y1-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2;
ttsom[i].ax:=listepolycercle[-1+indiceelementmodif].mess[i].ax+x1-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2;
ttsom[i].ay:=listepolycercle[-1+indiceelementmodif].mess[i].ay+y1-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2;
end;

if listepolycercle[-1+nombrepolycercle+1].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
ttpoly,ttsom,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant) then
 listepolycercle[-1+indiceelementmodif].create(
 listepolycercle[-1+indiceelementmodif].nombresommet,
ttpoly,ttsom,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant)
else
listepolycercle[-1+indiceelementmodif].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
listepolycercle[-1+indiceelementmodif].messommets,
listepolycercle[-1+indiceelementmodif].mess,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant);
retaillePpolycercle(listepolycercle,nombrepolycercle+1,nombrepolycercle);
Rafraichit;
end;

 mdgroupe: begin
 listegroupe[-1+indiceelementmodif].translate(x1-
 listegroupe[-1+indiceelementmodif].isox,y1-listegroupe[-1+indiceelementmodif].isoy);
   Rafraichit;
end;

mdecran: begin
  retaillePecran(listeecran,nombreecran,nombreecran+1);
if listeecran[-1+nombreecran+1].create(
listeecran[-1+indiceelementmodif].a1x+x1-
listeecran[-1+indiceelementmodif].cx,
listeecran[-1+indiceelementmodif].a1y+y1-
listeecran[-1+indiceelementmodif].cy,
listeecran[-1+indiceelementmodif].a2x+x1-
listeecran[-1+indiceelementmodif].cx,
listeecran[-1+indiceelementmodif].a2y+y1-
listeecran[-1+indiceelementmodif].cy,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur) then
 listeecran[-1+indiceelementmodif].create(
listeecran[-1+indiceelementmodif].a1x+x1-
listeecran[-1+indiceelementmodif].cx,
listeecran[-1+indiceelementmodif].a1y+y1-
listeecran[-1+indiceelementmodif].cy,
listeecran[-1+indiceelementmodif].a2x+x1-
listeecran[-1+indiceelementmodif].cx,
listeecran[-1+indiceelementmodif].a2y+y1-
listeecran[-1+indiceelementmodif].cy,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur) else
 listeecran[-1+indiceelementmodif].create(
listeecran[-1+indiceelementmodif].a1x,
listeecran[-1+indiceelementmodif].a1y,
listeecran[-1+indiceelementmodif].a2x,
listeecran[-1+indiceelementmodif].a2y,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur);
retaillePecran(listeecran,nombreecran+1,nombreecran);
Rafraichit;
end; {du cas ecran}


mddiaphragme: begin
retaillePdiaphragme(listediaphragme,nombrediaphragme,nombrediaphragme+1);
if listediaphragme[-1+nombrediaphragme+1].create2(x1,y1,
listediaphragme[-1+indiceelementmodif].anglepolaire,
listediaphragme[-1+indiceelementmodif].rint,
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur) then
 listediaphragme[-1+indiceelementmodif].create2(x1,y1,
listediaphragme[-1+indiceelementmodif].anglepolaire,
listediaphragme[-1+indiceelementmodif].rint,
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur)
else
listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
listediaphragme[-1+indiceelementmodif].anglepolaire,
listediaphragme[-1+indiceelementmodif].rint,
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur);
retaillePdiaphragme(listediaphragme,nombrediaphragme+1,nombrediaphragme);
Rafraichit;
 end; {du cas diaphragme}


mdlsr: begin
  retaillePlsr(listelsr,nombrelsr,nombrelsr+1);
if listelsr[-1+nombrelsr+1].create(
listelsr[-1+indiceelementmodif].a1x+x1-
listelsr[-1+indiceelementmodif].cx,
listelsr[-1+indiceelementmodif].a1y+y1-
listelsr[-1+indiceelementmodif].cy,
listelsr[-1+indiceelementmodif].a2x+x1-
listelsr[-1+indiceelementmodif].cx,
listelsr[-1+indiceelementmodif].a2y+y1-
listelsr[-1+indiceelementmodif].cy,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur) then
 listelsr[-1+indiceelementmodif].create(
listelsr[-1+indiceelementmodif].a1x+x1-
listelsr[-1+indiceelementmodif].cx,
listelsr[-1+indiceelementmodif].a1y+y1-
listelsr[-1+indiceelementmodif].cy,
listelsr[-1+indiceelementmodif].a2x+x1-
listelsr[-1+indiceelementmodif].cx,
listelsr[-1+indiceelementmodif].a2y+y1-
listelsr[-1+indiceelementmodif].cy,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur) else
 listelsr[-1+indiceelementmodif].create(
listelsr[-1+indiceelementmodif].a1x,
listelsr[-1+indiceelementmodif].a1y,
listelsr[-1+indiceelementmodif].a2x,
listelsr[-1+indiceelementmodif].a2y,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur);
retaillePlsr(listelsr,nombrelsr+1,nombrelsr);
Rafraichit;
end; {du cas lsr}

 mdrayon: begin
retaillePrayon(listerayon,nombrerayon,nombrerayon+1);
if listerayon[-1+nombrerayon+1].create(
listerayon[-1+indiceelementmodif].ax+x1-
listerayon[-1+indiceelementmodif].cx,
listerayon[-1+indiceelementmodif].ay+y1-
listerayon[-1+indiceelementmodif].cy,
listerayon[-1+indiceelementmodif].kx,
listerayon[-1+indiceelementmodif].ky,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment) then
 listerayon[-1+indiceelementmodif].create(
listerayon[-1+indiceelementmodif].ax+x1-
listerayon[-1+indiceelementmodif].cx,
listerayon[-1+indiceelementmodif].ay+y1-
listerayon[-1+indiceelementmodif].cy,
listerayon[-1+indiceelementmodif].kx,
listerayon[-1+indiceelementmodif].ky,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment)
else
listerayon[-1+indiceelementmodif].create(
listerayon[-1+indiceelementmodif].ax,
listerayon[-1+indiceelementmodif].ay,
listerayon[-1+indiceelementmodif].kx,
listerayon[-1+indiceelementmodif].ky,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment);
retaillePrayon(listerayon,nombrerayon+1,nombrerayon);
Rafraichit;
 end; {du cas rayon}



mdsourceponctuelle: begin
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle,nombresourceponctuelle+1);
if listesourceponctuelle[-1+nombresourceponctuelle+1].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx+x1-listesourceponctuelle[-1+indiceelementmodif].gx,
listesourceponctuelle[-1+indiceelementmodif].sy+y1-listesourceponctuelle[-1+indiceelementmodif].gy,
 listesourceponctuelle[-1+indiceelementmodif].a1x+x1-listesourceponctuelle[-1+indiceelementmodif].gx,
listesourceponctuelle[-1+indiceelementmodif].a1y+y1-listesourceponctuelle[-1+indiceelementmodif].gy,
listesourceponctuelle[-1+indiceelementmodif].a2x+x1-listesourceponctuelle[-1+indiceelementmodif].gx,
listesourceponctuelle[-1+indiceelementmodif].a2y+y1-listesourceponctuelle[-1+indiceelementmodif].gy,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment) then
 listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx+x1-listesourceponctuelle[-1+indiceelementmodif].gx,
listesourceponctuelle[-1+indiceelementmodif].sy+y1-listesourceponctuelle[-1+indiceelementmodif].gy,
 listesourceponctuelle[-1+indiceelementmodif].a1x+x1-listesourceponctuelle[-1+indiceelementmodif].gx,
listesourceponctuelle[-1+indiceelementmodif].a1y+y1-listesourceponctuelle[-1+indiceelementmodif].gy,
listesourceponctuelle[-1+indiceelementmodif].a2x+x1-listesourceponctuelle[-1+indiceelementmodif].gx,
listesourceponctuelle[-1+indiceelementmodif].a2y+y1-listesourceponctuelle[-1+indiceelementmodif].gy,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment)

else
listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,
 listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment);
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle+1,nombresourceponctuelle);
Rafraichit;
end;





mdondeplane: begin
retaillePondeplane(listeondeplane,nombreondeplane,nombreondeplane+1);
if listeondeplane[-1+nombreondeplane+1].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
listeondeplane[-1+indiceelementmodif].sx+x1-
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].sy+y1-
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].a1x+x1-
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y+y1-
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].a2x+x1-
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a2y+y1-
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment) then
 listeondeplane[-1+indiceelementmodif].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
listeondeplane[-1+indiceelementmodif].sx+x1-
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].sy+y1-
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].a1x+x1-
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y+y1-
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].a2x+x1-
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a2y+y1-
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment)

else
listeondeplane[-1+indiceelementmodif].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
listeondeplane[-1+indiceelementmodif].sx,
listeondeplane[-1+indiceelementmodif].sy,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,
listeondeplane[-1+indiceelementmodif].a2x,
listeondeplane[-1+indiceelementmodif].a2y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment);
retaillePondeplane(listeondeplane,nombreondeplane+1,nombreondeplane);
Rafraichit;
 end; {du cas ondeplane}
mdmscopa: begin
retaillePmscopa(listemscopa,nombremscopa,nombremscopa+1);
if listemscopa[-1+nombremscopa+1].create2(
listemscopa[-1+indiceelementmodif].a1x+x1-
listemscopa[-1+indiceelementmodif].sx,
listemscopa[-1+indiceelementmodif].a1y+y1-
listemscopa[-1+indiceelementmodif].sy,
listemscopa[-1+indiceelementmodif].a2x+x1-
listemscopa[-1+indiceelementmodif].sx,
listemscopa[-1+indiceelementmodif].a2y+y1-
listemscopa[-1+indiceelementmodif].sy,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou) then
 listemscopa[-1+indiceelementmodif].create2(
listemscopa[-1+indiceelementmodif].a1x+x1-
listemscopa[-1+indiceelementmodif].sx,
listemscopa[-1+indiceelementmodif].a1y+y1-
listemscopa[-1+indiceelementmodif].sy,
listemscopa[-1+indiceelementmodif].a2x+x1-
listemscopa[-1+indiceelementmodif].sx,
listemscopa[-1+indiceelementmodif].a2y+y1-
listemscopa[-1+indiceelementmodif].sy,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou)
else
listemscopa[-1+indiceelementmodif].create2(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou);
retaillePmscopa(listemscopa,nombremscopa+1,nombremscopa);
Rafraichit;
 end; {du cas mscopa}

mdmscore: begin
retaillePmscore(listemscore,nombremscore,nombremscore+1);
if listemscore[-1+nombremscore+1].create2(
listemscore[-1+indiceelementmodif].a1x+x1-
listemscore[-1+indiceelementmodif].sx,
listemscore[-1+indiceelementmodif].a1y+y1-
listemscore[-1+indiceelementmodif].sy,
listemscore[-1+indiceelementmodif].a2x+x1-
listemscore[-1+indiceelementmodif].sx,
listemscore[-1+indiceelementmodif].a2y+y1-
listemscore[-1+indiceelementmodif].sy,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
 listemscore[-1+indiceelementmodif].trou,
 listemscore[-1+indiceelementmodif].diametretrou) then
 listemscore[-1+indiceelementmodif].create2(
listemscore[-1+indiceelementmodif].a1x+x1-
listemscore[-1+indiceelementmodif].sx,
listemscore[-1+indiceelementmodif].a1y+y1-
listemscore[-1+indiceelementmodif].sy,
listemscore[-1+indiceelementmodif].a2x+x1-
listemscore[-1+indiceelementmodif].sx,
listemscore[-1+indiceelementmodif].a2y+y1-
listemscore[-1+indiceelementmodif].sy,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
 listemscore[-1+indiceelementmodif].trou,
 listemscore[-1+indiceelementmodif].diametretrou)
else
listemscore[-1+indiceelementmodif].create2(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
 listemscore[-1+indiceelementmodif].trou,
 listemscore[-1+indiceelementmodif].diametretrou);
retaillePmscore(listemscore,nombremscore+1,nombremscore);
Rafraichit;
 end; {du cas mscore}



mdmiroirconique: begin
retaillePmiroirconique(listemiroirconique,nombremiroirconique,nombremiroirconique+1);
if listemiroirconique[-1+nombremiroirconique+1].create2(
listemiroirconique[-1+indiceelementmodif].fx+x1-
listemiroirconique[-1+indiceelementmodif].sx,
listemiroirconique[-1+indiceelementmodif].fy+y1-
listemiroirconique[-1+indiceelementmodif].sy,
listemiroirconique[-1+indiceelementmodif].theta0,
listemiroirconique[-1+indiceelementmodif].theta1,
listemiroirconique[-1+indiceelementmodif].theta2,
listemiroirconique[-1+indiceelementmodif].excentricite,
listemiroirconique[-1+indiceelementmodif].parametre,
listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal) then
 listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].fx+x1-
listemiroirconique[-1+indiceelementmodif].sx,
listemiroirconique[-1+indiceelementmodif].fy+y1-
listemiroirconique[-1+indiceelementmodif].sy,
listemiroirconique[-1+indiceelementmodif].theta0,
listemiroirconique[-1+indiceelementmodif].theta1,
listemiroirconique[-1+indiceelementmodif].theta2,
listemiroirconique[-1+indiceelementmodif].excentricite,
listemiroirconique[-1+indiceelementmodif].parametre,
listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal)
else
listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].fx,
listemiroirconique[-1+indiceelementmodif].fy,
listemiroirconique[-1+indiceelementmodif].theta0,
listemiroirconique[-1+indiceelementmodif].theta1,
listemiroirconique[-1+indiceelementmodif].theta2,
listemiroirconique[-1+indiceelementmodif].excentricite,
listemiroirconique[-1+indiceelementmodif].parametre,
listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal) ;
retaillePmiroirconique(listemiroirconique,nombremiroirconique+1,nombremiroirconique);
Rafraichit;
 end; {du cas miroirconique}



 mdmscepa: begin
retaillePmscepa(listemscepa,nombremscepa,nombremscepa+1);
if listemscepa[-1+nombremscepa+1].create2(
listemscepa[-1+indiceelementmodif].a1x+x1-
listemscepa[-1+indiceelementmodif].sx,
listemscepa[-1+indiceelementmodif].a1y+y1-
listemscepa[-1+indiceelementmodif].sy,
listemscepa[-1+indiceelementmodif].a2x+x1-
listemscepa[-1+indiceelementmodif].sx,
listemscepa[-1+indiceelementmodif].a2y+y1-
listemscepa[-1+indiceelementmodif].sy,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou) then
 listemscepa[-1+indiceelementmodif].create2(
listemscepa[-1+indiceelementmodif].a1x+x1-
listemscepa[-1+indiceelementmodif].sx,
listemscepa[-1+indiceelementmodif].a1y+y1-
listemscepa[-1+indiceelementmodif].sy,
listemscepa[-1+indiceelementmodif].a2x+x1-
listemscepa[-1+indiceelementmodif].sx,
listemscepa[-1+indiceelementmodif].a2y+y1-
listemscepa[-1+indiceelementmodif].sy,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou)
else
listemscepa[-1+indiceelementmodif].create2(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou);
retaillePmscepa(listemscepa,nombremscepa+1,nombremscepa);
Rafraichit;
 end; {du cas mscepa}



mdmscere: begin
retaillePmscere(listemscere,nombremscere,nombremscere+1);
if listemscere[-1+nombremscere+1].create2(
listemscere[-1+indiceelementmodif].a1x+x1-
listemscere[-1+indiceelementmodif].sx,
listemscere[-1+indiceelementmodif].a1y+y1-
listemscere[-1+indiceelementmodif].sy,
listemscere[-1+indiceelementmodif].a2x+x1-
listemscere[-1+indiceelementmodif].sx,
listemscere[-1+indiceelementmodif].a2y+y1-
listemscere[-1+indiceelementmodif].sy,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
 listemscere[-1+indiceelementmodif].trou,
 listemscere[-1+indiceelementmodif].diametretrou) then
 listemscere[-1+indiceelementmodif].create2(
listemscere[-1+indiceelementmodif].a1x+x1-
listemscere[-1+indiceelementmodif].sx,
listemscere[-1+indiceelementmodif].a1y+y1-
listemscere[-1+indiceelementmodif].sy,
listemscere[-1+indiceelementmodif].a2x+x1-
listemscere[-1+indiceelementmodif].sx,
listemscere[-1+indiceelementmodif].a2y+y1-
listemscere[-1+indiceelementmodif].sy,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
 listemscere[-1+indiceelementmodif].trou,
 listemscere[-1+indiceelementmodif].diametretrou)
else
listemscere[-1+indiceelementmodif].create2(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
 listemscere[-1+indiceelementmodif].trou,
 listemscere[-1+indiceelementmodif].diametretrou);
retaillePmscere(listemscere,nombremscere+1,nombremscere);
Rafraichit;
 end; {du cas mscere}

 mdlmc: begin
retaillePlmc(listelmc,nombrelmc,nombrelmc+1);
if listelmc[-1+nombrelmc+1].create2(
listelmc[-1+indiceelementmodif].a1x+x1-
listelmc[-1+indiceelementmodif].ox,
listelmc[-1+indiceelementmodif].a1y+y1-
listelmc[-1+indiceelementmodif].oy,
listelmc[-1+indiceelementmodif].a2x+x1-
listelmc[-1+indiceelementmodif].ox,
listelmc[-1+indiceelementmodif].a2y+y1-
listelmc[-1+indiceelementmodif].oy,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal) then
 listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x+x1-
listelmc[-1+indiceelementmodif].ox,
listelmc[-1+indiceelementmodif].a1y+y1-
listelmc[-1+indiceelementmodif].oy,
listelmc[-1+indiceelementmodif].a2x+x1-
listelmc[-1+indiceelementmodif].ox,
listelmc[-1+indiceelementmodif].a2y+y1-
listelmc[-1+indiceelementmodif].oy,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal)
else
listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal);
retaillePlmc(listelmc,nombrelmc+1,nombrelmc);
Rafraichit;
 end; {du cas lmc}

 mdlec: begin
retaillePlec(listelec,nombrelec,nombrelec+1);
if listelec[-1+nombrelec+1].create(
listelec[-1+indiceelementmodif].s1x+x1-
listelec[-1+indiceelementmodif].ox,
listelec[-1+indiceelementmodif].s1y+y1-
listelec[-1+indiceelementmodif].oy,
listelec[-1+indiceelementmodif].s2x+x1-
listelec[-1+indiceelementmodif].ox,
listelec[-1+indiceelementmodif].s2y+y1-
listelec[-1+indiceelementmodif].oy,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant) then
 listelec[-1+indiceelementmodif].create(
listelec[-1+indiceelementmodif].s1x+x1-
listelec[-1+indiceelementmodif].ox,
listelec[-1+indiceelementmodif].s1y+y1-
listelec[-1+indiceelementmodif].oy,
listelec[-1+indiceelementmodif].s2x+x1-
listelec[-1+indiceelementmodif].ox,
listelec[-1+indiceelementmodif].s2y+y1-
listelec[-1+indiceelementmodif].oy,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant)
else
listelec[-1+indiceelementmodif].create(
listelec[-1+indiceelementmodif].s1x,
listelec[-1+indiceelementmodif].s1y,
listelec[-1+indiceelementmodif].s2x,
listelec[-1+indiceelementmodif].s2y,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant);
retaillePlec(listelec,nombrelec+1,nombrelec);
Rafraichit;
 end; {du cas lec}


 mdlmd: begin
retaillePlmd(listelmd,nombrelmd,nombrelmd+1);
if listelmd[-1+nombrelmd+1].create2(
listelmd[-1+indiceelementmodif].a1x+x1-
listelmd[-1+indiceelementmodif].ox,
listelmd[-1+indiceelementmodif].a1y+y1-
listelmd[-1+indiceelementmodif].oy,
listelmd[-1+indiceelementmodif].a2x+x1-
listelmd[-1+indiceelementmodif].ox,
listelmd[-1+indiceelementmodif].a2y+y1-
listelmd[-1+indiceelementmodif].oy,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal) then
 listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x+x1-
listelmd[-1+indiceelementmodif].ox,
listelmd[-1+indiceelementmodif].a1y+y1-
listelmd[-1+indiceelementmodif].oy,
listelmd[-1+indiceelementmodif].a2x+x1-
listelmd[-1+indiceelementmodif].ox,
listelmd[-1+indiceelementmodif].a2y+y1-
listelmd[-1+indiceelementmodif].oy,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal)
else
listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal);
retaillePlmd(listelmd,nombrelmd+1,nombrelmd);
Rafraichit;
 end; {du cas lmd}
end; {du case}
 modetranslation:=false;
 form1.StatusBar1.Panels[3].text:=rsModeDPlaceme3;
 form1.StatusBar1.Panels[2].text:=rsFaitesPasser2;
 modifencours:=false;
 if modeduplication then begin
 modeduplication:=false; modemodif:=false; modeinfo:=false;
 form1.activeboutons;
 form1.StatusBar1.Panels[3].text:='';
 form1.StatusBar1.Panels[2].text:='';
 form1.image1.Cursor:=crdefault;
 modifencours:=false;
 Rafraichit;
 end;
 exit;
 end;{du cas translation}

 if moderotation then   begin
 case typeelementmodif of


 mdoeil: begin
if (((x1<>listeoeil[-1+indiceelementmodif].cx) or
 (y1<>listeoeil[-1+indiceelementmodif].cy)))
 then begin
retaillePoeil(listeoeil,nombreoeil,nombreoeil+1);
if listeoeil[-1+nombreoeil+1].create(
listeoeil[-1+indiceelementmodif].cx,
listeoeil[-1+indiceelementmodif].cy,
x1,y1,
listeoeil[-1+indiceelementmodif].epaisseur,
listeoeil[-1+indiceelementmodif].couleur) then
 listeoeil[-1+indiceelementmodif].create(
listeoeil[-1+indiceelementmodif].cx,
listeoeil[-1+indiceelementmodif].cy,
x1,y1,
listeoeil[-1+indiceelementmodif].epaisseur,
listeoeil[-1+indiceelementmodif].couleur)
else
listeoeil[-1+indiceelementmodif].create(
listeoeil[-1+indiceelementmodif].cx,
listeoeil[-1+indiceelementmodif].cy,
listeoeil[-1+indiceelementmodif].ax,
listeoeil[-1+indiceelementmodif].ay,
listeoeil[-1+indiceelementmodif].epaisseur,
listeoeil[-1+indiceelementmodif].couleur);
retaillePoeil(listeoeil,nombreoeil+1,nombreoeil);
Rafraichit;
end;
end;



mdprisme: begin
if ((tprirot=tpa) and ((x1<>listeprisme[-1+indiceelementmodif].ax) or
 (y1<>listeprisme[-1+indiceelementmodif].ay))) then begin
retaillePprisme(listeprisme,nombreprisme,nombreprisme+1);
if listeprisme[-1+nombreprisme+1].create(
listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].gy,

listeprisme[-1+indiceelementmodif].gx+2/3*listeprisme[-1+indiceelementmodif].hauteur*
cos(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)),

listeprisme[-1+indiceelementmodif].gy+2/3*listeprisme[-1+indiceelementmodif].hauteur*
sin(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)) ,

listeprisme[-1+indiceelementmodif].gx+2/3*listeprisme[-1+indiceelementmodif].hauteur*
cos(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy))+
listeprisme[-1+indiceelementmodif].hauteur/cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*
cos(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)+pi+
listeprisme[-1+indiceelementmodif].angle_sommet/2),

listeprisme[-1+indiceelementmodif].gy+2/3*listeprisme[-1+indiceelementmodif].hauteur*
sin(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy))+
listeprisme[-1+indiceelementmodif].hauteur/cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*
sin(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)+pi+
listeprisme[-1+indiceelementmodif].angle_sommet/2),

listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant) then
 listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].gy,

listeprisme[-1+indiceelementmodif].gx+2/3*listeprisme[-1+indiceelementmodif].hauteur*
cos(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)),

listeprisme[-1+indiceelementmodif].gy+2/3*listeprisme[-1+indiceelementmodif].hauteur*
sin(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)) ,

listeprisme[-1+indiceelementmodif].gx+2/3*listeprisme[-1+indiceelementmodif].hauteur*
cos(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy))+
listeprisme[-1+indiceelementmodif].hauteur/cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*
cos(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)+pi+
listeprisme[-1+indiceelementmodif].angle_sommet/2),

listeprisme[-1+indiceelementmodif].gy+2/3*listeprisme[-1+indiceelementmodif].hauteur*
sin(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy))+
listeprisme[-1+indiceelementmodif].hauteur/cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*
sin(donneanglepolairedans02pi(x1-listeprisme[-1+indiceelementmodif].gx,y1-listeprisme[-1+indiceelementmodif].gy)+pi+
listeprisme[-1+indiceelementmodif].angle_sommet/2),

listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant)
else
listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].ax,
listeprisme[-1+indiceelementmodif].ay,
listeprisme[-1+indiceelementmodif].bx,
listeprisme[-1+indiceelementmodif].by,
listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant);
retaillePprisme(listeprisme,nombreprisme+1,nombreprisme);
Rafraichit;
end;


if ((tprirot=tpc) and ((x1<>listeprisme[-1+indiceelementmodif].cx) or
 (y1<>listeprisme[-1+indiceelementmodif].cy))) then begin
 hx:=listeprisme[-1+indiceelementmodif].gx -0.5*(listeprisme[-1+indiceelementmodif].ax-listeprisme[-1+indiceelementmodif].gx);
 hy:=listeprisme[-1+indiceelementmodif].gy -0.5*(listeprisme[-1+indiceelementmodif].ay-listeprisme[-1+indiceelementmodif].gy);
 ux:=(listeprisme[-1+indiceelementmodif].ax-listeprisme[-1+indiceelementmodif].gx)/
 sqrt(sqr(listeprisme[-1+indiceelementmodif].ax-listeprisme[-1+indiceelementmodif].gx)+
 sqr(listeprisme[-1+indiceelementmodif].ay-listeprisme[-1+indiceelementmodif].gy));
uy:=(listeprisme[-1+indiceelementmodif].ay-listeprisme[-1+indiceelementmodif].gy)/
 sqrt(sqr(listeprisme[-1+indiceelementmodif].ax-listeprisme[-1+indiceelementmodif].gx)+
 sqr(listeprisme[-1+indiceelementmodif].ay-listeprisme[-1+indiceelementmodif].gy));
 lambda:=(x1-hx)*ux+(y1-hy)*uy;

retaillePprisme(listeprisme,nombreprisme,nombreprisme+1);
if listeprisme[-1+nombreprisme+1].create(
listeprisme[-1+indiceelementmodif].gx,
   listeprisme[-1+indiceelementmodif].gy,
                 listeprisme[-1+indiceelementmodif].ax,
               listeprisme[-1+indiceelementmodif].ay ,
            x1-lambda*ux,
            y1-lambda*uy,

listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant) then
 listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].gx,
   listeprisme[-1+indiceelementmodif].gy,
                 listeprisme[-1+indiceelementmodif].ax,
               listeprisme[-1+indiceelementmodif].ay ,
            x1-lambda*ux,
            y1-lambda*uy,

listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant)
else
listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].ax,
listeprisme[-1+indiceelementmodif].ay,
listeprisme[-1+indiceelementmodif].bx,
listeprisme[-1+indiceelementmodif].by,
listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant);
retaillePprisme(listeprisme,nombreprisme+1,nombreprisme);
Rafraichit;
end;



if ((tprirot=tpb) and ((x1<>listeprisme[-1+indiceelementmodif].bx) or
 (y1<>listeprisme[-1+indiceelementmodif].by))) then begin
 ux:=cos(donneanglepolairedans02pi(listeprisme[-1+indiceelementmodif].bx-listeprisme[-1+indiceelementmodif].ax,
 listeprisme[-1+indiceelementmodif].by-listeprisme[-1+indiceelementmodif].ay));
 uy:=sin(donneanglepolairedans02pi(listeprisme[-1+indiceelementmodif].bx-listeprisme[-1+indiceelementmodif].ax,
 listeprisme[-1+indiceelementmodif].by-listeprisme[-1+indiceelementmodif].ay));
 lambda:=-(x1-listeprisme[-1+indiceelementmodif].ax)*ux-(y1-listeprisme[-1+indiceelementmodif].ay)*uy;

retaillePprisme(listeprisme,nombreprisme,nombreprisme+1);
if listeprisme[-1+nombreprisme+1].create(
listeprisme[-1+indiceelementmodif].ax+2/3*abs(lambda)*
cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*cos(listeprisme[-1+indiceelementmodif].angle_axe+pi),


listeprisme[-1+indiceelementmodif].ay+2/3*
abs(lambda)*
cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*sin(listeprisme[-1+indiceelementmodif].angle_axe+pi),



listeprisme[-1+indiceelementmodif].ax,

listeprisme[-1+indiceelementmodif].ay ,

listeprisme[-1+indiceelementmodif].ax-lambda*ux,

listeprisme[-1+indiceelementmodif].ay-lambda*uy,

listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant) then
 listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].ax+2/3*abs(lambda)*
cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*cos(listeprisme[-1+indiceelementmodif].angle_axe+pi),


listeprisme[-1+indiceelementmodif].ay+2/3*
abs(lambda)*
cos(listeprisme[-1+indiceelementmodif].angle_sommet/2)*sin(listeprisme[-1+indiceelementmodif].angle_axe+pi),



listeprisme[-1+indiceelementmodif].ax,

listeprisme[-1+indiceelementmodif].ay ,

listeprisme[-1+indiceelementmodif].ax-lambda*ux,

listeprisme[-1+indiceelementmodif].ay-lambda*uy,

listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant)
else
listeprisme[-1+indiceelementmodif].create(
listeprisme[-1+indiceelementmodif].gx,
listeprisme[-1+indiceelementmodif].gy,
listeprisme[-1+indiceelementmodif].ax,
listeprisme[-1+indiceelementmodif].ay,
listeprisme[-1+indiceelementmodif].bx,
listeprisme[-1+indiceelementmodif].by,
listeprisme[-1+indiceelementmodif].indicerouge,
listeprisme[-1+indiceelementmodif].indicebleu,
listeprisme[-1+indiceelementmodif].indicevert,
listeprisme[-1+indiceelementmodif].couleurbord,
 listeprisme[-1+indiceelementmodif].couleurfond,
 listeprisme[-1+indiceelementmodif].ReflechiEntrant,
 listeprisme[-1+indiceelementmodif].ReflechiSortant);
retaillePprisme(listeprisme,nombreprisme+1,nombreprisme);
Rafraichit;
end;

end;





mdmetre: begin
if ((tprot=tpa1) and ((x1<>listemetre[-1+indiceelementmodif].a2x) or
 (y1<>listemetre[-1+indiceelementmodif].a2y)))
 then begin
retaillePmetre(listemetre,nombremetre,nombremetre+1);
if listemetre[-1+nombremetre+1].create(
x1,y1,
 listemetre[-1+indiceelementmodif].a2x,
listemetre[-1+indiceelementmodif].a2y) then
 listemetre[-1+indiceelementmodif].create(
 x1,y1,
 listemetre[-1+indiceelementmodif].a2x,
listemetre[-1+indiceelementmodif].a2y)
else
listemetre[-1+indiceelementmodif].create(
listemetre[-1+indiceelementmodif].a1x,
listemetre[-1+indiceelementmodif].a1y,
listemetre[-1+indiceelementmodif].a2x,
listemetre[-1+indiceelementmodif].a2y);
retaillePmetre(listemetre,nombremetre+1,nombremetre);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listemetre[-1+indiceelementmodif].a1x) or
 (y1<>listemetre[-1+indiceelementmodif].a1y)))
 then begin
retaillePmetre(listemetre,nombremetre,nombremetre+1);
if listemetre[-1+nombremetre+1].create(
listemetre[-1+indiceelementmodif].a1x,
listemetre[-1+indiceelementmodif].a1y,
 x1,y1) then
 listemetre[-1+indiceelementmodif].create(
 listemetre[-1+indiceelementmodif].a1x,
listemetre[-1+indiceelementmodif].a1y,
 x1,y1)
else
listemetre[-1+indiceelementmodif].create(
listemetre[-1+indiceelementmodif].a1x,
listemetre[-1+indiceelementmodif].a1y,
listemetre[-1+indiceelementmodif].a2x,
listemetre[-1+indiceelementmodif].a2y);
Rafraichit;
end;
 end; {du cas metre}

mdfleche: begin
if ((tprot=tpa1) and ((x1<>listefleche[-1+indiceelementmodif].a2x) or
 (y1<>listefleche[-1+indiceelementmodif].a2y)))
 then begin
retaillePfleche(listefleche,nombrefleche,nombrefleche+1);
if listefleche[-1+nombrefleche+1].create(
x1,y1,
 listefleche[-1+indiceelementmodif].a2x,
listefleche[-1+indiceelementmodif].a2y,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2) then
 listefleche[-1+indiceelementmodif].create(
 x1,y1,
 listefleche[-1+indiceelementmodif].a2x,
listefleche[-1+indiceelementmodif].a2y,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2)
else
listefleche[-1+indiceelementmodif].create(
listefleche[-1+indiceelementmodif].a1x,
listefleche[-1+indiceelementmodif].a1y,
listefleche[-1+indiceelementmodif].a2x,
listefleche[-1+indiceelementmodif].a2y,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2);
retaillePfleche(listefleche,nombrefleche+1,nombrefleche);
Rafraichit;
end;
if ((tprot=tpa2) and ((x1<>listefleche[-1+indiceelementmodif].a1x) or
 (y1<>listefleche[-1+indiceelementmodif].a1y)))
 then begin
retaillePfleche(listefleche,nombrefleche,nombrefleche+1);
if listefleche[-1+nombrefleche+1].create(
 listefleche[-1+indiceelementmodif].a1x,
listefleche[-1+indiceelementmodif].a1y,x1,y1,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2) then
 listefleche[-1+indiceelementmodif].create(
 listefleche[-1+indiceelementmodif].a1x,
listefleche[-1+indiceelementmodif].a1y,x1,y1,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2)
else
listefleche[-1+indiceelementmodif].create(
listefleche[-1+indiceelementmodif].a1x,
listefleche[-1+indiceelementmodif].a1y,
listefleche[-1+indiceelementmodif].a2x,
listefleche[-1+indiceelementmodif].a2y,
listefleche[-1+indiceelementmodif].epaisseur,
listefleche[-1+indiceelementmodif].couleur,
listefleche[-1+indiceelementmodif].ext1,
listefleche[-1+indiceelementmodif].ext2,
listefleche[-1+indiceelementmodif].styletrait,
listefleche[-1+indiceelementmodif].taille1,
listefleche[-1+indiceelementmodif].taille2);
retaillePfleche(listefleche,nombrefleche+1,nombrefleche);
Rafraichit;
end;
end;

mdangle: begin
if ((tprot=tpa1) and ((x1<>listeangle[-1+indiceelementmodif].a2x) or
 (y1<>listeangle[-1+indiceelementmodif].a2y)))
 then begin
retaillePangle(listeangle,nombreangle,nombreangle+1);
if listeangle[-1+nombreangle+1].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
x1,y1,
 listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y) then
 listeangle[-1+indiceelementmodif].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
x1,y1,
 listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y)
else
listeangle[-1+indiceelementmodif].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y);
retaillePangle(listeangle,nombreangle+1,nombreangle);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listeangle[-1+indiceelementmodif].a1x) or
 (y1<>listeangle[-1+indiceelementmodif].a1y)))
 then begin
retaillePangle(listeangle,nombreangle,nombreangle+1);
if listeangle[-1+nombreangle+1].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
 x1,y1) then
 listeangle[-1+indiceelementmodif].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
 listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
 x1,y1)
else
listeangle[-1+indiceelementmodif].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y);
retaillePangle(listeangle,nombreangle+1,nombreangle);
Rafraichit;
end;

if ((tprot=tpce) and ((x1<>listeangle[-1+indiceelementmodif].cx) or
 (y1<>listeangle[-1+indiceelementmodif].cy)))
 then begin
retaillePangle(listeangle,nombreangle,nombreangle+1);
if listeangle[-1+nombreangle+1].create(x1,y1,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y ) then
 listeangle[-1+indiceelementmodif].create(x1,y1,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y)
else
listeangle[-1+indiceelementmodif].create(
listeangle[-1+indiceelementmodif].cx,
listeangle[-1+indiceelementmodif].cy,
listeangle[-1+indiceelementmodif].a1x,
listeangle[-1+indiceelementmodif].a1y,
listeangle[-1+indiceelementmodif].a2x,
listeangle[-1+indiceelementmodif].a2y);
retaillePangle(listeangle,nombreangle+1,nombreangle);
Rafraichit;
end;
 end; {du cas angle}

mdsphere: begin
if ((x1<>listesphere[-1+indiceelementmodif].cx) or (y1<>listesphere[-1+indiceelementmodif].cy)) then begin
retaillepsphere(listesphere,nombresphere,nombresphere+1);
if listesphere[-1+nombresphere+1].create(
listesphere[-1+indiceelementmodif].cx,
listesphere[-1+indiceelementmodif].cy,
sqrt(sqr(x1-listesphere[-1+indiceelementmodif].cx)+
sqr(y1-listesphere[-1+indiceelementmodif].cy)),
listesphere[-1+indiceelementmodif].indicerouge,
listesphere[-1+indiceelementmodif].indicebleu,
listesphere[-1+indiceelementmodif].indicevert,
listesphere[-1+indiceelementmodif].couleurbord,
listesphere[-1+indiceelementmodif].couleurfond,
listesphere[-1+indiceelementmodif].reflechientrant,
listesphere[-1+indiceelementmodif].reflechisortant) then
listesphere[-1+indiceelementmodif].create(
listesphere[-1+indiceelementmodif].cx,
listesphere[-1+indiceelementmodif].cy,
sqrt(sqr(x1-listesphere[-1+indiceelementmodif].cx)+
sqr(y1-listesphere[-1+indiceelementmodif].cy)),
listesphere[-1+indiceelementmodif].indicerouge,
listesphere[-1+indiceelementmodif].indicebleu,
listesphere[-1+indiceelementmodif].indicevert,
listesphere[-1+indiceelementmodif].couleurbord,
listesphere[-1+indiceelementmodif].couleurfond,
listesphere[-1+indiceelementmodif].reflechientrant,
listesphere[-1+indiceelementmodif].reflechisortant)
 else
listesphere[-1+indiceelementmodif].create(
listesphere[-1+indiceelementmodif].cx,
listesphere[-1+indiceelementmodif].cy,
listesphere[-1+indiceelementmodif].rayon,
listesphere[-1+indiceelementmodif].indicerouge,
listesphere[-1+indiceelementmodif].indicebleu,
listesphere[-1+indiceelementmodif].indicevert,
listesphere[-1+indiceelementmodif].couleurbord,
listesphere[-1+indiceelementmodif].couleurfond,
listesphere[-1+indiceelementmodif].reflechientrant,
listesphere[-1+indiceelementmodif].reflechisortant);
 retaillepsphere(listesphere,nombresphere+1,nombresphere);
 Rafraichit;
 end;
  end;


mdpolyhedre:
if (  (x1<>listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace].ax) or
 (y1<>listepolyhedre[-1+indiceelementmodif].messommets[indicepointdeplace].ay))
 then begin
retaillePpolyhedre(listepolyhedre,nombrepolyhedre,nombrepolyhedre+1);
for i:=1 to listepolyhedre[-1+indiceelementmodif].nombresommet do
begin
ttpoly[i].ax:=listepolyhedre[-1+indiceelementmodif].messommets[i].ax;
ttpoly[i].ay:=listepolyhedre[-1+indiceelementmodif].messommets[i].ay;
end;
ttpoly[indicepointdeplace].ax:=x1;
ttpoly[indicepointdeplace].ay:=y1;


if listepolyhedre[-1+nombrepolyhedre+1].create(
listepolyhedre[-1+indiceelementmodif].nombresommet,
ttpoly,
 listepolyhedre[-1+indiceelementmodif].indicerouge,
 listepolyhedre[-1+indiceelementmodif].indicebleu,
 listepolyhedre[-1+indiceelementmodif].indicevert,
listepolyhedre[-1+indiceelementmodif].couleurbord,
listepolyhedre[-1+indiceelementmodif].couleurfond,
listepolyhedre[-1+indiceelementmodif].reflechientrant,
listepolyhedre[-1+indiceelementmodif].reflechisortant) then
 listepolyhedre[-1+indiceelementmodif].create(
 listepolyhedre[-1+indiceelementmodif].nombresommet,
ttpoly,
 listepolyhedre[-1+indiceelementmodif].indicerouge,
 listepolyhedre[-1+indiceelementmodif].indicebleu,
 listepolyhedre[-1+indiceelementmodif].indicevert,
listepolyhedre[-1+indiceelementmodif].couleurbord,
listepolyhedre[-1+indiceelementmodif].couleurfond,
listepolyhedre[-1+indiceelementmodif].reflechientrant,
listepolyhedre[-1+indiceelementmodif].reflechisortant)
else
listepolyhedre[-1+indiceelementmodif].create(
listepolyhedre[-1+indiceelementmodif].nombresommet,
listepolyhedre[-1+indiceelementmodif].messommets,
 listepolyhedre[-1+indiceelementmodif].indicerouge,
 listepolyhedre[-1+indiceelementmodif].indicebleu,
 listepolyhedre[-1+indiceelementmodif].indicevert,
listepolyhedre[-1+indiceelementmodif].couleurbord,
listepolyhedre[-1+indiceelementmodif].couleurfond,
listepolyhedre[-1+indiceelementmodif].reflechientrant,
listepolyhedre[-1+indiceelementmodif].reflechisortant);
retaillePpolyhedre(listepolyhedre,nombrepolyhedre+1,nombrepolyhedre);
Rafraichit;
end;


mdpolycercle:  begin
if ((tprot=tpa1) and (  (x1<>listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax) or
 (y1<>listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay)))
 then begin
retaillePpolycercle(listepolycercle,nombrepolycercle,nombrepolycercle+1);
for i:=1 to listepolycercle[-1+indiceelementmodif].nombresommet do
begin
ttpoly[i].ax:=listepolycercle[-1+indiceelementmodif].messommets[i].ax;
ttpoly[i].ay:=listepolycercle[-1+indiceelementmodif].messommets[i].ay;
ttsom[i].ax:=listepolycercle[-1+indiceelementmodif].mess[i].ax;
ttsom[i].ay:=listepolycercle[-1+indiceelementmodif].mess[i].ay;
end;
ttpoly[indicepointdeplace].ax:=x1;
ttpoly[indicepointdeplace].ay:=y1;
 {si le segment précédent est un arc de cercle}
 if (indicepointdeplace>1) and
not(listepolycercle[-1+indiceelementmodif].rectiligne[indicepointdeplace-1]) then begin
dAB:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax)+
sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay));
dIS:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace-1].ax-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))+
sqr(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace-1].ay-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay)));
if  (listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax)*
(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace-1].ay-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay))-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay)*
(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace-1].ax-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))<0 then
begin
 ttsom[indicepointdeplace-1].ax:=(y1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax+x1);
 ttsom[indicepointdeplace-1].ay:=-(x1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay+y1);
end else begin
 ttsom[indicepointdeplace-1].ax:=-(y1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax+x1);
 ttsom[indicepointdeplace-1].ay:=(x1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace-1].ay+y1);
 end;
end;


 {si le segment précédent est un arc de cercle}
 if (indicepointdeplace=1) and
not(listepolycercle[-1+indiceelementmodif].rectiligne[listepolycercle[-1+indiceelementmodif].nombresommet]) then begin
dAB:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax)+
sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay));
dIS:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].MesS[listepolycercle[-1+indiceelementmodif].nombresommet].ax-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))+
sqr(listepolycercle[-1+indiceelementmodif].MesS[listepolycercle[-1+indiceelementmodif].nombresommet].ay-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay)));
if  (listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax)*
(listepolycercle[-1+indiceelementmodif].MesS[listepolycercle[-1+indiceelementmodif].nombresommet].ay-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay))-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay)*
(listepolycercle[-1+indiceelementmodif].MesS[listepolycercle[-1+indiceelementmodif].nombresommet].ax-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))<0 then
begin
 ttsom[listepolycercle[-1+indiceelementmodif].nombresommet].ax:=(y1-listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax+x1);
 ttsom[listepolycercle[-1+indiceelementmodif].nombresommet].ay:=-(x1-listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay+y1);
end else begin
 ttsom[listepolycercle[-1+indiceelementmodif].nombresommet].ax:=-(y1-listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax+x1); ;
 ttsom[listepolycercle[-1+indiceelementmodif].nombresommet].ay:=(x1-listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[listepolycercle[-1+indiceelementmodif].nombresommet].ay+y1);
 end;
end;


 {si le segment suivant est un arc de cercle}
 if (indicepointdeplace<listepolycercle[-1+indiceelementmodif].nombresommet) and
not(listepolycercle[-1+indiceelementmodif].rectiligne[indicepointdeplace]) then begin
dAB:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)+
sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay));
dIS:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ax-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))+
sqr(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ay-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay)));
if  (listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)*
(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ay-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay))-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)*
(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ax-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))<0 then
begin
 ttsom[indicepointdeplace].ax:=(y1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax+x1);
 ttsom[indicepointdeplace].ay:=-(x1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay+y1);
end else begin
 ttsom[indicepointdeplace].ax:=-(y1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax+x1);
 ttsom[indicepointdeplace].ay:=(x1-listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay+y1);
 end;
end;

  {si le segment suivant est un arc de cercle}
 if (indicepointdeplace=listepolycercle[-1+indiceelementmodif].nombresommet) and
not(listepolycercle[-1+indiceelementmodif].rectiligne[indicepointdeplace]) then begin
dAB:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[1].ax)+
sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[1].ay));
dIS:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ax-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[1].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))+
sqr(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ay-
0.5*(listepolycercle[-1+indiceelementmodif].messommets[1].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay)));
if  (listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax-
listepolycercle[-1+indiceelementmodif].messommets[1].ax)*
(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ay-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[1].ay+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay))-
(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
listepolycercle[-1+indiceelementmodif].messommets[1].ay)*
(listepolycercle[-1+indiceelementmodif].MesS[indicepointdeplace].ax-0.5*
(listepolycercle[-1+indiceelementmodif].messommets[1].ax+
listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax))<0 then
begin
 ttsom[indicepointdeplace].ax:=(y1-listepolycercle[-1+indiceelementmodif].messommets[1].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[1].ax+x1);
 ttsom[indicepointdeplace].ay:=-(x1-listepolycercle[-1+indiceelementmodif].messommets[1].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[1].ay+y1);
end else begin
 ttsom[indicepointdeplace].ax:=-(y1-listepolycercle[-1+indiceelementmodif].messommets[1].ay)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[1].ax+x1);
 ttsom[indicepointdeplace].ay:=(x1-listepolycercle[-1+indiceelementmodif].messommets[1].ax)
 *dIS/dAB+0.5*(listepolycercle[-1+indiceelementmodif].messommets[1].ay+y1);
 end;
end;


if listepolycercle[-1+nombrepolycercle+1].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
ttpoly,ttsom,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant) then
 listepolycercle[-1+indiceelementmodif].create(
 listepolycercle[-1+indiceelementmodif].nombresommet,
ttpoly,ttsom,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant)
else
listepolycercle[-1+indiceelementmodif].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
listepolycercle[-1+indiceelementmodif].messommets,
listepolycercle[-1+indiceelementmodif].mess,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant);
retaillePpolycercle(listepolycercle,nombrepolycercle+1,nombrepolycercle);
Rafraichit;
end;

if ((tprot=tpce))
 then begin
retaillePpolycercle(listepolycercle,nombrepolycercle,nombrepolycercle+1);
for i:=1 to listepolycercle[-1+indiceelementmodif].nombresommet do
begin
tts[i].ax:=listepolycercle[-1+indiceelementmodif].mess[i].ax;
tts[i].ay:=listepolycercle[-1+indiceelementmodif].mess[i].ay;
end;

 AiAj:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax
 -listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)+
  sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay
  -listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay));
  ux:=(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
  listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/AiAj;
  uy:=-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax
  -listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/AiAj;
  tts[indicepointdeplace].ax:=
  (listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax+
  listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2+
(  (x1-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax
+listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2)*ux+
  (y1-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay
  +listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2)*uy
  )*ux;
  tts[indicepointdeplace].ay:=(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay
  +listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2+
(  (x1-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax
+listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2)*ux+
  (y1-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay+
  listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2)*uy
  )*uy;



if listepolycercle[-1+nombrepolycercle+1].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
listepolycercle[-1+indiceelementmodif].messommets,
tts,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant) then
 listepolycercle[-1+indiceelementmodif].create(
 listepolycercle[-1+indiceelementmodif].nombresommet,
listepolycercle[-1+indiceelementmodif].messommets,
tts,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant)
else
listepolycercle[-1+indiceelementmodif].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
listepolycercle[-1+indiceelementmodif].messommets,
listepolycercle[-1+indiceelementmodif].mess,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant);
retaillePpolycercle(listepolycercle,nombrepolycercle+1,nombrepolycercle);
Rafraichit;
end;

if ((tprot=tpso))
 then begin
retaillePpolycercle(listepolycercle,nombrepolycercle,nombrepolycercle+1);
for i:=1 to listepolycercle[-1+indiceelementmodif].nombresommet do
begin
tts[i].ax:=listepolycercle[-1+indiceelementmodif].mess[i].ax;
tts[i].ay:=listepolycercle[-1+indiceelementmodif].mess[i].ay;
end;

 AiAj:=sqrt(sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax
 -listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)+
  sqr(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay
  -listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay));

  ux:=(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay-
  listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/AiAj;

  uy:=-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax
  -listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/AiAj;

  tts[indicepointdeplace].ax:=
  (listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax+
  listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2+
(  (x1-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax
+listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2)*ux+
  (y1-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay
  +listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2)*uy
  )*ux;

  tts[indicepointdeplace].ay:=(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay
  +listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2+
(  (x1-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ax
+listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ax)/2)*ux+
  (y1-(listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace].ay+
  listepolycercle[-1+indiceelementmodif].messommets[indicepointdeplace+1].ay)/2)*uy
  )*uy;



if listepolycercle[-1+nombrepolycercle+1].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
listepolycercle[-1+indiceelementmodif].messommets,
tts,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant) then
 listepolycercle[-1+indiceelementmodif].create(
 listepolycercle[-1+indiceelementmodif].nombresommet,
listepolycercle[-1+indiceelementmodif].messommets,
tts,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant)
else
listepolycercle[-1+indiceelementmodif].create(
listepolycercle[-1+indiceelementmodif].nombresommet,
listepolycercle[-1+indiceelementmodif].messommets,
listepolycercle[-1+indiceelementmodif].mess,
listepolycercle[-1+indiceelementmodif].rectiligne,
 listepolycercle[-1+indiceelementmodif].indicerouge,
 listepolycercle[-1+indiceelementmodif].indicebleu,
 listepolycercle[-1+indiceelementmodif].indicevert,
listepolycercle[-1+indiceelementmodif].couleurbord,
listepolycercle[-1+indiceelementmodif].couleurfond,
listepolycercle[-1+indiceelementmodif].reflechientrant,
listepolycercle[-1+indiceelementmodif].reflechisortant);
retaillePpolycercle(listepolycercle,nombrepolycercle+1,nombrepolycercle);
Rafraichit;
end;
end;




 mdmiroirplan: begin
if ((tprot=tpa1) and ((x1<>listemiroirplan[-1+indiceelementmodif].a2x) or
 (y1<>listemiroirplan[-1+indiceelementmodif].a2y)))
 then begin
retaillePMiroirplan(listemiroirplan,nombremiroirplan,nombremiroirplan+1);
if listemiroirplan[-1+nombremiroirplan+1].create(
x1,y1,
 listemiroirplan[-1+indiceelementmodif].a2x,
listemiroirplan[-1+indiceelementmodif].a2y,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures) then
 listemiroirplan[-1+indiceelementmodif].create(
 x1,y1,
 listemiroirplan[-1+indiceelementmodif].a2x,
listemiroirplan[-1+indiceelementmodif].a2y,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures)
else
listemiroirplan[-1+indiceelementmodif].create(
listemiroirplan[-1+indiceelementmodif].a1x,
listemiroirplan[-1+indiceelementmodif].a1y,
listemiroirplan[-1+indiceelementmodif].a2x,
listemiroirplan[-1+indiceelementmodif].a2y,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures);
retaillePMiroirplan(listemiroirplan,nombremiroirplan+1,nombremiroirplan);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listemiroirplan[-1+indiceelementmodif].a1x) or
 (y1<>listemiroirplan[-1+indiceelementmodif].a1y)))
 then begin
retaillePMiroirplan(listemiroirplan,nombremiroirplan,nombremiroirplan+1);
if listemiroirplan[-1+nombremiroirplan+1].create(
listemiroirplan[-1+indiceelementmodif].a1x,
listemiroirplan[-1+indiceelementmodif].a1y,
 x1,y1,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures) then
 listemiroirplan[-1+indiceelementmodif].create(
 listemiroirplan[-1+indiceelementmodif].a1x,
listemiroirplan[-1+indiceelementmodif].a1y,
 x1,y1,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures)
else
listemiroirplan[-1+indiceelementmodif].create(
listemiroirplan[-1+indiceelementmodif].a1x,
listemiroirplan[-1+indiceelementmodif].a1y,
listemiroirplan[-1+indiceelementmodif].a2x,
listemiroirplan[-1+indiceelementmodif].a2y,
listemiroirplan[-1+indiceelementmodif].epaisseur,
listemiroirplan[-1+indiceelementmodif].couleur,
listemiroirplan[-1+indiceelementmodif].hachures);
retaillePMiroirplan(listemiroirplan,nombremiroirplan+1,nombremiroirplan);
Rafraichit;
end;
 end; {du cas miroir plan}







 mdReseau: begin
if ((tprot=tpa1) and ((x1<>listeReseau[-1+indiceelementmodif].a2x) or
 (y1<>listeReseau[-1+indiceelementmodif].a2y)))
 then begin
retaillePReseau(listeReseau,nombreReseau,nombreReseau+1);
if listeReseau[-1+nombreReseau+1].create(
x1,y1,
 listeReseau[-1+indiceelementmodif].a2x,
listeReseau[-1+indiceelementmodif].a2y,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listeReseau[-1+indiceelementmodif].entransmission,
listeReseau[-1+indiceelementmodif].hachures,
listeReseau[-1+indiceelementmodif].ordre_min,
listeReseau[-1+indiceelementmodif].ordre_max) then
 listeReseau[-1+indiceelementmodif].create(
 x1,y1,
 listeReseau[-1+indiceelementmodif].a2x,
listeReseau[-1+indiceelementmodif].a2y,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listeReseau[-1+indiceelementmodif].entransmission,
listeReseau[-1+indiceelementmodif].hachures,
listeReseau[-1+indiceelementmodif].ordre_min,
listeReseau[-1+indiceelementmodif].ordre_max)
else
listeReseau[-1+indiceelementmodif].create(
listeReseau[-1+indiceelementmodif].a1x,
listeReseau[-1+indiceelementmodif].a1y,
listeReseau[-1+indiceelementmodif].a2x,
listeReseau[-1+indiceelementmodif].a2y,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listeReseau[-1+indiceelementmodif].entransmission,
listeReseau[-1+indiceelementmodif].hachures,
listeReseau[-1+indiceelementmodif].ordre_min,
listeReseau[-1+indiceelementmodif].ordre_max);
retaillePReseau(listeReseau,nombreReseau+1,nombreReseau);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listeReseau[-1+indiceelementmodif].a1x) or
 (y1<>listeReseau[-1+indiceelementmodif].a1y)))
 then begin
retaillePReseau(listeReseau,nombreReseau,nombreReseau+1);
if listeReseau[-1+nombreReseau+1].create(
listeReseau[-1+indiceelementmodif].a1x,
listeReseau[-1+indiceelementmodif].a1y,
 x1,y1,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listeReseau[-1+indiceelementmodif].entransmission,
listeReseau[-1+indiceelementmodif].hachures,
listeReseau[-1+indiceelementmodif].ordre_min,
listeReseau[-1+indiceelementmodif].ordre_max) then
 listeReseau[-1+indiceelementmodif].create(
 listeReseau[-1+indiceelementmodif].a1x,
listeReseau[-1+indiceelementmodif].a1y,
 x1,y1,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listeReseau[-1+indiceelementmodif].entransmission,
listeReseau[-1+indiceelementmodif].hachures,
listeReseau[-1+indiceelementmodif].ordre_min,
listeReseau[-1+indiceelementmodif].ordre_max)
else
listeReseau[-1+indiceelementmodif].create(
listeReseau[-1+indiceelementmodif].a1x,
listeReseau[-1+indiceelementmodif].a1y,
listeReseau[-1+indiceelementmodif].a2x,
listeReseau[-1+indiceelementmodif].a2y,
listeReseau[-1+indiceelementmodif].epaisseur,
listeReseau[-1+indiceelementmodif].couleur,
listeReseau[-1+indiceelementmodif].pas,
listeReseau[-1+indiceelementmodif].entransmission,
listeReseau[-1+indiceelementmodif].hachures,
listeReseau[-1+indiceelementmodif].ordre_min,
listeReseau[-1+indiceelementmodif].ordre_max);
retaillePReseau(listeReseau,nombreReseau+1,nombreReseau);
Rafraichit;
end;
 end; {du cas reseau}





  mdecran: begin
if ((tprot=tpa1) and ((x1<>listeecran[-1+indiceelementmodif].a2x) or
 (y1<>listeecran[-1+indiceelementmodif].a2y)))
 then begin
retaillePecran(listeecran,nombreecran,nombreecran+1);
if listeecran[-1+nombreecran+1].create(
x1,y1,
 listeecran[-1+indiceelementmodif].a2x,
listeecran[-1+indiceelementmodif].a2y,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur) then
 listeecran[-1+indiceelementmodif].create(
 x1,y1,
 listeecran[-1+indiceelementmodif].a2x,
listeecran[-1+indiceelementmodif].a2y,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur)
else
listeecran[-1+indiceelementmodif].create(
listeecran[-1+indiceelementmodif].a1x,
listeecran[-1+indiceelementmodif].a1y,
listeecran[-1+indiceelementmodif].a2x,
listeecran[-1+indiceelementmodif].a2y,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur);
retaillePecran(listeecran,nombreecran+1,nombreecran);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listeecran[-1+indiceelementmodif].a1x) or
 (y1<>listeecran[-1+indiceelementmodif].a1y)))
 then begin
retaillePecran(listeecran,nombreecran,nombreecran+1);
if listeecran[-1+nombreecran+1].create(
listeecran[-1+indiceelementmodif].a1x,
listeecran[-1+indiceelementmodif].a1y,
 x1,y1,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur) then
 listeecran[-1+indiceelementmodif].create(
 listeecran[-1+indiceelementmodif].a1x,
listeecran[-1+indiceelementmodif].a1y,
 x1,y1,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur)
else
listeecran[-1+indiceelementmodif].create(
listeecran[-1+indiceelementmodif].a1x,
listeecran[-1+indiceelementmodif].a1y,
listeecran[-1+indiceelementmodif].a2x,
listeecran[-1+indiceelementmodif].a2y,
listeecran[-1+indiceelementmodif].epaisseur,
listeecran[-1+indiceelementmodif].couleur);
retaillePecran(listeecran,nombreecran+1,nombreecran);
Rafraichit;
end;
 end; {du cas ecran}


  mdlsr: begin
if ((tprot=tpa1) and ((x1<>listelsr[-1+indiceelementmodif].a2x) or
 (y1<>listelsr[-1+indiceelementmodif].a2y)))
 then begin
retaillePlsr(listelsr,nombrelsr,nombrelsr+1);
if listelsr[-1+nombrelsr+1].create(
x1,y1,
 listelsr[-1+indiceelementmodif].a2x,
listelsr[-1+indiceelementmodif].a2y,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur) then
 listelsr[-1+indiceelementmodif].create(
 x1,y1,
 listelsr[-1+indiceelementmodif].a2x,
listelsr[-1+indiceelementmodif].a2y,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur)
else
listelsr[-1+indiceelementmodif].create(
listelsr[-1+indiceelementmodif].a1x,
listelsr[-1+indiceelementmodif].a1y,
listelsr[-1+indiceelementmodif].a2x,
listelsr[-1+indiceelementmodif].a2y,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur);
retaillePlsr(listelsr,nombrelsr+1,nombrelsr);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listelsr[-1+indiceelementmodif].a1x) or
 (y1<>listelsr[-1+indiceelementmodif].a1y)))
 then begin
retaillePlsr(listelsr,nombrelsr,nombrelsr+1);
if listelsr[-1+nombrelsr+1].create(
listelsr[-1+indiceelementmodif].a1x,
listelsr[-1+indiceelementmodif].a1y,
 x1,y1,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur) then
 listelsr[-1+indiceelementmodif].create(
 listelsr[-1+indiceelementmodif].a1x,
listelsr[-1+indiceelementmodif].a1y,
 x1,y1,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur)
else
listelsr[-1+indiceelementmodif].create(
listelsr[-1+indiceelementmodif].a1x,
listelsr[-1+indiceelementmodif].a1y,
listelsr[-1+indiceelementmodif].a2x,
listelsr[-1+indiceelementmodif].a2y,
listelsr[-1+indiceelementmodif].epaisseur,
listelsr[-1+indiceelementmodif].couleur);
retaillePlsr(listelsr,nombrelsr+1,nombrelsr);
Rafraichit;
end;
 end; {du cas lsr}

 mdrayon: begin
 if ((tprot=tpa1) and ((x1<>listerayon[-1+indiceelementmodif].bx) or
 (y1<>listerayon[-1+indiceelementmodif].by)))
 then begin
retaillePrayon(listerayon,nombrerayon,nombrerayon+1);
if listerayon[-1+nombrerayon+1].create(x1,y1,
listerayon[-1+indiceelementmodif].bx-x1,
listerayon[-1+indiceelementmodif].by-y1,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment) then
 listerayon[-1+indiceelementmodif].create(x1,y1,
listerayon[-1+indiceelementmodif].bx-x1,
listerayon[-1+indiceelementmodif].by-y1,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment)
else
listerayon[-1+indiceelementmodif].create(
listerayon[-1+indiceelementmodif].ax,
listerayon[-1+indiceelementmodif].ay,
listerayon[-1+indiceelementmodif].kx,
listerayon[-1+indiceelementmodif].ky,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment);
retaillePrayon(listerayon,nombrerayon+1,nombrerayon);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listerayon[-1+indiceelementmodif].ax) or
 (y1<>listerayon[-1+indiceelementmodif].ay)))
 then begin
retaillePrayon(listerayon,nombrerayon,nombrerayon+1);
if listerayon[-1+nombrerayon+1].create(
listerayon[-1+indiceelementmodif].ax,
listerayon[-1+indiceelementmodif].ay,
-listerayon[-1+indiceelementmodif].ax+x1,
-listerayon[-1+indiceelementmodif].ay+y1,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment) then
 listerayon[-1+indiceelementmodif].create(
 listerayon[-1+indiceelementmodif].ax,
listerayon[-1+indiceelementmodif].ay,
-listerayon[-1+indiceelementmodif].ax+x1,
-listerayon[-1+indiceelementmodif].ay+y1,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment)
else
listerayon[-1+indiceelementmodif].create(
listerayon[-1+indiceelementmodif].ax,
listerayon[-1+indiceelementmodif].ay,
listerayon[-1+indiceelementmodif].kx,
listerayon[-1+indiceelementmodif].ky,
listerayon[-1+indiceelementmodif].couleur,
listerayon[-1+indiceelementmodif].epaisseur,
listerayon[-1+indiceelementmodif].vav,
listerayon[-1+indiceelementmodif].vaa,
listerayon[-1+indiceelementmodif].nombremaxenfant,
listerayon[-1+indiceelementmodif].maxsegment);
retaillePrayon(listerayon,nombrerayon+1,nombrerayon);
Rafraichit;
end;
 end; {du cas rayon}



 mddiaphragme: begin
  if (( (tprot=tpa1) or (tprot=tpap1)) and ((x1<>listediaphragme[-1+indiceelementmodif].cx) or
 (y1<>listediaphragme[-1+indiceelementmodif].cy)))
 then begin
retaillePdiaphragme(listediaphragme,nombrediaphragme,nombrediaphragme+1);
if listediaphragme[-1+nombrediaphragme+1].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
listediaphragme[-1+indiceelementmodif].anglepolaire,
sqrt(sqr(x1-listediaphragme[-1+indiceelementmodif].cx)+sqr(y1-listediaphragme[-1+indiceelementmodif].cy)),
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur) then
 listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
listediaphragme[-1+indiceelementmodif].anglepolaire,
sqrt(sqr(x1-listediaphragme[-1+indiceelementmodif].cx)+sqr(y1-listediaphragme[-1+indiceelementmodif].cy)),
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur)
else
listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
listediaphragme[-1+indiceelementmodif].anglepolaire,
listediaphragme[-1+indiceelementmodif].rint,
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur);
retaillePdiaphragme(listediaphragme,nombrediaphragme+1,nombrediaphragme);
Rafraichit;
end;


   if ((tprot=tpa2) and ((x1<>listediaphragme[-1+indiceelementmodif].cx) or
 (y1<>listediaphragme[-1+indiceelementmodif].cy)))
 then begin
retaillePdiaphragme(listediaphragme,nombrediaphragme,nombrediaphragme+1);
if listediaphragme[-1+nombrediaphragme+1].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
donneanglepolairedanspipi(x1-listediaphragme[-1+indiceelementmodif].ap2x,y1-listediaphragme[-1+indiceelementmodif].ap2y),
listediaphragme[-1+indiceelementmodif].rint,
sqrt(sqr(x1-listediaphragme[-1+indiceelementmodif].ap2x)+sqr(y1-listediaphragme[-1+indiceelementmodif].ap2y))/2,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur) then
 listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
donneanglepolairedanspipi(x1-listediaphragme[-1+indiceelementmodif].ap2x,y1-listediaphragme[-1+indiceelementmodif].ap2y),
listediaphragme[-1+indiceelementmodif].rint,
sqrt(sqr(x1-listediaphragme[-1+indiceelementmodif].ap2x)+sqr(y1-listediaphragme[-1+indiceelementmodif].ap2y))/2,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur)
else
listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
listediaphragme[-1+indiceelementmodif].anglepolaire,
listediaphragme[-1+indiceelementmodif].rint,
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur);
retaillePdiaphragme(listediaphragme,nombrediaphragme+1,nombrediaphragme);
Rafraichit;
end;


  if ((tprot=tpap2) and ((x1<>listediaphragme[-1+indiceelementmodif].cx) or
 (y1<>listediaphragme[-1+indiceelementmodif].cy)))
 then begin
retaillePdiaphragme(listediaphragme,nombrediaphragme,nombrediaphragme+1);
if listediaphragme[-1+nombrediaphragme+1].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
donneanglepolairedanspipi(-x1+listediaphragme[-1+indiceelementmodif].a2x,-y1+listediaphragme[-1+indiceelementmodif].a2y),
listediaphragme[-1+indiceelementmodif].rint,
sqrt(sqr(x1-listediaphragme[-1+indiceelementmodif].a2x)+sqr(y1-listediaphragme[-1+indiceelementmodif].a2y))/2,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur) then
 listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
donneanglepolairedanspipi(-x1+listediaphragme[-1+indiceelementmodif].a2x,-y1+listediaphragme[-1+indiceelementmodif].a2y),
listediaphragme[-1+indiceelementmodif].rint,
sqrt(sqr(x1-listediaphragme[-1+indiceelementmodif].a2x)+sqr(y1-listediaphragme[-1+indiceelementmodif].a2y))/2,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur)
else
listediaphragme[-1+indiceelementmodif].create2(
listediaphragme[-1+indiceelementmodif].cx,
listediaphragme[-1+indiceelementmodif].cy,
listediaphragme[-1+indiceelementmodif].anglepolaire,
listediaphragme[-1+indiceelementmodif].rint,
listediaphragme[-1+indiceelementmodif].rext,
listediaphragme[-1+indiceelementmodif].couleur,
listediaphragme[-1+indiceelementmodif].epaisseur);
retaillePdiaphragme(listediaphragme,nombrediaphragme+1,nombrediaphragme);
Rafraichit;
end;
      end;


 mdmscopa: begin
 if ((tprot=tpa1) and ((x1<>listemscopa[-1+indiceelementmodif].a2x) or
 (y1<>listemscopa[-1+indiceelementmodif].a2y)))
 then begin
retaillePmscopa(listemscopa,nombremscopa,nombremscopa+1);
if listemscopa[-1+nombremscopa+1].create2(
x1,y1,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou) then
 listemscopa[-1+indiceelementmodif].create2(x1,y1,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou)
else
listemscopa[-1+indiceelementmodif].create2(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou);
retaillePmscopa(listemscopa,nombremscopa+1,nombremscopa);
Rafraichit;
end;
if ((tprot=tpa2) and ((x1<>listemscopa[-1+indiceelementmodif].a1x) or
 (y1<>listemscopa[-1+indiceelementmodif].a1y)))
 then begin
retaillePmscopa(listemscopa,nombremscopa,nombremscopa+1);
if listemscopa[-1+nombremscopa+1].create2(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,x1,y1,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou) then
 listemscopa[-1+indiceelementmodif].create2(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,x1,y1,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou)
else
listemscopa[-1+indiceelementmodif].create2(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou);
retaillePmscopa(listemscopa,nombremscopa+1,nombremscopa);
Rafraichit;
 end;

 if ((tprot=tpfo) and ((x1<>listemscopa[-1+indiceelementmodif].sx) or
 (y1<>listemscopa[-1+indiceelementmodif].sy)))
 then begin
 lambda:=((x1-listemscopa[-1+indiceelementmodif].sx)*(listemscopa[-1+indiceelementmodif].cx-
 listemscopa[-1+indiceelementmodif].sx)+(y1-listemscopa[-1+indiceelementmodif].sy)*
 (listemscopa[-1+indiceelementmodif].cy-listemscopa[-1+indiceelementmodif].sy))/
 (sqr(listemscopa[-1+indiceelementmodif].cx-listemscopa[-1+indiceelementmodif].sx)+
 sqr(listemscopa[-1+indiceelementmodif].cy-listemscopa[-1+indiceelementmodif].sy));
 if lambda<0 then lambda:=0.1;
 xx1:=listemscopa[-1+indiceelementmodif].sx+lambda*(listemscopa[-1+indiceelementmodif].cx-
 listemscopa[-1+indiceelementmodif].sx);
 yy1:=listemscopa[-1+indiceelementmodif].sy+lambda*(listemscopa[-1+indiceelementmodif].cy-
 listemscopa[-1+indiceelementmodif].sy);
retaillePmscopa(listemscopa,nombremscopa,nombremscopa+1);
if listemscopa[-1+nombremscopa+1].create(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou) then
 listemscopa[-1+indiceelementmodif].create(
 listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou)
else
listemscopa[-1+indiceelementmodif].create2(
listemscopa[-1+indiceelementmodif].a1x,
listemscopa[-1+indiceelementmodif].a1y,
listemscopa[-1+indiceelementmodif].a2x,
listemscopa[-1+indiceelementmodif].a2y,
listemscopa[-1+indiceelementmodif].focale,
listemscopa[-1+indiceelementmodif].epaisseur,
listemscopa[-1+indiceelementmodif].couleur,
listemscopa[-1+indiceelementmodif].couleuraxe,
listemscopa[-1+indiceelementmodif].hachures,
listemscopa[-1+indiceelementmodif].axefocal,
listemscopa[-1+indiceelementmodif].trou,
listemscopa[-1+indiceelementmodif].diametretrou);
retaillePmscopa(listemscopa,nombremscopa+1,nombremscopa);
Rafraichit;
end;
 end; {du cas mscopa}




 mdmiroirconique: begin
 if ((tprot=tpa2) and ((x1<>listemiroirconique[-1+indiceelementmodif].a1x) or
 (y1<>listemiroirconique[-1+indiceelementmodif].a1y)))
 then begin

retaillePmiroirconique(listemiroirconique,nombremiroirconique,nombremiroirconique+1);
dtheta:=donneanglepolairedans02pi(x1-listemiroirconique[-1+indiceelementmodif].a1x,
y1-listemiroirconique[-1+indiceelementmodif].a1y)-
donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].a2x-listemiroirconique[-1+indiceelementmodif].a1x,
listemiroirconique[-1+indiceelementmodif].a2y-listemiroirconique[-1+indiceelementmodif].a1y);
if listemiroirconique[-1+nombremiroirconique+1].create2(
listemiroirconique[-1+indiceelementmodif].a1x+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a1x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a1y))*
cos(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a1x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a1y)+dtheta),

listemiroirconique[-1+indiceelementmodif].a1y+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a1x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a1y))*
sin(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a1x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a1y)+dtheta),

listemiroirconique[-1+indiceelementmodif].theta0+dtheta,
listemiroirconique[-1+indiceelementmodif].theta1+dtheta,
listemiroirconique[-1+indiceelementmodif].theta2+dtheta,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal) then
 listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].a1x+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a1x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a1y))*
cos(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a1x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a1y)+dtheta),

listemiroirconique[-1+indiceelementmodif].a1y+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a1x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a1y))*
sin(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a1x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a1y)+dtheta),

listemiroirconique[-1+indiceelementmodif].theta0+dtheta,
listemiroirconique[-1+indiceelementmodif].theta1+dtheta,
listemiroirconique[-1+indiceelementmodif].theta2+dtheta,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal)
else
listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].fx,
listemiroirconique[-1+indiceelementmodif].fy,
listemiroirconique[-1+indiceelementmodif].theta0,
listemiroirconique[-1+indiceelementmodif].theta1,
listemiroirconique[-1+indiceelementmodif].theta2,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal);
retaillePmiroirconique(listemiroirconique,nombremiroirconique+1,nombremiroirconique);
Rafraichit;
end;


 if ((tprot=tpa1) and ((x1<>listemiroirconique[-1+indiceelementmodif].a2x) or
 (y1<>listemiroirconique[-1+indiceelementmodif].a2y)))
 then begin

retaillePmiroirconique(listemiroirconique,nombremiroirconique,nombremiroirconique+1);
dtheta:=donneanglepolairedans02pi(x1-listemiroirconique[-1+indiceelementmodif].a2x,
y1-listemiroirconique[-1+indiceelementmodif].a2y)-
donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].a1x-listemiroirconique[-1+indiceelementmodif].a2x,
listemiroirconique[-1+indiceelementmodif].a1y-listemiroirconique[-1+indiceelementmodif].a2y);
if listemiroirconique[-1+nombremiroirconique+1].create2(
listemiroirconique[-1+indiceelementmodif].a2x+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a2x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a2y))*
cos(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a2x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a2y)+dtheta),

listemiroirconique[-1+indiceelementmodif].a2y+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a2x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a2y))*
sin(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a2x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a2y)+dtheta),

listemiroirconique[-1+indiceelementmodif].theta0+dtheta,
listemiroirconique[-1+indiceelementmodif].theta1+dtheta,
listemiroirconique[-1+indiceelementmodif].theta2+dtheta,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal) then
 listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].a2x+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a2x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a2y))*
cos(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a2x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a2y)+dtheta),

listemiroirconique[-1+indiceelementmodif].a2y+
sqrt(sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].a2x)+
sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].a2y))*
sin(donneanglepolairedans02pi(listemiroirconique[-1+indiceelementmodif].fx-
listemiroirconique[-1+indiceelementmodif].a2x,listemiroirconique[-1+indiceelementmodif].fy-
listemiroirconique[-1+indiceelementmodif].a2y)+dtheta),

listemiroirconique[-1+indiceelementmodif].theta0+dtheta,
listemiroirconique[-1+indiceelementmodif].theta1+dtheta,
listemiroirconique[-1+indiceelementmodif].theta2+dtheta,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal)
else
listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].fx,
listemiroirconique[-1+indiceelementmodif].fy,
listemiroirconique[-1+indiceelementmodif].theta0,
listemiroirconique[-1+indiceelementmodif].theta1,
listemiroirconique[-1+indiceelementmodif].theta2,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal);
retaillePmiroirconique(listemiroirconique,nombremiroirconique+1,nombremiroirconique);
Rafraichit;
end;

 if ((tprot=tpfo) and ((x1<>listemiroirconique[-1+indiceelementmodif].sx) or
 (y1<>listemiroirconique[-1+indiceelementmodif].sy)))
 then begin
 lambda:=((x1-listemiroirconique[-1+indiceelementmodif].sx)*(listemiroirconique[-1+indiceelementmodif].fx-
 listemiroirconique[-1+indiceelementmodif].sx)+(y1-listemiroirconique[-1+indiceelementmodif].sy)*
 (listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].sy))/
 (sqr(listemiroirconique[-1+indiceelementmodif].fx-listemiroirconique[-1+indiceelementmodif].sx)+
 sqr(listemiroirconique[-1+indiceelementmodif].fy-listemiroirconique[-1+indiceelementmodif].sy));
 if lambda<0 then lambda:=0.1;
 xx1:=listemiroirconique[-1+indiceelementmodif].sx+lambda*(listemiroirconique[-1+indiceelementmodif].fx-
 listemiroirconique[-1+indiceelementmodif].sx);
 yy1:=listemiroirconique[-1+indiceelementmodif].sy+lambda*(listemiroirconique[-1+indiceelementmodif].fy-
 listemiroirconique[-1+indiceelementmodif].sy);
retaillePmiroirconique(listemiroirconique,nombremiroirconique,nombremiroirconique+1);
if listemiroirconique[-1+nombremiroirconique+1].create(
xx1,yy1,
listemiroirconique[-1+indiceelementmodif].sx,
listemiroirconique[-1+indiceelementmodif].sy,
listemiroirconique[-1+indiceelementmodif].a1x,
listemiroirconique[-1+indiceelementmodif].a1y,
listemiroirconique[-1+indiceelementmodif].a2x,
listemiroirconique[-1+indiceelementmodif].a2y,
listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal) then
 listemiroirconique[-1+indiceelementmodif].create(
xx1,yy1,
listemiroirconique[-1+indiceelementmodif].sx,
listemiroirconique[-1+indiceelementmodif].sy,
listemiroirconique[-1+indiceelementmodif].a1x,
listemiroirconique[-1+indiceelementmodif].a1y,
listemiroirconique[-1+indiceelementmodif].a2x,
listemiroirconique[-1+indiceelementmodif].a2y,
listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal)
else
listemiroirconique[-1+indiceelementmodif].create2(
listemiroirconique[-1+indiceelementmodif].fx,
listemiroirconique[-1+indiceelementmodif].fy,
listemiroirconique[-1+indiceelementmodif].theta0,
listemiroirconique[-1+indiceelementmodif].theta1,
listemiroirconique[-1+indiceelementmodif].theta2,
listemiroirconique[-1+indiceelementmodif].excentricite,
 listemiroirconique[-1+indiceelementmodif].parametre,
 listemiroirconique[-1+indiceelementmodif].concave,
listemiroirconique[-1+indiceelementmodif].couleur,
listemiroirconique[-1+indiceelementmodif].couleuraxe,
listemiroirconique[-1+indiceelementmodif].hachures,
listemiroirconique[-1+indiceelementmodif].axefocal);
retaillePmiroirconique(listemiroirconique,nombremiroirconique+1,nombremiroirconique);
Rafraichit;
end;
 end; {du cas miroirconique}



  mdmscore: begin
 if ((tprot=tpa1) and ((x1<>listemscore[-1+indiceelementmodif].a2x) or
 (y1<>listemscore[-1+indiceelementmodif].a2y)))
 then begin
retaillePmscore(listemscore,nombremscore,nombremscore+1);
if listemscore[-1+nombremscore+1].create2(
x1,y1,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
 listemscore[-1+indiceelementmodif].trou,
 listemscore[-1+indiceelementmodif].diametretrou) then
 listemscore[-1+indiceelementmodif].create2(x1,y1,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
 listemscore[-1+indiceelementmodif].trou,
 listemscore[-1+indiceelementmodif].diametretrou)
else
listemscore[-1+indiceelementmodif].create2(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
 listemscore[-1+indiceelementmodif].trou,
 listemscore[-1+indiceelementmodif].diametretrou);
retaillePmscore(listemscore,nombremscore+1,nombremscore);
Rafraichit;
end;
if ((tprot=tpa2) and ((x1<>listemscore[-1+indiceelementmodif].a1x) or
 (y1<>listemscore[-1+indiceelementmodif].a1y)))
 then begin
retaillePmscore(listemscore,nombremscore,nombremscore+1);
if listemscore[-1+nombremscore+1].create2(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,x1,y1,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
 listemscore[-1+indiceelementmodif].trou,
 listemscore[-1+indiceelementmodif].diametretrou) then
 listemscore[-1+indiceelementmodif].create2(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,x1,y1,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
 listemscore[-1+indiceelementmodif].trou,
 listemscore[-1+indiceelementmodif].diametretrou)
else
listemscore[-1+indiceelementmodif].create2(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
 listemscore[-1+indiceelementmodif].trou,
 listemscore[-1+indiceelementmodif].diametretrou);
retaillePmscore(listemscore,nombremscore+1,nombremscore);
Rafraichit;
 end;


 if ((tprot=tpce) and ((x1<>listemscore[-1+indiceelementmodif].sx) or
 (y1<>listemscore[-1+indiceelementmodif].sy)))
 then begin
 lambda:=((x1-listemscore[-1+indiceelementmodif].sx)*(listemscore[-1+indiceelementmodif].cx-
 listemscore[-1+indiceelementmodif].sx)+(y1-listemscore[-1+indiceelementmodif].sy)*
 (listemscore[-1+indiceelementmodif].cy-listemscore[-1+indiceelementmodif].sy))/
 (sqr(listemscore[-1+indiceelementmodif].cx-listemscore[-1+indiceelementmodif].sx)+
 sqr(listemscore[-1+indiceelementmodif].cy-listemscore[-1+indiceelementmodif].sy));
 if lambda<0 then lambda:=0.1;
 xx1:=listemscore[-1+indiceelementmodif].sx+lambda*(listemscore[-1+indiceelementmodif].cx-
 listemscore[-1+indiceelementmodif].sx);
 yy1:=listemscore[-1+indiceelementmodif].sy+lambda*(listemscore[-1+indiceelementmodif].cy-
 listemscore[-1+indiceelementmodif].sy);
retaillePmscore(listemscore,nombremscore,nombremscore+1);
if listemscore[-1+nombremscore+1].create(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
 listemscore[-1+indiceelementmodif].trou,
 listemscore[-1+indiceelementmodif].diametretrou) then
 listemscore[-1+indiceelementmodif].create(
 listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
 listemscore[-1+indiceelementmodif].trou,
 listemscore[-1+indiceelementmodif].diametretrou)
else
listemscore[-1+indiceelementmodif].create2(
listemscore[-1+indiceelementmodif].a1x,
listemscore[-1+indiceelementmodif].a1y,
listemscore[-1+indiceelementmodif].a2x,
listemscore[-1+indiceelementmodif].a2y,
listemscore[-1+indiceelementmodif].rayoncourbure,
listemscore[-1+indiceelementmodif].epaisseur,
listemscore[-1+indiceelementmodif].couleur,
listemscore[-1+indiceelementmodif].couleuraxe,
listemscore[-1+indiceelementmodif].hachures,
listemscore[-1+indiceelementmodif].axefocal,
listemscore[-1+indiceelementmodif].aigu,
 listemscore[-1+indiceelementmodif].trou,
 listemscore[-1+indiceelementmodif].diametretrou);
retaillePmscore(listemscore,nombremscore+1,nombremscore);
Rafraichit;
end;
 end; {du cas mscore}


 mdmscepa: begin
 if ((tprot=tpa1) and ((x1<>listemscepa[-1+indiceelementmodif].a2x) or
 (y1<>listemscepa[-1+indiceelementmodif].a2y)))
 then begin
retaillePmscepa(listemscepa,nombremscepa,nombremscepa+1);
if listemscepa[-1+nombremscepa+1].create2(
x1,y1,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou) then
 listemscepa[-1+indiceelementmodif].create2(x1,y1,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou)
else
listemscepa[-1+indiceelementmodif].create2(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou);
retaillePmscepa(listemscepa,nombremscepa+1,nombremscepa);
Rafraichit;
end;
if ((tprot=tpa2) and ((x1<>listemscepa[-1+indiceelementmodif].a1x) or
 (y1<>listemscepa[-1+indiceelementmodif].a1y)))
 then begin
retaillePmscepa(listemscepa,nombremscepa,nombremscepa+1);
if listemscepa[-1+nombremscepa+1].create2(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,x1,y1,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou) then
 listemscepa[-1+indiceelementmodif].create2(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,x1,y1,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou)
else
listemscepa[-1+indiceelementmodif].create2(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou);
retaillePmscepa(listemscepa,nombremscepa+1,nombremscepa);
Rafraichit;
 end;


  if ((tprot=tpfo) and ((x1<>listemscepa[-1+indiceelementmodif].sx) or
 (y1<>listemscepa[-1+indiceelementmodif].sy)))
 then begin
 lambda:=((x1-listemscepa[-1+indiceelementmodif].sx)*(listemscepa[-1+indiceelementmodif].cx-
 listemscepa[-1+indiceelementmodif].sx)+(y1-listemscepa[-1+indiceelementmodif].sy)*
 (listemscepa[-1+indiceelementmodif].cy-listemscepa[-1+indiceelementmodif].sy))/
 (sqr(listemscepa[-1+indiceelementmodif].cx-listemscepa[-1+indiceelementmodif].sx)+
 sqr(listemscepa[-1+indiceelementmodif].cy-listemscepa[-1+indiceelementmodif].sy));
 if lambda<0 then lambda:=0.1;
 xx1:=listemscepa[-1+indiceelementmodif].sx+lambda*(listemscepa[-1+indiceelementmodif].cx-
 listemscepa[-1+indiceelementmodif].sx);
 yy1:=listemscepa[-1+indiceelementmodif].sy+lambda*(listemscepa[-1+indiceelementmodif].cy-
 listemscepa[-1+indiceelementmodif].sy);
retaillePmscepa(listemscepa,nombremscepa,nombremscepa+1);
if listemscepa[-1+nombremscepa+1].create(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou) then
 listemscepa[-1+indiceelementmodif].create(
 listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou)
else
listemscepa[-1+indiceelementmodif].create2(
listemscepa[-1+indiceelementmodif].a1x,
listemscepa[-1+indiceelementmodif].a1y,
listemscepa[-1+indiceelementmodif].a2x,
listemscepa[-1+indiceelementmodif].a2y,
listemscepa[-1+indiceelementmodif].focale,
listemscepa[-1+indiceelementmodif].epaisseur,
listemscepa[-1+indiceelementmodif].couleur,
listemscepa[-1+indiceelementmodif].couleuraxe,
listemscepa[-1+indiceelementmodif].hachures,
listemscepa[-1+indiceelementmodif].axefocal,
listemscepa[-1+indiceelementmodif].trou,
listemscepa[-1+indiceelementmodif].diametretrou);
retaillePmscepa(listemscepa,nombremscepa+1,nombremscepa);
Rafraichit;
end;
 end; {du cas mscepa}


  mdmscere: begin
 if ((tprot=tpa1) and ((x1<>listemscere[-1+indiceelementmodif].a2x) or
 (y1<>listemscere[-1+indiceelementmodif].a2y)))
 then begin
retaillePmscere(listemscere,nombremscere,nombremscere+1);
if listemscere[-1+nombremscere+1].create2(
x1,y1,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
 listemscere[-1+indiceelementmodif].trou,
 listemscere[-1+indiceelementmodif].diametretrou) then
 listemscere[-1+indiceelementmodif].create2(x1,y1,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
 listemscere[-1+indiceelementmodif].trou,
 listemscere[-1+indiceelementmodif].diametretrou)
else
listemscere[-1+indiceelementmodif].create2(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
 listemscere[-1+indiceelementmodif].trou,
 listemscere[-1+indiceelementmodif].diametretrou);
retaillePmscere(listemscere,nombremscere+1,nombremscere);
Rafraichit;
end;
if ((tprot=tpa2) and ((x1<>listemscere[-1+indiceelementmodif].a1x) or
 (y1<>listemscere[-1+indiceelementmodif].a1y)))
 then begin
retaillePmscere(listemscere,nombremscere,nombremscere+1);
if listemscere[-1+nombremscere+1].create2(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,x1,y1,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
 listemscere[-1+indiceelementmodif].trou,
 listemscere[-1+indiceelementmodif].diametretrou) then
 listemscere[-1+indiceelementmodif].create2(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,x1,y1,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
 listemscere[-1+indiceelementmodif].trou,
 listemscere[-1+indiceelementmodif].diametretrou)
else
listemscere[-1+indiceelementmodif].create2(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
 listemscere[-1+indiceelementmodif].trou,
 listemscere[-1+indiceelementmodif].diametretrou);
retaillePmscere(listemscere,nombremscere+1,nombremscere);
Rafraichit;
 end;


 if ((tprot=tpce) and ((x1<>listemscere[-1+indiceelementmodif].sx) or
 (y1<>listemscere[-1+indiceelementmodif].sy)))
 then begin
 lambda:=((x1-listemscere[-1+indiceelementmodif].sx)*(listemscere[-1+indiceelementmodif].cx-
 listemscere[-1+indiceelementmodif].sx)+(y1-listemscere[-1+indiceelementmodif].sy)*
 (listemscere[-1+indiceelementmodif].cy-listemscere[-1+indiceelementmodif].sy))/
 (sqr(listemscere[-1+indiceelementmodif].cx-listemscere[-1+indiceelementmodif].sx)+
 sqr(listemscere[-1+indiceelementmodif].cy-listemscere[-1+indiceelementmodif].sy));
 if lambda<0 then lambda:=0.1;
 xx1:=listemscere[-1+indiceelementmodif].sx+lambda*(listemscere[-1+indiceelementmodif].cx-
 listemscere[-1+indiceelementmodif].sx);
 yy1:=listemscere[-1+indiceelementmodif].sy+lambda*(listemscere[-1+indiceelementmodif].cy-
 listemscere[-1+indiceelementmodif].sy);
retaillePmscere(listemscere,nombremscere,nombremscere+1);
if listemscere[-1+nombremscere+1].create(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
 listemscere[-1+indiceelementmodif].trou,
 listemscere[-1+indiceelementmodif].diametretrou) then
 listemscere[-1+indiceelementmodif].create(
 listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
xx1,yy1,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
 listemscere[-1+indiceelementmodif].trou,
 listemscere[-1+indiceelementmodif].diametretrou)
else
listemscere[-1+indiceelementmodif].create2(
listemscere[-1+indiceelementmodif].a1x,
listemscere[-1+indiceelementmodif].a1y,
listemscere[-1+indiceelementmodif].a2x,
listemscere[-1+indiceelementmodif].a2y,
listemscere[-1+indiceelementmodif].rayoncourbure,
listemscere[-1+indiceelementmodif].epaisseur,
listemscere[-1+indiceelementmodif].couleur,
listemscere[-1+indiceelementmodif].couleuraxe,
listemscere[-1+indiceelementmodif].hachures,
listemscere[-1+indiceelementmodif].axefocal,
listemscere[-1+indiceelementmodif].aigu,
 listemscere[-1+indiceelementmodif].trou,
 listemscere[-1+indiceelementmodif].diametretrou);
retaillePmscere(listemscere,nombremscere+1,nombremscere);
Rafraichit;
end;
 end; {du cas mscere}



 mdlmc: begin
 if ((tprot=tpa1) and ((x1<>listelmc[-1+indiceelementmodif].a2x) or
 (y1<>listelmc[-1+indiceelementmodif].a2y))) then begin
retaillePlmc(listelmc,nombrelmc,nombrelmc+1);
if listelmc[-1+nombrelmc+1].create2(x1,y1,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal) then
 listelmc[-1+indiceelementmodif].create2(x1,y1,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal)
else
listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal);
retaillePlmc(listelmc,nombrelmc+1,nombrelmc);
Rafraichit;
end;

 if ((tprot=tpa2) and ((x1<>listelmc[-1+indiceelementmodif].a1x) or
 (y1<>listelmc[-1+indiceelementmodif].a1y))) then begin
retaillePlmc(listelmc,nombrelmc,nombrelmc+1);
if listelmc[-1+nombrelmc+1].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,x1,y1,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal) then
 listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,x1,y1,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal)
else
listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal);
retaillePlmc(listelmc,nombrelmc+1,nombrelmc);
Rafraichit;
end;


 if ((tprot=tpf1) and ((x1<>listelmc[-1+indiceelementmodif].ox) or
 (y1<>listelmc[-1+indiceelementmodif].oy))) then begin
lambda:=((x1-listelmc[-1+indiceelementmodif].ox)*(listelmc[-1+indiceelementmodif].f1x-
 listelmc[-1+indiceelementmodif].ox)+(y1-listelmc[-1+indiceelementmodif].oy)*
 (listelmc[-1+indiceelementmodif].f1y-listelmc[-1+indiceelementmodif].oy))/
 (sqr(listelmc[-1+indiceelementmodif].f1x-listelmc[-1+indiceelementmodif].ox)+
 sqr(listelmc[-1+indiceelementmodif].f1y-listelmc[-1+indiceelementmodif].oy));
 xx1:=listelmc[-1+indiceelementmodif].ox+lambda*(listelmc[-1+indiceelementmodif].f1x-
 listelmc[-1+indiceelementmodif].ox);
 yy1:=listelmc[-1+indiceelementmodif].oy+lambda*(listelmc[-1+indiceelementmodif].f1y-
 listelmc[-1+indiceelementmodif].oy);
 retaillePlmc(listelmc,nombrelmc,nombrelmc+1);
if listelmc[-1+nombrelmc+1].create(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal) then
 listelmc[-1+indiceelementmodif].create(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal)
else
listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal);
retaillePlmc(listelmc,nombrelmc+1,nombrelmc);
Rafraichit;
 end;


 if ((tprot=tpf2) and ((x1<>listelmc[-1+indiceelementmodif].ox) or
 (y1<>listelmc[-1+indiceelementmodif].oy))) then begin
lambda:=((x1-listelmc[-1+indiceelementmodif].ox)*(listelmc[-1+indiceelementmodif].f2x-
 listelmc[-1+indiceelementmodif].ox)+(y1-listelmc[-1+indiceelementmodif].oy)*
 (listelmc[-1+indiceelementmodif].f2y-listelmc[-1+indiceelementmodif].oy))/
 (sqr(listelmc[-1+indiceelementmodif].f2x-listelmc[-1+indiceelementmodif].ox)+
 sqr(listelmc[-1+indiceelementmodif].f2y-listelmc[-1+indiceelementmodif].oy));
 xx1:=listelmc[-1+indiceelementmodif].ox+lambda*(listelmc[-1+indiceelementmodif].f2x-
 listelmc[-1+indiceelementmodif].ox);
 yy1:=listelmc[-1+indiceelementmodif].oy+lambda*(listelmc[-1+indiceelementmodif].f2y-
 listelmc[-1+indiceelementmodif].oy);
 retaillePlmc(listelmc,nombrelmc,nombrelmc+1);
if listelmc[-1+nombrelmc+1].create(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal) then
 listelmc[-1+indiceelementmodif].create(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal)
else
listelmc[-1+indiceelementmodif].create2(
listelmc[-1+indiceelementmodif].a1x,
listelmc[-1+indiceelementmodif].a1y,
listelmc[-1+indiceelementmodif].a2x,
listelmc[-1+indiceelementmodif].a2y,
listelmc[-1+indiceelementmodif].focale,
listelmc[-1+indiceelementmodif].epaisseur,
listelmc[-1+indiceelementmodif].couleur,
listelmc[-1+indiceelementmodif].couleuraxe,
listelmc[-1+indiceelementmodif].axefocal);
retaillePlmc(listelmc,nombrelmc+1,nombrelmc);
Rafraichit;
 end;
 end; {du cas lmc}


{cas lec}
mdlec: begin
 if ((tprot=tpa1) and ((x1<>listelec[-1+indiceelementmodif].s2x) or
 (y1<>listelec[-1+indiceelementmodif].s2y))) then begin
retaillePlec(listelec,nombrelec,nombrelec+1);
if listelec[-1+nombrelec+1].create(x1,y1,
listelec[-1+indiceelementmodif].s2x,
listelec[-1+indiceelementmodif].s2y,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant) then
 listelec[-1+indiceelementmodif].create(x1,y1,
listelec[-1+indiceelementmodif].s2x,
listelec[-1+indiceelementmodif].s2y,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant)
else
listelec[-1+indiceelementmodif].create(
listelec[-1+indiceelementmodif].s1x,
listelec[-1+indiceelementmodif].s1y,
listelec[-1+indiceelementmodif].s2x,
listelec[-1+indiceelementmodif].s2y,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant);
retaillePlec(listelec,nombrelec+1,nombrelec);
Rafraichit;
end;

 if ((tprot=tpa2) and ((x1<>listelec[-1+indiceelementmodif].s1x) or
 (y1<>listelec[-1+indiceelementmodif].s1y))) then begin
retaillePlec(listelec,nombrelec,nombrelec+1);
if listelec[-1+nombrelec+1].create(
listelec[-1+indiceelementmodif].s1x,
listelec[-1+indiceelementmodif].s1y,
x1,y1,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant) then
 listelec[-1+indiceelementmodif].create(
listelec[-1+indiceelementmodif].s1x,
listelec[-1+indiceelementmodif].s1y,
x1,y1,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant)
else
listelec[-1+indiceelementmodif].create(
listelec[-1+indiceelementmodif].s1x,
listelec[-1+indiceelementmodif].s1y,
listelec[-1+indiceelementmodif].s2x,
listelec[-1+indiceelementmodif].s2y,
listelec[-1+indiceelementmodif].r1,
listelec[-1+indiceelementmodif].r2,
listelec[-1+indiceelementmodif].diametre,
listelec[-1+indiceelementmodif].couleurfond,
listelec[-1+indiceelementmodif].couleuraxe,
listelec[-1+indiceelementmodif].axefocal,
listelec[-1+indiceelementmodif].indicerouge,
listelec[-1+indiceelementmodif].indicebleu,
listelec[-1+indiceelementmodif].indicevert,
listelec[-1+indiceelementmodif].reflechientrant,
listelec[-1+indiceelementmodif].reflechisortant);
retaillePlec(listelec,nombrelec+1,nombrelec);
Rafraichit;
end;    end;
{fin cas lec}

 mdlmd: begin
 if ((tprot=tpa1) and ((x1<>listelmd[-1+indiceelementmodif].a2x) or
 (y1<>listelmd[-1+indiceelementmodif].a2y))) then begin
retaillePlmd(listelmd,nombrelmd,nombrelmd+1);
if listelmd[-1+nombrelmd+1].create2(x1,y1,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal) then
 listelmd[-1+indiceelementmodif].create2(x1,y1,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal)
else
listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal);
retaillePlmd(listelmd,nombrelmd+1,nombrelmd);
Rafraichit;
end;

 if ((tprot=tpa2) and ((x1<>listelmd[-1+indiceelementmodif].a1x) or
 (y1<>listelmd[-1+indiceelementmodif].a1y))) then begin
retaillePlmd(listelmd,nombrelmd,nombrelmd+1);
if listelmd[-1+nombrelmd+1].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,x1,y1,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal) then
 listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,x1,y1,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal)
else
listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal);
retaillePlmd(listelmd,nombrelmd+1,nombrelmd);
Rafraichit;
end;


 if ((tprot=tpf1) and ((x1<>listelmd[-1+indiceelementmodif].ox) or
 (y1<>listelmd[-1+indiceelementmodif].oy))) then begin
lambda:=((x1-listelmd[-1+indiceelementmodif].ox)*(listelmd[-1+indiceelementmodif].f1x-
 listelmd[-1+indiceelementmodif].ox)+(y1-listelmd[-1+indiceelementmodif].oy)*
 (listelmd[-1+indiceelementmodif].f1y-listelmd[-1+indiceelementmodif].oy))/
 (sqr(listelmd[-1+indiceelementmodif].f1x-listelmd[-1+indiceelementmodif].ox)+
 sqr(listelmd[-1+indiceelementmodif].f1y-listelmd[-1+indiceelementmodif].oy));
 xx1:=listelmd[-1+indiceelementmodif].ox+lambda*(listelmd[-1+indiceelementmodif].f1x-
 listelmd[-1+indiceelementmodif].ox);
 yy1:=listelmd[-1+indiceelementmodif].oy+lambda*(listelmd[-1+indiceelementmodif].f1y-
 listelmd[-1+indiceelementmodif].oy);
 retaillePlmd(listelmd,nombrelmd,nombrelmd+1);
if listelmd[-1+nombrelmd+1].create(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal) then
 listelmd[-1+indiceelementmodif].create(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal)
else
listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal);
retaillePlmd(listelmd,nombrelmd+1,nombrelmd);
Rafraichit;
 end;


 if ((tprot=tpf2) and ((x1<>listelmd[-1+indiceelementmodif].ox) or
 (y1<>listelmd[-1+indiceelementmodif].oy))) then begin
lambda:=((x1-listelmd[-1+indiceelementmodif].ox)*(listelmd[-1+indiceelementmodif].f2x-
 listelmd[-1+indiceelementmodif].ox)+(y1-listelmd[-1+indiceelementmodif].oy)*
 (listelmd[-1+indiceelementmodif].f2y-listelmd[-1+indiceelementmodif].oy))/
 (sqr(listelmd[-1+indiceelementmodif].f2x-listelmd[-1+indiceelementmodif].ox)+
 sqr(listelmd[-1+indiceelementmodif].f2y-listelmd[-1+indiceelementmodif].oy));
 xx1:=listelmd[-1+indiceelementmodif].ox+lambda*(listelmd[-1+indiceelementmodif].f2x-
 listelmd[-1+indiceelementmodif].ox);
 yy1:=listelmd[-1+indiceelementmodif].oy+lambda*(listelmd[-1+indiceelementmodif].f2y-
 listelmd[-1+indiceelementmodif].oy);
 retaillePlmd(listelmd,nombrelmd,nombrelmd+1);
if listelmd[-1+nombrelmd+1].create(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal) then
 listelmd[-1+indiceelementmodif].create(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
xx1,yy1,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal)
else
listelmd[-1+indiceelementmodif].create2(
listelmd[-1+indiceelementmodif].a1x,
listelmd[-1+indiceelementmodif].a1y,
listelmd[-1+indiceelementmodif].a2x,
listelmd[-1+indiceelementmodif].a2y,
listelmd[-1+indiceelementmodif].focale,
listelmd[-1+indiceelementmodif].epaisseur,
listelmd[-1+indiceelementmodif].couleur,
listelmd[-1+indiceelementmodif].couleuraxe,
listelmd[-1+indiceelementmodif].axefocal);
retaillePlmd(listelmd,nombrelmd+1,nombrelmd);
Rafraichit;
 end;
 end; {du cas lmd}


mdsourceponctuelle: begin
if ((tprot=tpa1) and ((x1<>listesourceponctuelle[-1+indiceelementmodif].sx) or
 (y1<>listesourceponctuelle[-1+indiceelementmodif].sy)))
 then begin
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle,nombresourceponctuelle+1);
if listesourceponctuelle[-1+nombresourceponctuelle+1].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,x1,y1,
 listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment) then
 listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,x1,y1,
 listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment)

else
listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,
 listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment);
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle+1,nombresourceponctuelle);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listesourceponctuelle[-1+indiceelementmodif].sx) or
 (y1<>listesourceponctuelle[-1+indiceelementmodif].sy)))
 then begin
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle,nombresourceponctuelle+1);
if listesourceponctuelle[-1+nombresourceponctuelle+1].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,x1,y1,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment) then
 listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,x1,y1,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment)

else
listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,
 listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment);
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle+1,nombresourceponctuelle);
Rafraichit;
end;


if ((tprot=tpa0) and ((x1<>listesourceponctuelle[-1+indiceelementmodif].a1x) or
 (y1<>listesourceponctuelle[-1+indiceelementmodif].a1y)) and
 ((x1<>listesourceponctuelle[-1+indiceelementmodif].a2x) or
 (y1<>listesourceponctuelle[-1+indiceelementmodif].a2y)))
 then begin
retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle,nombresourceponctuelle+1);
if listesourceponctuelle[-1+nombresourceponctuelle+1].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,x1,y1,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,
listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment) then
 listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,x1,y1,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,
listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment)

else
listesourceponctuelle[-1+indiceelementmodif].create(
listesourceponctuelle[-1+indiceelementmodif].nombrederayon,
listesourceponctuelle[-1+indiceelementmodif].sx,
listesourceponctuelle[-1+indiceelementmodif].sy,
listesourceponctuelle[-1+indiceelementmodif].a1x,
listesourceponctuelle[-1+indiceelementmodif].a1y,
 listesourceponctuelle[-1+indiceelementmodif].a2x,
listesourceponctuelle[-1+indiceelementmodif].a2y,
listesourceponctuelle[-1+indiceelementmodif].couleur,
listesourceponctuelle[-1+indiceelementmodif].epaisseur,
listesourceponctuelle[-1+indiceelementmodif].vav,
listesourceponctuelle[-1+indiceelementmodif].vaa,
listesourceponctuelle[-1+indiceelementmodif].maxenfantparrayon,
listesourceponctuelle[-1+indiceelementmodif].sourcevirtuelle,
listesourceponctuelle[-1+indiceelementmodif].tracersurfacesonde,
listesourceponctuelle[-1+indiceelementmodif].listechemins,
listesourceponctuelle[-1+indiceelementmodif].maxsegment);

retaillePsourceponctuelle(listesourceponctuelle,nombresourceponctuelle+1,nombresourceponctuelle);
Rafraichit;
end;
 end; {du cas sourceponctuelle}



mdondeplane: begin
if ((tprot=tpa1) and ((x1<>listeondeplane[-1+indiceelementmodif].a1x) or
 (y1<>listeondeplane[-1+indiceelementmodif].a1y)))
 then begin
retaillePondeplane(listeondeplane,nombreondeplane,nombreondeplane+1);
if listeondeplane[-1+nombreondeplane+1].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,x1,y1,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,
 listeondeplane[-1+indiceelementmodif].a2x,
listeondeplane[-1+indiceelementmodif].a2y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment) then
 listeondeplane[-1+indiceelementmodif].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,x1,y1,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,
 listeondeplane[-1+indiceelementmodif].a2x,
listeondeplane[-1+indiceelementmodif].a2y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment)

else
listeondeplane[-1+indiceelementmodif].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
listeondeplane[-1+indiceelementmodif].sx,
listeondeplane[-1+indiceelementmodif].sy,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,
 listeondeplane[-1+indiceelementmodif].a2x,
listeondeplane[-1+indiceelementmodif].a2y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment);
retaillePondeplane(listeondeplane,nombreondeplane+1,nombreondeplane);
Rafraichit;
end;

if ((tprot=tpa2) and ((x1<>listeondeplane[-1+indiceelementmodif].a1x) or
 (y1<>listeondeplane[-1+indiceelementmodif].a1y)))
 then begin
retaillePondeplane(listeondeplane,nombreondeplane,nombreondeplane+1);
if listeondeplane[-1+nombreondeplane+1].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
listeondeplane[-1+indiceelementmodif].sx,
listeondeplane[-1+indiceelementmodif].sy,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,x1,y1,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment) then
 listeondeplane[-1+indiceelementmodif].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
listeondeplane[-1+indiceelementmodif].sx,
listeondeplane[-1+indiceelementmodif].sy,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,x1,y1,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment)

else
listeondeplane[-1+indiceelementmodif].create(
listeondeplane[-1+indiceelementmodif].nombrederayon,
listeondeplane[-1+indiceelementmodif].sx,
listeondeplane[-1+indiceelementmodif].sy,
listeondeplane[-1+indiceelementmodif].a1x,
listeondeplane[-1+indiceelementmodif].a1y,
 listeondeplane[-1+indiceelementmodif].a2x,
 listeondeplane[-1+indiceelementmodif].a2y,
listeondeplane[-1+indiceelementmodif].couleur,
listeondeplane[-1+indiceelementmodif].epaisseur,
listeondeplane[-1+indiceelementmodif].vav,
listeondeplane[-1+indiceelementmodif].vaa,
listeondeplane[-1+indiceelementmodif].maxenfantparrayon,
listeondeplane[-1+indiceelementmodif].tracersurfacesonde,
listeondeplane[-1+indiceelementmodif].listechemins,
listeondeplane[-1+indiceelementmodif].maxsegment);
retaillePondeplane(listeondeplane,nombreondeplane+1,nombreondeplane);
Rafraichit;
end;
 end; {du cas ondeplane}


 end; {du case}
moderotation:=false;
 form1.StatusBar1.Panels[3].text:=rsModeDPlaceme4;
 form1.StatusBar1.Panels[2].text:=rsFaitesPasser4;
 modifencours:=false;
 exit;
 end; {du cas rotation}


  end;











 function fleche.create(_a1x,_a1y,_a2x,_a2y:extended; _epaisseur:integer;
  _couleur:tcolor; _ext1,_ext2:textremite; _styletrait:tpenstyle;
  _taille1,_taille2:integer):boolean;
   var taille:extended;
   begin
    a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
 cx:=(a1x+a2x)/2; cy:=(a1y+a2y)/2;
 epaisseur:=_epaisseur; couleur:=_couleur;
 ext1:=_ext1; ext2:=_ext2; styletrait:=_styletrait;
 taille1:=_taille1; taille2:=_taille2;
 taille:=sqrt((a2x-a1x)*(a2x-a1x)+(a2y-a1y)*(a2y-a1y));
 if ((taille<form1.taillemini) or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax)) then
 begin
 create:=false;
 exit;
 end;
 anglepolaire:=donneanglepolairedanspipi(a2x-a1x,a2y-a1y);
 create:=true;
  modifie:=true;
   end;


function miroirplan.create(_a1x,_a1y,_a2x,_a2y:extended; _epaisseur:integer;
  _couleur:tcolor; _hachures:boolean):boolean;
var i:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
 cx:=(a1x+a2x)/2; cy:=(a1y+a2y)/2;
 epaisseur:=_epaisseur; couleur:=_couleur; hachures:=_hachures;
 taille:=sqrt((a2x-a1x)*(a2x-a1x)+(a2y-a1y)*(a2y-a1y));
 if ((taille<form1.taillemini) or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax)) then
 begin
 create:=false;
 exit;
 end;
 create:=true;
  modifie:=true;
  anglepolaire:=donneanglepolairedanspipi(a2x-a1x,a2y-a1y);
  normalex:=cos(anglepolaire+Pi/2);
  normaley:=sin(anglepolaire+Pi/2);

 end;


function reseau.create(_a1x,_a1y,_a2x,_a2y:extended; _epaisseur:integer;
  _couleur:tcolor; _pas:extended; _entransmission, _hachures:boolean; _ordre_min,_ordre_max:integer):boolean;
var i:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
 cx:=(a1x+a2x)/2; cy:=(a1y+a2y)/2;
 epaisseur:=_epaisseur; couleur:=_couleur; hachures:=_hachures;
 taille:=sqrt((a2x-a1x)*(a2x-a1x)+(a2y-a1y)*(a2y-a1y));
 if ((taille<form1.taillemini) or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax)) then
 begin
 create:=false;
 exit;
 end;
 create:=true;
  modifie:=true;
  anglepolaire:=donneanglepolairedanspipi(a2x-a1x,a2y-a1y);
  normalex:=cos(anglepolaire+Pi/2);
  normaley:=sin(anglepolaire+Pi/2);
   entransmission:=_entransmission;
   pas:=_pas;
   nombre_trait_par_mm:=1e-3/pas;
  if _ordre_min<=_ordre_max then begin
  ordre_min:=_ordre_min;
ordre_max:=_ordre_max;
end else begin
   ordre_max:=_ordre_min;
ordre_min:=_ordre_max;
  end;
 end;



function ecran.create(_a1x,_a1y,_a2x,_a2y:extended; _epaisseur:integer;
  _couleur:tcolor):boolean;
var i:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
 cx:=(a1x+a2x)/2; cy:=(a1y+a2y)/2;
 epaisseur:=_epaisseur; couleur:=_couleur;
 taille:=sqrt((a2x-a1x)*(a2x-a1x)+(a2y-a1y)*(a2y-a1y));
 if ((taille<form1.taillemini) or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax)) then
 begin
 create:=false;
 exit;
 end;
 create:=true;
  modifie:=true;
  anglepolaire:=donneanglepolairedanspipi(a2x-a1x,a2y-a1y);
  normalex:=cos(anglepolaire+Pi/2);
  normaley:=sin(anglepolaire+Pi/2);

 end;



function lsr.create(_a1x,_a1y,_a2x,_a2y:extended; _epaisseur:integer;
  _couleur:tcolor):boolean;
var i:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
 cx:=(a1x+a2x)/2; cy:=(a1y+a2y)/2;
 epaisseur:=_epaisseur; couleur:=_couleur;
 taille:=sqrt((a2x-a1x)*(a2x-a1x)+(a2y-a1y)*(a2y-a1y));
 if ((taille<form1.taillemini) or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax)) then
 begin
 create:=false;
 exit;
 end;
 create:=true;
  modifie:=true;
  anglepolaire:=donneanglepolairedanspipi(a2x-a1x,a2y-a1y);
  normalex:=cos(anglepolaire+Pi/2);
  normaley:=sin(anglepolaire+Pi/2);

 end;


 function Mscopa.create(_a1x,_a1y,_a2x,_a2y,_fx,_fy:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_trou:boolean; _diametretrou:extended):boolean;
 var i:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y; fx:=_fx; fy:=_fy;
 sx:=(a1x+a2x)/2; sy:=(a1y+a2y)/2;
 cx:=sx+2*(fx-sx); cy:=sy+2*(fy-sy);
 focale:=sqrt(sqr(fx-sx)+sqr(fy-sy));
 epaisseur:=_epaisseur; couleur:=_couleur; hachures:=_hachures;
 axefocal:=_axefocal;   couleuraxe:=_couleuraxe;
 trou:=_trou; diametretrou:=_diametretrou;
 taille:=sqrt((a2x-a1x)*(a2x-a1x)+(a2y-a1y)*(a2y-a1y));
 if ((taille<form1.taillemini) or (focale<form1.taillemini) or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax) or (trou and (diametretrou>taille))) then
 begin
 create:=false;
 exit;
 end;
 create:=true;
  modifie:=true;
 anglepolaire:=donneanglepolairedanspipi(a2x-a1x,a2y-a1y);
  normalex:=cos(anglepolaire+Pi/2);
  normaley:=sin(anglepolaire+Pi/2);
  if not(trou) then begin
  t1x:=sx; t1y:=sy; t2x:=sx; t2y:=sy;
  end else begin
  t1x:=sx+diametretrou/2*cos(anglepolaire+Pi);
  t1y:=sy+diametretrou/2*sin(anglepolaire+Pi);
  t2x:=sx+diametretrou/2*cos(anglepolaire);
  t2y:=sy+diametretrou/2*sin(anglepolaire);
  end;


 end;

 procedure segment.create(_a1x,_a1y,_a2x,_a2y,_ap:extended; _epaisseur:integer;
  _couleur:tcolor; _virtuelavant,_virtuelarriere:boolean);

    begin

    a1x:=_a1x; a1y:=_a1y; a2x:=_a2x; a2y:=_a2y; epaisseur:=_epaisseur;
    couleur:=_couleur; virtuelavant:=_virtuelavant;  ap:=_ap;
    virtuelarriere:=_virtuelarriere;
    end;


 function Mscore.create(_a1x,_a1y,_a2x,_a2y,_cx,_cy:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_trou:boolean; _diametretrou:extended):boolean;
 var i:integer;
 monmax_x,monmax_y,monmin_x,monmin_y:extended;
 jj:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y; cx:=_cx; cy:=_cy;
 rayoncourbure:=sqrt((cx-a1x)*(cx-a1x)+(cy-a1y)*(cy-a1y));
 epaisseur:=_epaisseur; couleur:=_couleur; hachures:=_hachures;
 axefocal:=_axefocal;   couleuraxe:=_couleuraxe;
   trou:=_trou; diametretrou:=_diametretrou;
   if not(trou) then diametretrou:=0;
  if (a2x=cx) then
  if (a2y>cy) then theta2:=Pi/2 else theta2:=-Pi/2
  else begin
  theta2:=arctan((a2y-cy)/(a2x-cx));
  if (a2x<cx) then theta2:=theta2+Pi;
  end;


  if (a1x=cx) then
  if (a1y>cy) then theta1:=Pi/2 else theta1:=-Pi/2
  else begin
  theta1:=arctan((a1y-cy)/(a1x-cx));
  if (a1x<cx) then theta1:=theta1+Pi;
  end;

  if theta1<0 then theta1:=theta1+Pi*2;
  if theta1>2*Pi then theta1:=theta1-Pi*2;
    if theta1>theta2 then theta2:=theta2+2*Pi;
    if theta1>theta2 then theta2:=theta2+2*Pi;
     if (theta2-theta1<=Pi) then aigu:=true else aigu:=false;
   taille:=abs(rayoncourbure*(theta2-theta1));
 if  ((taille<form1.taillemini) or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax) or (trou and (diametretrou>abs(theta2-theta1)))) then
 begin
 create:=false;
 exit;
 end;
 create:=true;
  modifie:=true;
 if not(trou) then begin
 theta1p:=theta1;
 theta2p:=theta2;
 end else begin
 theta1p:=(theta1+theta2)/2-diametretrou/2;
 theta2p:=(theta1+theta2)/2+diametretrou/2;
 end;
 sx:=cx+rayoncourbure*cos((theta1+theta2)/2);
 sy:=cy+rayoncourbure*sin((theta1+theta2)/2);
 circonference:=abs(rayoncourbure*(theta2-theta1));

  monmax_x:=cx+rayoncourbure*cos(theta1);
 monmax_y:=cy+rayoncourbure*sin(theta1);
  monmin_x:=monmax_x; monmin_y:=monmax_y;
  for jj:=1 to 200 do begin
  if trou then begin
  monmax_x:=maximum(cx+rayoncourbure*cos(theta1+(theta1p-theta1)*jj/200),monmax_x);
  monmin_x:=minimum(cx+rayoncourbure*cos(theta1+(theta1p-theta1)*jj/200),monmin_x);
  monmax_y:=maximum(cy+rayoncourbure*sin(theta1+(theta1p-theta1)*jj/200),monmax_y);
  monmin_y:=minimum(cy+rayoncourbure*sin(theta1+(theta1p-theta1)*jj/200),monmin_y);
  monmax_x:=maximum(cx+rayoncourbure*cos(theta2p+(theta2-theta2p)*jj/200),monmax_x);
  monmin_x:=minimum(cx+rayoncourbure*cos(theta2p+(theta2-theta2p)*jj/200),monmin_x);
  monmax_y:=maximum(cy+rayoncourbure*sin(theta2p+(theta2-theta2p)*jj/200),monmax_y);
  monmin_y:=minimum(cy+rayoncourbure*sin(theta2p+(theta2-theta2p)*jj/200),monmin_y);
  end else begin
   monmax_x:=maximum(cx+rayoncourbure*cos(theta1+(theta2-theta1)*jj/200),monmax_x);
  monmin_x:=minimum(cx+rayoncourbure*cos(theta1+(theta2-theta1)*jj/200),monmin_x);
  monmax_y:=maximum(cy+rayoncourbure*sin(theta1+(theta2-theta1)*jj/200),monmax_y);
  monmin_y:=minimum(cy+rayoncourbure*sin(theta1+(theta2-theta1)*jj/200),monmin_y);
  end;
  end;
  if ((monmin_x<xxmin) or (monmax_x>xxmax) or (monmin_y<yymin) or
 (monmax_y>yymax) ) then
 begin
 create:=false;
 exit;
 end;


 end;


 function Mscore.create2(_a1x,_a1y,_a2x,_a2y,_rayon:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_aigu,_trou:boolean; _diametretrou:extended):boolean;
 var i:integer; delta,lambda,xI,yI:extended;
  monmax_x,monmax_y,monmin_x,monmin_y:extended;
 jj:integer;
 begin
a1x:=_a1x;  aigu:=_aigu;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
 epaisseur:=_epaisseur; couleur:=_couleur; hachures:=_hachures;
 axefocal:=_axefocal;   couleuraxe:=_couleuraxe;  rayoncourbure:=_rayon;
  trou:=_trou; diametretrou:=_diametretrou;
   if not(trou) then diametretrou:=0;
   xI:=(a1x+a2x)/2; yI:=(a1y+a2y)/2;
   delta:=4*sqr((a1x-xI)*(a2y-a1y)+(yI-a1y)*(a2x-a1x))-4*(sqr(a2y-a1y)+
   sqr(a2x-a1x))*(sqr(xI-a1x)+sqr(yI-a1y)-sqr(rayoncourbure));
   if ((delta<0) or ((a1x=a2x) and (a1y=a2y))) then begin
   create2:=false;
   exit;
   end;
  if aigu then lambda:=(-2*((a1x-xI)*(a2y-a1y)+(yI-a1y)*(a2x-a1x))+sqrt(delta))/2/
   (sqr(a2y-a1y)+
   sqr(a2x-a1x)) else
       lambda:=(-2*((a1x-xI)*(a2y-a1y)+(yI-a1y)*(a2x-a1x))-sqrt(delta))/2/
   (sqr(a2y-a1y)+
   sqr(a2x-a1x));
   cx:=xI-lambda*(a2y-a1y);
   cy:=yI+lambda*(a2x-a1x);
  if (a2x=cx) then
  if (a2y>cy) then theta2:=Pi/2 else theta2:=-Pi/2
  else begin
  theta2:=arctan((a2y-cy)/(a2x-cx));
  if (a2x<cx) then theta2:=theta2+Pi;
  end;


  if (a1x=cx) then
  if (a1y>cy) then theta1:=Pi/2 else theta1:=-Pi/2
  else begin
  theta1:=arctan((a1y-cy)/(a1x-cx));
  if (a1x<cx) then theta1:=theta1+Pi;
  end;

  if theta1<0 then theta1:=theta1+Pi*2;
  if theta1>2*Pi then theta1:=theta1-Pi*2;
    if theta1>theta2 then theta2:=theta2+2*Pi;
    if theta1>theta2 then theta2:=theta2+2*Pi;
   taille:=abs(rayoncourbure*(theta2-theta1));
 if  ((taille<form1.taillemini) or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax) or (trou and (diametretrou>abs(theta2-theta1)))) then
 begin
 create2:=false;
 exit;
 end;
 create2:=true;
  modifie:=true;
  if not(trou) then begin
 theta1p:=theta1;
 theta2p:=theta2;
 end else begin
 theta1p:=(theta1+theta2)/2-diametretrou/2;
 theta2p:=(theta1+theta2)/2+diametretrou/2;
 end;
 sx:=cx+rayoncourbure*cos((theta1+theta2)/2);
 sy:=cy+rayoncourbure*sin((theta1+theta2)/2);
 circonference:=abs(rayoncourbure*(theta2-theta1));

  monmax_x:=cx+rayoncourbure*cos(theta1);
 monmax_y:=cy+rayoncourbure*sin(theta1);
  monmin_x:=monmax_x; monmin_y:=monmax_y;
  for jj:=1 to 200 do begin
  if trou then begin
  monmax_x:=maximum(cx+rayoncourbure*cos(theta1+(theta1p-theta1)*jj/200),monmax_x);
  monmin_x:=minimum(cx+rayoncourbure*cos(theta1+(theta1p-theta1)*jj/200),monmin_x);
  monmax_y:=maximum(cy+rayoncourbure*sin(theta1+(theta1p-theta1)*jj/200),monmax_y);
  monmin_y:=minimum(cy+rayoncourbure*sin(theta1+(theta1p-theta1)*jj/200),monmin_y);
  monmax_x:=maximum(cx+rayoncourbure*cos(theta2p+(theta2-theta2p)*jj/200),monmax_x);
  monmin_x:=minimum(cx+rayoncourbure*cos(theta2p+(theta2-theta2p)*jj/200),monmin_x);
  monmax_y:=maximum(cy+rayoncourbure*sin(theta2p+(theta2-theta2p)*jj/200),monmax_y);
  monmin_y:=minimum(cy+rayoncourbure*sin(theta2p+(theta2-theta2p)*jj/200),monmin_y);
  end else begin
   monmax_x:=maximum(cx+rayoncourbure*cos(theta1+(theta2-theta1)*jj/200),monmax_x);
  monmin_x:=minimum(cx+rayoncourbure*cos(theta1+(theta2-theta1)*jj/200),monmin_x);
  monmax_y:=maximum(cy+rayoncourbure*sin(theta1+(theta2-theta1)*jj/200),monmax_y);
  monmin_y:=minimum(cy+rayoncourbure*sin(theta1+(theta2-theta1)*jj/200),monmin_y);
  end;
  end;
  if ((monmin_x<xxmin) or (monmax_x>xxmax) or (monmin_y<yymin) or
 (monmax_y>yymax) ) then
 begin
 create2:=false;
 exit;
 end;
 end;



 function Mscere.create(_a1x,_a1y,_a2x,_a2y,_cx,_cy:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_trou:boolean; _diametretrou:extended):boolean;
 var i:integer;
  monmax_x,monmax_y,monmin_x,monmin_y:extended;
 jj:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y; cx:=_cx; cy:=_cy;
 rayoncourbure:=sqrt((cx-a1x)*(cx-a1x)+(cy-a1y)*(cy-a1y));
 epaisseur:=_epaisseur; couleur:=_couleur; hachures:=_hachures;
 axefocal:=_axefocal;   couleuraxe:=_couleuraxe;
  trou:=_trou; diametretrou:=_diametretrou;
   if not(trou) then diametretrou:=0;
  if (a2x=cx) then
  if (a2y>cy) then theta2:=Pi/2 else theta2:=-Pi/2
  else begin
  theta2:=arctan((a2y-cy)/(a2x-cx));
  if (a2x<cx) then theta2:=theta2+Pi;
  end;


  if (a1x=cx) then
  if (a1y>cy) then theta1:=Pi/2 else theta1:=-Pi/2
  else begin
  theta1:=arctan((a1y-cy)/(a1x-cx));
  if (a1x<cx) then theta1:=theta1+Pi;
  end;

  if theta1<0 then theta1:=theta1+Pi*2;
  if theta1>2*Pi then theta1:=theta1-Pi*2;
    if theta1>theta2 then theta2:=theta2+2*Pi;
    if theta1>theta2 then theta2:=theta2+2*Pi;
    if (theta2-theta1<=Pi) then aigu:=true else aigu:=false;
   taille:=abs(rayoncourbure*(theta2-theta1));
 if  ((taille<form1.taillemini) or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax) or (trou and (diametretrou>abs(theta2-theta1)))) then
 begin
 create:=false;
 exit;
 end;
 create:=true;
  modifie:=true;
 sx:=cx+rayoncourbure*cos((theta1+theta2)/2);
 sy:=cy+rayoncourbure*sin((theta1+theta2)/2);
 circonference:=abs(rayoncourbure*(theta2-theta1));
  if not(trou) then begin
 theta1p:=theta1;
 theta2p:=theta2;
 end else begin
 theta1p:=(theta1+theta2)/2-diametretrou/2;
 theta2p:=(theta1+theta2)/2+diametretrou/2;
 end;
  monmax_x:=cx+rayoncourbure*cos(theta1);
 monmax_y:=cy+rayoncourbure*sin(theta1);
  monmin_x:=monmax_x; monmin_y:=monmax_y;
 for jj:=1 to 200 do begin
  if trou then begin
  monmax_x:=maximum(cx+rayoncourbure*cos(theta1+(theta1p-theta1)*jj/200),monmax_x);
  monmin_x:=minimum(cx+rayoncourbure*cos(theta1+(theta1p-theta1)*jj/200),monmin_x);
  monmax_y:=maximum(cy+rayoncourbure*sin(theta1+(theta1p-theta1)*jj/200),monmax_y);
  monmin_y:=minimum(cy+rayoncourbure*sin(theta1+(theta1p-theta1)*jj/200),monmin_y);
  monmax_x:=maximum(cx+rayoncourbure*cos(theta2p+(theta2-theta2p)*jj/200),monmax_x);
  monmin_x:=minimum(cx+rayoncourbure*cos(theta2p+(theta2-theta2p)*jj/200),monmin_x);
  monmax_y:=maximum(cy+rayoncourbure*sin(theta2p+(theta2-theta2p)*jj/200),monmax_y);
  monmin_y:=minimum(cy+rayoncourbure*sin(theta2p+(theta2-theta2p)*jj/200),monmin_y);
  end else begin
   monmax_x:=maximum(cx+rayoncourbure*cos(theta1+(theta2-theta1)*jj/200),monmax_x);
  monmin_x:=minimum(cx+rayoncourbure*cos(theta1+(theta2-theta1)*jj/200),monmin_x);
  monmax_y:=maximum(cy+rayoncourbure*sin(theta1+(theta2-theta1)*jj/200),monmax_y);
  monmin_y:=minimum(cy+rayoncourbure*sin(theta1+(theta2-theta1)*jj/200),monmin_y);
  end;
  end;
  if ((monmin_x<xxmin) or (monmax_x>xxmax) or (monmin_y<yymin) or
 (monmax_y>yymax) ) then
 begin
 create:=false;
 exit;
 end;
 end;

 function Mscere.create2(_a1x,_a1y,_a2x,_a2y,_rayon:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_aigu,_trou:boolean; _diametretrou:extended):boolean;
 var i:integer; delta,lambda,xI,yI:extended;
  monmax_x,monmax_y,monmin_x,monmin_y:extended;
 jj:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
 epaisseur:=_epaisseur; couleur:=_couleur; hachures:=_hachures; aigu:=_aigu;
 axefocal:=_axefocal;   couleuraxe:=_couleuraxe;  rayoncourbure:=_rayon;
  trou:=_trou; diametretrou:=_diametretrou;
   if not(trou) then diametretrou:=0;
   xI:=(a1x+a2x)/2; yI:=(a1y+a2y)/2;
   delta:=4*sqr((a1x-xI)*(a2y-a1y)+(yI-a1y)*(a2x-a1x))-4*(sqr(a2y-a1y)+
   sqr(a2x-a1x))*(sqr(xI-a1x)+sqr(yI-a1y)-sqr(rayoncourbure));
   if ((delta<0) or ((a1x=a2x) and (a1y=a2y))) then begin
   create2:=false;
   exit;
   end;
  if aigu then lambda:=(-2*((a1x-xI)*(a2y-a1y)+(yI-a1y)*(a2x-a1x))+sqrt(delta))/2/
   (sqr(a2y-a1y)+
   sqr(a2x-a1x))else
   lambda:=(-2*((a1x-xI)*(a2y-a1y)+(yI-a1y)*(a2x-a1x))-sqrt(delta))/2/
   (sqr(a2y-a1y)+
   sqr(a2x-a1x));
   cx:=xI-lambda*(a2y-a1y);
   cy:=yI+lambda*(a2x-a1x);
  if (a2x=cx) then
  if (a2y>cy) then theta2:=Pi/2 else theta2:=-Pi/2
  else begin
  theta2:=arctan((a2y-cy)/(a2x-cx));
  if (a2x<cx) then theta2:=theta2+Pi;
  end;


  if (a1x=cx) then
  if (a1y>cy) then theta1:=Pi/2 else theta1:=-Pi/2
  else begin
  theta1:=arctan((a1y-cy)/(a1x-cx));
  if (a1x<cx) then theta1:=theta1+Pi;
  end;

  if theta1<0 then theta1:=theta1+Pi*2;
  if theta1>2*Pi then theta1:=theta1-Pi*2;
    if theta1>theta2 then theta2:=theta2+2*Pi;
    if theta1>theta2 then theta2:=theta2+2*Pi;
   taille:=abs(rayoncourbure*(theta2-theta1));
 if  ((taille<form1.taillemini) or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax) or (trou and (diametretrou>abs(theta2-theta1)))) then
 begin
 create2:=false;
 exit;
 end;
 create2:=true;
  modifie:=true;
  if not(trou) then begin
 theta1p:=theta1;
 theta2p:=theta2;
 end else begin
 theta1p:=(theta1+theta2)/2-diametretrou/2;
 theta2p:=(theta1+theta2)/2+diametretrou/2;
 end;
 sx:=cx+rayoncourbure*cos((theta1+theta2)/2);
 sy:=cy+rayoncourbure*sin((theta1+theta2)/2);
 circonference:=abs(rayoncourbure*(theta2-theta1));
  monmax_x:=cx+rayoncourbure*cos(theta1);
 monmax_y:=cy+rayoncourbure*sin(theta1);
  monmin_x:=monmax_x; monmin_y:=monmax_y;
  for jj:=1 to 200 do begin
  if trou then begin
  monmax_x:=maximum(cx+rayoncourbure*cos(theta1+(theta1p-theta1)*jj/200),monmax_x);
  monmin_x:=minimum(cx+rayoncourbure*cos(theta1+(theta1p-theta1)*jj/200),monmin_x);
  monmax_y:=maximum(cy+rayoncourbure*sin(theta1+(theta1p-theta1)*jj/200),monmax_y);
  monmin_y:=minimum(cy+rayoncourbure*sin(theta1+(theta1p-theta1)*jj/200),monmin_y);
  monmax_x:=maximum(cx+rayoncourbure*cos(theta2p+(theta2-theta2p)*jj/200),monmax_x);
  monmin_x:=minimum(cx+rayoncourbure*cos(theta2p+(theta2-theta2p)*jj/200),monmin_x);
  monmax_y:=maximum(cy+rayoncourbure*sin(theta2p+(theta2-theta2p)*jj/200),monmax_y);
  monmin_y:=minimum(cy+rayoncourbure*sin(theta2p+(theta2-theta2p)*jj/200),monmin_y);
  end else begin
   monmax_x:=maximum(cx+rayoncourbure*cos(theta1+(theta2-theta1)*jj/200),monmax_x);
  monmin_x:=minimum(cx+rayoncourbure*cos(theta1+(theta2-theta1)*jj/200),monmin_x);
  monmax_y:=maximum(cy+rayoncourbure*sin(theta1+(theta2-theta1)*jj/200),monmax_y);
  monmin_y:=minimum(cy+rayoncourbure*sin(theta1+(theta2-theta1)*jj/200),monmin_y);
  end;
  end;
  if ((monmin_x<xxmin) or (monmax_x>xxmax) or (monmin_y<yymin) or
 (monmax_y>yymax) ) then
 begin
 create2:=false;
 exit;
 end;
 end;

 procedure echange(var a,b:extended);
 var c:extended;
 begin
 c:=a;
 a:=b;
 b:=c;
 end;




 function lec.create(_s1x,_s1y,_s2x,_s2y,_r1,_r2,_diametre:extended;
  _couleurfond,_couleuraxe:tcolor; _axefocal:boolean;
  _indicerouge,_indicebleu,_indicevert:extended;
 _ReflechiEntrant,_ReflechiSortant:TReflechiPolyhedre):boolean;
  var phi1,phi2,C1C2,S1S2,delta:extended;
  begin

  r1:=_r1; r2:=_r2;  s1x:=_s1x; s1y:=_s1y; s2x:=_s2x; s2y:=_s2y;
  ox:=(s1x+s2x)/2; oy:=(s1y+s2y)/2;
 indicerouge:=_indicerouge;
 indicebleu:=_indicebleu;
 indicevert:=_indicevert;
 ReflechiEntrant:=_ReflechiEntrant;
 ReflechiSortant:=_ReflechiSortant;
 couleurfond:=_couleurfond;
 create:=true;
 axefocal:=_axefocal;   couleuraxe:=_couleuraxe;  diametre:=_diametre;

 if ((s1x=s2x) and (s1y=s2y)) then  begin
  create:=false;
  exit;
  end;

  if ((r1=0) or (r2=0)) then begin
  create:=false;
  exit;
  end;



  S1S2:=sqrt(sqr(s2x-s1x)+sqr(s2y-s1y));
   apaf:=donneanglepolairedans02pi(s2x-s1x,s2y-s1y);
  c1x:=s1x-r1*cos(apaf);
  c1y:=s1y-r1*sin(apaf);
  c2x:=s2x-r2*cos(apaf);
  c2y:=s2y-r2*sin(apaf);
  C1C2:=sqrt(sqr(c2x-c1x)+sqr(c2y-c1y));

  {determine si elle est a bord mince ou epais}

  delta:=16*sqr(r2)*sqr(C1C2)-4*sqr(sqr(C1C2)+sqr(r2)-sqr(r1));
  mince:=(delta>0) and (sqr(C1C2)+sqr(r2)-sqr(r1)-2*abs(r2)*(c2x-c1x)<>0);



  if (not(mince) and ((diametre>2*abs(r1)) or (diametre>2*abs(r2)))) then
  diametre:=minimum(abs(r2),abs(r1))*2*0.999;


  if ((diametre<form1.taillemini) or (s1x<xxmin) or (s1x>xxmax) or (s1y<yymin) or
 (s1y>yymax) or (s2x<xxmin) or (s2x>xxmax) or (s2y<yymin) or
 (s2y>yymax)) then
 begin
 create:=false;
 exit;
 end;



  {if mince then begin

 if r1*r2>0 then phi1:=arccos((sqr(C1C2)+sqr(r1)-sqr(r2))/2/C1C2/abs(r1)) else
        phi1:=arccos(-(sqr(C1C2)+sqr(r1)-sqr(r2))/2/C1C2/abs(r1));
    diametremax:=2*abs(r1*sin(phi1));

  if r1*r2>0 then phi2:=arccos(-(sqr(C1C2)+sqr(r2)-sqr(r1))/2/C1C2/abs(r2)) else
      phi2:=arccos((sqr(C1C2)+sqr(r2)-sqr(r1))/2/C1C2/abs(r2));

   end;}

  if mince then begin
  if (sqr(C1C2)+sqr(r2)-sqr(r1)-2*abs(r2)*(c2x-c1x))>0 then begin
   theta1_2:=2*arctan( (-4*abs(r2)*(c2y-c1y)-sqrt(delta))/2/(sqr(C1C2)+sqr(r2)-sqr(r1)-2*abs(r2)*(c2x-c1x)));
  theta2_2:=2*arctan( (-4*abs(r2)*(c2y-c1y)+sqrt(delta))/
   2/(sqr(C1C2)+sqr(r2)-sqr(r1)-2*abs(r2)*(c2x-c1x))) end else  begin
   theta1_2:=2*arctan( (-4*abs(r2)*(c2y-c1y)+sqrt(delta))/2/(sqr(C1C2)+sqr(r2)-sqr(r1)-2*abs(r2)*(c2x-c1x)));
  theta2_2:=2*arctan( (-4*abs(r2)*(c2y-c1y)-sqrt(delta))/
   2/(sqr(C1C2)+sqr(r2)-sqr(r1)-2*abs(r2)*(c2x-c1x))); end;
     if theta1_2<0 then theta1_2:=theta1_2+2*pi;
      if theta2_2<0 then theta2_2:=theta2_2+2*pi;
      if theta1_2>theta2_2 then echange(theta1_2,theta2_2);

     if ( (abs((theta1_2+theta2_2)/2-apaf)<=abs(apaf*1e-10)) and (r2<0)) or
        (  (abs((theta1_2+theta2_2)/2-apaf)>abs(apaf*1e-10)) and (r2>0))
      then   begin
     echange(theta1_2,theta2_2);
      theta2_2:=theta2_2+2*pi;
               end;



   delta:=16*sqr(r1)*sqr(C1C2)-4*sqr(sqr(C1C2)+sqr(r1)-sqr(r2));
   if (sqr(C1C2)+sqr(r1)-sqr(r2)-2*abs(r1)*(c1x-c2x))>0 then begin
  theta1_1:=2*arctan( (-4*abs(r1)*(c1y-c2y)-sqrt(delta))/
   2/(sqr(C1C2)+sqr(r1)-sqr(r2)-2*abs(r1)*(c1x-c2x)));
    theta2_1:=2*arctan( (-4*abs(r1)*(c1y-c2y)+sqrt(delta))/
   2/(sqr(C1C2)+sqr(r1)-sqr(r2)-2*abs(r1)*(c1x-c2x))); end else begin
   theta1_1:=2*arctan( (-4*abs(r1)*(c1y-c2y)+sqrt(delta))/
   2/(sqr(C1C2)+sqr(r1)-sqr(r2)-2*abs(r1)*(c1x-c2x)));
    theta2_1:=2*arctan( (-4*abs(r1)*(c1y-c2y)-sqrt(delta))/
   2/(sqr(C1C2)+sqr(r1)-sqr(r2)-2*abs(r1)*(c1x-c2x))); end;

   if theta1_1<0 then theta1_1:=theta1_1+2*pi;
      if theta2_1<0 then theta2_1:=theta2_1+2*pi;
      if theta1_1>theta2_1 then echange(theta1_1,theta2_1);

    if ( (abs((theta1_1+theta2_1)/2-apaf)<=abs(apaf*1e-10)) and (r1<0)) or
        (  (abs((theta1_1+theta2_1)/2-apaf)>abs(apaf*1e-10)) and (r1>0))
      then    begin
     echange(theta1_1,theta2_1);
        theta2_1:=theta2_1+2*pi;
               end;
    diametremax:=abs(r1)*sqrt(sqr(cos(theta2_1)-cos(theta1_1))+sqr(sin(theta2_1)-sin(theta1_1)));
  end;



if mince then
if (
( (r1<0) and (diametre>diametremax) and (cos(theta1_1-apaf)>0))
or
 ( (r1>0) and (diametre>diametremax) and (cos(theta1_1-apaf)<0))
 or
 ( (r2<0) and (diametre>diametremax) and (cos(theta1_2-apaf)>0))
or
 ( (r2>0) and (diametre>diametremax) and (cos(theta1_2-apaf)<0))
 )
 then begin
create:=false;
exit;
end;


  if mince then
    tronque:=(diametre<diametremax)
   else tronque:=true;


     a1x:=c1x+abs(r1)*cos(theta2_1);
  a1y:=c1y+abs(r1)*sin(theta2_1);
  b1x:=c1x+abs(r1)*cos(theta1_1);
  b1y:=c1y+abs(r1)*sin(theta1_1);


     if r1*r2>0 then begin
  a2x:=c2x+abs(r2)*cos(theta2_2);
  a2y:=c2y+abs(r2)*sin(theta2_2);
  b2x:=c2x+abs(r2)*cos(theta1_2);
  b2y:=c2y+abs(r2)*sin(theta1_2);
    end else begin
   a2x:=c2x+abs(r2)*cos(theta1_2);
  a2y:=c2y+abs(r2)*sin(theta1_2);
  b2x:=c2x+abs(r2)*cos(theta2_2);
  b2y:=c2y+abs(r2)*sin(theta2_2);
    end;


  if mince and not(tronque) then begin
  if (r2>0) and (r1<0) then begin
  phi2:=arccos((sqr(r1)-sqr(r2)-sqr(C1C2))/2/abs(r2)/(-C1C2));
  phi1:=pi-arcsin(abs(r2)*sin(phi2)/abs(r1));
   end;
  if (r2>0) and (r1>0) then begin
  phi2:=arccos((sqr(r1)-sqr(r2)-sqr(C1C2))/2/abs(r2)/(C1C2));
  phi1:=arcsin(abs(r2)*sin(phi2)/abs(r1));
   end;
 if (r2<0) and (r1<0) then begin
  phi2:=arccos((sqr(r1)-sqr(r2)-sqr(C1C2))/2/abs(r2)/(C1C2));
  phi1:=pi-arcsin(abs(r2)*sin(phi2)/abs(r1));
   end;
    theta1[1]:=apaf-phi1;
    theta2[1]:=apaf+phi1;
    theta1[2]:=apaf+phi2;
    theta2[2]:=apaf-phi2;
    MesSommets[1].ax:=c1x+abs(r1)*cos(theta1[1]);
    MesSommets[1].ay:=c1y+abs(r1)*sin(theta1[1]);
     MesSommets[2].ax:=c1x+abs(r1)*cos(theta2[1]);
    MesSommets[2].ay:=c1y+abs(r1)*sin(theta2[1]);
    MesSommets[3].ax:=c1x+abs(r1)*cos(theta1[1]);
    MesSommets[3].ay:=c1y+abs(r1)*sin(theta1[1]);

     MesCentres[1].ax:=c1x;
      MesCentres[1].ay:=c1y;
       MesCentres[2].ax:=c2x;
      MesCentres[2].ay:=c2y;
      rectiligne[1]:=false;
  rectiligne[2]:=false;

  rentrant[1]:=(r1>0);
  rentrant[2]:=(r2<0);
      trig[1]:=(r1>0);
      trig[2]:=(r2<0);

  end;


  if tronque then begin
  if r1>0 then
    phi1:=arcsin(diametre/2/abs(r1))
    else
    phi1:=pi-arcsin(diametre/2/abs(r1));
   if r2>0 then
    phi2:=arcsin(diametre/2/abs(r2))
    else
    phi2:=pi-arcsin(diametre/2/abs(r2));


    theta1[1]:=apaf-phi1;
    theta2[1]:=apaf+phi1;
    theta1[3]:=apaf+phi2;
    theta2[3]:=apaf-phi2;
    MesSommets[1].ax:=c1x+abs(r1)*cos(theta1[1]);
    MesSommets[1].ay:=c1y+abs(r1)*sin(theta1[1]);
     MesSommets[2].ax:=c1x+abs(r1)*cos(theta2[1]);
    MesSommets[2].ay:=c1y+abs(r1)*sin(theta2[1]);
    MesSommets[3].ax:=c2x+abs(r2)*cos(theta1[3]);
    MesSommets[3].ay:=c2y+abs(r2)*sin(theta1[3]);
     MesSommets[4].ax:=c2x+abs(r2)*cos(theta2[3]);
    MesSommets[4].ay:=c2y+abs(r2)*sin(theta2[3]);
    MesSommets[5].ax:=c1x+abs(r1)*cos(theta1[1]);
    MesSommets[5].ay:=c1y+abs(r1)*sin(theta1[1]);
     MesCentres[1].ax:=c1x;
      MesCentres[1].ay:=c1y;
       MesCentres[3].ax:=c2x;
      MesCentres[3].ay:=c2y;
      rectiligne[1]:=false;
  rectiligne[2]:=true;
  rectiligne[3]:=false;
  rectiligne[4]:=true;
  rentrant[1]:=(r1>0);
  rentrant[3]:=(r2<0);

      trig[1]:=(r1>0);
      trig[2]:=false;
      trig[3]:=(r2<0);
      trig[4]:=false;
if r1>0 then begin
  theta1_1:=apaf-phi1;
  theta2_1:=apaf+phi1;
  end else begin
 theta1_1:=apaf+phi1;
  theta2_1:=apaf-phi1+2*pi;
  end;

  if r2>0 then begin
  theta1_2:=apaf-phi2;
  theta2_2:=apaf+phi2;
  end else begin
 theta1_2:=apaf+phi2;
  theta2_2:=apaf-phi2+2*pi;
  end;

  if theta1_1<0 then theta1_1:=theta1_1+2*pi;
  if theta1_1>theta2_1  then theta2_1:=theta2_1+2*pi;
  if theta1_1>theta2_1  then theta2_1:=theta2_1+2*pi;

   if theta1_2<0 then theta1_2:=theta1_2+2*pi;
  if theta1_2>theta2_2  then theta2_2:=theta2_2+2*pi;
  if theta1_2>theta2_2  then theta2_2:=theta2_2+2*pi;



  a1x:=c1x+abs(r1)*cos(theta2_1);
  a1y:=c1y+abs(r1)*sin(theta2_1);
  b1x:=c1x+abs(r1)*cos(theta1_1);
  b1y:=c1y+abs(r1)*sin(theta1_1);


     if r1*r2>0 then begin
  a2x:=c2x+abs(r2)*cos(theta2_2);
  a2y:=c2y+abs(r2)*sin(theta2_2);
  b2x:=c2x+abs(r2)*cos(theta1_2);
  b2y:=c2y+abs(r2)*sin(theta1_2);
    end else begin
   a2x:=c2x+abs(r2)*cos(theta1_2);
  a2y:=c2y+abs(r2)*sin(theta1_2);
  b2x:=c2x+abs(r2)*cos(theta2_2);
  b2y:=c2y+abs(r2)*sin(theta2_2);
    end;
 if ((a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax)   or (b1x<xxmin) or (b1x>xxmax) or (b1y<yymin) or
 (b1y>yymax) or (b2x<xxmin) or (b2x>xxmax) or (b2y<yymin) or
 (b2y>yymax) ) then
 begin
 create:=false;
 exit;
 end;
  end;

   modifie:=true;
  end;

  procedure lec.dessine(mc:tmonbitmap);
  var ap1x,ap1y,bp1x,bp1y,ap2x,ap2y,bp2x,bp2y,I1S1,I2S2,i1x,i1y,i2x,i2y:extended;
  fx1,fy1,fx2,fy2,r1x,r1y,r2x,r2y:longint;
  titi:array[1..4] of tpoint;
  old_pencolor:tcolor;
old_penmode:tpenmode;
 old_penstyle:tpenstyle;
 old_penwidth:integer;
 old_brushcolor:tcolor;
 old_brushstyle:tbrushstyle; lx,ly:array of extended;
  label 125;
  begin

    old_pencolor:=form1.image1.Picture.Bitmap.Canvas.Pen.Color;
old_penmode:=form1.image1.Picture.Bitmap.Canvas.Pen.Mode;
 old_penstyle:=form1.image1.Picture.Bitmap.Canvas.Pen.Style;
 old_penwidth:=form1.image1.Picture.Bitmap.Canvas.Pen.Width;
 old_brushcolor:=form1.image1.Picture.Bitmap.Canvas.Brush.Color;
 old_brushstyle:=form1.image1.Picture.Bitmap.Canvas.Brush.Style;

 setlength(lx,4); setlength(ly,4);
 lx[0]:=a1x; lx[1]:=a2x; lx[2]:=b2x; lx[3]:=b1x;
 ly[0]:=a1y; ly[1]:=a2y; ly[2]:=b2y; ly[3]:=b1y;
  if not(tronque) then begin
  if ((r1<0) and (r2>0)) then begin
  form1.Image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond;
   form1.Image1.Picture.Bitmap.Canvas.pen.Color:=couleurfond;
    form1.Image1.Picture.Bitmap.Canvas.Brush.Style:=bssolid;
    form1.Image1.Picture.Bitmap.Canvas.pen.Mode:=pmcopy;
    mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
     mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
     mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
     mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);
    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
    mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
     mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
     mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
     mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
  end;

  if ((r1>0) and (r2>0)) then begin
  form1.Image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond;
   form1.Image1.Picture.Bitmap.Canvas.pen.Color:=couleurfond;
    form1.Image1.Picture.Bitmap.Canvas.Brush.Style:=bssolid;
    form1.Image1.Picture.Bitmap.Canvas.pen.Mode:=pmcopy;
    mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
     mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
     mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
     mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
    form1.Image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond xor couleurfondsimulation;
   form1.Image1.Picture.Bitmap.Canvas.pen.Color:=couleurfond xor couleurfondsimulation; ;
    form1.Image1.Picture.Bitmap.Canvas.Brush.Style:=bssolid;
    form1.Image1.Picture.Bitmap.Canvas.pen.Mode:=pmxor;
    mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
     mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
     mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
     mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);
    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

  end;

  if ((r1<0) and (r2<0)) then begin
  form1.Image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond;
   form1.Image1.Picture.Bitmap.Canvas.pen.Color:=couleurfond;
    form1.Image1.Picture.Bitmap.Canvas.Brush.Style:=bssolid;
    form1.Image1.Picture.Bitmap.Canvas.pen.Mode:=pmcopy;
     mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
     mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
     mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
     mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);

    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
    form1.Image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond xor couleurfondsimulation;
   form1.Image1.Picture.Bitmap.Canvas.pen.Color:=couleurfond xor couleurfondsimulation; ;
    form1.Image1.Picture.Bitmap.Canvas.Brush.Style:=bssolid;
    form1.Image1.Picture.Bitmap.Canvas.pen.Mode:=pmxor;
    mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
     mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
     mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
     mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

  end;

     end;

  if tronque then begin

   if ((r1>0) and (r2>0)) then begin
  form1.Image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond;
   form1.Image1.Picture.Bitmap.Canvas.pen.Color:=couleurfond;
    form1.Image1.Picture.Bitmap.Canvas.Brush.Style:=bssolid;
    form1.Image1.Picture.Bitmap.Canvas.pen.Mode:=pmcopy;
    mc.tracepolygone(4,lx,ly,couleurfond,couleurfond,false,pmcopy,true);
    mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
     mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
     mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
     mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
    form1.Image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond xor couleurfondsimulation;
   form1.Image1.Picture.Bitmap.Canvas.pen.Color:=couleurfond xor couleurfondsimulation; ;
    form1.Image1.Picture.Bitmap.Canvas.Brush.Style:=bssolid;
    form1.Image1.Picture.Bitmap.Canvas.pen.Mode:=pmxor;
    mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
     mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
     mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
     mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);
    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

  end;

 if ((r1<0) and (r2>0)) then begin
  form1.Image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond;
   form1.Image1.Picture.Bitmap.Canvas.pen.Color:=couleurfond;
    form1.Image1.Picture.Bitmap.Canvas.Brush.Style:=bssolid;
    form1.Image1.Picture.Bitmap.Canvas.pen.Mode:=pmcopy;
    mc.tracepolygone(4,lx,ly,couleurfond,couleurfond,false,pmcopy,true);
    mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
     mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
     mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
     mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
    mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
     mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
     mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
     mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);
    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

  end;

 if ((r1>0) and (r2<0)) then begin
  form1.Image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond;
   form1.Image1.Picture.Bitmap.Canvas.pen.Color:=couleurfond;
    form1.Image1.Picture.Bitmap.Canvas.Brush.Style:=bssolid;
    form1.Image1.Picture.Bitmap.Canvas.pen.Mode:=pmcopy;
    mc.tracepolygone(4,lx,ly,couleurfond,couleurfond,false,pmcopy,true);
     form1.Image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond xor couleurfondsimulation;
   form1.Image1.Picture.Bitmap.Canvas.pen.Color:=couleurfond xor couleurfondsimulation; ;
    form1.Image1.Picture.Bitmap.Canvas.Brush.Style:=bssolid;
    form1.Image1.Picture.Bitmap.Canvas.pen.Mode:=pmxor;
    mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
     mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
     mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
     mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

    mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
     mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
     mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
     mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);
    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

  end;


 if ((r1<0) and (r2<0)) then begin
  form1.Image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond;
   form1.Image1.Picture.Bitmap.Canvas.pen.Color:=couleurfond;
    form1.Image1.Picture.Bitmap.Canvas.Brush.Style:=bssolid;
    form1.Image1.Picture.Bitmap.Canvas.pen.Mode:=pmcopy;
    mc.tracepolygone(4,lx,ly,couleurfond,couleurfond,false,pmcopy,true);
    mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
     mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
     mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
     mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);

    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
    form1.Image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond xor couleurfondsimulation;
   form1.Image1.Picture.Bitmap.Canvas.pen.Color:=couleurfond xor couleurfondsimulation; ;
    form1.Image1.Picture.Bitmap.Canvas.Brush.Style:=bssolid;
    form1.Image1.Picture.Bitmap.Canvas.pen.Mode:=pmxor;
      mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
     mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
     mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
     mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
    form1.Image1.Picture.Bitmap.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

  end;
  end;

    form1.image1.Picture.Bitmap.Canvas.Pen.Color:=old_pencolor;
form1.image1.Picture.Bitmap.Canvas.Pen.Mode:=old_penmode;
 form1.image1.Picture.Bitmap.Canvas.Pen.Style:=old_penstyle;
 form1.image1.Picture.Bitmap.Canvas.Pen.Width:=old_penwidth;
 form1.image1.Picture.Bitmap.Canvas.Brush.Color:=old_brushcolor;
 form1.image1.Picture.Bitmap.Canvas.Brush.Style:=old_brushstyle;



if not(   mc.arcdecercle(c1x,c1y,abs(r1),1,theta1_1,theta2_1,clblack,pmcopy,pssolid,true)) then
mc.trait(a1x,a1y,b1x,b1y,1,clblack,pssolid,pmcopy,true);
if not(  mc.arcdecercle(c2x,c2y,abs(r2),1,theta1_2,theta2_2,clblack,pmcopy,pssolid,true)) then
mc.trait(a2x,a2y,b2x,b2y,1,clblack,pssolid,pmcopy,true);
if tronque then begin
    mc.trait(a1x,a1y,a2x,a2y,1,clblack,pssolid,pmcopy,true);
     mc.trait(b1x,b1y,b2x,b2y,1,clblack,pssolid,pmcopy,true);
     end;
  if axefocal then mc.trait(c1x,c1y,c2x,c2y,1,couleuraxe,psdashdot,pmcopy,true);

  if axefocal then mc.trait(s1x,s1y,s2x,s2y,1,couleuraxe,psdashdot,pmcopy,true);
  if ((modeinfo or modemodif) and not(modeduplication)) then begin
  if modemodif then
mc.croixx(ox,oy,3,
2,couleurtrans,pmcopy,true) else
  mc.cercle(ox,oy,3,1,couleurpoignees,pmcopy,true);
  mc.cercle(s1x,s1y,3,1,couleurpoignees,pmcopy,true);
  mc.cercle(s2x,s2y,3,1,couleurpoignees,pmcopy,true);
  end;

  if modeduplication then
  mc.cercle(ox,oy,3,1,couleurpoignees,pmcopy,true);
  if modesuppression then      begin
  mc.cercle(ox,oy,3,1,couleursuppression,pmcopy,true);
    mc.cercle(s1x,s1y,3,1,couleursuppression,pmcopy,true);
     mc.cercle(s2x,s2y,3,1,couleursuppression,pmcopy,true);
     end;
     if modegroupement then
mc.croixx(ox,oy,3,
2,clpurple,pmcopy,true);
  end;




   procedure lec.dessinePS(mc:tmonpostscript);
  var ap1x,ap1y,bp1x,bp1y,ap2x,ap2y,bp2x,bp2y,I1S1,I2S2,i1x,i1y,i2x,i2y:extended;
  fx1,fy1,fx2,fy2,r1x,r1y,r2x,r2y:longint;
  titi:array[1..4] of tpoint;
  old_pencolor:tcolor;
old_penmode:tpenmode;
 old_penstyle:tpenstyle;
 old_penwidth:integer;
 old_brushcolor:tcolor;
 old_brushstyle:tbrushstyle; lx,ly:array of extended;

  label 125;
  begin

    old_pencolor:=ps.Pen.Color;
old_penmode:=ps.Pen.Mode;
 old_penstyle:=ps.Pen.Style;
 old_penwidth:=ps.Pen.Width;
 old_brushcolor:=ps.Brush.Color;
 old_brushstyle:=ps.Brush.Style;

 if tronque then begin


 mc.tracepolycercle(MesSommets,4, MesCentres,
 rectiligne,rentrant,theta1,theta2,couleurfond,clblack,trig);
  mc.trait(a1x,a1y,a2x,a2y,1,clblack,pssolid,pmcopy,true);
     mc.trait(b1x,b1y,b2x,b2y,1,clblack,pssolid,pmcopy,true);
   mc.arcdecercle(c1x,c1y,abs(r1),1,theta1_1,theta2_1,clblack,pmcopy,pssolid,true);
mc.arcdecercle(c2x,c2y,abs(r2),1,theta1_2,theta2_2,clblack,pmcopy,pssolid,true);
 end else
 begin
 mc.tracepolycercle(MesSommets,2, MesCentres,
 rectiligne,rentrant,theta1,theta2,couleurfond,clblack,trig);

   mc.arcdecercle(c1x,c1y,abs(r1),1,theta1_1,theta2_1,clblack,pmcopy,pssolid,true);
mc.arcdecercle(c2x,c2y,abs(r2),1,theta1_2,theta2_2,clblack,pmcopy,pssolid,true);


 end;






  if axefocal then mc.trait(c1x,c1y,c2x,c2y,1,couleuraxe,psdashdot,pmcopy,true);

  if axefocal then mc.trait(s1x,s1y,s2x,s2y,1,couleuraxe,psdashdot,pmcopy,true);
  if ((modeinfo or modemodif) and not(modeduplication)) then begin
  if modemodif then
mc.croixx(ox,oy,3,
2,couleurtrans,pmcopy,true) else
  mc.cercle(ox,oy,3,1,couleurpoignees,pmcopy,true);
  mc.cercle(s1x,s1y,3,1,couleurpoignees,pmcopy,true);
  mc.cercle(s2x,s2y,3,1,couleurpoignees,pmcopy,true);
  end;

  if modeduplication then
  mc.cercle(ox,oy,3,1,couleurpoignees,pmcopy,true);
  if modesuppression then      begin
  mc.cercle(ox,oy,3,1,couleursuppression,pmcopy,true);
    mc.cercle(s1x,s1y,3,1,couleursuppression,pmcopy,true);
     mc.cercle(s2x,s2y,3,1,couleursuppression,pmcopy,true);
     end;
     if modegroupement then
mc.croixx(ox,oy,3,
2,clpurple,pmcopy,true);
  end;






   procedure lec.imprime(mc:tmyimprimante);
  var ap1x,ap1y,bp1x,bp1y,ap2x,ap2y,bp2x,bp2y,I1S1,I2S2,i1x,i1y,i2x,i2y:extended;
  fx1,fy1,fx2,fy2,r1x,r1y,r2x,r2y:longint;
  titi:array[1..4] of tpoint;
 old_pencolor:tcolor;
old_penmode:tpenmode;
 old_penstyle:tpenstyle;
 old_penwidth:integer;
 old_brushcolor:tcolor;
 old_brushstyle:tbrushstyle; lx,ly:array of extended;
  begin

  old_pencolor:=imprimante.Canvas.Pen.Color;
 old_penmode:=imprimante.Canvas.Pen.Mode;
  old_penstyle:=imprimante.Canvas.Pen.Style;
  old_penwidth:=imprimante.Canvas.Pen.Width;
  old_brushcolor:=imprimante.Canvas.Brush.Color;
  old_brushstyle:=imprimante.Canvas.Brush.Style;

  setlength(lx,4); setlength(ly,4);
  lx[0]:=a1x; lx[1]:=a2x; lx[2]:=b2x; lx[3]:=b1x;
  ly[0]:=a1y; ly[1]:=a2y; ly[2]:=b2y; ly[3]:=b1y;
   if not(tronque) then begin
   if ((r1<0) and (r2>0)) then begin
   imprimante.Canvas.Brush.Color:=couleurfond;
    imprimante.Canvas.pen.Color:=couleurfond;
     imprimante.Canvas.Brush.Style:=bssolid;
     imprimante.Canvas.pen.Mode:=pmcopy;
     mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
      mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
      mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
      mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);
     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
     mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
      mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
      mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
      mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
   end;

   if ((r1>0) and (r2>0)) then begin
   imprimante.Canvas.Brush.Color:=couleurfond;
    imprimante.Canvas.pen.Color:=couleurfond;
     imprimante.Canvas.Brush.Style:=bssolid;
     imprimante.Canvas.pen.Mode:=pmcopy;
     mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
      mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
      mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
      mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
     imprimante.Canvas.Brush.Color:=couleurfondsimulation;
    imprimante.Canvas.pen.Color:=couleurfondsimulation; ;
     imprimante.Canvas.Brush.Style:=bssolid;
     imprimante.Canvas.pen.Mode:=pmcopy;
     mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
      mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
      mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
      mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);
     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

   end;

   if ((r1<0) and (r2<0)) then begin
   imprimante.Canvas.Brush.Color:=couleurfond;
    imprimante.Canvas.pen.Color:=couleurfond;
     imprimante.Canvas.Brush.Style:=bssolid;
     imprimante.Canvas.pen.Mode:=pmcopy;
      mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
      mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
      mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
      mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);

     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
     imprimante.Canvas.Brush.Color:=couleurfondsimulation;
    imprimante.Canvas.pen.Color:=couleurfondsimulation; ;
     imprimante.Canvas.Brush.Style:=bssolid;
     imprimante.Canvas.pen.Mode:=pmcopy;
     mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
      mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
      mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
      mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

   end;

      end;

   if tronque then begin

    if ((r1>0) and (r2>0)) then begin
   imprimante.Canvas.Brush.Color:=couleurfond;
    imprimante.Canvas.pen.Color:=couleurfond;
     imprimante.Canvas.Brush.Style:=bssolid;
     imprimante.Canvas.pen.Mode:=pmcopy;
     mc.tracepolygone(4,lx,ly,couleurfond,couleurfond,false,pmcopy,true);
     mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
      mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
      mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
      mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
     imprimante.Canvas.Brush.Color:=couleurfondsimulation;
    imprimante.Canvas.pen.Color:=couleurfondsimulation; ;
     imprimante.Canvas.Brush.Style:=bssolid;
     imprimante.Canvas.pen.Mode:=pmcopy;
     mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
      mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
      mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
      mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);
     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

   end;

  if ((r1<0) and (r2>0)) then begin
   imprimante.Canvas.Brush.Color:=couleurfond;
    imprimante.Canvas.pen.Color:=couleurfond;
     imprimante.Canvas.Brush.Style:=bssolid;
     imprimante.Canvas.pen.Mode:=pmcopy;
     mc.tracepolygone(4,lx,ly,couleurfond,couleurfond,false,pmcopy,true);
     mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
      mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
      mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
      mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
     mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
      mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
      mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
      mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);
     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

   end;

  if ((r1>0) and (r2<0)) then begin
   imprimante.Canvas.Brush.Color:=couleurfond;
    imprimante.Canvas.pen.Color:=couleurfond;
     imprimante.Canvas.Brush.Style:=bssolid;
     imprimante.Canvas.pen.Mode:=pmcopy;
     mc.tracepolygone(4,lx,ly,couleurfond,couleurfond,false,pmcopy,true);
      imprimante.Canvas.Brush.Color:=couleurfondsimulation;
    imprimante.Canvas.pen.Color:=couleurfondsimulation; ;
     imprimante.Canvas.Brush.Style:=bssolid;
     imprimante.Canvas.pen.Mode:=pmcopy;
     mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
      mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
      mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
      mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

     mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
      mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
      mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
      mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);
     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

   end;


  if ((r1<0) and (r2<0)) then begin
   imprimante.Canvas.Brush.Color:=couleurfond;
    imprimante.Canvas.pen.Color:=couleurfond;
     imprimante.Canvas.Brush.Style:=bssolid;
     imprimante.Canvas.pen.Mode:=pmcopy;
     mc.tracepolygone(4,lx,ly,couleurfond,couleurfond,false,pmcopy,true);
     mc.invconvert(r1x,r1y,c1x-abs(r1),c1y+abs(r1),true);
      mc.invconvert(r2x,r2y,c1x+abs(r1),c1y-abs(r1),true);
      mc.invconvert(fx1,fy1,c1x+abs(r1)*cos(theta1_1),c1y+abs(r1)*sin(theta1_1),true);
      mc.invconvert(fx2,fy2,c1x+abs(r1)*cos(theta2_1),c1y+abs(r1)*sin(theta2_1),true);

     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);
     imprimante.Canvas.Brush.Color:=couleurfondsimulation;
    imprimante.Canvas.pen.Color:=couleurfondsimulation; ;
     imprimante.Canvas.Brush.Style:=bssolid;
     imprimante.Canvas.pen.Mode:=pmcopy;
       mc.invconvert(r1x,r1y,c2x-abs(r2),c2y+abs(r2),true);
      mc.invconvert(r2x,r2y,c2x+abs(r2),c2y-abs(r2),true);
      mc.invconvert(fx1,fy1,c2x+abs(r2)*cos(theta1_2),c2y+abs(r2)*sin(theta1_2),true);
      mc.invconvert(fx2,fy2,c2x+abs(r2)*cos(theta2_2),c2y+abs(r2)*sin(theta2_2),true);
     imprimante.Canvas.Chord(r1x,r1y,r2x,r2y,fx1,fy1,fx2,fy2);

   end;
   end;

     imprimante.Canvas.Pen.Color:=old_pencolor;
 imprimante.Canvas.Pen.Mode:=old_penmode;
  imprimante.Canvas.Pen.Style:=old_penstyle;
  imprimante.Canvas.Pen.Width:=old_penwidth;
  imprimante.Canvas.Brush.Color:=old_brushcolor;
  imprimante.Canvas.Brush.Style:=old_brushstyle;

if not(   mc.arcdecercle(c1x,c1y,abs(r1),1,theta1_1,theta2_1,clblack,pmcopy,pssolid,true)) then
mc.trait(a1x,a1y,b1x,b1y,1,clblack,pssolid,pmcopy,true);
if not(  mc.arcdecercle(c2x,c2y,abs(r2),1,theta1_2,theta2_2,clblack,pmcopy,pssolid,true)) then
mc.trait(a2x,a2y,b2x,b2y,1,clblack,pssolid,pmcopy,true);
if tronque then begin
    mc.trait(a1x,a1y,a2x,a2y,1,clblack,pssolid,pmcopy,true);
     mc.trait(b1x,b1y,b2x,b2y,1,clblack,pssolid,pmcopy,true);
     end;
  if axefocal then mc.trait(c1x,c1y,c2x,c2y,1,couleuraxe,psdashdot,pmcopy,true);

  if axefocal then mc.trait(s1x,s1y,s2x,s2y,1,couleuraxe,psdashdot,pmcopy,true);
  if ((modeinfo or modemodif) and not(modeduplication)) then begin
  if modemodif then
mc.croixx(ox,oy,3,
2,couleurtrans,pmcopy,true) else
  mc.cercle(ox,oy,3,1,couleurpoignees,pmcopy,true);
  mc.cercle(s1x,s1y,3,1,couleurpoignees,pmcopy,true);
  mc.cercle(s2x,s2y,3,1,couleurpoignees,pmcopy,true);
  end;

  if modeduplication then
  mc.cercle(ox,oy,3,1,couleurpoignees,pmcopy,true);
  if modesuppression then      begin
  mc.cercle(ox,oy,3,1,couleursuppression,pmcopy,true);
    mc.cercle(s1x,s1y,3,1,couleursuppression,pmcopy,true);
     mc.cercle(s2x,s2y,3,1,couleursuppression,pmcopy,true);
     end;
     if modegroupement then
mc.croixx(ox,oy,3,
2,clpurple,pmcopy,true);
  end;

 function lmc.create(_a1x,_a1y,_a2x,_a2y,_fx,_fy:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _axefocal:boolean):boolean;
   var i:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y; f1x:=_fx; f1y:=_fy;
 ox:=(a1x+a2x)/2; oy:=(a1y+a2y)/2;
 f2x:=2*ox-f1x;  f2y:=2*oy-f1y;
 focale:=sqrt((ox-f1x)*(ox-f1x)+(oy-f1y)*(oy-f1y));
 epaisseur:=_epaisseur; couleur:=_couleur;
 axefocal:=_axefocal;   couleuraxe:=_couleuraxe;
 taille:=sqrt((a2x-a1x)*(a2x-a1x)+(a2y-a1y)*(a2y-a1y));
 rayonmonture:=taille/2;
 if ((taille<form1.taillemini) or (focale<form1.taillemini)or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax)) then
 begin
 create:=false;
 exit;
 end;
 create:=true;
  modifie:=true;
  if (a1x=a2x) then
  if (a2y>a1y) then anglepolaire:=Pi/2 else anglepolaire:=-Pi/2
  else begin
  anglepolaire:=arctan((a2y-a1y)/(a2x-a1x));
  if (a2x<a1x) then anglepolaire:=anglepolaire+Pi;
  end;
  if anglepolaire>Pi then anglepolaire:=anglepolaire-Pi*2;
  normalex:=cos(anglepolaire+Pi/2);
  normaley:=sin(anglepolaire+Pi/2);

 end;

 function lmd.create(_a1x,_a1y,_a2x,_a2y,_fx,_fy:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _axefocal:boolean):boolean;
   var i:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y; f1x:=_fx; f1y:=_fy;
 ox:=(a1x+a2x)/2; oy:=(a1y+a2y)/2;
 f2x:=2*ox-f1x;  f2y:=2*oy-f1y;
 focale:=sqrt((ox-f1x)*(ox-f1x)+(oy-f1y)*(oy-f1y));
 epaisseur:=_epaisseur; couleur:=_couleur;
 axefocal:=_axefocal;   couleuraxe:=_couleuraxe;
 taille:=sqrt((a2x-a1x)*(a2x-a1x)+(a2y-a1y)*(a2y-a1y));
 if ((taille<form1.taillemini) or (focale<form1.taillemini)or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax)) then
 begin
 create:=false;
 exit;
 end;
 create:=true;
  modifie:=true;
  if (a1x=a2x) then
  if (a2y>a1y) then anglepolaire:=Pi/2 else anglepolaire:=-Pi/2
  else begin
  anglepolaire:=arctan((a2y-a1y)/(a2x-a1x));
  if (a2x<a1x) then anglepolaire:=anglepolaire+Pi;
  end;
  if anglepolaire>Pi then anglepolaire:=anglepolaire-Pi*2;
  normalex:=cos(anglepolaire+Pi/2);
  normaley:=sin(anglepolaire+Pi/2);

 end;



  function lmc.create2(_a1x,_a1y,_a2x,_a2y,_focale:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _axefocal:boolean):boolean;
  var i:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
 ox:=(a1x+a2x)/2; oy:=(a1y+a2y)/2;

 focale:=abs(_focale);
 epaisseur:=_epaisseur; couleur:=_couleur;
 axefocal:=_axefocal;   couleuraxe:=_couleuraxe;
 taille:=sqrt((a2x-a1x)*(a2x-a1x)+(a2y-a1y)*(a2y-a1y));
  rayonmonture:=taille/2;
 if ((taille<form1.taillemini) or (focale<form1.taillemini)or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax)) then
 begin
 create2:=false;
 exit;
 end;
 create2:=true;
  modifie:=true;
  if (a1x=a2x) then
  if (a2y>a1y) then anglepolaire:=Pi/2 else anglepolaire:=-Pi/2
  else begin
  anglepolaire:=arctan((a2y-a1y)/(a2x-a1x));
  if (a2x<a1x) then anglepolaire:=anglepolaire+Pi;
  end;
  if anglepolaire>Pi then anglepolaire:=anglepolaire-Pi*2;
    f1x:=ox+focale*cos(anglepolaire+Pi/2);
    f1y:=oy+focale*sin(anglepolaire+Pi/2);
    f2x:=ox-focale*cos(anglepolaire+Pi/2);
    f2y:=oy-focale*sin(anglepolaire+Pi/2);
  normalex:=cos(anglepolaire+Pi/2);
  normaley:=sin(anglepolaire+Pi/2);

 end;

  function lmd.create2(_a1x,_a1y,_a2x,_a2y,_focale:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _axefocal:boolean):boolean;
  var i:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
 ox:=(a1x+a2x)/2; oy:=(a1y+a2y)/2;

 focale:=abs(_focale);
 epaisseur:=_epaisseur; couleur:=_couleur;
 axefocal:=_axefocal;   couleuraxe:=_couleuraxe;
 taille:=sqrt((a2x-a1x)*(a2x-a1x)+(a2y-a1y)*(a2y-a1y));
 if ((taille<form1.taillemini) or (focale<form1.taillemini)or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax)) then
 begin
 create2:=false;
 exit;
 end;
 create2:=true;
  modifie:=true;
  if (a1x=a2x) then
  if (a2y>a1y) then anglepolaire:=Pi/2 else anglepolaire:=-Pi/2
  else begin
  anglepolaire:=arctan((a2y-a1y)/(a2x-a1x));
  if (a2x<a1x) then anglepolaire:=anglepolaire+Pi;
  end;
  if anglepolaire>Pi then anglepolaire:=anglepolaire-Pi*2;
    f1x:=ox+focale*cos(anglepolaire+Pi/2);
    f1y:=oy+focale*sin(anglepolaire+Pi/2);
    f2x:=ox-focale*cos(anglepolaire+Pi/2);
    f2y:=oy-focale*sin(anglepolaire+Pi/2);
  normalex:=cos(anglepolaire+Pi/2);
  normaley:=sin(anglepolaire+Pi/2);

 end;

 function Mscepa.create(_a1x,_a1y,_a2x,_a2y,_fx,_fy:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_trou:boolean;
  _diametretrou:extended):boolean;
 var i:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y; fx:=_fx; fy:=_fy;
 sx:=(a1x+a2x)/2; sy:=(a1y+a2y)/2;
 cx:=sx+2*(fx-sx); cy:=sy+2*(fy-sy);
 focale:=sqrt(sqr(fx-sx)+sqr(fy-sy));
 epaisseur:=_epaisseur; couleur:=_couleur; hachures:=_hachures;
 axefocal:=_axefocal;   couleuraxe:=_couleuraxe;   trou:=_trou;
 diametretrou:=_diametretrou;
 taille:=sqrt((a2x-a1x)*(a2x-a1x)+(a2y-a1y)*(a2y-a1y));
 if ((taille<form1.taillemini) or (focale<form1.taillemini)or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax)or (trou and (diametretrou>taille)) ) then
 begin
 create:=false;
 exit;
 end;
 create:=true;
  modifie:=true;
  anglepolaire:=donneanglepolairedanspipi(a2x-a1x,a2y-a1y);
  normalex:=cos(anglepolaire+Pi/2);
  normaley:=sin(anglepolaire+Pi/2);
  if not(trou) then begin
  t1x:=sx; t1y:=sy; t2x:=sx; t2y:=sy;
  end else begin
  t1x:=sx+diametretrou/2*cos(anglepolaire+Pi);
  t1y:=sy+diametretrou/2*sin(anglepolaire+Pi);
  t2x:=sx+diametretrou/2*cos(anglepolaire);
  t2y:=sy+diametretrou/2*sin(anglepolaire);
  end;

 end;

 function mscopa.create2(_a1x,_a1y,_a2x,_a2y,_focale:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_trou:boolean; _diametretrou:extended):boolean;
 var i:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
 sx:=(a1x+a2x)/2; sy:=(a1y+a2y)/2;

 focale:=_focale;
 epaisseur:=_epaisseur; couleur:=_couleur; hachures:=_hachures;
 axefocal:=_axefocal;   couleuraxe:=_couleuraxe;
 trou:=_trou; diametretrou:=_diametretrou;
 taille:=sqrt((a2x-a1x)*(a2x-a1x)+(a2y-a1y)*(a2y-a1y));
 if ((taille<form1.taillemini) or (focale<form1.taillemini)or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax) or (trou and (diametretrou>taille))) then
 begin
 create2:=false;
 exit;
 end;
 create2:=true;
  modifie:=true;
  anglepolaire:=donneanglepolairedanspipi(a2x-a1x,a2y-a1y);

    fx:=sx+focale*cos(anglepolaire+Pi/2);
    fy:=sy+focale*sin(anglepolaire+Pi/2);
  cx:=sx+2*(fx-sx); cy:=sy+2*(fy-sy);
  normalex:=cos(anglepolaire+Pi/2);
  normaley:=sin(anglepolaire+Pi/2);
   if not(trou) then begin
  t1x:=sx; t1y:=sy; t2x:=sx; t2y:=sy;
  end else begin
  t1x:=sx+diametretrou/2*cos(anglepolaire+Pi);
  t1y:=sy+diametretrou/2*sin(anglepolaire+Pi);
  t2x:=sx+diametretrou/2*cos(anglepolaire);
  t2y:=sy+diametretrou/2*sin(anglepolaire);
  end;
 end;


 function mscepa.create2(_a1x,_a1y,_a2x,_a2y,_focale:extended; _epaisseur:integer;
  _couleur,_couleuraxe:tcolor; _hachures,_axefocal,_trou:boolean;
  _diametretrou:extended):boolean;
 var i:integer;
 begin
a1x:=_a1x;
 a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
 sx:=(a1x+a2x)/2; sy:=(a1y+a2y)/2;

 focale:=_focale;
 epaisseur:=_epaisseur; couleur:=_couleur; hachures:=_hachures;
 axefocal:=_axefocal;   couleuraxe:=_couleuraxe;
  trou:=_trou; diametretrou:=_diametretrou;
 taille:=sqrt((a2x-a1x)*(a2x-a1x)+(a2y-a1y)*(a2y-a1y));
 if ((taille<form1.taillemini) or (focale<form1.taillemini)or (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or
 (a1y>yymax) or (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or
 (a2y>yymax) or (trou and (diametretrou>taille))) then
 begin
 create2:=false;
 exit;
 end;
 create2:=true;
  modifie:=true;
  if (a1x=a2x) then
  if (a2y>a1y) then anglepolaire:=Pi/2 else anglepolaire:=-Pi/2
  else begin
  anglepolaire:=arctan((a2y-a1y)/(a2x-a1x));
  if (a2x<a1x) then anglepolaire:=anglepolaire+Pi;
  end;
  if anglepolaire>Pi then anglepolaire:=anglepolaire-Pi*2;
    fx:=sx-focale*cos(anglepolaire+Pi/2);
    fy:=sy-focale*sin(anglepolaire+Pi/2);
  cx:=sx+2*(fx-sx); cy:=sy+2*(fy-sy);
  normalex:=cos(anglepolaire+Pi/2);
  normaley:=sin(anglepolaire+Pi/2);
  if not(trou) then begin
  t1x:=sx; t1y:=sy; t2x:=sx; t2y:=sy;
  end else begin
  t1x:=sx+diametretrou/2*cos(anglepolaire+Pi);
  t1y:=sy+diametretrou/2*sin(anglepolaire+Pi);
  t2x:=sx+diametretrou/2*cos(anglepolaire);
  t2y:=sy+diametretrou/2*sin(anglepolaire);
  end;

 end;




 function rayon.create (_ax,_ay,_kx,_ky:extended;
 _couleur:tcolor;
  _epaisseur:integer; _vav,_vaa:shortstring;
  _nombremaxenfant,_maxsegment:integer):boolean;
 var i:integer;
 begin
 maxsegment:=_maxsegment;
 ax:=_ax; ay:=_ay; kx:=_kx; ky:=_ky; couleur:=_couleur; epaisseur:=_epaisseur;
  bx:=ax+kx; by:=ay+ky;
  vav:=_vav; vaa:=_vaa;
  for i:=1 to maxsegment do
  liste_vav[i]:=(pos(','+inttostr(i)+',',vav)<>0) or (pos('('+inttostr(i)+',',vav)<>0) or
  (pos(','+inttostr(i)+')',vav)<>0) or
  (pos('('+inttostr(i)+')',vav)<>0);
  for i:=1 to maxsegment do
  liste_vaa[i]:=(pos(','+inttostr(i)+',',vaa)<>0) or (pos('('+inttostr(i)+',',vaa)<>0) or
  (pos(','+inttostr(i)+')',vaa)<>0) or
  (pos('('+inttostr(i)+')',vaa)<>0);
 nombremaxenfant:=_nombremaxenfant;

 if (((kx=0) and (ky=0)) or (sqrt(sqr(kx)+sqr(ky))<form1.taillemini)or (ax<xxmin) or (ax>xxmax) or (ay<yymin) or
 (ay>yymax) or (ax+kx<xxmin) or (ax+kx>xxmax) or (ay+ky<yymin) or
 (ay+ky>yymax)) then begin
 create:=false;
 exit;
 end else create:=true;
  modifie:=true;
 cx:=ax+kx/2; cy:=ay+ky/2;
  if (kx=0) then
  if (ky>0) then anglepolaire:=Pi/2 else anglepolaire:=-Pi/2
  else begin
  anglepolaire:=arctan(ky/kx);
  if (kx<0) then anglepolaire:=anglepolaire+Pi;
  end;
  if anglepolaire>Pi then anglepolaire:=anglepolaire-Pi*2;

  end;

   function rayon.createenfant (_ax,_ay,_kx,_ky:extended;
 _couleur:tcolor;
  _epaisseur:integer;_vav,_vaa:shortstring;
  _nombremaxenfant,_maxsegment,indicesegment:integer):boolean;

  var i:integer;

 begin
 ax:=_ax; ay:=_ay; kx:=_kx; ky:=_ky; couleur:=_couleur; epaisseur:=_epaisseur;
 vaa:=_vaa;
 vav:=_vav; bx:=ax+kx; by:=ay+ky;
 nombremaxenfant:=_nombremaxenfant; maxsegment:=_maxsegment;
  for i:=1 to maxsegment do
  liste_vav[i]:=(pos(','+inttostr(i+indicesegment)+',',vav)<>0) or (pos('('+inttostr(i+indicesegment)+',',vav)<>0) or
  (pos(','+inttostr(i+indicesegment)+')',vav)<>0) or
  (pos('('+inttostr(i+indicesegment)+')',vav)<>0);
  for i:=1 to maxsegment do
  liste_vaa[i]:=(pos(','+inttostr(i+indicesegment)+',',vaa)<>0) or (pos('('+inttostr(i+indicesegment)+',',vaa)<>0) or
  (pos(','+inttostr(i+indicesegment)+')',vaa)<>0) or
  (pos('('+inttostr(i+indicesegment)+')',vaa)<>0);
  vav:='(';
  for i:=1 to maxsegment do
  if liste_vav[i] then vav:=vav+inttostr(i)+',';
  if vav[length(vav)]=',' then vav[length(vav)]:=')' else
  vav:=vav+')';
  vaa:='(';
  for i:=1 to maxsegment do
  if liste_vaa[i] then vaa:=vaa+inttostr(i)+',';
  if vaa[length(vaa)]=',' then vaa[length(vaa)]:=')' else
  vaa:=vaa+')';

 if (((kx=0) and (ky=0)) or (sqrt(sqr(kx)+sqr(ky))<form1.taillemini)or (ax<xxmin) or (ax>xxmax) or (ay<yymin) or
 (ay>yymax) or (ax+kx/1000<xxmin) or (ax+kx/1000>xxmax) or (ay+ky/1000<yymin) or
 (ay+ky/1000>yymax)) then begin
 createenfant:=false;
 exit;
 end else createenfant:=true;
 cx:=ax+kx/2; cy:=ay+ky/2;
  if (kx=0) then
  if (ky>0) then anglepolaire:=Pi/2 else anglepolaire:=-Pi/2
  else begin
  anglepolaire:=arctan(ky/kx);
  if (kx<0) then anglepolaire:=anglepolaire+Pi;
  end;
  if anglepolaire>Pi then anglepolaire:=anglepolaire-Pi*2;

  end;

 function SourcePonctuelle.create(_nombrederayon:integer; _sx,_sy,_a1x,_a1y,_a2x,_a2y:extended;
  _couleur:tcolor; _epaisseur:integer; _vav,_vaa:shortstring;
  _maxenfantparrayon:integer; _sourcevirtuelle,_tracersurfacesonde:boolean;
  _listechemins:shortstring;_maxsegment:integer):boolean;
  var tt1,tt2,rra:extended;
  i,i1,i2,i3:integer;
  erreur:boolean;
   ss:string;
  label 157,159;
  begin
  maxsegment:=_maxsegment;
  if ((_sx<xxmin) or (_sx>xxmax) or (_sy<yymin) or (_sy>yymax) or
  (_a1x<xxmin) or (_a1x>xxmax) or (_a1y<yymin) or (_a1y>yymax) or
  (_a2x<xxmin) or (_a2x>xxmax) or (_a2y<yymin) or (_a2y>yymax) ) then begin
  create:=false;
  exit;
  end;
  sourcevirtuelle:=_sourcevirtuelle;   tracersurfacesonde:=_tracersurfacesonde;
  listechemins:=_listechemins;
  nombrecheminsoptiques:=0;
  ss:=listechemins;
    erreur:=false;
 157: i1:=pos(' ',ss);
 if length(ss)=0 then goto 159;
 if i1=0  then begin
      try
      inc(nombrecheminsoptiques);
      listecheminsoptiques[nombrecheminsoptiques]:=strtofloat(ss);
             except
       end;
       goto 159;
       end;
 try
   inc(nombrecheminsoptiques);
      listecheminsoptiques[nombrecheminsoptiques]:=strtofloat(copy(ss,1,i1-1));
if i1<length(ss) then ss:=copy(ss,i1+1,length(ss)-(i1+1)+1);
     except
      dec(nombrecheminsoptiques);
      erreur:=true;
       end;
       if erreur then goto 159;
       goto 157;
  159:
  sx:=_sx; sy:=_sy; a1x:=_a1x; a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
  gx:=(a1x+a2x)/2; gy:=(a1y+a2y)/2;  vaa:=_vaa; vav:=_vav;
  nombrederayon:=_nombrederayon;  maxenfantparrayon:=_maxenfantparrayon;
  couleur:=_couleur;     epaisseur:=_epaisseur;
  if ((nombrederayon<=1) or(nombrederayon>maxrayonsparsourceponctuelle)) then begin
  create:=false;
  exit;
  end;


  {source relle}
  if not(sourcevirtuelle) then begin

  if not (ray[1].create(sx,sy,a1x-sx,a1y-sy,couleur,epaisseur,vav,
  vaa,maxenfantparrayon,maxsegment)) then begin
  create:=false;
  exit;
  end;
  tt1:=ray[1].anglepolaire;
  if not(ray[nombrederayon].create(sx,sy,a2x-sx,a2y-sy,couleur,epaisseur,vav,
  vaa,maxenfantparrayon,maxsegment)) then begin
  create:=false;
  exit;
  end;
  tt2:=ray[nombrederayon].anglepolaire;
  if nombrederayon=2 then begin
  create:=true;
   modifie:=true;
  exit;
  end;
  create:=true;

  rra:=sqrt(sqr(a1x-sx)+sqr(a1y-sy));
  if (sqrt(sqr(a2x-sx)+sqr(a2y-sy))<rra) then
  rra:=sqrt(sqr(a2x-sx)+sqr(a2y-sy));
  if tt2<tt1 then tt2:=tt2+2*Pi;
  if tt2<tt1 then tt2:=tt2+2*Pi;
  for i:=2 to nombrederayon-1 do
  if not(ray[i].create(sx,sy,rra*cos(tt1+(i-1)*(tt2-tt1)/(nombrederayon-1)),
  rra*sin(tt1+(i-1)*(tt2-tt1)/(nombrederayon-1)),couleur,epaisseur,vav,
  vaa,maxenfantparrayon,maxsegment)) then
  begin
  create:=false;
  exit;
  end;
   modifie:=true;
  end;

  {source virtuelle}

   {source relle}
  if (sourcevirtuelle) then begin

  if not (ray[1].create(a1x,a1y,-a1x+sx,-a1y+sy,couleur,epaisseur,vav,
  vaa,maxenfantparrayon,maxsegment)) then begin
  create:=false;
  exit;
  end;
  tt1:=ray[1].anglepolaire;
  if not(ray[nombrederayon].create(a2x,a2y,-a2x+sx,-a2y+sy,couleur,epaisseur,vav,
  vaa,maxenfantparrayon,maxsegment)) then begin
  create:=false;
  exit;
  end;
  tt2:=ray[nombrederayon].anglepolaire;
  if nombrederayon=2 then begin
  create:=true;
   modifie:=true;
  exit;
  end;
  create:=true;

  rra:=sqrt(sqr(a1x-sx)+sqr(a1y-sy));
  if (sqrt(sqr(a2x-sx)+sqr(a2y-sy))<rra) then
  rra:=sqrt(sqr(a2x-sx)+sqr(a2y-sy));
  if tt2<tt1 then tt2:=tt2+2*Pi;
  if tt2<tt1 then tt2:=tt2+2*Pi;
  for i:=2 to nombrederayon-1 do
  if not(ray[i].create(sx-rra*cos(tt1+(i-1)*(tt2-tt1)/(nombrederayon-1)),
  sy-rra*sin(tt1+(i-1)*(tt2-tt1)/(nombrederayon-1)),rra*cos(tt1+(i-1)*(tt2-tt1)/(nombrederayon-1)),
  rra*sin(tt1+(i-1)*(tt2-tt1)/(nombrederayon-1)),couleur,epaisseur,vav,
  vaa,maxenfantparrayon,maxsegment)) then
  begin
  create:=false;
  exit;
  end;
   modifie:=true;
  end;

    end;

    function OndePlane.create(_nombrederayon:integer; _sx,_sy,_a1x,_a1y,_a2x,_a2y:extended;
  _couleur:tcolor; _epaisseur:integer; _vav,_vaa:shortstring;_maxenfantparrayon:integer;
  _tracersurfacesonde:boolean;
  _listechemins:shortstring;_maxsegment:integer):boolean;
  var i,i1:integer;
  erreur:boolean; ss:string;
  tyty:extended;
  label 157,159;
  begin
  maxsegment:=_maxsegment;
   tracersurfacesonde:=_tracersurfacesonde;
  listechemins:=_listechemins;
  nombrecheminsoptiques:=0;
  ss:=listechemins;
    erreur:=false;
 157: i1:=pos(' ',ss);
 if length(ss)=0 then goto 159;
 if i1=0  then begin
      try
      inc(nombrecheminsoptiques);
      listecheminsoptiques[nombrecheminsoptiques]:=strtofloat(ss);
             except
       end;
       goto 159;
       end;
 try
   inc(nombrecheminsoptiques);
      listecheminsoptiques[nombrecheminsoptiques]:=strtofloat(copy(ss,1,i1-1));
if i1<length(ss) then ss:=copy(ss,i1+1,length(ss)-(i1+1)+1);
     except
      dec(nombrecheminsoptiques);
      erreur:=true;
       end;
       if erreur then goto 159;
       goto 157;
  159:
   sx:=_sx; sy:=_sy; a1x:=_a1x; a1y:=_a1y; a2x:=_a2x; a2y:=_a2y;
  gx:=(a1x+a2x)/2; gy:=(a1y+a2y)/2;
  tyty:=sqrt(sqr(a2x-a1x)+sqr(a2y-a1y));
 if (sqr(sx-a1x)+sqr(sy-a1y))=0 then begin
 create:=false;
 exit;
 end;

  if (sx-a1x)*(a2y-a1y)-(sy-a1y)*(a2x-a1x)>0 then begin
     a2y:=a1y+(sx-a1x)*tyty/sqrt(sqr(sx-a1x)+sqr(sy-a1y));
     a2x:=a1x-(sy-a1y)*tyty/sqrt(sqr(sx-a1x)+sqr(sy-a1y));
      end else begin
       a2y:=a1y-(sx-a1x)*tyty/sqrt(sqr(sx-a1x)+sqr(sy-a1y));
     a2x:=a1x+(sy-a1y)*tyty/sqrt(sqr(sx-a1x)+sqr(sy-a1y));
      end;
  vav:=_vav; vaa:=_vaa;     couleur:=_couleur;     epaisseur:=_epaisseur;
  if ((sx<xxmin) or (sx>xxmax) or (sy<yymin) or (sy>yymax) or
  (a1x<xxmin) or (a1x>xxmax) or (a1y<yymin) or (a1y>yymax) or
  (a2x<xxmin) or (a2x>xxmax) or (a2y<yymin) or (a2y>yymax) or
  (a2x+sx-a1x<xxmin) or (a2x+sx-a1x>xxmax) or (a2y+sy-a1y<yymin) or (a2y
  +sy-a1y>yymax)) then begin
  create:=false;
  exit;
  end;

  nombrederayon:=_nombrederayon;  maxenfantparrayon:=_maxenfantparrayon;
  if ((nombrederayon<=1) or(nombrederayon>maxrayonsparondeplane)) then begin
  create:=false;
  exit;
  end;

  if not (ray[1].create(a1x,a1y,-a1x+sx,-a1y+sy,couleur,epaisseur,vav,vaa,maxenfantparrayon,maxsegment)) then begin
  create:=false;
  exit;
  end;

  if not(ray[nombrederayon].create(a2x,a2y,-a1x+sx,-a1y+sy,couleur,epaisseur,vav,vaa,maxenfantparrayon,maxsegment)) then begin
  create:=false;
  exit;
  end;
  if nombrederayon=2 then begin
  create:=true;
   modifie:=true;
  exit;
  end;
  create:=true;
   modifie:=true;
  for i:=2 to nombrederayon-1 do
  ray[i].create(a1x+(a2x-a1x)*(i-1)/(nombrederayon-1),a1y+(a2y-a1y)*(i-1)/(nombrederayon-1),
  -a1x+sx,-a1y+sy,couleur,epaisseur,vav,vaa,maxenfantparrayon,maxsegment);
    end;


    procedure fleche.dessine(mc:tmonbitmap);
    var diag:extended;  ra1,ra2:integer;
    begin
   mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,self.styletrait,pmcopy,true);

if (modemodif and not(modeinfo) and not(modeduplication)) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
 mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true);
end;

if (modeinfo and not(modeduplication)) then  begin
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
 end;

if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
  if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
if modeduplication then
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);

diag:=sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin));

case ext1 of
  tffleche: begin
  mc.trait(a1x,a1y,a1x+taille1/1000*diag*cos(anglepolaire+Pi/4),
  a1y+taille1/1000*diag*sin(anglepolaire+pi/4),self.epaisseur,self.couleur,pssolid,pmcopy,true);
   mc.trait(a1x,a1y,a1x+taille1/1000*diag*cos(anglepolaire-Pi/4),
  a1y+taille1/1000*diag*sin(anglepolaire-pi/4),self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
  ttrait: begin
  mc.trait(a1x+taille1/1000*diag/2*cos(anglepolaire-Pi/2),
  a1y+taille1/1000*diag/2*sin(anglepolaire-Pi/2),a1x+taille1/1000*diag/2*cos(anglepolaire+Pi/2),
  a1y+taille1/1000*diag/2*sin(anglepolaire+pi/2),self.epaisseur,self.couleur,pssolid,pmcopy,true); end;
   trond: begin
   mc.invconvert(ra1,ra2,taille1/1000*diag,yymax-taille1/1000*diag,true);
   if ra1>ra2 then ra1:=ra2;
    mc.cercle(a1x,a1y,ra1,self.epaisseur,self.couleur,pmcopy,true); end;
    tcroix: begin
    mc.trait(a1x-taille1/1000*diag/2,a1y, a1x+taille1/1000*diag/2,a1y,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);
     mc.trait(a1x,a1y-taille1/1000*diag/2, a1x,a1y+taille1/1000*diag/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
    tcroixx: begin
    mc.trait(a1x-taille1/1000*diag/2*sqrt(2)/2,a1y-taille1/1000*diag/2*sqrt(2)/2,
     a1x+taille1/1000*diag/2*sqrt(2)/2,a1y+taille1/1000*diag/2*sqrt(2)/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);
     mc.trait(a1x+taille1/1000*diag/2*sqrt(2)/2,a1y-taille1/1000*diag/2*sqrt(2)/2,
     a1x-taille1/1000*diag/2*sqrt(2)/2,a1y+taille1/1000*diag/2*sqrt(2)/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
    tdisque: begin
    mc.disque(a1x,a1y,taille1/1000*diag,self.couleur,self.couleur,false,true); end;
    end;

   case ext2 of
  tffleche: begin
  mc.trait(a2x,a2y,a2x+taille2/1000*diag*cos(anglepolaire+3*Pi/4),
  a2y+taille2/1000*diag*sin(anglepolaire+3*pi/4),self.epaisseur,self.couleur,pssolid,pmcopy,true);
   mc.trait(a2x,a2y,a2x+taille2/1000*diag*cos(anglepolaire-3*Pi/4),
  a2y+taille2/1000*diag*sin(anglepolaire-3*pi/4),self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
  ttrait: begin
  mc.trait(a2x+taille2/1000*diag/2*cos(anglepolaire-Pi/2),
  a2y+taille2/1000*diag/2*sin(anglepolaire-Pi/2),a2x+taille2/1000*diag/2*cos(anglepolaire+Pi/2),
  a2y+taille2/1000*diag/2*sin(anglepolaire+pi/2),self.epaisseur,self.couleur,pssolid,pmcopy,true); end;
   trond: begin
   mc.invconvert(ra1,ra2,taille2/1000*diag,taille2/1000*diag,true);
   if ra1>ra2 then ra1:=ra2;
    mc.cercle(a2x,a2y,ra1,self.epaisseur,self.couleur,pmcopy,true); end;
    tcroix: begin
    mc.trait(a2x-taille2/1000*diag/2,a2y, a2x+taille2/1000*diag/2,a2y,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);
     mc.trait(a2x,a2y-taille2/1000*diag/2, a2x,a2y+taille2/1000*diag/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
    tcroixx: begin
    mc.trait(a2x-taille2/1000*diag/2*sqrt(2)/2,a2y-taille2/1000*diag/2*sqrt(2)/2,
     a2x+taille2/1000*diag/2*sqrt(2)/2,a2y+taille2/1000*diag/2*sqrt(2)/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);
     mc.trait(a2x+taille2/1000*diag/2*sqrt(2)/2,a2y-taille2/1000*diag/2*sqrt(2)/2,
     a2x-taille2/1000*diag/2*sqrt(2)/2,a2y+taille2/1000*diag/2*sqrt(2)/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
    tdisque: begin
    mc.disque(a2x,a2y,taille2/1000*diag,self.couleur,self.couleur,false,true); end;
    end;


    end;



     procedure fleche.dessinePS(mc:tmonpostscript);
    var diag:extended;  ra1,ra2:integer;
    begin
   mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,self.styletrait,pmcopy,true);

if (modemodif and not(modeinfo) and not(modeduplication)) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
 mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true);
end;

if (modeinfo and not(modeduplication)) then  begin
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
 end;

if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
  if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
if modeduplication then
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);

diag:=sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin));

case ext1 of
  tffleche: begin
  mc.trait(a1x,a1y,a1x+taille1/1000*diag*cos(anglepolaire+Pi/4),
  a1y+taille1/1000*diag*sin(anglepolaire+pi/4),self.epaisseur,self.couleur,pssolid,pmcopy,true);
   mc.trait(a1x,a1y,a1x+taille1/1000*diag*cos(anglepolaire-Pi/4),
  a1y+taille1/1000*diag*sin(anglepolaire-pi/4),self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
  ttrait: begin
  mc.trait(a1x+taille1/1000*diag/2*cos(anglepolaire-Pi/2),
  a1y+taille1/1000*diag/2*sin(anglepolaire-Pi/2),a1x+taille1/1000*diag/2*cos(anglepolaire+Pi/2),
  a1y+taille1/1000*diag/2*sin(anglepolaire+pi/2),self.epaisseur,self.couleur,pssolid,pmcopy,true); end;
   trond: begin
   mc.invconvert(ra1,ra2,taille1/1000*diag,yymax-taille1/1000*diag,true);
   if ra1>ra2 then ra1:=ra2;
    mc.cercle(a1x,a1y,ra1,self.epaisseur,self.couleur,pmcopy,true); end;
    tcroix: begin
    mc.trait(a1x-taille1/1000*diag/2,a1y, a1x+taille1/1000*diag/2,a1y,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);
     mc.trait(a1x,a1y-taille1/1000*diag/2, a1x,a1y+taille1/1000*diag/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
    tcroixx: begin
    mc.trait(a1x-taille1/1000*diag/2*sqrt(2)/2,a1y-taille1/1000*diag/2*sqrt(2)/2,
     a1x+taille1/1000*diag/2*sqrt(2)/2,a1y+taille1/1000*diag/2*sqrt(2)/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);
     mc.trait(a1x+taille1/1000*diag/2*sqrt(2)/2,a1y-taille1/1000*diag/2*sqrt(2)/2,
     a1x-taille1/1000*diag/2*sqrt(2)/2,a1y+taille1/1000*diag/2*sqrt(2)/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
    tdisque: begin
    mc.disque(a1x,a1y,taille1/1000*diag,self.couleur,self.couleur,false,true); end;
    end;

   case ext2 of
  tffleche: begin
  mc.trait(a2x,a2y,a2x+taille2/1000*diag*cos(anglepolaire+3*Pi/4),
  a2y+taille2/1000*diag*sin(anglepolaire+3*pi/4),self.epaisseur,self.couleur,pssolid,pmcopy,true);
   mc.trait(a2x,a2y,a2x+taille2/1000*diag*cos(anglepolaire-3*Pi/4),
  a2y+taille2/1000*diag*sin(anglepolaire-3*pi/4),self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
  ttrait: begin
  mc.trait(a2x+taille2/1000*diag/2*cos(anglepolaire-Pi/2),
  a2y+taille2/1000*diag/2*sin(anglepolaire-Pi/2),a2x+taille2/1000*diag/2*cos(anglepolaire+Pi/2),
  a2y+taille2/1000*diag/2*sin(anglepolaire+pi/2),self.epaisseur,self.couleur,pssolid,pmcopy,true); end;
   trond: begin
   mc.invconvert(ra1,ra2,taille2/1000*diag,taille2/1000*diag,true);
   if ra1>ra2 then ra1:=ra2;
    mc.cercle(a2x,a2y,ra1,self.epaisseur,self.couleur,pmcopy,true); end;
    tcroix: begin
    mc.trait(a2x-taille2/1000*diag/2,a2y, a2x+taille2/1000*diag/2,a2y,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);
     mc.trait(a2x,a2y-taille2/1000*diag/2, a2x,a2y+taille2/1000*diag/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
    tcroixx: begin
    mc.trait(a2x-taille2/1000*diag/2*sqrt(2)/2,a2y-taille2/1000*diag/2*sqrt(2)/2,
     a2x+taille2/1000*diag/2*sqrt(2)/2,a2y+taille2/1000*diag/2*sqrt(2)/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);
     mc.trait(a2x+taille2/1000*diag/2*sqrt(2)/2,a2y-taille2/1000*diag/2*sqrt(2)/2,
     a2x-taille2/1000*diag/2*sqrt(2)/2,a2y+taille2/1000*diag/2*sqrt(2)/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
    tdisque: begin
    mc.disque(a2x,a2y,taille2/1000*diag,self.couleur,self.couleur,false,true); end;
    end;


    end;


     procedure fleche.imprime(mc:tmyimprimante);
    var diag:extended;  ra1,ra2:integer;
    begin
   mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,self.styletrait,pmcopy,true);

if (modemodif and not(modeinfo) and not(modeduplication)) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
 mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true);
end;

if (modeinfo and not(modeduplication)) then  begin
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
 end;

if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
  if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
if modeduplication then
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);

diag:=sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin));

case ext1 of
  tffleche: begin
  mc.trait(a1x,a1y,a1x+taille1/1000*diag*cos(anglepolaire+Pi/4),
  a1y+taille1/1000*diag*sin(anglepolaire+pi/4),self.epaisseur,self.couleur,pssolid,pmcopy,true);
   mc.trait(a1x,a1y,a1x+taille1/1000*diag*cos(anglepolaire-Pi/4),
  a1y+taille1/1000*diag*sin(anglepolaire-pi/4),self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
  ttrait: begin
  mc.trait(a1x+taille1/1000*diag/2*cos(anglepolaire-Pi/2),
  a1y+taille1/1000*diag/2*sin(anglepolaire-Pi/2),a1x+taille1/1000*diag/2*cos(anglepolaire+Pi/2),
  a1y+taille1/1000*diag/2*sin(anglepolaire+pi/2),self.epaisseur,self.couleur,pssolid,pmcopy,true); end;
   trond: begin
   mc.invconvert(ra1,ra2,taille1/1000*diag,yymax-taille1/1000*diag,true);
   if ra1>ra2 then ra1:=ra2;
    mc.cercle(a1x,a1y,ra1,self.epaisseur,self.couleur,pmcopy,true); end;
    tcroix: begin
    mc.trait(a1x-taille1/1000*diag/2,a1y, a1x+taille1/1000*diag/2,a1y,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);
     mc.trait(a1x,a1y-taille1/1000*diag/2, a1x,a1y+taille1/1000*diag/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
    tcroixx: begin
    mc.trait(a1x-taille1/1000*diag/2*sqrt(2)/2,a1y-taille1/1000*diag/2*sqrt(2)/2,
     a1x+taille1/1000*diag/2*sqrt(2)/2,a1y+taille1/1000*diag/2*sqrt(2)/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);
     mc.trait(a1x+taille1/1000*diag/2*sqrt(2)/2,a1y-taille1/1000*diag/2*sqrt(2)/2,
     a1x-taille1/1000*diag/2*sqrt(2)/2,a1y+taille1/1000*diag/2*sqrt(2)/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
    tdisque: begin
    mc.disque(a1x,a1y,taille1/1000*diag,self.couleur,self.couleur,false,true); end;
    end;

   case ext2 of
  tffleche: begin
  mc.trait(a2x,a2y,a2x+taille2/1000*diag*cos(anglepolaire+3*Pi/4),
  a2y+taille2/1000*diag*sin(anglepolaire+3*pi/4),self.epaisseur,self.couleur,pssolid,pmcopy,true);
   mc.trait(a2x,a2y,a2x+taille2/1000*diag*cos(anglepolaire-3*Pi/4),
  a2y+taille2/1000*diag*sin(anglepolaire-3*pi/4),self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
  ttrait: begin
  mc.trait(a2x+taille2/1000*diag/2*cos(anglepolaire-Pi/2),
  a2y+taille2/1000*diag/2*sin(anglepolaire-Pi/2),a2x+taille2/1000*diag/2*cos(anglepolaire+Pi/2),
  a2y+taille2/1000*diag/2*sin(anglepolaire+pi/2),self.epaisseur,self.couleur,pssolid,pmcopy,true); end;
   trond: begin
   mc.invconvert(ra1,ra2,taille2/1000*diag,taille2/1000*diag,true);
   if ra1>ra2 then ra1:=ra2;
    mc.cercle(a2x,a2y,ra1,self.epaisseur,self.couleur,pmcopy,true); end;
    tcroix: begin
    mc.trait(a2x-taille2/1000*diag/2,a2y, a2x+taille2/1000*diag/2,a2y,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);
     mc.trait(a2x,a2y-taille2/1000*diag/2, a2x,a2y+taille2/1000*diag/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
    tcroixx: begin
    mc.trait(a2x-taille2/1000*diag/2*sqrt(2)/2,a2y-taille2/1000*diag/2*sqrt(2)/2,
     a2x+taille2/1000*diag/2*sqrt(2)/2,a2y+taille2/1000*diag/2*sqrt(2)/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);
     mc.trait(a2x+taille2/1000*diag/2*sqrt(2)/2,a2y-taille2/1000*diag/2*sqrt(2)/2,
     a2x-taille2/1000*diag/2*sqrt(2)/2,a2y+taille2/1000*diag/2*sqrt(2)/2,
    self.epaisseur,self.couleur,pssolid,pmcopy,true);  end;
    tdisque: begin
    mc.disque(a2x,a2y,taille2/1000*diag,self.couleur,self.couleur,false,true); end;
    end;


    end;

 procedure miroirplan.dessine(var mc:tmonbitmap);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
if ((modemodif or modeinfo) and (not(modeduplication))) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;
if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(taille/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 mc.trait(a1x+i/(nbtrait+1)*(a2x-a1x),a1y+i/(nbtrait+1)*(a2y-a1y),
 a1x+i/
 (nbtrait+1)*(a2x-a1x)+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/2),a1y+i/(nbtrait+1)*(a2y-a1y)+ttai/100/zoomfactor*
 sin(anglepolaire-Pi/2),
 self.epaisseur,self.couleur,pssolid,pmcopy,true);
 end;
  if modeduplication then
  mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
end;




  procedure reseau.dessine(var mc:tmonbitmap);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,psdot,pmcopy,true);
if ((modemodif or modeinfo) and (not(modeduplication))) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;
if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
if (self.hachures) and not(self.entransmission) then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(taille/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 mc.trait(a1x+i/(nbtrait+1)*(a2x-a1x),a1y+i/(nbtrait+1)*(a2y-a1y),
 a1x+i/
 (nbtrait+1)*(a2x-a1x)+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/2),a1y+i/(nbtrait+1)*(a2y-a1y)+ttai/100/zoomfactor*
 sin(anglepolaire-Pi/2),
 self.epaisseur,self.couleur,pssolid,pmcopy,true);
 end;
  if modeduplication then
  mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
end;


 procedure miroirplan.dessinePS(mc:tmonpostscript);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
if ((modemodif or modeinfo) and (not(modeduplication))) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;
if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
if (self.hachures)  then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(taille/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 mc.trait(a1x+i/(nbtrait+1)*(a2x-a1x),a1y+i/(nbtrait+1)*(a2y-a1y),
 a1x+i/
 (nbtrait+1)*(a2x-a1x)+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/2),a1y+i/(nbtrait+1)*(a2y-a1y)+ttai/100/zoomfactor*
 sin(anglepolaire-Pi/2),
 self.epaisseur,self.couleur,pssolid,pmcopy,true);
 end;
  if modeduplication then
  mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
end;



  procedure reseau.dessinePS(mc:tmonpostscript);
 var i:integer; ttai:extended;  nbtrait:integer;
  begin
  ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
  mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,psdot,pmcopy,true);
 if ((modemodif or modeinfo) and (not(modeduplication))) then begin
 mc.cercle(a1x,a1y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 mc.cercle(a2x,a2y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 if modemodif then
 mc.croixx(cx,cy,3*self.epaisseur,
 self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(cx,cy,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 end;
 if (modesuppression) then begin
 mc.cercle(a1x,a1y,3*self.epaisseur,
 self.epaisseur,couleursuppression,pmcopy,true);
 mc.cercle(a2x,a2y,3*self.epaisseur,
 self.epaisseur,couleursuppression,pmcopy,true);
 mc.cercle(cx,cy,3*self.epaisseur,
 self.epaisseur,couleursuppression,pmcopy,true);
 end;
 if (self.hachures) and not(self.entransmission) then begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 nbtrait:=(trunc(taille/(ttai/100))+1)*zoomfactor;
  for i:=1 to nbtrait do
  mc.trait(a1x+i/(nbtrait+1)*(a2x-a1x),a1y+i/(nbtrait+1)*(a2y-a1y),
  a1x+i/
  (nbtrait+1)*(a2x-a1x)+ttai/100/zoomfactor*
  cos(anglepolaire-Pi/2),a1y+i/(nbtrait+1)*(a2y-a1y)+ttai/100/zoomfactor*
  sin(anglepolaire-Pi/2),
  self.epaisseur,self.couleur,pssolid,pmcopy,true);
  end;
   if modeduplication then
   mc.cercle(cx,cy,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 if modegroupement then
 mc.croixx(cx,cy,3,
 2,clpurple,pmcopy,true);
 end;

 procedure miroirplan.imprime(mc:tmyimprimante);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
if ((modemodif or modeinfo) and (not(modeduplication))) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;
if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(taille/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 mc.trait(a1x+i/(nbtrait+1)*(a2x-a1x),a1y+i/(nbtrait+1)*(a2y-a1y),
 a1x+i/
 (nbtrait+1)*(a2x-a1x)+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/2),a1y+i/(nbtrait+1)*(a2y-a1y)+ttai/100/zoomfactor*
 sin(anglepolaire-Pi/2),
 self.epaisseur,self.couleur,pssolid,pmcopy,true);
 end;
  if modeduplication then
  mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
end;



  procedure reseau.imprime(mc:tmyimprimante);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,psdot,pmcopy,true);
if ((modemodif or modeinfo) and (not(modeduplication))) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;
if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
if (self.hachures) and not(self.entransmission) then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(taille/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 mc.trait(a1x+i/(nbtrait+1)*(a2x-a1x),a1y+i/(nbtrait+1)*(a2y-a1y),
 a1x+i/
 (nbtrait+1)*(a2x-a1x)+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/2),a1y+i/(nbtrait+1)*(a2y-a1y)+ttai/100/zoomfactor*
 sin(anglepolaire-Pi/2),
 self.epaisseur,self.couleur,pssolid,pmcopy,true);
 end;
  if modeduplication then
  mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
end;


 procedure ecran.imprime(mc:tmyimprimante);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;
 if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
if modeduplication then
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
  if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
end;


 procedure ecran.dessine(mc:tmonbitmap);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;
 if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
if modeduplication then
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
  if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
end;



  procedure ecran.dessinePS(mc:tmonpostscript);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;
 if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;
if modeduplication then
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
  if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
end;




procedure angle.dessine(mc:tmonbitmap);
var t1,t2,r1,r2,r,agp,ttai:extended;
xi,yi:integer;
s:string;

begin


ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

 mc.trait(cx,cy,a1x,a1y,1,clblack,pssolid,pmcopy,true);
 mc.trait(cx,cy,a2x,a2y,1,clblack,pssolid,pmcopy,true);
if not (modeduplication) then begin
 mc.cercle(a1x,a1y,3,1,clblack,pmcopy,true);
    mc.cercle(a2x,a2y,3,1,clblack,pmcopy,true);
     mc.cercle(cx,cy,3,1,clblack,pmcopy,true);
     if modeinfo then
     mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
     if modemodif then begin
      mc.cercle(a1x,a1y,3,1,couleurpoignees,pmcopy,true);
    mc.cercle(a2x,a2y,3,1,couleurpoignees,pmcopy,true);
     mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
     mc.croixx(dx,dy,3,2,couleurtrans,pmcopy,true)
     end;
     if modesuppression then begin
      mc.cercle(a1x,a1y,3,1,couleursuppression,pmcopy,true);
    mc.cercle(a2x,a2y,3,1,couleursuppression,pmcopy,true);
     mc.cercle(cx,cy,3,1,couleursuppression,pmcopy,true);
     end;
     end else
        mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
 t1:=donneanglepolairedans02pi(a1x-cx,a1y-cy);
 t2:=donneanglepolairedans02pi(a2x-cx,a2y-cy);
 if t2<t1 then t2:=t2+2*pi;
 r1:=sqrt(sqr(a1x-cx)+sqr(a1y-cy));
  r2:=sqrt(sqr(a2x-cx)+sqr(a2y-cy));
  r:=r1;
  if r2<r then r:=r2;
  r:=r/3;
  if t1<>t2 then mc.arcdecercle(cx,cy,r,1,t1,t2,clblack,pmcopy,pssolid,true);
  agp:=(t1+t2)/2;

  form1.image1.Picture.Bitmap.Canvas.font.Color:=clblack;
 form1.image1.Picture.Bitmap.Canvas.font.Name:='Arial Narrow';
  form1.image1.Picture.Bitmap.Canvas.font.Charset:=DEFAULT_CHARSET;
  form1.image1.Picture.Bitmap.Canvas.font.size:=10;
  form1.image1.Picture.Bitmap.Canvas.font.Style:=[];
 {mc.trait(cx+r*cos(agp),cy+r*sin(agp),cx+r*cos(agp)+ttai/100/zoomfactor*cos(agp),
 cy+r*sin(agp)+ttai/100/zoomfactor*sin(agp),1,clblack,pssolid,pmcopy,true);  }
 mc.invconvert(xi,yi,cx+r*cos(agp){+ttai/100/zoomfactor*cos(agp)},
 cy+r*sin(agp){+ttai/100/zoomfactor*sin(agp)},true) ;

   s:=floattostrf((t2-t1)*180/pi,fffixed,5+decimalesangles,decimalesangles)+'°';
   if agp<=pi/2 then mc.ecrireI(xi,yi-form1.image1.Picture.Bitmap.Canvas.textheight(s),s,form1.image1.Picture.Bitmap.Canvas.font);
   if ((agp>pi/2) and (agp<=pi)) then
  mc.ecrireI(xi-form1.image1.Picture.Bitmap.Canvas.textwidth(s),yi-form1.image1.Picture.Bitmap.Canvas.textheight(s),s,form1.image1.Picture.Bitmap.Canvas.font);
   if ((agp>pi) and (agp<=3*pi/2)) then
      mc.ecrireI(xi-form1.image1.Picture.Bitmap.Canvas.textwidth(s),yi,s,form1.image1.Picture.Bitmap.Canvas.font);
      if agp>3*pi/2  then
      mc.ecrireI(xi,yi,s,form1.image1.Picture.Bitmap.Canvas.font);
       if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
end;



procedure angle.dessinePS(mc:tmonpostscript);
var t1,t2,r1,r2,r,agp,ttai:extended;
xi,yi:integer;
s:string;
 old_font:tfont;
begin


ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

 mc.trait(cx,cy,a1x,a1y,1,clblack,pssolid,pmcopy,true);
 mc.trait(cx,cy,a2x,a2y,1,clblack,pssolid,pmcopy,true);
if not (modeduplication) then begin
 mc.cercle(a1x,a1y,3,1,clblack,pmcopy,true);
    mc.cercle(a2x,a2y,3,1,clblack,pmcopy,true);
     mc.cercle(cx,cy,3,1,clblack,pmcopy,true);
     if modeinfo then
     mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
     if modemodif then begin
      mc.cercle(a1x,a1y,3,1,couleurpoignees,pmcopy,true);
    mc.cercle(a2x,a2y,3,1,couleurpoignees,pmcopy,true);
     mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
     mc.croixx(dx,dy,3,2,couleurtrans,pmcopy,true)
     end;
     if modesuppression then begin
      mc.cercle(a1x,a1y,3,1,couleursuppression,pmcopy,true);
    mc.cercle(a2x,a2y,3,1,couleursuppression,pmcopy,true);
     mc.cercle(cx,cy,3,1,couleursuppression,pmcopy,true);
     end;
     end else
        mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
 t1:=donneanglepolairedans02pi(a1x-cx,a1y-cy);
 t2:=donneanglepolairedans02pi(a2x-cx,a2y-cy);
 if t2<t1 then t2:=t2+2*pi;
 r1:=sqrt(sqr(a1x-cx)+sqr(a1y-cy));
  r2:=sqrt(sqr(a2x-cx)+sqr(a2y-cy));
  r:=r1;
  if r2<r then r:=r2;
  r:=r/3;
  if t1<>t2 then mc.arcdecercle(cx,cy,r,1,t1,t2,clblack,pmcopy,pssolid,true);
  agp:=(t1+t2)/2;
   old_font:=ps.font;
  ps.font.Color:=clblack;
 ps.font.Name:='Arial Narrow';
  ps.font.Charset:=DEFAULT_CHARSET;
  ps.font.size:=10;
  ps.font.Style:=[];
 {mc.trait(cx+r*cos(agp),cy+r*sin(agp),cx+r*cos(agp)+ttai/100/zoomfactor*cos(agp),
 cy+r*sin(agp)+ttai/100/zoomfactor*sin(agp),1,clblack,pssolid,pmcopy,true);  }
 mc.invconvert(xi,yi,cx+r*cos(agp){+ttai/100/zoomfactor*cos(agp)},
 cy+r*sin(agp){+ttai/100/zoomfactor*sin(agp)},true) ;

   s:=floattostrf((t2-t1)*180/pi,fffixed,5+decimalesangles,decimalesangles)+'°';
   if agp<=pi/2 then mc.ecrireI(xi,yi-form1.image1.Picture.Bitmap.Canvas.textheight(s),s,form1.image1.Picture.Bitmap.Canvas.font);
   if ((agp>pi/2) and (agp<=pi)) then
  mc.ecrireI(xi-form1.image1.Picture.Bitmap.Canvas.textwidth(s),yi-form1.image1.Picture.Bitmap.Canvas.textheight(s),s,form1.image1.Picture.Bitmap.Canvas.font);
   if ((agp>pi) and (agp<=3*pi/2)) then
      mc.ecrireI(xi-form1.image1.Picture.Bitmap.Canvas.textwidth(s),yi,s,form1.image1.Picture.Bitmap.Canvas.font);
      if agp>3*pi/2  then
      mc.ecrireI(xi,yi,s,form1.image1.Picture.Bitmap.Canvas.font);
       if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
       ps.font:=old_font;
end;



procedure angle.imprime(mc:tmyimprimante);
var t1,t2,r1,r2,r,agp,ttai:extended;
xi,yi:integer;
s:string;
begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

 mc.trait(cx,cy,a1x,a1y,1,clblack,pssolid,pmcopy,true);
 mc.trait(cx,cy,a2x,a2y,1,clblack,pssolid,pmcopy,true);
if not (modeduplication) then begin
 mc.cercle(a1x,a1y,3,1,clblack,pmcopy,true);
    mc.cercle(a2x,a2y,3,1,clblack,pmcopy,true);
     mc.cercle(cx,cy,3,1,clblack,pmcopy,true);
     if modeinfo then
     mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
     if modemodif then begin
      mc.cercle(a1x,a1y,3,1,couleurpoignees,pmcopy,true);
    mc.cercle(a2x,a2y,3,1,couleurpoignees,pmcopy,true);
     mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
     mc.croixx(dx,dy,3,2,couleurtrans,pmcopy,true)
     end;
     if modesuppression then begin
      mc.cercle(a1x,a1y,3,1,couleursuppression,pmcopy,true);
    mc.cercle(a2x,a2y,3,1,couleursuppression,pmcopy,true);
     mc.cercle(cx,cy,3,1,couleursuppression,pmcopy,true);
     end;
     end else
        mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
 t1:=donneanglepolairedans02pi(a1x-cx,a1y-cy);
 t2:=donneanglepolairedans02pi(a2x-cx,a2y-cy);
 if t2<t1 then t2:=t2+2*pi;
 r1:=sqrt(sqr(a1x-cx)+sqr(a1y-cy));
  r2:=sqrt(sqr(a2x-cx)+sqr(a2y-cy));
  r:=r1;
  if r2<r then r:=r2;
  r:=r/3;
  if t1<>t2 then mc.arcdecercle(cx,cy,r,1,t1,t2,clblack,pmcopy,pssolid,true);
  agp:=(t1+t2)/2;

  imprimante.canvas.font.Color:=clblack;
 imprimante.canvas.font.Name:='Arial Narrow';
  imprimante.canvas.font.Charset:=DEFAULT_CHARSET;
  imprimante.canvas.font.size:=10;
 imprimante.canvas.font.Style:=[];
 {mc.trait(cx+r*cos(agp),cy+r*sin(agp),cx+r*cos(agp)+ttai/100/zoomfactor*cos(agp),
 cy+r*sin(agp)+ttai/100/zoomfactor*sin(agp),1,clblack,pssolid,pmcopy,true);  }
 mc.invconvert(xi,yi,cx+r*cos(agp){+ttai/100/zoomfactor*cos(agp)},
 cy+r*sin(agp){+ttai/100/zoomfactor*sin(agp)},true) ;

   s:=floattostrf((t2-t1)*180/pi,fffixed,5+decimalesangles,decimalesangles)+'°';
   if agp<=pi/2 then mc.ecrireI(xi,yi-imprimante.canvas.textheight(s),s,imprimante.canvas.font);
   if ((agp>pi/2) and (agp<=pi)) then
   mc.ecrireI(xi-imprimante.canvas.textwidth(s),yi-imprimante.canvas.textheight(s),s,imprimante.canvas.font);
   if ((agp>pi) and (agp<=3*pi/2)) then
      mc.ecrireI(xi-imprimante.canvas.textwidth(s),yi,s,imprimante.canvas.font);
      if agp>3*pi/2  then
     mc.ecrireI(xi,yi,s,imprimante.canvas.font);
       if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
end;

procedure angle.dessinebis(mc:tmonbitmap);
var t1,t2,r1,r2,r,agp,ttai,deltat,signe,t3:extended;
xi,yi:integer;
s:string;    old_font:tfont;
begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

  t1:=donneanglepolairedans02pi(a1x-cx,a1y-cy);
 t2:=donneanglepolairedans02pi(a2x-cx,a2y-cy);
   if t2>=t1 then signe:=1 else signe:=-1;
 if signe=-1 then begin
 t3:=t1; t1:=t2; t2:=t3; end;
deltat:=t2-t1;
if deltat>pi then begin
t1:=t2; t2:=t1+2*pi-deltat; end;



 r1:=sqrt(sqr(a1x-cx)+sqr(a1y-cy));
  r2:=sqrt(sqr(a2x-cx)+sqr(a2y-cy));
  r:=r1;
  if r2<r then r:=r2;
  r:=r/2;
   mc.arcdecercle(cx,cy,r,1,t1,t2,clblack,pmcopy,pssolid,true);
  agp:=(t1+t2)/2;

  deltat:=t2-t1;

    old_font:=form1.image1.Picture.Bitmap.Canvas.font;
   form1.image1.Picture.Bitmap.Canvas.font.Color:=clblack;
   form1.image1.Picture.Bitmap.Canvas.font.Name:='Arial Narrow';
  form1.image1.Picture.Bitmap.Canvas.font.Charset:=DEFAULT_CHARSET;
  form1.image1.Picture.Bitmap.Canvas.font.size:=10;
  form1.image1.Picture.Bitmap.Canvas.font.Style:=[];


 {mc.trait(cx+r*cos(agp),cy+r*sin(agp),cx+r*cos(agp)+ttai/100/zoomfactor*cos(agp),
 cy+r*sin(agp)+ttai/100/zoomfactor*sin(agp),1,clblack,pssolid,pmcopy,true);  }
 mc.invconvert(xi,yi,cx+r*cos(agp){+ttai/100/zoomfactor*cos(agp)},
 cy+r*sin(agp){+ttai/100/zoomfactor*sin(agp)},true) ;

   s:=floattostrf(signe*deltat*180/pi,fffixed,5+decimalesangles,decimalesangles)+'°';
   if agp<=pi/2 then mc.ecrireI(xi,yi-form1.image1.Picture.Bitmap.Canvas.textheight(s),s,form1.image1.Picture.Bitmap.Canvas.font);
   if ((agp>pi/2) and (agp<=pi)) then
  mc.ecrireI(xi-form1.image1.Picture.Bitmap.Canvas.textwidth(s),yi-form1.image1.Picture.Bitmap.Canvas.textheight(s),s,form1.image1.Picture.Bitmap.Canvas.font);
   if ((agp>pi) and (agp<=3*pi/2)) then
      mc.ecrireI(xi-form1.image1.Picture.Bitmap.Canvas.textwidth(s),yi,s,form1.image1.Picture.Bitmap.Canvas.font);
      if agp>3*pi/2  then
       mc.ecrireI(xi,yi,s,form1.image1.Picture.Bitmap.Canvas.font);

      form1.image1.Picture.Bitmap.Canvas.font:=old_font;
end;



procedure angle.dessinebisPS(mc:tmonpostscript);
var t1,t2,r1,r2,r,agp,ttai,deltat,signe,t3:extended;
xi,yi:integer;
s:string;    old_font:tfont;
begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

  t1:=donneanglepolairedans02pi(a1x-cx,a1y-cy);
 t2:=donneanglepolairedans02pi(a2x-cx,a2y-cy);
   if t2>=t1 then signe:=1 else signe:=-1;
 if signe=-1 then begin
 t3:=t1; t1:=t2; t2:=t3; end;
deltat:=t2-t1;
if deltat>pi then begin
t1:=t2; t2:=t1+2*pi-deltat; end;



 r1:=sqrt(sqr(a1x-cx)+sqr(a1y-cy));
  r2:=sqrt(sqr(a2x-cx)+sqr(a2y-cy));
  r:=r1;
  if r2<r then r:=r2;
  r:=r/2;
   mc.arcdecercle(cx,cy,r,1,t1,t2,clblack,pmcopy,pssolid,true);
  agp:=(t1+t2)/2;

  deltat:=t2-t1;

     old_font:=ps.Font;
   ps.font.Color:=clblack;
   ps.font.Name:='Arial Narrow';
  ps.font.Charset:=DEFAULT_CHARSET;
  ps.font.size:=10;
  ps.font.Style:=[];


 {mc.trait(cx+r*cos(agp),cy+r*sin(agp),cx+r*cos(agp)+ttai/100/zoomfactor*cos(agp),
 cy+r*sin(agp)+ttai/100/zoomfactor*sin(agp),1,clblack,pssolid,pmcopy,true);  }
 mc.invconvert(xi,yi,cx+r*cos(agp){+ttai/100/zoomfactor*cos(agp)},
 cy+r*sin(agp){+ttai/100/zoomfactor*sin(agp)},true) ;

   s:=floattostrf(signe*deltat*180/pi,fffixed,5+decimalesangles,decimalesangles)+'°';
   if agp<=pi/2 then mc.ecrireI(xi,yi-form1.image1.Picture.Bitmap.Canvas.textheight(s),s,form1.image1.Picture.Bitmap.Canvas.font);
   if ((agp>pi/2) and (agp<=pi)) then
  mc.ecrireI(xi-form1.image1.Picture.Bitmap.Canvas.textwidth(s),yi-form1.image1.Picture.Bitmap.Canvas.textheight(s),s,form1.image1.Picture.Bitmap.Canvas.font);
   if ((agp>pi) and (agp<=3*pi/2)) then
      mc.ecrireI(xi-form1.image1.Picture.Bitmap.Canvas.textwidth(s),yi,s,form1.image1.Picture.Bitmap.Canvas.font);
      if agp>3*pi/2  then
       mc.ecrireI(xi,yi,s,form1.image1.Picture.Bitmap.Canvas.font);

      ps.Font:=old_font;
end;





procedure angle.imprimebis(mc:tmyimprimante);
var t1,t2,r1,r2,r,agp,ttai,deltat,signe,t3:extended;
xi,yi:integer;
s:string;      old_font:tfont;
begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

  t1:=donneanglepolairedans02pi(a1x-cx,a1y-cy);
 t2:=donneanglepolairedans02pi(a2x-cx,a2y-cy);
   if t2>=t1 then signe:=1 else signe:=-1;
 if signe=-1 then begin
 t3:=t1; t1:=t2; t2:=t3; end;
deltat:=t2-t1;
if deltat>pi then begin
t1:=t2; t2:=t1+2*pi-deltat; end;



 r1:=sqrt(sqr(a1x-cx)+sqr(a1y-cy));
  r2:=sqrt(sqr(a2x-cx)+sqr(a2y-cy));
  r:=r1;
  if r2<r then r:=r2;
  r:=r/2;
   mc.arcdecercle(cx,cy,r,1,t1,t2,clblack,pmcopy,pssolid,true);
  agp:=(t1+t2)/2;

  deltat:=t2-t1;
     old_font:=imprimante.Canvas.Font;

   imprimante.canvas.font.Color:=clblack;
   imprimante.canvas.font.Name:='Arial Narrow';
  imprimante.canvas.font.Charset:=DEFAULT_CHARSET;
  imprimante.canvas.font.size:=10;
  imprimante.canvas.font.Style:=[];


 {mc.trait(cx+r*cos(agp),cy+r*sin(agp),cx+r*cos(agp)+ttai/100/zoomfactor*cos(agp),
 cy+r*sin(agp)+ttai/100/zoomfactor*sin(agp),1,clblack,pssolid,pmcopy,true);  }
 mc.invconvert(xi,yi,cx+r*cos(agp){+ttai/100/zoomfactor*cos(agp)},
 cy+r*sin(agp){+ttai/100/zoomfactor*sin(agp)},true) ;

   s:=floattostrf(signe*deltat*180/pi,fffixed,5+decimalesangles,decimalesangles)+'°';
   if agp<=pi/2 then mc.ecrireI(xi,yi-imprimante.canvas.textheight(s),s,imprimante.canvas.font);
   if ((agp>pi/2) and (agp<=pi)) then
   mc.ecrireI(xi-imprimante.canvas.textwidth(s),yi-imprimante.canvas.textheight(s),s,imprimante.canvas.font);
   if ((agp>pi) and (agp<=3*pi/2)) then
      mc.ecrireI(xi-imprimante.canvas.textwidth(s),yi,s,imprimante.canvas.font);
      if agp>3*pi/2  then
       mc.ecrireI(xi,yi,s,imprimante.canvas.font);
      imprimante.Canvas.Font:=old_font;
end;


procedure metre.dessine(mc:tmonbitmap);
var agp,ttai:extended;
xi,yi:integer;
s:string;  old_font:tfont;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,1,clblack,pssolid,pmcopy,true);
if not(modeduplication) then begin
 mc.cercle(a1x,a1y,3,1,clblack,pmcopy,true);

    mc.cercle(a2x,a2y,3,1,clblack,pmcopy,true);
    if modeinfo then
     mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
     if modemodif then begin
       mc.cercle(a1x,a1y,3,1,couleurpoignees,pmcopy,true);
mc.croixx((a1x+a2x)/2,(a1y+a2y)/2,3,
2,couleurtrans,pmcopy,true);
    mc.cercle(a2x,a2y,3,1,couleurpoignees,pmcopy,true);
    end;

    if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);

    if modesuppression then begin
       mc.cercle(a1x,a1y,3,1,couleursuppression,pmcopy,true);

    mc.cercle(a2x,a2y,3,1,couleursuppression,pmcopy,true);
    end;
     end;
    if modeduplication then begin
        mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
    end;


ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

agp:=donneanglepolairedans02pi(a2x-a1x,a2y-a1y);

{mc.trait((a1x+a2x)/2,(a1y+a2y)/2,(a1x+a2x)/2+ttai/100/zoomfactor*cos(agp+pi/2),
 (a1y+a2y)/2+ttai/100/zoomfactor*sin(agp+pi/2),1,clblack,pssolid,pmcopy,true); }

 mc.invconvert(xi,yi,(a1x+a2x)/2{+ttai/100/zoomfactor*cos(agp+pi/2)},
 (a1y+a2y)/2{+ttai/100/zoomfactor*sin(agp+pi/2)},true);

 old_font:=form1.Font;
  form1.image1.Picture.Bitmap.Canvas.font.Color:=clblack;
   form1.image1.Picture.Bitmap.Canvas.font.Name:='Arial Narrow';
  form1.image1.Picture.Bitmap.Canvas.font.Charset:=DEFAULT_CHARSET;
  form1.image1.Picture.Bitmap.Canvas.font.size:=10;
  form1.image1.Picture.Bitmap.Canvas.font.Style:=[];


   s:=floattostrf(sqrt(sqr(a2x-a1x)+sqr(a2y-a1y)),fffixed,4
  +trunc(ln(zoomfactor)/ln(10)),trunc(ln(zoomfactor)/ln(10)))+' '+unitelongueur;

   if (abs(agp)<1e-10) or (abs(agp-2*pi)<1e-10)
   then form1.image1.Picture.Bitmap.Canvas.TextOut(xi-form1.image1.Picture.Bitmap.Canvas.textwidth(s),yi-form1.image1.Picture.Bitmap.Canvas.textheight(s),s)
   else
   if (abs(agp-pi/2)<1e-10) then form1.image1.Picture.Bitmap.Canvas.TextOut(xi-form1.image1.Picture.Bitmap.Canvas.textwidth(s),
   yi-form1.image1.Picture.Bitmap.Canvas.textheight(s),s)
   else
   if (abs(agp-pi)<1e-10)  then    form1.image1.Picture.Bitmap.Canvas.TextOut(xi-form1.image1.Picture.Bitmap.Canvas.textwidth(s),yi,s)
     else
    if (abs(agp-2*pi/2)<1e-10) then   form1.image1.Picture.Bitmap.Canvas.TextOut(xi,yi,s) else begin

    if agp+pi/2>4*pi/2 then form1.image1.Picture.Bitmap.Canvas.TextOut(xi,yi-form1.image1.Picture.Bitmap.Canvas.textheight(s),s);
   if ((agp+pi/2>pi/2) and (agp+pi/2<pi)) then
          form1.image1.Picture.Bitmap.Canvas.TextOut(xi-form1.image1.Picture.Bitmap.Canvas.textwidth(s),yi-form1.image1.Picture.Bitmap.Canvas.textheight(s),s);
              if ((agp+pi/2>pi) and (agp+pi/2<3*pi/2)) then
      form1.image1.Picture.Bitmap.Canvas.TextOut(xi-form1.image1.Picture.Bitmap.Canvas.textwidth(s),yi,s);
      if ((agp+pi/2>3*pi/2) and (agp+pi/2<4*pi/2))  then
       form1.image1.Picture.Bitmap.Canvas.TextOut(xi,yi,s);
       end;
       form1.Font:=old_font;
 end;


procedure metre.dessinePS(mc:tmonpostscript);
var agp,ttai:extended;
xi,yi:integer;
s:string;  old_font:tfont;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,1,clblack,pssolid,pmcopy,true);
if not(modeduplication) then begin
 mc.cercle(a1x,a1y,3,1,clblack,pmcopy,true);

    mc.cercle(a2x,a2y,3,1,clblack,pmcopy,true);
    if modeinfo then
     mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
     if modemodif then begin
       mc.cercle(a1x,a1y,3,1,couleurpoignees,pmcopy,true);
mc.croixx((a1x+a2x)/2,(a1y+a2y)/2,3,
2,couleurtrans,pmcopy,true);
    mc.cercle(a2x,a2y,3,1,couleurpoignees,pmcopy,true);
    end;

    if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);

    if modesuppression then begin
       mc.cercle(a1x,a1y,3,1,couleursuppression,pmcopy,true);

    mc.cercle(a2x,a2y,3,1,couleursuppression,pmcopy,true);
    end;
     end;
    if modeduplication then begin
        mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
    end;


ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

agp:=donneanglepolairedans02pi(a2x-a1x,a2y-a1y);

{mc.trait((a1x+a2x)/2,(a1y+a2y)/2,(a1x+a2x)/2+ttai/100/zoomfactor*cos(agp+pi/2),
 (a1y+a2y)/2+ttai/100/zoomfactor*sin(agp+pi/2),1,clblack,pssolid,pmcopy,true); }

 mc.invconvert(xi,yi,(a1x+a2x)/2{+ttai/100/zoomfactor*cos(agp+pi/2)},
 (a1y+a2y)/2{+ttai/100/zoomfactor*sin(agp+pi/2)},true);

 old_font:=ps.Font;
  ps.font.Color:=clblack;
   ps.font.Name:='Arial Narrow';
 ps.font.Charset:=DEFAULT_CHARSET;
  ps.font.size:=10;
  ps.font.Style:=[];


   s:=floattostrf(sqrt(sqr(a2x-a1x)+sqr(a2y-a1y)),fffixed,4
  +trunc(ln(zoomfactor)/ln(10)),trunc(ln(zoomfactor)/ln(10)))+' '+unitelongueur;

   if (abs(agp)<1e-10) or (abs(agp-2*pi)<1e-10)
   then ps.TextOut(xi-ps.textwidth(s),yi-ps.textheight(s),s)
   else
   if (abs(agp-pi/2)<1e-10) then ps.TextOut(xi-ps.textwidth(s),
   yi-ps.textheight(s),s)
   else
   if (abs(agp-pi)<1e-10)  then    ps.TextOut(xi-ps.textwidth(s),yi,s)
     else
    if (abs(agp-2*pi/2)<1e-10) then   ps.TextOut(xi,yi,s) else begin

    if agp+pi/2>4*pi/2 then ps.TextOut(xi,yi-ps.textheight(s),s);
   if ((agp+pi/2>pi/2) and (agp+pi/2<pi)) then
          ps.TextOut(xi-ps.textwidth(s),yi-ps.textheight(s),s);
              if ((agp+pi/2>pi) and (agp+pi/2<3*pi/2)) then
      ps.TextOut(xi-ps.textwidth(s),yi,s);
      if ((agp+pi/2>3*pi/2) and (agp+pi/2<4*pi/2))  then
       ps.TextOut(xi,yi,s);
       end;
       ps.Font:=old_font;
 end;





 procedure metre.imprime(mc:tmyimprimante);
var agp,ttai:extended;
xi,yi:integer; old_font:tfont;
s:string;
 begin
 old_font:=imprimante.Canvas.Font;
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,1,clblack,pssolid,pmcopy,true);
if not(modeduplication) then begin
 mc.cercle(a1x,a1y,3,1,clblack,pmcopy,true);

    mc.cercle(a2x,a2y,3,1,clblack,pmcopy,true);
    if modeinfo then
     mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
     if modemodif then begin
       mc.cercle(a1x,a1y,3,1,couleurpoignees,pmcopy,true);
mc.croixx((a1x+a2x)/2,(a1y+a2y)/2,3,
2,couleurtrans,pmcopy,true);
    mc.cercle(a2x,a2y,3,1,couleurpoignees,pmcopy,true);
    end;

    if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);

    if modesuppression then begin
       mc.cercle(a1x,a1y,3,1,couleursuppression,pmcopy,true);

    mc.cercle(a2x,a2y,3,1,couleursuppression,pmcopy,true);
    end;
     end;
    if modeduplication then begin
        mc.cercle(cx,cy,3,1,couleurpoignees,pmcopy,true);
    end;


ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

agp:=donneanglepolairedans02pi(a2x-a1x,a2y-a1y);

{mc.trait((a1x+a2x)/2,(a1y+a2y)/2,(a1x+a2x)/2+ttai/100/zoomfactor*cos(agp+pi/2),
 (a1y+a2y)/2+ttai/100/zoomfactor*sin(agp+pi/2),1,clblack,pssolid,pmcopy,true); }

 mc.invconvert(xi,yi,(a1x+a2x)/2{+ttai/100/zoomfactor*cos(agp+pi/2)},
 (a1y+a2y)/2{+ttai/100/zoomfactor*sin(agp+pi/2)},true);

  imprimante.canvas.font.Color:=clblack;
   imprimante.canvas.font.Name:='Arial Narrow';
  imprimante.canvas.font.Charset:=DEFAULT_CHARSET;
  imprimante.canvas.font.size:=10;
  imprimante.canvas.font.Style:=[];


   s:=floattostrf(sqrt(sqr(a2x-a1x)+sqr(a2y-a1y)),fffixed,4
  +trunc(ln(zoomfactor)/ln(10)),trunc(ln(zoomfactor)/ln(10)))+' '+unitelongueur;

   if (abs(agp)<1e-10) or (abs(agp-2*pi)<1e-10)
   then imprimante.canvas.TextOut(xi-imprimante.canvas.textwidth(s),yi-imprimante.canvas.textheight(s),s)
   else
   if (abs(agp-pi/2)<1e-10) then imprimante.canvas.TextOut(xi-imprimante.canvas.textwidth(s),
   yi-imprimante.canvas.textheight(s),s)
   else
   if (abs(agp-pi)<1e-10)  then    imprimante.canvas.TextOut(xi-imprimante.canvas.textwidth(s),yi,s)
     else
    if (abs(agp-2*pi/2)<1e-10) then   imprimante.canvas.TextOut(xi,yi,s) else begin

    if agp+pi/2>4*pi/2 then imprimante.canvas.TextOut(xi,yi-imprimante.canvas.textheight(s),s);
   if ((agp+pi/2>pi/2) and (agp+pi/2<pi)) then
          imprimante.canvas.TextOut(xi-imprimante.canvas.textwidth(s),yi-imprimante.canvas.textheight(s),s);
              if ((agp+pi/2>pi) and (agp+pi/2<3*pi/2)) then
      imprimante.canvas.TextOut(xi-imprimante.canvas.textwidth(s),yi,s);
      if ((agp+pi/2>3*pi/2) and (agp+pi/2<4*pi/2))  then
       imprimante.canvas.TextOut(xi,yi,s);
       end;
   imprimante.canvas.Font:=old_font;
 end;



 procedure lsr.dessine(mc:tmonbitmap);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);

end;

if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;

if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);

 if modeduplication then
  mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;



  procedure lsr.dessinePS(mc:tmonpostscript);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);

end;

if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;

if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);

 if modeduplication then
  mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;





 procedure lsr.imprime(mc:tmyimprimante);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);

end;

if (modesuppression) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(a2x,a2y,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleursuppression,pmcopy,true);
end;

if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);

 if modeduplication then
  mc.cercle(cx,cy,3*self.epaisseur,
self.epaisseur,couleurpoignees,pmcopy,true);
end;

procedure mscopa.dessine(mc:tmonbitmap);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 if not(trou) then
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true) else begin
  mc.trait(a1x,a1y,t1x,t1y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
  mc.trait(a2x,a2y,t2x,t2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
  mc.trait(t1x,t1y,t2x,t2y,self.epaisseur,self.couleur,psdot,pmcopy,true)
  end;

  if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(sx,sy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;

   if (modesuppression) then begin
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
   mc.cercle(fx,fy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;

  if modeduplication then
   mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(taille/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 mc.trait(a1x+i/(nbtrait+1)*(a2x-a1x),a1y+i/(nbtrait+1)*(a2y-a1y),
 a1x+i/
 (nbtrait+1)*(a2x-a1x)+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/2),a1y+i/(nbtrait+1)*(a2y-a1y)+ttai/100/zoomfactor*
 sin(anglepolaire-Pi/2),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 end;
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
  mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+3*Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+3*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire+Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire+Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);

 if self.axefocal then begin
 mc.trait(sx,sy,fx,fy,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(fx,fy,2*self.epaisseur,self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) and not(modeduplication) then
 if modemodif then
mc.croixx(fx,fy,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(fx,fy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
end;



procedure mscopa.dessinePS(mc:tmonpostscript);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 if not(trou) then
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true) else begin
  mc.trait(a1x,a1y,t1x,t1y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
  mc.trait(a2x,a2y,t2x,t2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
  mc.trait(t1x,t1y,t2x,t2y,self.epaisseur,self.couleur,psdot,pmcopy,true)
  end;

  if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(sx,sy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;

   if (modesuppression) then begin
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
   mc.cercle(fx,fy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;

  if modeduplication then
   mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(taille/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 mc.trait(a1x+i/(nbtrait+1)*(a2x-a1x),a1y+i/(nbtrait+1)*(a2y-a1y),
 a1x+i/
 (nbtrait+1)*(a2x-a1x)+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/2),a1y+i/(nbtrait+1)*(a2y-a1y)+ttai/100/zoomfactor*
 sin(anglepolaire-Pi/2),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 end;
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
  mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+3*Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+3*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire+Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire+Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);

 if self.axefocal then begin
 mc.trait(sx,sy,fx,fy,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(fx,fy,2*self.epaisseur,self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) and not(modeduplication) then
 if modemodif then
mc.croixx(fx,fy,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(fx,fy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
end;





procedure mscopa.imprime(mc:tmyimprimante);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 if not(trou) then
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true) else begin
  mc.trait(a1x,a1y,t1x,t1y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
  mc.trait(a2x,a2y,t2x,t2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
  mc.trait(t1x,t1y,t2x,t2y,self.epaisseur,self.couleur,psdot,pmcopy,true)
  end;

  if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(sx,sy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;

   if (modesuppression) then begin
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
   mc.cercle(fx,fy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;

  if modeduplication then
   mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(taille/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 mc.trait(a1x+i/(nbtrait+1)*(a2x-a1x),a1y+i/(nbtrait+1)*(a2y-a1y),
 a1x+i/
 (nbtrait+1)*(a2x-a1x)+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/2),a1y+i/(nbtrait+1)*(a2y-a1y)+ttai/100/zoomfactor*
 sin(anglepolaire-Pi/2),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 end;
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
  mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+3*Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+3*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire+Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire+Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);

 if self.axefocal then begin
 mc.trait(sx,sy,fx,fy,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(fx,fy,2*self.epaisseur,self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) and not(modeduplication) then
 if modemodif then
mc.croixx(fx,fy,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(fx,fy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
end;


procedure lmc.dessine(mc:tmonbitmap);
var  ttai:extended;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  if modemodif then
mc.croixx(ox,oy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;

  if modegroupement then
mc.croixx(ox,oy,3,
2,clpurple,pmcopy,true);
  if (modesuppression) then begin
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(f1x,f1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(f2x,f2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;


  if modeduplication then
 mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

  mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire-Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire-3*Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire-3*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire+3*Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire+3*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);

 if self.axefocal then  begin
 mc.trait(f1x,f1y,f2x,f2y,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
  mc.cercle(f1x,f1y,2*self.epaisseur,
 self.epaisseur,self.couleuraxe,pmcopy,true);
 mc.cercle(f2x,f2y,2*self.epaisseur,
 self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(f1x,f1y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(f1x,f1y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 if modemodif then
mc.croixx(f2x,f2y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(f2x,f2y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 end;
end;



procedure lmc.dessinePS(mc:tmonpostscript);
var  ttai:extended;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  if modemodif then
mc.croixx(ox,oy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;

  if modegroupement then
mc.croixx(ox,oy,3,
2,clpurple,pmcopy,true);
  if (modesuppression) then begin
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(f1x,f1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(f2x,f2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;


  if modeduplication then
 mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

  mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire-Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire-3*Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire-3*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire+3*Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire+3*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);

 if self.axefocal then  begin
 mc.trait(f1x,f1y,f2x,f2y,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
  mc.cercle(f1x,f1y,2*self.epaisseur,
 self.epaisseur,self.couleuraxe,pmcopy,true);
 mc.cercle(f2x,f2y,2*self.epaisseur,
 self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(f1x,f1y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(f1x,f1y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 if modemodif then
mc.croixx(f2x,f2y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(f2x,f2y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 end;
end;




procedure lmc.imprime(mc:tmyimprimante);
var  ttai:extended;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  if modemodif then
mc.croixx(ox,oy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;

  if modegroupement then
mc.croixx(ox,oy,3,
2,clpurple,pmcopy,true);
  if (modesuppression) then begin
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(f1x,f1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(f2x,f2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;


  if modeduplication then
 mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

  mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire-Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire-3*Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire-3*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire+3*Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire+3*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);

 if self.axefocal then  begin
 mc.trait(f1x,f1y,f2x,f2y,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
  mc.cercle(f1x,f1y,2*self.epaisseur,
 self.epaisseur,self.couleuraxe,pmcopy,true);
 mc.cercle(f2x,f2y,2*self.epaisseur,
 self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(f1x,f1y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(f1x,f1y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 if modemodif then
mc.croixx(f2x,f2y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(f2x,f2y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 end;
end;

 procedure lmd.dessine(mc:tmonbitmap);
var  ttai:extended;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(ox,oy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;


  if modegroupement then
mc.croixx(ox,oy,3,
2,clpurple,pmcopy,true);

  if (modesuppression) then begin
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(f1x,f1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(f2x,f2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;


  if modeduplication then
   mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

  mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+3*Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+3*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+5*Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+5*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire+Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire+Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire-Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);

 if self.axefocal then  begin
 mc.trait(f1x,f1y,f2x,f2y,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(f1x,f1y,2*self.epaisseur,
 self.epaisseur,self.couleuraxe,pmcopy,true);
 mc.cercle(f2x,f2y,2*self.epaisseur,
 self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(f1x,f1y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(f1x,f1y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 if modemodif then
mc.croixx(f2x,f2y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(f2x,f2y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 end;
end;


 procedure lmd.dessinePS(mc:tmonpostscript);
var  ttai:extended;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(ox,oy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;


  if modegroupement then
mc.croixx(ox,oy,3,
2,clpurple,pmcopy,true);

  if (modesuppression) then begin
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(f1x,f1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(f2x,f2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;


  if modeduplication then
   mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

  mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+3*Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+3*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+5*Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+5*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire+Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire+Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire-Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);

 if self.axefocal then  begin
 mc.trait(f1x,f1y,f2x,f2y,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(f1x,f1y,2*self.epaisseur,
 self.epaisseur,self.couleuraxe,pmcopy,true);
 mc.cercle(f2x,f2y,2*self.epaisseur,
 self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(f1x,f1y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(f1x,f1y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 if modemodif then
mc.croixx(f2x,f2y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(f2x,f2y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 end;
end;


procedure lmd.imprime(mc:tmyimprimante);
var  ttai:extended;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(ox,oy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;


  if modegroupement then
mc.croixx(ox,oy,3,
2,clpurple,pmcopy,true);

  if (modesuppression) then begin
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(f1x,f1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(f2x,f2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;


  if modeduplication then
   mc.cercle(ox,oy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));

  mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+3*Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+3*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+5*Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+5*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire+Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire+Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire-Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);

 if self.axefocal then  begin
 mc.trait(f1x,f1y,f2x,f2y,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(f1x,f1y,2*self.epaisseur,
 self.epaisseur,self.couleuraxe,pmcopy,true);
 mc.cercle(f2x,f2y,2*self.epaisseur,
 self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(f1x,f1y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(f1x,f1y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 if modemodif then
mc.croixx(f2x,f2y,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(f2x,f2y,3*self.epaisseur,
 self.epaisseur,couleurpoignees,pmcopy,true);
 end;
end;

procedure mscepa.dessine(mc:tmonbitmap);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 if not(trou) then
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true) else begin
  mc.trait(a1x,a1y,t1x,t1y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
  mc.trait(a2x,a2y,t2x,t2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
  mc.trait(t1x,t1y,t2x,t2y,self.epaisseur,self.couleur,psdot,pmcopy,true)
  end;

 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(sx,sy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;

   if (modesuppression) then begin
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
   mc.cercle(fx,fy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;


  if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);



  if modeduplication then
  mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(taille/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 mc.trait(a1x+i/(nbtrait+1)*(a2x-a1x),a1y+i/(nbtrait+1)*(a2y-a1y),
 a1x+i/
 (nbtrait+1)*(a2x-a1x)+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/2),a1y+i/(nbtrait+1)*(a2y-a1y)+ttai/100/zoomfactor*
 sin(anglepolaire-Pi/2),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 end;
  mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+5*Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+5*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire-Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);

 if self.axefocal then  begin
 mc.trait(sx,sy,fx,fy,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(fx,fy,2*self.epaisseur,self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) and not(modeduplication) then
 if modemodif then
mc.croixx(fx,fy,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(fx,fy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
end;

procedure mscepa.dessinePS(mc:tmonpostscript);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 if not(trou) then
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true) else begin
  mc.trait(a1x,a1y,t1x,t1y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
  mc.trait(a2x,a2y,t2x,t2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
  mc.trait(t1x,t1y,t2x,t2y,self.epaisseur,self.couleur,psdot,pmcopy,true)
  end;

 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(sx,sy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;

   if (modesuppression) then begin
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
   mc.cercle(fx,fy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;


  if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);



  if modeduplication then
  mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(taille/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 mc.trait(a1x+i/(nbtrait+1)*(a2x-a1x),a1y+i/(nbtrait+1)*(a2y-a1y),
 a1x+i/
 (nbtrait+1)*(a2x-a1x)+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/2),a1y+i/(nbtrait+1)*(a2y-a1y)+ttai/100/zoomfactor*
 sin(anglepolaire-Pi/2),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 end;
  mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+5*Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+5*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire-Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);

 if self.axefocal then  begin
 mc.trait(sx,sy,fx,fy,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(fx,fy,2*self.epaisseur,self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) and not(modeduplication) then
 if modemodif then
mc.croixx(fx,fy,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(fx,fy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
end;


procedure mscepa.imprime(mc:tmyimprimante);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 if not(trou) then
 mc.trait(a1x,a1y,a2x,a2y,self.epaisseur,self.couleur,pssolid,pmcopy,true) else begin
  mc.trait(a1x,a1y,t1x,t1y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
  mc.trait(a2x,a2y,t2x,t2y,self.epaisseur,self.couleur,pssolid,pmcopy,true);
  mc.trait(t1x,t1y,t2x,t2y,self.epaisseur,self.couleur,psdot,pmcopy,true)
  end;

 if not(modeduplication) then
 if (modemodif or modeinfo) then begin
 if modemodif then
mc.croixx(sx,sy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;

   if (modesuppression) then begin
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
   mc.cercle(fx,fy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;


  if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);



  if modeduplication then
  mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(taille/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 mc.trait(a1x+i/(nbtrait+1)*(a2x-a1x),a1y+i/(nbtrait+1)*(a2y-a1y),
 a1x+i/
 (nbtrait+1)*(a2x-a1x)+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/2),a1y+i/(nbtrait+1)*(a2y-a1y)+ttai/100/zoomfactor*
 sin(anglepolaire-Pi/2),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 end;
  mc.trait(a1x,a1y, a1x+ttai/100/zoomfactor*
 cos(anglepolaire+5*Pi/4),a1y+ttai/100/zoomfactor* sin(anglepolaire+5*Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 mc.trait(a2x,a2y, a2x+ttai/100/zoomfactor*
 cos(anglepolaire-Pi/4),a2y+ttai/100/zoomfactor* sin(anglepolaire-Pi/4),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);

 if self.axefocal then  begin
 mc.trait(sx,sy,fx,fy,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(fx,fy,2*self.epaisseur,self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) and not(modeduplication) then
 if modemodif then
mc.croixx(fx,fy,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(fx,fy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
end;



procedure mscore.dessine(mc:tmonbitmap);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
if not(trou) then mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta1,theta2,self.couleur,pmcopy,pssolid,true) else
begin
mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta1,theta1p,self.couleur,pmcopy,pssolid,true);
mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta2p,theta2,self.couleur,pmcopy,pssolid,true);
end;
if not(modeduplication) then
if (modemodif or modeinfo) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
 mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
 if modemodif then
mc.croixx(sx,sy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
   mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
   end;
 if modeduplication then
  mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);

   if (modesuppression) then begin
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
   mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;

  if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);

  if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(circonference/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 if (not(trou) or
 (trou and ((theta1+
 i/(nbtrait+1)*(theta2-theta1)<=theta1p) or
 (theta1+
 i/(nbtrait+1)*(theta2-theta1)>=theta2p)))) then
 mc.trait(cx+(rayoncourbure)*cos(theta1+
 i/(nbtrait+1)*(theta2-theta1)),cy+(rayoncourbure)*sin(theta1+
 i/(nbtrait+1)*(theta2-theta1)),
 cx+(rayoncourbure+ttai/100/zoomfactor)*cos(theta1+
 i/(nbtrait+1)*(theta2-theta1)),cy+(rayoncourbure+ttai/100/zoomfactor)*sin(theta1+
 i/(nbtrait+1)*(theta2-theta1)),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 end;

 if self.axefocal then   begin
 mc.trait(sx,sy,cx,cy,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(cx,cy,2*self.epaisseur,self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) and not(modeduplication)
 then
 if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
end;




procedure mscore.dessinePS(mc:tmonpostscript);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
if not(trou) then  mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta1,theta2,self.couleur,pmcopy,pssolid,true)
else
begin
mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta1,theta1p,self.couleur,pmcopy,pssolid,true);
mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta2p,theta2,self.couleur,pmcopy,pssolid,true);
end;
if not(modeduplication) then
if (modemodif or modeinfo) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
 mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
 if modemodif then
mc.croixx(sx,sy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
   mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
   end;
 if modeduplication then
  mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);

   if (modesuppression) then begin
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
   mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;

  if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);

  if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(circonference/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 if (not(trou) or
 (trou and ((theta1+
 i/(nbtrait+1)*(theta2-theta1)<=theta1p) or
 (theta1+
 i/(nbtrait+1)*(theta2-theta1)>=theta2p)))) then
 mc.trait(cx+(rayoncourbure)*cos(theta1+
 i/(nbtrait+1)*(theta2-theta1)),cy+(rayoncourbure)*sin(theta1+
 i/(nbtrait+1)*(theta2-theta1)),
 cx+(rayoncourbure+ttai/100/zoomfactor)*cos(theta1+
 i/(nbtrait+1)*(theta2-theta1)),cy+(rayoncourbure+ttai/100/zoomfactor)*sin(theta1+
 i/(nbtrait+1)*(theta2-theta1)),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 end;

 if self.axefocal then   begin
 mc.trait(sx,sy,cx,cy,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(cx,cy,2*self.epaisseur,self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) and not(modeduplication)
 then
 if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
end;





procedure mscore.imprime(mc:tmyimprimante);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
if not(trou) then mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta1,theta2,self.couleur,pmcopy,pssolid,true) else
begin
mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta1,theta1p,self.couleur,pmcopy,pssolid,true);
mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta2p,theta2,self.couleur,pmcopy,pssolid,true);
end;
if not(modeduplication) then
if (modemodif or modeinfo) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
 mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
 if modemodif then
mc.croixx(sx,sy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
   mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
   end;
 if modeduplication then
  mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);

   if (modesuppression) then begin
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
   mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;

  if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);

  if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(circonference/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
 if (not(trou) or
 (trou and ((theta1+
 i/(nbtrait+1)*(theta2-theta1)<=theta1p) or
 (theta1+
 i/(nbtrait+1)*(theta2-theta1)>=theta2p)))) then
 mc.trait(cx+(rayoncourbure)*cos(theta1+
 i/(nbtrait+1)*(theta2-theta1)),cy+(rayoncourbure)*sin(theta1+
 i/(nbtrait+1)*(theta2-theta1)),
 cx+(rayoncourbure+ttai/100/zoomfactor)*cos(theta1+
 i/(nbtrait+1)*(theta2-theta1)),cy+(rayoncourbure+ttai/100/zoomfactor)*sin(theta1+
 i/(nbtrait+1)*(theta2-theta1)),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 end;

 if self.axefocal then   begin
 mc.trait(sx,sy,cx,cy,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(cx,cy,2*self.epaisseur,self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) and not(modeduplication)
 then
 if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
end;





procedure mscere.dessine(mc:tmonbitmap);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 if not(trou) then mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta1,theta2,self.couleur,pmcopy,pssolid,true) else
begin
mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta1,theta1p,self.couleur,pmcopy,pssolid,true);
mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta2p,theta2,self.couleur,pmcopy,pssolid,true);
end;

if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);


if not(modeduplication) then
if (modemodif or modeinfo) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
 mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
 if modemodif then
mc.croixx(sx,sy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;
  if modeduplication then
  mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);

   if (modesuppression) then begin
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
   mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;


if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(circonference/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
  if (not(trou) or
 (trou and ((theta1+
 i/(nbtrait+1)*(theta2-theta1)<=theta1p) or
 (theta1+
 i/(nbtrait+1)*(theta2-theta1)>=theta2p)))) then
 mc.trait(cx+(rayoncourbure)*cos(theta1+
 i/(nbtrait+1)*(theta2-theta1)),cy+(rayoncourbure)*sin(theta1+
 i/(nbtrait+1)*(theta2-theta1)),
 cx+(rayoncourbure-ttai/100/zoomfactor)*cos(theta1+
 i/(nbtrait+1)*(theta2-theta1)),cy+(rayoncourbure-ttai/100/zoomfactor)*sin(theta1+
 i/(nbtrait+1)*(theta2-theta1)),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 end;

 if self.axefocal then begin
 mc.trait(sx,sy,cx,cy,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(cx,cy,2*self.epaisseur,self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) and not(modeduplication)
 then
 if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
end;



procedure mscere.dessinePS(mc:tmonpostscript);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 if not(trou) then mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta1,theta2,self.couleur,pmcopy,pssolid,true) else
begin
mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta1,theta1p,self.couleur,pmcopy,pssolid,true);
mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta2p,theta2,self.couleur,pmcopy,pssolid,true);
end;

if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);


if not(modeduplication) then
if (modemodif or modeinfo) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
 mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
 if modemodif then
mc.croixx(sx,sy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;
  if modeduplication then
  mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);

   if (modesuppression) then begin
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
   mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;


if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(circonference/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
  if (not(trou) or
 (trou and ((theta1+
 i/(nbtrait+1)*(theta2-theta1)<=theta1p) or
 (theta1+
 i/(nbtrait+1)*(theta2-theta1)>=theta2p)))) then
 mc.trait(cx+(rayoncourbure)*cos(theta1+
 i/(nbtrait+1)*(theta2-theta1)),cy+(rayoncourbure)*sin(theta1+
 i/(nbtrait+1)*(theta2-theta1)),
 cx+(rayoncourbure-ttai/100/zoomfactor)*cos(theta1+
 i/(nbtrait+1)*(theta2-theta1)),cy+(rayoncourbure-ttai/100/zoomfactor)*sin(theta1+
 i/(nbtrait+1)*(theta2-theta1)),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 end;

 if self.axefocal then begin
 mc.trait(sx,sy,cx,cy,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(cx,cy,2*self.epaisseur,self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) and not(modeduplication)
 then
 if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
end;





procedure mscere.imprime(mc:tmyimprimante);
var i:integer; ttai:extended;  nbtrait:integer;
 begin
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 if not(trou) then mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta1,theta2,self.couleur,pmcopy,pssolid,true) else
begin
mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta1,theta1p,self.couleur,pmcopy,pssolid,true);
mc.arcdecercle(cx,cy,rayoncourbure,self.epaisseur,theta2p,theta2,self.couleur,pmcopy,pssolid,true);
end;

if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);


if not(modeduplication) then
if (modemodif or modeinfo) then begin
mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
 mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
 if modemodif then
mc.croixx(sx,sy,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
  end;
  if modeduplication then
  mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);

   if (modesuppression) then begin
 mc.cercle(sx,sy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
   mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleursuppression,pmcopy,true);
  end;


if self.hachures then begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
nbtrait:=(trunc(circonference/(ttai/100))+1)*zoomfactor;
 for i:=1 to nbtrait do
  if (not(trou) or
 (trou and ((theta1+
 i/(nbtrait+1)*(theta2-theta1)<=theta1p) or
 (theta1+
 i/(nbtrait+1)*(theta2-theta1)>=theta2p)))) then
 mc.trait(cx+(rayoncourbure)*cos(theta1+
 i/(nbtrait+1)*(theta2-theta1)),cy+(rayoncourbure)*sin(theta1+
 i/(nbtrait+1)*(theta2-theta1)),
 cx+(rayoncourbure-ttai/100/zoomfactor)*cos(theta1+
 i/(nbtrait+1)*(theta2-theta1)),cy+(rayoncourbure-ttai/100/zoomfactor)*sin(theta1+
 i/(nbtrait+1)*(theta2-theta1)),
 self.epaisseur,self.couleur,psSolid,pmcopy,true);
 end;

 if self.axefocal then begin
 mc.trait(sx,sy,cx,cy,self.epaisseur,self.couleuraxe,psDashDot,pmcopy,true);
 mc.cercle(cx,cy,2*self.epaisseur,self.epaisseur,self.couleuraxe,pmcopy,true);
 end;
 if (modemodif or modeinfo) and not(modeduplication)
 then
 if modemodif then
mc.croixx(cx,cy,3*self.epaisseur,
self.epaisseur*2,claqua,pmcopy,true) else
 mc.cercle(cx,cy,3*self.epaisseur,self.epaisseur,couleurpoignees,pmcopy,true);
end;




  procedure polyhedre.dessine(mc:tmonbitmap);
  var lx,ly:array[1..maxsommet+1] of extended;
  i,j:integer;

  begin
  for i:=1 to nombresommet do begin
  lx[i]:=messommets[i].ax;
  ly[i]:=messommets[i].ay;
  end;





  mc.tracepolygone(nombresommet,lx,ly,couleurbord,couleurfond,false,pmcopy,true);
  if ((modeinfo or modemodif) and not(modeduplication)) then
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleurpoignees,pmcopy,true);
 if (modemodif or modeduplication) then
  for i:=1 to nombresommet do
  if modemodif then
mc.croixx((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
2,couleurtrans,pmcopy,true) else
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleurpoignees,pmcopy,true);

if (modesuppression) then  begin
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleursuppression,pmcopy,true);
for i:=1 to nombresommet do
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleursuppression,pmcopy,true);
end;

if modegroupement then
mc.croixx(xiso,yiso,3,
2,clpurple,pmcopy,true);
  end;




   procedure polyhedre.dessinePS(mc:tmonpostscript);
  var lx,ly:array[1..maxsommet+1] of extended;
  i,j:integer;

  begin
  for i:=1 to nombresommet do begin
  lx[i]:=messommets[i].ax;
  ly[i]:=messommets[i].ay;
  end;





  mc.tracepolygone(nombresommet,lx,ly,couleurbord,couleurfond,false,pmcopy,true);
  if ((modeinfo or modemodif) and not(modeduplication)) then
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleurpoignees,pmcopy,true);
 if (modemodif or modeduplication) then
  for i:=1 to nombresommet do
  if modemodif then
mc.croixx((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
2,couleurtrans,pmcopy,true) else
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleurpoignees,pmcopy,true);

if (modesuppression) then  begin
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleursuppression,pmcopy,true);
for i:=1 to nombresommet do
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleursuppression,pmcopy,true);
end;

if modegroupement then
mc.croixx(xiso,yiso,3,
2,clpurple,pmcopy,true);
  end;




   procedure polyhedre.imprime(mc:tmyimprimante);
  var lx,ly:array[1..maxsommet+1] of extended;
  i,j:integer;

  begin
  for i:=1 to nombresommet do begin
  lx[i]:=messommets[i].ax;
  ly[i]:=messommets[i].ay;
  end;
  mc.tracepolygone(nombresommet,lx,ly,couleurbord,couleurfond,false,pmcopy,true);
  if ((modeinfo or modemodif) and not(modeduplication)) then
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleurpoignees,pmcopy,true);
 if (modemodif or modeduplication) then
  for i:=1 to nombresommet do
  if modemodif then
mc.croixx((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
2,couleurtrans,pmcopy,true) else
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleurpoignees,pmcopy,true);

if (modesuppression) then  begin
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleursuppression,pmcopy,true);
for i:=1 to nombresommet do
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleursuppression,pmcopy,true);
end;

if modegroupement then
mc.croixx(xiso,yiso,3,
2,clpurple,pmcopy,true);
  end;




   procedure prisme.dessine(mc:tmonbitmap);
  var lx,ly:array[1..maxsommet+1] of extended;
  i,j:integer;

  begin
  for i:=1 to nombresommet do begin
  lx[i]:=messommets[i].ax;
  ly[i]:=messommets[i].ay;
  end;
  mc.tracepolygone(nombresommet,lx,ly,couleurbord,couleurfond,false,pmcopy,true);

  if ((modeinfo or modemodif) and not(modeduplication)) then
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleurpoignees,pmcopy,true);


 if (modemodif or modeduplication) then
  for i:=1 to nombresommet do
  if modemodif then
mc.croixx(gx,gy,3,
2,couleurtrans,pmcopy,true) else
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleurpoignees,pmcopy,true);

if (modesuppression) then  begin
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleursuppression,pmcopy,true);
for i:=1 to nombresommet do
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleursuppression,pmcopy,true);
end;

if modegroupement then
mc.croixx(xiso,yiso,3,
2,clpurple,pmcopy,true);
  end;



   procedure prisme.dessinePS(mc:tmonpostscript);
  var lx,ly:array[1..maxsommet+1] of extended;
  i,j:integer;

  begin
  for i:=1 to nombresommet do begin
  lx[i]:=messommets[i].ax;
  ly[i]:=messommets[i].ay;
  end;
  mc.tracepolygone(nombresommet,lx,ly,couleurbord,couleurfond,false,pmcopy,true);

  if ((modeinfo or modemodif) and not(modeduplication)) then
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleurpoignees,pmcopy,true);


 if (modemodif or modeduplication) then
  for i:=1 to nombresommet do
  if modemodif then
mc.croixx(gx,gy,3,
2,couleurtrans,pmcopy,true) else
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleurpoignees,pmcopy,true);

if (modesuppression) then  begin
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleursuppression,pmcopy,true);
for i:=1 to nombresommet do
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleursuppression,pmcopy,true);
end;

if modegroupement then
mc.croixx(xiso,yiso,3,
2,clpurple,pmcopy,true);
  end;




   procedure prisme.imprime(mc:tmyimprimante);
  var lx,ly:array[1..maxsommet+1] of extended;
  i,j:integer;

  begin
  for i:=1 to nombresommet do begin
  lx[i]:=messommets[i].ax;
  ly[i]:=messommets[i].ay;
  end;
  mc.tracepolygone(nombresommet,lx,ly,couleurbord,couleurfond,false,pmcopy,true);

  if ((modeinfo or modemodif) and not(modeduplication)) then
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleurpoignees,pmcopy,true);


 if (modemodif or modeduplication) then
  for i:=1 to nombresommet do
  if modemodif then
mc.croixx(gx,gy,3,
2,couleurtrans,pmcopy,true) else
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleurpoignees,pmcopy,true);

if (modesuppression) then  begin
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleursuppression,pmcopy,true);
for i:=1 to nombresommet do
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleursuppression,pmcopy,true);
end;

if modegroupement then
mc.croixx(xiso,yiso,3,
2,clpurple,pmcopy,true);
  end;






 procedure rayon.dessine(mc:tmonbitmap);

 var ttai:extended;
 begin
  ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
  if not(modeduplication) then
  if (modemodif or modeinfo) then begin
  mc.cercle(ax,ay,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(ax+kx,ay+ky,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);
  if modemodif then
mc.croixx(ax+kx/2,ay+ky/2,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(ax+kx/2,ay+ky/2,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);
  end;

  if (modesuppression) then begin
  mc.cercle(ax,ay,3*self.epaisseur,
  self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(ax+kx,ay+ky,3*self.epaisseur,
  self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(ax+kx/2,ay+ky/2,3*self.epaisseur,
  self.epaisseur,couleursuppression,pmcopy,true);
  end;

   if modeduplication then mc.cercle(cx,cy,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);

  if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
    end;




 procedure rayon.dessinePS(mc:tmonpostscript);

 var ttai:extended;
 begin
  ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
  if not(modeduplication) then
  if (modemodif or modeinfo) then begin
  mc.cercle(ax,ay,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(ax+kx,ay+ky,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);
  if modemodif then
mc.croixx(ax+kx/2,ay+ky/2,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(ax+kx/2,ay+ky/2,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);
  end;

  if (modesuppression) then begin
  mc.cercle(ax,ay,3*self.epaisseur,
  self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(ax+kx,ay+ky,3*self.epaisseur,
  self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(ax+kx/2,ay+ky/2,3*self.epaisseur,
  self.epaisseur,couleursuppression,pmcopy,true);
  end;

   if modeduplication then mc.cercle(cx,cy,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);

  if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
    end;





     procedure rayon.imprime(mc:tmyimprimante);

 var ttai:extended;
 begin
  ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
  if not(modeduplication) then
  if (modemodif or modeinfo) then begin
  mc.cercle(ax,ay,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(ax+kx,ay+ky,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);
  if modemodif then
mc.croixx(ax+kx/2,ay+ky/2,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(ax+kx/2,ay+ky/2,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);
  end;

  if (modesuppression) then begin
  mc.cercle(ax,ay,3*self.epaisseur,
  self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(ax+kx,ay+ky,3*self.epaisseur,
  self.epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(ax+kx/2,ay+ky/2,3*self.epaisseur,
  self.epaisseur,couleursuppression,pmcopy,true);
  end;

   if modeduplication then mc.cercle(cx,cy,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);

  if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
    end;


procedure DessineTousLesSegments(mc:tmonbitmap);
var i:integer;
ttai,xm,ym,nx,ny:extended;
begin
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
if nombretotalsegment=0 then exit;
if nombrenormale>0 then for i:=1 to nombrenormale do
   mc.trait(listenormale[-1+i].a1x,listenormale[-1+i].a1y,listenormale[-1+i].a2x,listenormale[-1+i].a2y,
   listenormale[-1+i].epaisseur,listenormale[-1+i].couleur,psdashdot,pmcopy,true);

 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
for i:=1 to nombretotalsegment do
if not (fantomespresents and fantomes[i]) then begin
   mc.trait(listesegment[-1+i].a1x,listesegment[-1+i].a1y,listesegment[-1+i].a2x,listesegment[-1+i].a2y,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,pssolid,pmcopy,true);
  if montrernumerossegments then
  begin

  form1.image1.Picture.Bitmap.Canvas.font.Color:=clblack;
  form1.image1.Picture.Bitmap.Canvas.font.Name:='Arial Narrow';
  form1.image1.Picture.Bitmap.Canvas.font.Charset:=DEFAULT_CHARSET;
  form1.image1.Picture.Bitmap.Canvas.font.size:=10;
  form1.image1.Picture.Bitmap.Canvas.font.Style:=[];
   mc.ecrire((listesegment[-1+i].a1x+listesegment[-1+i].a2x)/2,(listesegment[-1+i].a1y+listesegment[-1+i].a2y)/2,inttostr(i),true,policedefaut);
    end;
  mc.trait(listesegment[-1+i].a1x+(listesegment[-1+i].a2x-listesegment[-1+i].a1x)*positionempennage/1000,
  listesegment[-1+i].a1y+(listesegment[-1+i].a2y- listesegment[-1+i].a1y)*positionempennage/1000,
  listesegment[-1+i].a1x+(listesegment[-1+i].a2x-listesegment[-1+i].a1x)*positionempennage/1000+cos(listesegment[-1+i].ap+3*Pi/4)
  *ttai/1000/zoomfactor*tailleempennage,
listesegment[-1+i].a1y+(listesegment[-1+i].a2y-listesegment[-1+i].a1y)*positionempennage/1000+sin(listesegment[-1+i].ap+3*Pi/4)*ttai/1000/zoomfactor*tailleempennage,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,
pssolid,pmcopy,true);
   mc.trait(listesegment[-1+i].a1x+(listesegment[-1+i].a2x-listesegment[-1+i].a1x)*positionempennage/1000,
   listesegment[-1+i].a1y+(listesegment[-1+i].a2y- listesegment[-1+i].a1y)*positionempennage/1000,
   listesegment[-1+i].a1x+(listesegment[-1+i].a2x-listesegment[-1+i].a1x)*positionempennage/1000+cos(listesegment[-1+i].ap-3*Pi/4)
  *ttai/1000/zoomfactor*tailleempennage,
listesegment[-1+i].a1y+(listesegment[-1+i].a2y- listesegment[-1+i].a1y)*positionempennage/1000+sin(listesegment[-1+i].ap-3*Pi/4)*ttai/1000/zoomfactor*tailleempennage,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,
pssolid,pmcopy,true);
if listesegment[-1+i].virtuelarriere then begin
nx:=listesegment[-1+i].a1x-listesegment[-1+i].a2x;
ny:=listesegment[-1+i].a1y-listesegment[-1+i].a2y;

if nx=0 then
  if ny>0 then begin
  xm:=listesegment[-1+i].a2x;
   ym:=yymax;
   end else begin
    xm:=listesegment[-1+i].a2x;
   ym:=yymin;
   end;

  if ((ny=0) and (nx<>0)) then
  if nx>0 then begin
  xm:=xxmax;
   ym:=listesegment[-1+i].a2y;
   end else begin
    xm:=xxmin;
   ym:=listesegment[-1+i].a2y;
   end;

   if ((ny<>0) and (nx<>0)) then
    if ( (listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx<=yymax)
    and  (listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx>=yymin) and
    (nx<0))
    then begin
    ym:=listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx;
    xm:=xxmin;
    end else
     if ( (listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx<=yymax)
    and  (listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx>=yymin) and
    (nx>0))
    then begin
    ym:=listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx;
    xm:=xxmax;
    end else
     if ( (listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny<=xxmax)
    and  (listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny>=xxmin) and
    (ny<0))
    then begin
    xm:=listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny;
    ym:=yymin;
    end else
     if ( (listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny<=xxmax)
    and  (listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny>=xxmin) and
    (ny>0))
    then begin
    xm:=listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny;
    ym:=yymax;
    end;
    mc.trait(listesegment[-1+i].a1x,listesegment[-1+i].a1y,xm,ym,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,psdot,pmcopy,true);

  end;

  if listesegment[-1+i].virtuelavant then begin
nx:=-listesegment[-1+i].a1x+listesegment[-1+i].a2x;
ny:=-listesegment[-1+i].a1y+listesegment[-1+i].a2y;

if nx=0 then
  if ny>0 then begin
  xm:=listesegment[-1+i].a2x;
   ym:=yymax;
   end else begin
    xm:=listesegment[-1+i].a2x;
   ym:=yymin;
   end;

  if ((ny=0) and (nx<>0)) then
  if nx>0 then begin
  xm:=xxmax;
   ym:=listesegment[-1+i].a2y;
   end else begin
    xm:=xxmin;
   ym:=listesegment[-1+i].a2y;
   end;

   if ((ny<>0) and (nx<>0)) then
    if ( (listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx<=yymax)
    and  (listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx>=yymin) and
    (nx<0))
    then begin
    ym:=listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx;
    xm:=xxmin;
    end else
     if ( (listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx<=yymax)
    and  (listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx>=yymin) and
    (nx>0))
    then begin
    ym:=listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx;
    xm:=xxmax;
    end else
     if ( (listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny<=xxmax)
    and  (listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny>=xxmin) and
    (ny<0))
    then begin
    xm:=listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny;
    ym:=yymin;
    end else
     if ( (listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny<=xxmax)
    and  (listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny>=xxmin) and
    (ny>0))
    then begin
    xm:=listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny;
    ym:=yymax;
    end;
    mc.trait(listesegment[-1+i].a2x,listesegment[-1+i].a2y,xm,ym,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,psdot,pmcopy,true);

  end;
  end;
                end;


 procedure DessineTousLesSegmentsPS(mc:tmonpostscript);
var i:integer;        old_font:tfont;
ttai,xm,ym,nx,ny:extended;
begin
old_font:=ps.font;
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
if nombretotalsegment=0 then exit;
if nombrenormale>0 then for i:=1 to nombrenormale do
   mc.trait(listenormale[-1+i].a1x,listenormale[-1+i].a1y,listenormale[-1+i].a2x,listenormale[-1+i].a2y,
   listenormale[-1+i].epaisseur,listenormale[-1+i].couleur,psdashdot,pmcopy,true);

 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
for i:=1 to nombretotalsegment do
if not (fantomespresents and fantomes[i]) then begin
   mc.trait(listesegment[-1+i].a1x,listesegment[-1+i].a1y,listesegment[-1+i].a2x,listesegment[-1+i].a2y,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,pssolid,pmcopy,true);
  if montrernumerossegments then
  begin

  ps.font.Color:=clblack;
 ps.font.Name:='Arial Narrow';
  ps.font.Charset:=DEFAULT_CHARSET;
  ps.font.size:=10;
  ps.font.Style:=[];
   mc.ecrire((listesegment[-1+i].a1x+listesegment[-1+i].a2x)/2,(listesegment[-1+i].a1y+listesegment[-1+i].a2y)/2,inttostr(i),true,policedefaut);
    end;
  mc.trait(listesegment[-1+i].a1x+(listesegment[-1+i].a2x-listesegment[-1+i].a1x)*positionempennage/1000,
  listesegment[-1+i].a1y+(listesegment[-1+i].a2y- listesegment[-1+i].a1y)*positionempennage/1000,
  listesegment[-1+i].a1x+(listesegment[-1+i].a2x-listesegment[-1+i].a1x)*positionempennage/1000+cos(listesegment[-1+i].ap+3*Pi/4)
  *ttai/1000/zoomfactor*tailleempennage,
listesegment[-1+i].a1y+(listesegment[-1+i].a2y-listesegment[-1+i].a1y)*positionempennage/1000+sin(listesegment[-1+i].ap+3*Pi/4)*ttai/1000/zoomfactor*tailleempennage,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,
pssolid,pmcopy,true);
   mc.trait(listesegment[-1+i].a1x+(listesegment[-1+i].a2x-listesegment[-1+i].a1x)*positionempennage/1000,
   listesegment[-1+i].a1y+(listesegment[-1+i].a2y- listesegment[-1+i].a1y)*positionempennage/1000,
   listesegment[-1+i].a1x+(listesegment[-1+i].a2x-listesegment[-1+i].a1x)*positionempennage/1000+cos(listesegment[-1+i].ap-3*Pi/4)
  *ttai/1000/zoomfactor*tailleempennage,
listesegment[-1+i].a1y+(listesegment[-1+i].a2y- listesegment[-1+i].a1y)*positionempennage/1000+sin(listesegment[-1+i].ap-3*Pi/4)*ttai/1000/zoomfactor*tailleempennage,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,
pssolid,pmcopy,true);
if listesegment[-1+i].virtuelarriere then begin
nx:=listesegment[-1+i].a1x-listesegment[-1+i].a2x;
ny:=listesegment[-1+i].a1y-listesegment[-1+i].a2y;

if nx=0 then
  if ny>0 then begin
  xm:=listesegment[-1+i].a2x;
   ym:=yymax;
   end else begin
    xm:=listesegment[-1+i].a2x;
   ym:=yymin;
   end;

  if ((ny=0) and (nx<>0)) then
  if nx>0 then begin
  xm:=xxmax;
   ym:=listesegment[-1+i].a2y;
   end else begin
    xm:=xxmin;
   ym:=listesegment[-1+i].a2y;
   end;

   if ((ny<>0) and (nx<>0)) then
    if ( (listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx<=yymax)
    and  (listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx>=yymin) and
    (nx<0))
    then begin
    ym:=listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx;
    xm:=xxmin;
    end else
     if ( (listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx<=yymax)
    and  (listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx>=yymin) and
    (nx>0))
    then begin
    ym:=listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx;
    xm:=xxmax;
    end else
     if ( (listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny<=xxmax)
    and  (listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny>=xxmin) and
    (ny<0))
    then begin
    xm:=listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny;
    ym:=yymin;
    end else
     if ( (listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny<=xxmax)
    and  (listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny>=xxmin) and
    (ny>0))
    then begin
    xm:=listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny;
    ym:=yymax;
    end;
    mc.trait(listesegment[-1+i].a1x,listesegment[-1+i].a1y,xm,ym,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,psdot,pmcopy,true);

  end;

  if listesegment[-1+i].virtuelavant then begin
nx:=-listesegment[-1+i].a1x+listesegment[-1+i].a2x;
ny:=-listesegment[-1+i].a1y+listesegment[-1+i].a2y;

if nx=0 then
  if ny>0 then begin
  xm:=listesegment[-1+i].a2x;
   ym:=yymax;
   end else begin
    xm:=listesegment[-1+i].a2x;
   ym:=yymin;
   end;

  if ((ny=0) and (nx<>0)) then
  if nx>0 then begin
  xm:=xxmax;
   ym:=listesegment[-1+i].a2y;
   end else begin
    xm:=xxmin;
   ym:=listesegment[-1+i].a2y;
   end;

   if ((ny<>0) and (nx<>0)) then
    if ( (listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx<=yymax)
    and  (listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx>=yymin) and
    (nx<0))
    then begin
    ym:=listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx;
    xm:=xxmin;
    end else
     if ( (listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx<=yymax)
    and  (listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx>=yymin) and
    (nx>0))
    then begin
    ym:=listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx;
    xm:=xxmax;
    end else
     if ( (listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny<=xxmax)
    and  (listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny>=xxmin) and
    (ny<0))
    then begin
    xm:=listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny;
    ym:=yymin;
    end else
     if ( (listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny<=xxmax)
    and  (listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny>=xxmin) and
    (ny>0))
    then begin
    xm:=listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny;
    ym:=yymax;
    end;
    mc.trait(listesegment[-1+i].a2x,listesegment[-1+i].a2y,xm,ym,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,psdot,pmcopy,true);

  end;
  end;
ps.Font:=old_font;
                end;





                procedure ImprimeTousLesSegments(mc:tmyimprimante);
var i:integer;
ttai,xm,ym,nx,ny:extended;   old_font:tfont;
begin
old_font:=imprimante.canvas.font;
ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
if nombretotalsegment=0 then exit;
if nombrenormale>0 then for i:=1 to nombrenormale do
   mc.trait(listenormale[-1+i].a1x,listenormale[-1+i].a1y,listenormale[-1+i].a2x,listenormale[-1+i].a2y,
   listenormale[-1+i].epaisseur,listenormale[-1+i].couleur,psdashdot,pmcopy,true);

 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
for i:=1 to nombretotalsegment do
if not (fantomespresents and fantomes[i]) then begin
   mc.trait(listesegment[-1+i].a1x,listesegment[-1+i].a1y,listesegment[-1+i].a2x,listesegment[-1+i].a2y,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,pssolid,pmcopy,true);
  if montrernumerossegments then
  begin

  imprimante.canvas.font.Color:=clblack;
  imprimante.canvas.font.Name:='Arial Narrow';
  imprimante.canvas.font.Charset:=DEFAULT_CHARSET;
  imprimante.canvas.font.size:=10;
  imprimante.canvas.font.Style:=[];
   mc.ecrire((listesegment[-1+i].a1x+listesegment[-1+i].a2x)/2,(listesegment[-1+i].a1y+listesegment[-1+i].a2y)/2,inttostr(i),true,policedefaut);
    end;
  mc.trait(listesegment[-1+i].a1x+(listesegment[-1+i].a2x-listesegment[-1+i].a1x)*positionempennage/1000,
  listesegment[-1+i].a1y+(listesegment[-1+i].a2y- listesegment[-1+i].a1y)*positionempennage/1000,
  listesegment[-1+i].a1x+(listesegment[-1+i].a2x-listesegment[-1+i].a1x)*positionempennage/1000+cos(listesegment[-1+i].ap+3*Pi/4)
  *ttai/1000/zoomfactor*tailleempennage,
listesegment[-1+i].a1y+(listesegment[-1+i].a2y-listesegment[-1+i].a1y)*positionempennage/1000+sin(listesegment[-1+i].ap+3*Pi/4)*ttai/1000/zoomfactor*tailleempennage,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,
pssolid,pmcopy,true);
   mc.trait(listesegment[-1+i].a1x+(listesegment[-1+i].a2x-listesegment[-1+i].a1x)*positionempennage/1000,
   listesegment[-1+i].a1y+(listesegment[-1+i].a2y- listesegment[-1+i].a1y)*positionempennage/1000,
   listesegment[-1+i].a1x+(listesegment[-1+i].a2x-listesegment[-1+i].a1x)*positionempennage/1000+cos(listesegment[-1+i].ap-3*Pi/4)
  *ttai/1000/zoomfactor*tailleempennage,
listesegment[-1+i].a1y+(listesegment[-1+i].a2y- listesegment[-1+i].a1y)*positionempennage/1000+sin(listesegment[-1+i].ap-3*Pi/4)*ttai/1000/zoomfactor*tailleempennage,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,
pssolid,pmcopy,true);
if listesegment[-1+i].virtuelarriere then begin
nx:=listesegment[-1+i].a1x-listesegment[-1+i].a2x;
ny:=listesegment[-1+i].a1y-listesegment[-1+i].a2y;

if nx=0 then
  if ny>0 then begin
  xm:=listesegment[-1+i].a2x;
   ym:=yymax;
   end else begin
    xm:=listesegment[-1+i].a2x;
   ym:=yymin;
   end;

  if ((ny=0) and (nx<>0)) then
  if nx>0 then begin
  xm:=xxmax;
   ym:=listesegment[-1+i].a2y;
   end else begin
    xm:=xxmin;
   ym:=listesegment[-1+i].a2y;
   end;

   if ((ny<>0) and (nx<>0)) then
    if ( (listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx<=yymax)
    and  (listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx>=yymin) and
    (nx<0))
    then begin
    ym:=listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx;
    xm:=xxmin;
    end else
     if ( (listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx<=yymax)
    and  (listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx>=yymin) and
    (nx>0))
    then begin
    ym:=listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx;
    xm:=xxmax;
    end else
     if ( (listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny<=xxmax)
    and  (listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny>=xxmin) and
    (ny<0))
    then begin
    xm:=listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny;
    ym:=yymin;
    end else
     if ( (listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny<=xxmax)
    and  (listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny>=xxmin) and
    (ny>0))
    then begin
    xm:=listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny;
    ym:=yymax;
    end;
    mc.trait(listesegment[-1+i].a1x,listesegment[-1+i].a1y,xm,ym,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,psdot,pmcopy,true);

  end;

  if listesegment[-1+i].virtuelavant then begin
nx:=-listesegment[-1+i].a1x+listesegment[-1+i].a2x;
ny:=-listesegment[-1+i].a1y+listesegment[-1+i].a2y;

if nx=0 then
  if ny>0 then begin
  xm:=listesegment[-1+i].a2x;
   ym:=yymax;
   end else begin
    xm:=listesegment[-1+i].a2x;
   ym:=yymin;
   end;

  if ((ny=0) and (nx<>0)) then
  if nx>0 then begin
  xm:=xxmax;
   ym:=listesegment[-1+i].a2y;
   end else begin
    xm:=xxmin;
   ym:=listesegment[-1+i].a2y;
   end;

   if ((ny<>0) and (nx<>0)) then
    if ( (listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx<=yymax)
    and  (listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx>=yymin) and
    (nx<0))
    then begin
    ym:=listesegment[-1+i].a2y+(xxmin-listesegment[-1+i].a2x)*ny/nx;
    xm:=xxmin;
    end else
     if ( (listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx<=yymax)
    and  (listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx>=yymin) and
    (nx>0))
    then begin
    ym:=listesegment[-1+i].a2y+(xxmax-listesegment[-1+i].a2x)*ny/nx;
    xm:=xxmax;
    end else
     if ( (listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny<=xxmax)
    and  (listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny>=xxmin) and
    (ny<0))
    then begin
    xm:=listesegment[-1+i].a2x+(yymin-listesegment[-1+i].a2y)*nx/ny;
    ym:=yymin;
    end else
     if ( (listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny<=xxmax)
    and  (listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny>=xxmin) and
    (ny>0))
    then begin
    xm:=listesegment[-1+i].a2x+(yymax-listesegment[-1+i].a2y)*nx/ny;
    ym:=yymax;
    end;
    mc.trait(listesegment[-1+i].a2x,listesegment[-1+i].a2y,xm,ym,listesegment[-1+i].epaisseur,listesegment[-1+i].couleur,psdot,pmcopy,true);

  end;
  end;
imprimante.canvas.font:=old_font;
                end;


                procedure rayon.dessinebis(mc:tmonbitmap;extreme:boolean);
 var ttai:extended;
 begin
  ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
  if extreme then begin
  mc.cercle(ax,ay,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(ax+kx,ay+ky,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);
  end;

end;

                procedure rayon.dessinebisPS(mc:tmonpostscript;extreme:boolean);
                var ttai:extended;
                begin
                 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
                 if extreme then begin
                 mc.cercle(ax,ay,3*self.epaisseur,
                 self.epaisseur,couleurpoignees,pmcopy,true);
                 mc.cercle(ax+kx,ay+ky,3*self.epaisseur,
                 self.epaisseur,couleurpoignees,pmcopy,true);
                 end;

               end;


 procedure rayon.imprimebis(mc:tmyimprimante;extreme:boolean);
 var ttai:extended;
 begin
  ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
  if extreme then begin
  mc.cercle(ax,ay,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(ax+kx,ay+ky,3*self.epaisseur,
  self.epaisseur,couleurpoignees,pmcopy,true);
  end;

end;




  procedure sourceponctuelle.dessine(mc:tmonbitmap);
  var i:integer;
  begin

      if modegroupement then
mc.croixx((a1x+a2x)/2,(a1y+a2y)/2,3,
2,clpurple,pmcopy,true);
      if (modemodif or modeduplication) then
      if modemodif then
mc.croixx((a1x+a2x)/2,(a1y+a2y)/2,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
mc.cercle((a1x+a2x)/2,(a1y+a2y)/2,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
      if ((modemodif or modeinfo) and not(modeduplication)) then  begin
       mc.cercle(sx,sy,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  end;

   if (modesuppression) then  begin
   mc.cercle((a1x+a2x)/2,(a1y+a2y)/2,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
       mc.cercle(sx,sy,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  end;

   end;

  procedure sourceponctuelle.dessinePS(mc:tmonpostscript);
  var i:integer;
  begin

      if modegroupement then
mc.croixx((a1x+a2x)/2,(a1y+a2y)/2,3,
2,clpurple,pmcopy,true);
      if (modemodif or modeduplication) then
      if modemodif then
mc.croixx((a1x+a2x)/2,(a1y+a2y)/2,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
mc.cercle((a1x+a2x)/2,(a1y+a2y)/2,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
      if ((modemodif or modeinfo) and not(modeduplication)) then  begin
       mc.cercle(sx,sy,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  end;

   if (modesuppression) then  begin
   mc.cercle((a1x+a2x)/2,(a1y+a2y)/2,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
       mc.cercle(sx,sy,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  end;

   end;


   procedure sourceponctuelle.imprime(mc:tmyimprimante);
  var i:integer;
  begin

      if modegroupement then
mc.croixx((a1x+a2x)/2,(a1y+a2y)/2,3,
2,clpurple,pmcopy,true);
      if (modemodif or modeduplication) then
      if modemodif then
mc.croixx((a1x+a2x)/2,(a1y+a2y)/2,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
mc.cercle((a1x+a2x)/2,(a1y+a2y)/2,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
      if ((modemodif or modeinfo) and not(modeduplication)) then  begin
       mc.cercle(sx,sy,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  end;

   if (modesuppression) then  begin
   mc.cercle((a1x+a2x)/2,(a1y+a2y)/2,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
       mc.cercle(sx,sy,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  end;

   end;




 procedure OndePlane.dessine(mc:tmonbitmap);
  var i:integer;
  begin
  mc.trait(ray[1].ax,ray[1].ay,ray[nombrederayon].ax,ray[nombrederayon].ay,ray[1].epaisseur,
  ray[1].couleur,psdot,pmcopy,true);

    if nombrederayon>0 then
  for i:=1 to nombrederayon do
   ray[i].dessinebis(mc,false);

   if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);


      if ((modemodif or modeinfo) and not(modeduplication)) then  begin
       mc.cercle(sx,sy,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  if modemodif then
mc.croixx(a1x,a1y,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
   end;

     if ((modeinfo) and not(modeduplication)) then
       mc.cercle(sx+a2x-a1x,sy+a2y-a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);

   if (modesuppression) then  begin
       mc.cercle(sx,sy,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
   end;


  if modeduplication then  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
       end;


  procedure OndePlane.dessinePS(mc:tmonpostscript);
  var i:integer;
  begin
  mc.trait(ray[1].ax,ray[1].ay,ray[nombrederayon].ax,ray[nombrederayon].ay,ray[1].epaisseur,
  ray[1].couleur,psdot,pmcopy,true);

    if nombrederayon>0 then
  for i:=1 to nombrederayon do
   ray[i].dessinebisPS(mc,false);

   if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);


      if ((modemodif or modeinfo) and not(modeduplication)) then  begin
       mc.cercle(sx,sy,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  if modemodif then
mc.croixx(a1x,a1y,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
   end;

     if ((modeinfo) and not(modeduplication)) then
       mc.cercle(sx+a2x-a1x,sy+a2y-a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);

   if (modesuppression) then  begin
       mc.cercle(sx,sy,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
   end;


  if modeduplication then  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
       end;



       procedure OndePlane.imprime(mc:tmyimprimante);
  var i:integer;
  begin
  mc.trait(ray[1].ax,ray[1].ay,ray[nombrederayon].ax,ray[nombrederayon].ay,ray[1].epaisseur,
  ray[1].couleur,psdot,pmcopy,true);

    if nombrederayon>0 then
  for i:=1 to nombrederayon do
   ray[i].imprimebis(mc,false);

   if modegroupement then
mc.croixx(sx,sy,3,
2,clpurple,pmcopy,true);


      if ((modemodif or modeinfo) and not(modeduplication)) then  begin
       mc.cercle(sx,sy,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  if modemodif then
mc.croixx(a1x,a1y,3*self.epaisseur,
self.epaisseur*2,couleurtrans,pmcopy,true) else
  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
  mc.cercle(a2x,a2y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
   end;

     if ((modeinfo) and not(modeduplication)) then
       mc.cercle(sx+a2x-a1x,sy+a2y-a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);

   if (modesuppression) then  begin
       mc.cercle(sx,sy,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
  mc.cercle(a2x,a2y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleursuppression,pmcopy,true);
   end;


  if modeduplication then  mc.cercle(a1x,a1y,3*ray[1].epaisseur,
  ray[1].epaisseur,couleurpoignees,pmcopy,true);
       end;







 procedure sourceponctuelle.calculesegment;
 var i:integer;
 begin
 for i:=1 to nombrederayon do
 if not( (ray[i].couleur=clblack) and (unmilieudispersif or (nombrereseau>0))) then calculesegment0(ray[i].ax,
  ray[i].ay,ray[i].kx,ray[i].ky,ray[i].anglepolaire,ray[i].epaisseur,
  ray[i].couleur,vav,
  vaa,ray[i].nombremaxenfant,ray[i].maxsegment) else
   begin
   retailleprayon(listerayonenfant,nombreenfant,nombreenfant+1);
   inc(nombreenfant);
  listerayonenfant[-1+nombreenfant].createenfant(ray[i].ax,ray[i].ay
  ,ray[i].kx,ray[i].ky,clred,ray[i].epaisseur,
    vav,vaa,ray[i].nombremaxenfant,ray[i].maxsegment,0);
   retailleprayon(listerayonenfant,nombreenfant,nombreenfant+1);
   inc(nombreenfant);
  listerayonenfant[-1+nombreenfant].createenfant(ray[i].ax,ray[i].ay
  ,ray[i].kx,ray[i].ky,clgreen,ray[i].epaisseur,
    vav,vaa,ray[i].nombremaxenfant,ray[i].maxsegment,0);
    retailleprayon(listerayonenfant,nombreenfant,nombreenfant+1);
   inc(nombreenfant);
  listerayonenfant[-1+nombreenfant].createenfant(ray[i].ax,ray[i].ay
  ,ray[i].kx,ray[i].ky,clblue,ray[i].epaisseur,
    vav,vaa,ray[i].nombremaxenfant,ray[i].maxsegment,0);
  end;

 end;

 procedure ondeplane.calculesegment;
 var i:integer;
 begin
 for i:=1 to nombrederayon do
  if not( (ray[i].couleur=clblack) and (unmilieudispersif or (nombrereseau>0))) then calculesegment0(ray[i].ax,
  ray[i].ay,ray[i].kx,ray[i].ky,ray[i].anglepolaire,ray[i].epaisseur,
  ray[i].couleur,vav,
  vaa,ray[i].nombremaxenfant,ray[i].maxsegment) else
   begin
   retailleprayon(listerayonenfant,nombreenfant,nombreenfant+1);
   inc(nombreenfant);
  listerayonenfant[-1+nombreenfant].createenfant(ray[i].ax,ray[i].ay
  ,ray[i].kx,ray[i].ky,clred,ray[i].epaisseur,
    ray[i].vav,ray[i].vaa,ray[i].nombremaxenfant,ray[i].maxsegment,0);
   retailleprayon(listerayonenfant,nombreenfant,nombreenfant+1);
   inc(nombreenfant);
  listerayonenfant[-1+nombreenfant].createenfant(ray[i].ax,ray[i].ay
  ,ray[i].kx,ray[i].ky,clgreen,ray[i].epaisseur,
    ray[i].vav,ray[i].vaa,ray[i].nombremaxenfant,ray[i].maxsegment,0);
    retailleprayon(listerayonenfant,nombreenfant,nombreenfant+1);
   inc(nombreenfant);
  listerayonenfant[-1+nombreenfant].createenfant(ray[i].ax,ray[i].ay
  ,ray[i].kx,ray[i].ky,clblue,ray[i].epaisseur,
    ray[i].vav,ray[i].vaa,ray[i].nombremaxenfant,ray[i].maxsegment,0);
  end;

 end;

 procedure calculesegment0(ax,ay,kx,ky,anglepolaire:extended; epaisseur:integer;
 couleur:tcolor; vav,vaa:shortstring; nombremaxenfant,maxsegment:integer);
 var i,j,iii,jjj:integer;
 bordureatteinte,surfaceabsorbanteatteinte,unrefracte:boolean;
 distance,xact,yact,kxact,kyact,anglepolaireact,
 xfutur,yfutur,kxfutur,kyfutur,anglepolairefutur,anglepolairenormale:extended;
 lambda,lambda1,lambda2,mu,xinter,yinter,incidence,delta,tata,tata1,tata2,tati1,tati2:extended;
  surface_actuelle,surface_future:tsurface;   coteactuel,cotefutur:integer;
  indicesurfaceactuelle,indicesurfacefuture:integer;
  ffx,ffy,xenfant,yenfant,kxenfant,kyenfant,nnx,nny,agp:extended;
  xenfantreseau,yenfantreseau,kxenfantreseau,kyenfantreseau:array of extended;
  nombreenfantreseau:integer;
  naissance,triples:boolean;   nombresegment,nombrenaissance:integer;
  indiceoptiqueactuel,indiceoptiquefutur,patate:extended;
  aaa,bbb,ccc,xxx1,xxx2,rrr1,rrr2,rrr,xxx,nnnx,nnny:extended;
  l_vav,l_vaa:array[1..maxmaxsegment] of boolean;
  anglepolairenormaleatracer,cheminoptique,cheminsup,aic,
  aic0,AO,AOp,distancecentre,anglelimite:extended;
  normaleatracer,normale2cotes:boolean;
  angleincident,anglerefracte:angle;
  incidentatracer,refracteatracer:boolean;
     epsilon,xpact,ypact:extended;  boubou:integer;
     longueur_donde:extended;
 begin
 epsilon:=1e-10;
 if couleur=clred then longueur_donde:=longueur_donde_red;
 if couleur=clblue then longueur_donde:=longueur_donde_blue;
 if couleur=clgreen then longueur_donde:=longueur_donde_green;
 for i:=1 to maxsegment do
  l_vav[i]:=(pos(','+inttostr(i)+',',vav)<>0) or (pos('('+inttostr(i)+',',vav)<>0) or
  (pos(','+inttostr(i)+')',vav)<>0) or
  (pos('('+inttostr(i)+')',vav)<>0);
  for i:=1 to maxsegment do
  l_vaa[i]:=(pos(','+inttostr(i)+',',vaa)<>0) or (pos('('+inttostr(i)+',',vaa)<>0) or
  (pos(','+inttostr(i)+')',vaa)<>0) or
  (pos('('+inttostr(i)+')',vaa)<>0);

       cheminoptique:=0;
 bordureatteinte:=false; surfaceabsorbanteatteinte:=false;
 nombresegment:=0;   nombrenaissance:=0;  coteactuel:=0; cotefutur:=0;
 case couleur of
 clred: indiceoptiqueactuel:=indice_rouge_par_defaut;
 clgreen: indiceoptiqueactuel:=indice_vert_par_defaut;
 clblue: indiceoptiqueactuel:=indice_bleu_par_defaut;
 end;
    indiceoptiquefutur:=indiceoptiqueactuel;
xact:=ax; yact:=ay; kxact:=kx; kyact:=ky; anglepolaireact:=anglepolaire;

   surface_actuelle:=sur_bordure; surface_future:=sur_bordure;
 indicesurfaceactuelle:=0;    indicesurfacefuture:=0;
  incidentatracer:=false; refracteatracer:=false;

  if nombrepolycercle>0 then for i:=1 to nombrepolycercle do
 if listepolycercle[-1+i].estou(ax,ay)=Iinterieur then begin
 case couleur of
 clred: indiceoptiqueactuel:=listepolycercle[-1+i].indicerouge;
 clgreen: indiceoptiqueactuel:=listepolycercle[-1+i].indicevert;
 clblue: indiceoptiqueactuel:=listepolycercle[-1+i].indicebleu;
 end;
 end;

 if nombrepolyhedre>0 then for i:=1 to nombrepolyhedre do
 if listepolyhedre[-1+i].estou(ax,ay)=Iinterieur then begin
 case couleur of
 clred: indiceoptiqueactuel:=listepolyhedre[-1+i].indicerouge;
 clgreen: indiceoptiqueactuel:=listepolyhedre[-1+i].indicevert;
 clblue: indiceoptiqueactuel:=listepolyhedre[-1+i].indicebleu;
 end;
 end;

 if nombreprisme>0 then for i:=1 to nombreprisme do
 if listeprisme[-1+i].estou(ax,ay)=Iinterieur then begin
 case couleur of
 clred: indiceoptiqueactuel:=listeprisme[-1+i].indicerouge;
 clgreen: indiceoptiqueactuel:=listeprisme[-1+i].indicevert;
 clblue: indiceoptiqueactuel:=listeprisme[-1+i].indicebleu;
 end;
 end;

 if nombresphere>0 then for i:=1 to nombresphere do
 if sqrt(sqr(ax-listesphere[-1+i].cx)+sqr(ay-listesphere[-1+i].cy))<
 listesphere[-1+i].rayon then begin
 case couleur of
 clred: indiceoptiqueactuel:=listesphere[-1+i].indicerouge;
 clgreen: indiceoptiqueactuel:=listesphere[-1+i].indicevert;
 clblue: indiceoptiqueactuel:=listesphere[-1+i].indicebleu;
 end;
 end;

if nombrelec>0 then for i:=1 to nombrelec do
 if listelec[-1+i].estou(ax,ay)=Iinterieur then begin
 case couleur of
 clred: indiceoptiqueactuel:=listelec[-1+i].indicerouge;
 clgreen: indiceoptiqueactuel:=listelec[-1+i].indicevert;
 clblue: indiceoptiqueactuel:=listelec[-1+i].indicebleu;
 end;
 end;


 while (not(bordureatteinte) and not (surfaceabsorbanteatteinte) and
           (nombresegment<maxsegment)) do begin
    xpact:=xact;
     ypact:=yact;
 naissance:=false;  triples:=false;   cheminsup:=0;
distance:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin))*1.1;
 normaleatracer:=false;
  normale2cotes:=false;
{distance a la bordure superieure}
if kyact<>0 then begin
     mu:=(kyact*(xact-xxmin)-kxact*(yact-yymax))/(kyact*(xxmax-xxmin));
     lambda:=(yymax-yact)/kyact;
     if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=xxmin+mu*(xxmax-xxmin);
yinter:=yymax;
  if  sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  kxfutur:=kxact; kyfutur:=kyact; anglepolairefutur:=0;
  bordureatteinte:=true;   naissance:=false;
  surface_future:=sur_bordure;
  normaleatracer:=false;
  normale2cotes:=false;
   incidentatracer:=false;
 refracteatracer:=false;
     end; end; end;



{distance a la bordure inferieure}
if kyact<>0 then begin
     mu:=(kyact*(xact-xxmin)-kxact*(yact-yymin))/(kyact*(xxmax-xxmin));
     lambda:=(yymin-yact)/kyact;
     if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=xxmin+mu*(xxmax-xxmin);
yinter:=yymin;
 if  sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
 kxfutur:=kxact; kyfutur:=kyact; anglepolairefutur:=0;
  bordureatteinte:=true;    naissance:=false;
  surface_future:=sur_bordure;
  normaleatracer:=false;
  normale2cotes:=false;
   incidentatracer:=false;
 refracteatracer:=false;
     end; end; end;




{distance a la bordure gauche}
if kxact<>0 then begin
     mu:=(kyact*(xact-xxmin)-kxact*(yact-yymin))/(-kxact*(yymax-yymin));
     lambda:=(xxmin-xact)/kxact;
     if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=xxmin;
yinter:=yymin+mu*(yymax-yymin);
  if  sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
    kxfutur:=kxact; kyfutur:=kyact; anglepolairefutur:=0;
  bordureatteinte:=true;
  surface_future:=sur_bordure;
  normaleatracer:=false;
  normale2cotes:=false;
   incidentatracer:=false;
 refracteatracer:=false;
     end; end; end;


     {distance a la bordure droite}
if kxact<>0 then begin
     mu:=(kyact*(xact-xxmax)-kxact*(yact-yymin))/(-kxact*(yymax-yymin));
     lambda:=(xxmax-xact)/kxact;
     if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=xxmax;
yinter:=yymin+mu*(yymax-yymin);
  if  sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
    kxfutur:=kxact; kyfutur:=kyact; anglepolairefutur:=0;
  bordureatteinte:=true;   naissance:=false;
  surface_future:=sur_bordure;
  normaleatracer:=false;
  normale2cotes:=false;
   incidentatracer:=false;
 refracteatracer:=false;
     end; end; end;






     {test sur les miroirs plans}
         if nombremiroirplan>0 then
     for i:=1 to nombremiroirplan do
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_miroirplan)) then
     if ((kyact*(Listemiroirplan[-1+i].a2x-Listemiroirplan[-1+i].a1x)) <>
     (kxact*(Listemiroirplan[-1+i].a2y-Listemiroirplan[-1+i].a1y  ))  ) then begin
     mu:=(kyact*(xact-Listemiroirplan[-1+i].a1x)-kxact*(yact-Listemiroirplan[-1+i].a1y))/
     (kyact*(Listemiroirplan[-1+i].a2x-Listemiroirplan[-1+i].a1x)-
     kxact*(Listemiroirplan[-1+i].a2y-Listemiroirplan[-1+i].a1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      Listemiroirplan[-1+i].a2x-Listemiroirplan[-1+i].a1x)
      +Listemiroirplan[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(Listemiroirplan[-1+i].a2y-Listemiroirplan[-1+i].a1y)+
      Listemiroirplan[-1+i].a1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=Listemiroirplan[-1+i].a1x+mu*(Listemiroirplan[-1+i].a2x-Listemiroirplan[-1+i].a1x);
yinter:=Listemiroirplan[-1+i].a1y+mu*(Listemiroirplan[-1+i].a2y-Listemiroirplan[-1+i].a1y);
 if   ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;  naissance:=false;
  incidence:=Pi/2-Listemiroirplan[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  if ((incidence>Pi/2) or (incidence<-Pi/2)) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_miroirplan;
   indicesurfacefuture:=i;
   kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listemiroirplan[-1+i].anglepolaire-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listemiroirplan[-1+i].anglepolaire-anglepolaireact);
anglepolairefutur:=2*Listemiroirplan[-1+i].anglepolaire-anglepolaireact;
normaleatracer:=true;
anglepolairenormaleatracer:=Listemiroirplan[-1+i].anglepolaire+pi/2;
normale2cotes:=false;
 if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;

 angleincident.create(xfutur,yfutur,xfutur+cos(Listemiroirplan[-1+i].anglepolaire+pi/2)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 yfutur+sin(Listemiroirplan[-1+i].anglepolaire+pi/2)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 xact,yact) ;
 end;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
     end; end; end; end; {des miroirs plans}


      {test sur les ecrans}

     if nombreEcran>0 then
     for i:=1 to nombreEcran do
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_Ecran)) then
     if ((kyact*(ListeEcran[-1+i].a2x-ListeEcran[-1+i].a1x)) <>
     (kxact*(ListeEcran[-1+i].a2y-ListeEcran[-1+i].a1y  ))  ) then begin
     mu:=(kyact*(xact-ListeEcran[-1+i].a1x)-kxact*(yact-ListeEcran[-1+i].a1y))/
     (kyact*(ListeEcran[-1+i].a2x-ListeEcran[-1+i].a1x)-
     kxact*(ListeEcran[-1+i].a2y-ListeEcran[-1+i].a1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      ListeEcran[-1+i].a2x-ListeEcran[-1+i].a1x)
      +ListeEcran[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(ListeEcran[-1+i].a2y-ListeEcran[-1+i].a1y)+
      ListeEcran[-1+i].a1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=ListeEcran[-1+i].a1x+mu*(ListeEcran[-1+i].a2x-ListeEcran[-1+i].a1x);
yinter:=ListeEcran[-1+i].a1y+mu*(ListeEcran[-1+i].a2y-ListeEcran[-1+i].a1y);
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon))then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;       kxfutur:=kxact; kyfutur:=kyact;
  yfutur:=yinter;
  bordureatteinte:=false;      naissance:=false;
  normaleatracer:=false;
  normale2cotes:=false;
  incidence:=Pi/2-ListeEcran[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
       incidentatracer:=false;
 refracteatracer:=false;
   surfaceabsorbanteatteinte:=true;
    end; end; end; {des ecrans}


    {test sur les diaphragmes}

     if nombrediaphragme>0 then
     for i:=1 to nombrediaphragme do
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_diaphragme)) then
     if ((kyact*(Listediaphragme[-1+i].a2x-Listediaphragme[-1+i].a1x)) <>
     (kxact*(Listediaphragme[-1+i].a2y-Listediaphragme[-1+i].a1y  ))  ) then begin
     mu:=(kyact*(xact-Listediaphragme[-1+i].a1x)-kxact*(yact-Listediaphragme[-1+i].a1y))/
     (kyact*(Listediaphragme[-1+i].a2x-Listediaphragme[-1+i].a1x)-
     kxact*(Listediaphragme[-1+i].a2y-Listediaphragme[-1+i].a1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      Listediaphragme[-1+i].a2x-Listediaphragme[-1+i].a1x)
      +Listediaphragme[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(Listediaphragme[-1+i].a2y-Listediaphragme[-1+i].a1y)+
      Listediaphragme[-1+i].a1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=Listediaphragme[-1+i].a1x+mu*(Listediaphragme[-1+i].a2x-Listediaphragme[-1+i].a1x);
yinter:=Listediaphragme[-1+i].a1y+mu*(Listediaphragme[-1+i].a2y-Listediaphragme[-1+i].a1y);
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;       kxfutur:=kxact; kyfutur:=kyact;
  yfutur:=yinter;
  bordureatteinte:=false;      naissance:=false;
  normaleatracer:=false;
  normale2cotes:=false;
  incidence:=Pi/2-Listediaphragme[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     incidentatracer:=false;
 refracteatracer:=false;
   surfaceabsorbanteatteinte:=true;
    end; end; end; {des diaphragmes}

    {suite du test sur les diaphragmes}

     if nombrediaphragme>0 then
     for i:=1 to nombrediaphragme do
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_diaphragme)) then
     if ((kyact*(Listediaphragme[-1+i].ap2x-Listediaphragme[-1+i].ap1x)) <>
     (kxact*(Listediaphragme[-1+i].ap2y-Listediaphragme[-1+i].ap1y  ))  ) then begin
     mu:=(kyact*(xact-Listediaphragme[-1+i].ap1x)-kxact*(yact-Listediaphragme[-1+i].ap1y))/
     (kyact*(Listediaphragme[-1+i].ap2x-Listediaphragme[-1+i].ap1x)-
     kxact*(Listediaphragme[-1+i].ap2y-Listediaphragme[-1+i].ap1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      Listediaphragme[-1+i].ap2x-Listediaphragme[-1+i].ap1x)
      +Listediaphragme[-1+i].ap1x-xact)/kxact else
      lambda:=(mu*(Listediaphragme[-1+i].ap2y-Listediaphragme[-1+i].ap1y)+
      Listediaphragme[-1+i].ap1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=Listediaphragme[-1+i].ap1x+mu*(Listediaphragme[-1+i].ap2x-Listediaphragme[-1+i].ap1x);
yinter:=Listediaphragme[-1+i].ap1y+mu*(Listediaphragme[-1+i].ap2y-Listediaphragme[-1+i].ap1y);
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;       kxfutur:=kxact; kyfutur:=kyact;
  yfutur:=yinter;
  bordureatteinte:=false;      naissance:=false;
  normaleatracer:=false;
  normale2cotes:=false;
  incidence:=Pi/2-Listediaphragme[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
      incidentatracer:=false;
 refracteatracer:=false;
   surfaceabsorbanteatteinte:=true;
    end; end; end; {des diaphragmes}


    {test sur les lsrs}
           if nombrelsr>0 then
     for i:=1 to nombrelsr do
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_lsr)) then
     if ((kyact*(Listelsr[-1+i].a2x-Listelsr[-1+i].a1x)) <>
     (kxact*(Listelsr[-1+i].a2y-Listelsr[-1+i].a1y  ))  ) then begin
     mu:=(kyact*(xact-Listelsr[-1+i].a1x)-kxact*(yact-Listelsr[-1+i].a1y))/
     (kyact*(Listelsr[-1+i].a2x-Listelsr[-1+i].a1x)-
     kxact*(Listelsr[-1+i].a2y-Listelsr[-1+i].a1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      Listelsr[-1+i].a2x-Listelsr[-1+i].a1x)
      +Listelsr[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(Listelsr[-1+i].a2y-Listelsr[-1+i].a1y)+
      Listelsr[-1+i].a1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=Listelsr[-1+i].a1x+mu*(Listelsr[-1+i].a2x-Listelsr[-1+i].a1x);
yinter:=Listelsr[-1+i].a1y+mu*(Listelsr[-1+i].a2y-Listelsr[-1+i].a1y);
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;
  incidence:=Pi/2-Listelsr[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  surfaceabsorbanteatteinte:=false;
   surface_future:=sur_lsr;
   indicesurfacefuture:=i;
   normaleatracer:=true;
anglepolairenormaleatracer:=Listelsr[-1+i].anglepolaire+pi/2;
normale2cotes:=true;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;
  if not((incidence>Pi/2) or (incidence<-Pi/2)) then
 angleincident.create(xfutur,yfutur,xfutur+cos(Listelsr[-1+i].anglepolaire+pi/2)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 yfutur+sin(Listelsr[-1+i].anglepolaire+pi/2)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 xact,yact)  else
  angleincident.create(xfutur,yfutur,xfutur+cos(Listelsr[-1+i].anglepolaire+pi/2+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 yfutur+sin(Listelsr[-1+i].anglepolaire+pi/2+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 xact,yact) ;
 end;
   naissance:=true;
    kxenfant:=kxact; kyenfant:=kyact;
   xenfant:=xinter+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yenfant:=yinter+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
if ((incidence>Pi/2) or (incidence<-Pi/2)) then begin
 kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*(Listelsr[-1+i].anglepolaire+Pi)-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*(Listelsr[-1+i].anglepolaire+Pi)-anglepolaireact);
anglepolairefutur:=2*(Listelsr[-1+i].anglepolaire+Pi)-anglepolaireact;

if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
   end else begin
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listelsr[-1+i].anglepolaire-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listelsr[-1+i].anglepolaire-anglepolaireact);
anglepolairefutur:=2*Listelsr[-1+i].anglepolaire-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
     end; end; end; end;{des lsrs}





            {test sur les reseaux en transmission}
           if nombrereseau>0 then
     for i:=1 to nombrereseau do
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_reseau))
     and (Listereseau[-1+i].entransmission) then
     if ((kyact*(Listereseau[-1+i].a2x-Listereseau[-1+i].a1x)) <>
     (kxact*(Listereseau[-1+i].a2y-Listereseau[-1+i].a1y  ))  ) then begin
     mu:=(kyact*(xact-Listereseau[-1+i].a1x)-kxact*(yact-Listereseau[-1+i].a1y))/
     (kyact*(Listereseau[-1+i].a2x-Listereseau[-1+i].a1x)-
     kxact*(Listereseau[-1+i].a2y-Listereseau[-1+i].a1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      Listereseau[-1+i].a2x-Listereseau[-1+i].a1x)
      +Listereseau[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(Listereseau[-1+i].a2y-Listereseau[-1+i].a1y)+
      Listereseau[-1+i].a1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=Listereseau[-1+i].a1x+mu*(Listereseau[-1+i].a2x-Listereseau[-1+i].a1x);
yinter:=Listereseau[-1+i].a1y+mu*(Listereseau[-1+i].a2y-Listereseau[-1+i].a1y);
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;
  incidence:=Pi/2-Listereseau[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  surfaceabsorbanteatteinte:=false;
   surface_future:=sur_reseau;
   indicesurfacefuture:=i;
   normaleatracer:=true;
anglepolairenormaleatracer:=Listereseau[-1+i].anglepolaire+pi/2;
normale2cotes:=true;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;
  if not((incidence>Pi/2) or (incidence<-Pi/2)) then
 angleincident.create(xfutur,yfutur,xfutur+cos(Listereseau[-1+i].anglepolaire+pi/2)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 yfutur+sin(Listereseau[-1+i].anglepolaire+pi/2)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 xact,yact)  else
  angleincident.create(xfutur,yfutur,xfutur+cos(Listereseau[-1+i].anglepolaire+pi/2+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 yfutur+sin(Listereseau[-1+i].anglepolaire+pi/2+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 xact,yact) ;
 end;
   naissance:=true;
 //   application.messagebox(pchar(floattostr(longueur_donde)),'',mb_ok);
   nombreenfantreseau:=0;
   setlength(xenfantreseau,nombreenfantreseau);
    setlength(yenfantreseau,nombreenfantreseau);
    setlength(kxenfantreseau,nombreenfantreseau);
    setlength(kyenfantreseau,nombreenfantreseau);
 for boubou:=Listereseau[-1+i].ordre_min to   Listereseau[-1+i].ordre_max do
 if boubou<>0 then
 if  ((abs(incidence)<pi/2) and  (abs(sin(incidence)+boubou/Listereseau[-1+i].pas*longueur_donde)<1))
 or
  ((abs(incidence)>pi/2) and  (abs(sin(incidence-pi)+boubou/Listereseau[-1+i].pas*longueur_donde)<1))
 then begin
   inc(nombreenfantreseau);
   setlength(xenfantreseau,nombreenfantreseau);
    setlength(yenfantreseau,nombreenfantreseau);
    setlength(kxenfantreseau,nombreenfantreseau);
    setlength(kyenfantreseau,nombreenfantreseau);
    if abs(incidence)<pi/2 then begin
 kxenfantreseau[nombreenfantreseau-1]:=sqrt(kxact*kxact+kyact*kyact)*cos(Listereseau[-1+i].anglepolaire-pi/2+arcsin(sin(incidence)+boubou/Listereseau[-1+i].pas*longueur_donde));
 kyenfantreseau[nombreenfantreseau-1]:=sqrt(kxact*kxact+kyact*kyact)*sin(Listereseau[-1+i].anglepolaire-pi/2+arcsin(sin(incidence)+boubou/Listereseau[-1+i].pas*longueur_donde));
 end else begin
 kxenfantreseau[nombreenfantreseau-1]:=sqrt(kxact*kxact+kyact*kyact)*cos(Listereseau[-1+i].anglepolaire+pi/2+arcsin(sin(incidence-pi)+boubou/Listereseau[-1+i].pas*longueur_donde));
 kyenfantreseau[nombreenfantreseau-1]:=sqrt(kxact*kxact+kyact*kyact)*sin(Listereseau[-1+i].anglepolaire+pi/2+arcsin(sin(incidence-pi)+boubou/Listereseau[-1+i].pas*longueur_donde));
 end;
   xenfantreseau[nombreenfantreseau-1]:=xinter+kxenfantreseau[nombreenfantreseau-1]*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yenfantreseau[nombreenfantreseau-1]:=yinter+kyenfantreseau[nombreenfantreseau-1]*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     end;
 kxfutur:=kxact;
kyfutur:=kyact;
anglepolairefutur:=anglepolaireact;

 end;{du cas ou c'est le + proche}

     end; {du cas ou ca intercepte}
     end;{du cas reseau en transmission}




            {test sur les reseaux en reflexion}
           if nombrereseau>0 then
     for i:=1 to nombrereseau do
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_reseau))
     and not(Listereseau[-1+i].entransmission) then
     if ((kyact*(Listereseau[-1+i].a2x-Listereseau[-1+i].a1x)) <>
     (kxact*(Listereseau[-1+i].a2y-Listereseau[-1+i].a1y  ))  ) then begin
     mu:=(kyact*(xact-Listereseau[-1+i].a1x)-kxact*(yact-Listereseau[-1+i].a1y))/
     (kyact*(Listereseau[-1+i].a2x-Listereseau[-1+i].a1x)-
     kxact*(Listereseau[-1+i].a2y-Listereseau[-1+i].a1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      Listereseau[-1+i].a2x-Listereseau[-1+i].a1x)
      +Listereseau[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(Listereseau[-1+i].a2y-Listereseau[-1+i].a1y)+
      Listereseau[-1+i].a1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=Listereseau[-1+i].a1x+mu*(Listereseau[-1+i].a2x-Listereseau[-1+i].a1x);
yinter:=Listereseau[-1+i].a1y+mu*(Listereseau[-1+i].a2y-Listereseau[-1+i].a1y);
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;
  incidence:=Pi/2-Listereseau[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;


  if (abs(incidence)>=pi/2) then begin
   xfutur:=xinter;       kxfutur:=kxact; kyfutur:=kyact;
  yfutur:=yinter;
  bordureatteinte:=false;      naissance:=false;
  normaleatracer:=false;
  normale2cotes:=false;
        incidentatracer:=false;
 refracteatracer:=false;
   surfaceabsorbanteatteinte:=true;

  end else begin
  surfaceabsorbanteatteinte:=false;
   surface_future:=sur_reseau;
   indicesurfacefuture:=i;
   normaleatracer:=true;
anglepolairenormaleatracer:=Listereseau[-1+i].anglepolaire+pi/2;
normale2cotes:=true;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;

 angleincident.create(xfutur,yfutur,xfutur+cos(Listereseau[-1+i].anglepolaire+pi/2)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 yfutur+sin(Listereseau[-1+i].anglepolaire+pi/2)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 xact,yact)
 end;
   naissance:=true;
 //   application.messagebox(pchar(floattostr(longueur_donde)),'',mb_ok);
   nombreenfantreseau:=0;
   setlength(xenfantreseau,nombreenfantreseau);
    setlength(yenfantreseau,nombreenfantreseau);
    setlength(kxenfantreseau,nombreenfantreseau);
    setlength(kyenfantreseau,nombreenfantreseau);
 for boubou:=Listereseau[-1+i].ordre_min to   Listereseau[-1+i].ordre_max do
 if boubou<>0 then
 if  (abs(-sin(incidence)+boubou/Listereseau[-1+i].pas*longueur_donde)<1)

 then begin
   inc(nombreenfantreseau);
   setlength(xenfantreseau,nombreenfantreseau);
    setlength(yenfantreseau,nombreenfantreseau);
    setlength(kxenfantreseau,nombreenfantreseau);
    setlength(kyenfantreseau,nombreenfantreseau);

 kxenfantreseau[nombreenfantreseau-1]:=sqrt(kxact*kxact+kyact*kyact)*cos(Listereseau[-1+i].anglepolaire+pi/2+arcsin(-sin(incidence)+boubou/Listereseau[-1+i].pas*longueur_donde));
 kyenfantreseau[nombreenfantreseau-1]:=sqrt(kxact*kxact+kyact*kyact)*sin(Listereseau[-1+i].anglepolaire+pi/2+arcsin(-sin(incidence)+boubou/Listereseau[-1+i].pas*longueur_donde));

   xenfantreseau[nombreenfantreseau-1]:=xinter+kxenfantreseau[nombreenfantreseau-1]*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yenfantreseau[nombreenfantreseau-1]:=yinter+kyenfantreseau[nombreenfantreseau-1]*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     end;
 kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(Listereseau[-1+i].anglepolaire+pi/2-incidence);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(Listereseau[-1+i].anglepolaire+pi/2-incidence);
anglepolairefutur:=Listereseau[-1+i].anglepolaire+pi/2-incidence;
  end;
 end;{du cas ou c'est le + proche}

     end; {du cas ou ca intercepte}
     end;{du cas reseau en reflexion}




{test sur les miroirs spheriques concaves partaxiaux}

     if nombremscopa>0 then
     for i:=1 to nombremscopa do
     if not (listemscopa[-1+i].trou) then
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscopa)) then
     if ((kyact*(listemscopa[-1+i].a2x-listemscopa[-1+i].a1x)) <>
     (kxact*(listemscopa[-1+i].a2y-listemscopa[-1+i].a1y  ))  ) then begin
     mu:=(kyact*(xact-listemscopa[-1+i].a1x)-kxact*(yact-listemscopa[-1+i].a1y))/
     (kyact*(listemscopa[-1+i].a2x-listemscopa[-1+i].a1x)-
     kxact*(listemscopa[-1+i].a2y-listemscopa[-1+i].a1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      listemscopa[-1+i].a2x-listemscopa[-1+i].a1x)
      +listemscopa[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(listemscopa[-1+i].a2y-listemscopa[-1+i].a1y)+
      listemscopa[-1+i].a1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=listemscopa[-1+i].a1x+mu*(listemscopa[-1+i].a2x-listemscopa[-1+i].a1x);
yinter:=listemscopa[-1+i].a1y+mu*(listemscopa[-1+i].a2y-listemscopa[-1+i].a1y);
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter; naissance:=false;
  bordureatteinte:=false;
  incidence:=Pi/2-listemscopa[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  if ((incidence>Pi/2) or (incidence<-Pi/2)) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_mscopa;
   indicesurfacefuture:=i;
   lambda:=((listemscopa[-1+i].fx-listemscopa[-1+i].cx)*(listemscopa[-1+i].fx-listemscopa[-1+i].cx)+
   (listemscopa[-1+i].fy-listemscopa[-1+i].cy)*(listemscopa[-1+i].fy-listemscopa[-1+i].cy))/
   (kxact*(listemscopa[-1+i].fx-listemscopa[-1+i].cx)+kyact*(listemscopa[-1+i].fy-listemscopa[-1+i].cy));
   kxfutur:=sqrt(kxact*kxact+kyact*kyact)*(listemscopa[-1+i].cx-xinter+lambda*kxact)/
   sqrt((listemscopa[-1+i].cx-xinter+lambda*kxact)*(listemscopa[-1+i].cx-xinter+lambda*kxact)+
   (listemscopa[-1+i].cy-yinter+lambda*kyact)*(listemscopa[-1+i].cy-yinter+lambda*kyact));
  kyfutur:=sqrt(kxact*kxact+kyact*kyact)*(listemscopa[-1+i].cy-yinter+lambda*kyact)/
   sqrt((listemscopa[-1+i].cx-xinter+lambda*kxact)*(listemscopa[-1+i].cx-xinter+lambda*kxact)+
   (listemscopa[-1+i].cy-yinter+lambda*kyact)*(listemscopa[-1+i].cy-yinter+lambda*kyact));
   anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);
   normaleatracer:=false;
  normale2cotes:=false;
   incidentatracer:=false;
 refracteatracer:=false;
 if optionsurfacesonde then begin
 distancecentre:=sqrt(sqr(xinter-listemscopa[-1+i].sx)+sqr(yinter-listemscopa[-1+i].sy));
  cheminsup:=-sqr(distancecentre)/2/listemscopa[-1+i].focale;
  end;

     end; end; end; end; {des mscopa}


      {des mscopa troues}
     if nombremscopa>0 then
     for i:=1 to nombremscopa do
     if  (listemscopa[-1+i].trou) then
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscopa)) then
     if ((kyact*(listemscopa[-1+i].t1x-listemscopa[-1+i].a1x)) <>
     (kxact*(listemscopa[-1+i].t1y-listemscopa[-1+i].a1y  ))  ) then begin
     mu:=(kyact*(xact-listemscopa[-1+i].a1x)-kxact*(yact-listemscopa[-1+i].a1y))/
     (kyact*(listemscopa[-1+i].t1x-listemscopa[-1+i].a1x)-
     kxact*(listemscopa[-1+i].t1y-listemscopa[-1+i].a1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      listemscopa[-1+i].t1x-listemscopa[-1+i].a1x)
      +listemscopa[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(listemscopa[-1+i].t1y-listemscopa[-1+i].a1y)+
      listemscopa[-1+i].a1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=listemscopa[-1+i].a1x+mu*(listemscopa[-1+i].t1x-listemscopa[-1+i].a1x);
yinter:=listemscopa[-1+i].a1y+mu*(listemscopa[-1+i].t1y-listemscopa[-1+i].a1y);
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter; naissance:=false;
  bordureatteinte:=false;
  incidence:=Pi/2-listemscopa[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  if ((incidence>Pi/2) or (incidence<-Pi/2)) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_mscopa;
   indicesurfacefuture:=i;
   lambda:=((listemscopa[-1+i].fx-listemscopa[-1+i].cx)*(listemscopa[-1+i].fx-listemscopa[-1+i].cx)+
   (listemscopa[-1+i].fy-listemscopa[-1+i].cy)*(listemscopa[-1+i].fy-listemscopa[-1+i].cy))/
   (kxact*(listemscopa[-1+i].fx-listemscopa[-1+i].cx)+kyact*(listemscopa[-1+i].fy-listemscopa[-1+i].cy));
   kxfutur:=sqrt(kxact*kxact+kyact*kyact)*(listemscopa[-1+i].cx-xinter+lambda*kxact)/
   sqrt((listemscopa[-1+i].cx-xinter+lambda*kxact)*(listemscopa[-1+i].cx-xinter+lambda*kxact)+
   (listemscopa[-1+i].cy-yinter+lambda*kyact)*(listemscopa[-1+i].cy-yinter+lambda*kyact));
  kyfutur:=sqrt(kxact*kxact+kyact*kyact)*(listemscopa[-1+i].cy-yinter+lambda*kyact)/
   sqrt((listemscopa[-1+i].cx-xinter+lambda*kxact)*(listemscopa[-1+i].cx-xinter+lambda*kxact)+
   (listemscopa[-1+i].cy-yinter+lambda*kyact)*(listemscopa[-1+i].cy-yinter+lambda*kyact));
   anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);
   normaleatracer:=false;
  normale2cotes:=false;
   incidentatracer:=false;
 refracteatracer:=false;
  if optionsurfacesonde then begin
 distancecentre:=sqrt(sqr(xinter-listemscopa[-1+i].sx)+sqr(yinter-listemscopa[-1+i].sy));
  cheminsup:=-sqr(distancecentre)/2/listemscopa[-1+i].focale;
  end;

     end; end; end; end; {des mscopa}


       {mscopa troues, autre cote du trou}
     if nombremscopa>0 then
     for i:=1 to nombremscopa do
     if (listemscopa[-1+i].trou) then
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscopa)) then
     if ((kyact*(listemscopa[-1+i].a2x-listemscopa[-1+i].t2x)) <>
     (kxact*(listemscopa[-1+i].a2y-listemscopa[-1+i].t2y  ))  ) then begin
     mu:=(kyact*(xact-listemscopa[-1+i].t2x)-kxact*(yact-listemscopa[-1+i].t2y))/
     (kyact*(listemscopa[-1+i].a2x-listemscopa[-1+i].t2x)-
     kxact*(listemscopa[-1+i].a2y-listemscopa[-1+i].t2y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      listemscopa[-1+i].a2x-listemscopa[-1+i].t2x)
      +listemscopa[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(listemscopa[-1+i].a2y-listemscopa[-1+i].t2y)+
      listemscopa[-1+i].t2y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=listemscopa[-1+i].t2x+mu*(listemscopa[-1+i].a2x-listemscopa[-1+i].t2x);
yinter:=listemscopa[-1+i].t2y+mu*(listemscopa[-1+i].a2y-listemscopa[-1+i].t2y);
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter; naissance:=false;
  bordureatteinte:=false;
  incidence:=Pi/2-listemscopa[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  if ((incidence>Pi/2) or (incidence<-Pi/2)) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_mscopa;
   indicesurfacefuture:=i;
   lambda:=((listemscopa[-1+i].fx-listemscopa[-1+i].cx)*(listemscopa[-1+i].fx-listemscopa[-1+i].cx)+
   (listemscopa[-1+i].fy-listemscopa[-1+i].cy)*(listemscopa[-1+i].fy-listemscopa[-1+i].cy))/
   (kxact*(listemscopa[-1+i].fx-listemscopa[-1+i].cx)+kyact*(listemscopa[-1+i].fy-listemscopa[-1+i].cy));
   kxfutur:=sqrt(kxact*kxact+kyact*kyact)*(listemscopa[-1+i].cx-xinter+lambda*kxact)/
   sqrt((listemscopa[-1+i].cx-xinter+lambda*kxact)*(listemscopa[-1+i].cx-xinter+lambda*kxact)+
   (listemscopa[-1+i].cy-yinter+lambda*kyact)*(listemscopa[-1+i].cy-yinter+lambda*kyact));
  kyfutur:=sqrt(kxact*kxact+kyact*kyact)*(listemscopa[-1+i].cy-yinter+lambda*kyact)/
   sqrt((listemscopa[-1+i].cx-xinter+lambda*kxact)*(listemscopa[-1+i].cx-xinter+lambda*kxact)+
   (listemscopa[-1+i].cy-yinter+lambda*kyact)*(listemscopa[-1+i].cy-yinter+lambda*kyact));
   anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);
   normaleatracer:=false;
  normale2cotes:=false;
   incidentatracer:=false;
 refracteatracer:=false;
  if optionsurfacesonde then begin
 distancecentre:=sqrt(sqr(xinter-listemscopa[-1+i].sx)+sqr(yinter-listemscopa[-1+i].sy));
  cheminsup:=-sqr(distancecentre)/2/listemscopa[-1+i].focale;
  end;

     end; end; end; end; {des mscopa}


     {test sur les miroirs spheriques convexes partaxiaux}

     if nombremscepa>0 then
     for i:=1 to nombremscepa do
      if not (listemscepa[-1+i].trou) then
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscepa)) then
     if ((kyact*(listemscepa[-1+i].a2x-listemscepa[-1+i].a1x)) <>
     (kxact*(listemscepa[-1+i].a2y-listemscepa[-1+i].a1y  ))  ) then begin
     mu:=(kyact*(xact-listemscepa[-1+i].a1x)-kxact*(yact-listemscepa[-1+i].a1y))/
     (kyact*(listemscepa[-1+i].a2x-listemscepa[-1+i].a1x)-
     kxact*(listemscepa[-1+i].a2y-listemscepa[-1+i].a1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      listemscepa[-1+i].a2x-listemscepa[-1+i].a1x)
      +listemscepa[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(listemscepa[-1+i].a2y-listemscepa[-1+i].a1y)+
      listemscepa[-1+i].a1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=listemscepa[-1+i].a1x+mu*(listemscepa[-1+i].a2x-listemscepa[-1+i].a1x);
yinter:=listemscepa[-1+i].a1y+mu*(listemscepa[-1+i].a2y-listemscepa[-1+i].a1y);
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
  incidence:=Pi/2-listemscepa[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  if ((incidence>Pi/2) or (incidence<-Pi/2)) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_mscepa;
   indicesurfacefuture:=i;
   lambda:=((listemscepa[-1+i].fx-listemscepa[-1+i].cx)*(listemscepa[-1+i].fx-listemscepa[-1+i].cx)+
   (listemscepa[-1+i].fy-listemscepa[-1+i].cy)*(listemscepa[-1+i].fy-listemscepa[-1+i].cy))/
   (kxact*(listemscepa[-1+i].fx-listemscepa[-1+i].cx)+kyact*(listemscepa[-1+i].fy-listemscepa[-1+i].cy));
   kxfutur:=-sqrt(kxact*kxact+kyact*kyact)*(listemscepa[-1+i].cx-xinter+lambda*kxact)/
   sqrt((listemscepa[-1+i].cx-xinter+lambda*kxact)*(listemscepa[-1+i].cx-xinter+lambda*kxact)+
   (listemscepa[-1+i].cy-yinter+lambda*kyact)*(listemscepa[-1+i].cy-yinter+lambda*kyact));
  kyfutur:=-sqrt(kxact*kxact+kyact*kyact)*(listemscepa[-1+i].cy-yinter+lambda*kyact)/
   sqrt((listemscepa[-1+i].cx-xinter+lambda*kxact)*(listemscepa[-1+i].cx-xinter+lambda*kxact)+
   (listemscepa[-1+i].cy-yinter+lambda*kyact)*(listemscepa[-1+i].cy-yinter+lambda*kyact));
   anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);
   normaleatracer:=false;
  normale2cotes:=false;
   incidentatracer:=false;
 refracteatracer:=false;
  if optionsurfacesonde then begin
 distancecentre:=sqrt(sqr(xinter-listemscepa[-1+i].sx)+sqr(yinter-listemscepa[-1+i].sy));
  cheminsup:=sqr(distancecentre)/2/listemscepa[-1+i].focale;
  end;

     end; end; end; end; {des mscepa}


     {test sur les miroirs spheriques convexes partaxiaux troues}

     if nombremscepa>0 then
     for i:=1 to nombremscepa do
      if  (listemscepa[-1+i].trou) then
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscepa)) then
     if ((kyact*(listemscepa[-1+i].t1x-listemscepa[-1+i].a1x)) <>
     (kxact*(listemscepa[-1+i].t1y-listemscepa[-1+i].a1y  ))  ) then begin
     mu:=(kyact*(xact-listemscepa[-1+i].a1x)-kxact*(yact-listemscepa[-1+i].a1y))/
     (kyact*(listemscepa[-1+i].t1x-listemscepa[-1+i].a1x)-
     kxact*(listemscepa[-1+i].t1y-listemscepa[-1+i].a1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      listemscepa[-1+i].t1x-listemscepa[-1+i].a1x)
      +listemscepa[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(listemscepa[-1+i].t1y-listemscepa[-1+i].a1y)+
      listemscepa[-1+i].a1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=listemscepa[-1+i].a1x+mu*(listemscepa[-1+i].t1x-listemscepa[-1+i].a1x);
yinter:=listemscepa[-1+i].a1y+mu*(listemscepa[-1+i].t1y-listemscepa[-1+i].a1y);
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon))then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
  incidence:=Pi/2-listemscepa[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  if ((incidence>Pi/2) or (incidence<-Pi/2)) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_mscepa;
   indicesurfacefuture:=i;
   lambda:=((listemscepa[-1+i].fx-listemscepa[-1+i].cx)*(listemscepa[-1+i].fx-listemscepa[-1+i].cx)+
   (listemscepa[-1+i].fy-listemscepa[-1+i].cy)*(listemscepa[-1+i].fy-listemscepa[-1+i].cy))/
   (kxact*(listemscepa[-1+i].fx-listemscepa[-1+i].cx)+kyact*(listemscepa[-1+i].fy-listemscepa[-1+i].cy));
   kxfutur:=-sqrt(kxact*kxact+kyact*kyact)*(listemscepa[-1+i].cx-xinter+lambda*kxact)/
   sqrt((listemscepa[-1+i].cx-xinter+lambda*kxact)*(listemscepa[-1+i].cx-xinter+lambda*kxact)+
   (listemscepa[-1+i].cy-yinter+lambda*kyact)*(listemscepa[-1+i].cy-yinter+lambda*kyact));
  kyfutur:=-sqrt(kxact*kxact+kyact*kyact)*(listemscepa[-1+i].cy-yinter+lambda*kyact)/
   sqrt((listemscepa[-1+i].cx-xinter+lambda*kxact)*(listemscepa[-1+i].cx-xinter+lambda*kxact)+
   (listemscepa[-1+i].cy-yinter+lambda*kyact)*(listemscepa[-1+i].cy-yinter+lambda*kyact));
   anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);
   normaleatracer:=false;
  normale2cotes:=false;
   incidentatracer:=false;
 refracteatracer:=false;
  if optionsurfacesonde then begin
 distancecentre:=sqrt(sqr(xinter-listemscepa[-1+i].sx)+sqr(yinter-listemscepa[-1+i].sy));
  cheminsup:=sqr(distancecentre)/2/listemscepa[-1+i].focale;
  end;
     end; end; end; end; {des mscepa troues}


     {test sur les miroirs spheriques convexes partaxiauxtroues, autre cote du trou}

     if nombremscepa>0 then
     for i:=1 to nombremscepa do
      if  (listemscepa[-1+i].trou) then
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscepa)) then
     if ((kyact*(listemscepa[-1+i].a2x-listemscepa[-1+i].t2x)) <>
     (kxact*(listemscepa[-1+i].a2y-listemscepa[-1+i].t2y  ))  ) then begin
     mu:=(kyact*(xact-listemscepa[-1+i].t2x)-kxact*(yact-listemscepa[-1+i].t2y))/
     (kyact*(listemscepa[-1+i].a2x-listemscepa[-1+i].t2x)-
     kxact*(listemscepa[-1+i].a2y-listemscepa[-1+i].t2y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      listemscepa[-1+i].a2x-listemscepa[-1+i].t2x)
      +listemscepa[-1+i].t2x-xact)/kxact else
      lambda:=(mu*(listemscepa[-1+i].a2y-listemscepa[-1+i].t2y)+
      listemscepa[-1+i].t2y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=listemscepa[-1+i].t2x+mu*(listemscepa[-1+i].a2x-listemscepa[-1+i].t2x);
yinter:=listemscepa[-1+i].t2y+mu*(listemscepa[-1+i].a2y-listemscepa[-1+i].t2y);
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
  incidence:=Pi/2-listemscepa[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  if ((incidence>Pi/2) or (incidence<-Pi/2)) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_mscepa;
   indicesurfacefuture:=i;
   lambda:=((listemscepa[-1+i].fx-listemscepa[-1+i].cx)*(listemscepa[-1+i].fx-listemscepa[-1+i].cx)+
   (listemscepa[-1+i].fy-listemscepa[-1+i].cy)*(listemscepa[-1+i].fy-listemscepa[-1+i].cy))/
   (kxact*(listemscepa[-1+i].fx-listemscepa[-1+i].cx)+kyact*(listemscepa[-1+i].fy-listemscepa[-1+i].cy));
   kxfutur:=-sqrt(kxact*kxact+kyact*kyact)*(listemscepa[-1+i].cx-xinter+lambda*kxact)/
   sqrt((listemscepa[-1+i].cx-xinter+lambda*kxact)*(listemscepa[-1+i].cx-xinter+lambda*kxact)+
   (listemscepa[-1+i].cy-yinter+lambda*kyact)*(listemscepa[-1+i].cy-yinter+lambda*kyact));
  kyfutur:=-sqrt(kxact*kxact+kyact*kyact)*(listemscepa[-1+i].cy-yinter+lambda*kyact)/
   sqrt((listemscepa[-1+i].cx-xinter+lambda*kxact)*(listemscepa[-1+i].cx-xinter+lambda*kxact)+
   (listemscepa[-1+i].cy-yinter+lambda*kyact)*(listemscepa[-1+i].cy-yinter+lambda*kyact));
   anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);
   normaleatracer:=false;
  normale2cotes:=false;
   incidentatracer:=false;
 refracteatracer:=false;
  if optionsurfacesonde then begin
 distancecentre:=sqrt(sqr(xinter-listemscepa[-1+i].sx)+sqr(yinter-listemscepa[-1+i].sy));
  cheminsup:=sqr(distancecentre)/2/listemscepa[-1+i].focale;
  end;
     end; end; end; end; {des mscepa troues, autre cote du trou}


     {test sur les lentilles minces convergentes}

     if nombrelmc>0 then
     for i:=1 to nombrelmc do
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_lmc)) then
     if ((kyact*(listelmc[-1+i].a2x-listelmc[-1+i].a1x)) <>
     (kxact*(listelmc[-1+i].a2y-listelmc[-1+i].a1y  ))  ) then begin
     mu:=(kyact*(xact-listelmc[-1+i].a1x)-kxact*(yact-listelmc[-1+i].a1y))/
     (kyact*(listelmc[-1+i].a2x-listelmc[-1+i].a1x)-
     kxact*(listelmc[-1+i].a2y-listelmc[-1+i].a1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      listelmc[-1+i].a2x-listelmc[-1+i].a1x)
      +listelmc[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(listelmc[-1+i].a2y-listelmc[-1+i].a1y)+
      listelmc[-1+i].a1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=listelmc[-1+i].a1x+mu*(listelmc[-1+i].a2x-listelmc[-1+i].a1x);
yinter:=listelmc[-1+i].a1y+mu*(listelmc[-1+i].a2y-listelmc[-1+i].a1y);
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
  incidence:=Pi/2-listelmc[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_lmc;
   indicesurfacefuture:=i;
   if ((kxact*(listelmc[-1+i].f1x-listelmc[-1+i].ox)+kyact*(listelmc[-1+i].f1y-listelmc[-1+i].oy))>0) then begin
   ffx:=listelmc[-1+i].f1x;
   ffy:=listelmc[-1+i].f1y
   end
   else begin
   ffx:=listelmc[-1+i].f2x;
   ffy:=listelmc[-1+i].f2y;
   end;
   lambda:=sqr(listelmc[-1+i].focale)/
   (kxact*(ffx-listelmc[-1+i].ox)+kyact*(ffy-listelmc[-1+i].oy));
   kxfutur:=sqrt(kxact*kxact+kyact*kyact)*(listelmc[-1+i].ox-xinter+lambda*kxact)/
   sqrt((listelmc[-1+i].ox-xinter+lambda*kxact)*(listelmc[-1+i].ox-xinter+lambda*kxact)+
   (listelmc[-1+i].oy-yinter+lambda*kyact)*(listelmc[-1+i].oy-yinter+lambda*kyact));
  kyfutur:=sqrt(kxact*kxact+kyact*kyact)*(listelmc[-1+i].oy-yinter+lambda*kyact)/
   sqrt((listelmc[-1+i].ox-xinter+lambda*kxact)*(listelmc[-1+i].ox-xinter+lambda*kxact)+
   (listelmc[-1+i].oy-yinter+lambda*kyact)*(listelmc[-1+i].oy-yinter+lambda*kyact));
   anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);
   normaleatracer:=false;
  normale2cotes:=false;
   incidentatracer:=false;
 refracteatracer:=false;
 if optionsurfacesonde then begin

  cheminsup:=(sqr(listelmc[-1+i].rayonmonture)-sqr(distancecentre))/2/listelmc[-1+i].focale;

 end;


     end; end; end; {des lmc}


   {test sur les lentilles minces divergentes}

     if nombrelmd>0 then
     for i:=1 to nombrelmd do
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_lmd)) then
     if ((kyact*(listelmd[-1+i].a2x-listelmd[-1+i].a1x)) <>
     (kxact*(listelmd[-1+i].a2y-listelmd[-1+i].a1y  ))  ) then begin
     mu:=(kyact*(xact-listelmd[-1+i].a1x)-kxact*(yact-listelmd[-1+i].a1y))/
     (kyact*(listelmd[-1+i].a2x-listelmd[-1+i].a1x)-
     kxact*(listelmd[-1+i].a2y-listelmd[-1+i].a1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      listelmd[-1+i].a2x-listelmd[-1+i].a1x)
      +listelmd[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(listelmd[-1+i].a2y-listelmd[-1+i].a1y)+
      listelmd[-1+i].a1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=listelmd[-1+i].a1x+mu*(listelmd[-1+i].a2x-listelmd[-1+i].a1x);
yinter:=listelmd[-1+i].a1y+mu*(listelmd[-1+i].a2y-listelmd[-1+i].a1y);
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;  naissance:=false;
  incidence:=Pi/2-listelmd[-1+i].anglepolaire+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_lmd;
   indicesurfacefuture:=i;
   if ((kxact*(listelmd[-1+i].f1x-listelmd[-1+i].ox)+kyact*(listelmd[-1+i].f1y-listelmd[-1+i].oy))<0) then begin
   ffx:=listelmd[-1+i].f1x;
   ffy:=listelmd[-1+i].f1y
   end
   else begin
   ffx:=listelmd[-1+i].f2x;
   ffy:=listelmd[-1+i].f2y;
   end;
   lambda:=((ffx-listelmd[-1+i].ox)*(ffx-listelmd[-1+i].ox)+
   (ffy-listelmd[-1+i].oy)*(ffy-listelmd[-1+i].oy))/
   (kxact*(ffx-listelmd[-1+i].ox)+kyact*(ffy-listelmd[-1+i].oy));
   kxfutur:=-sqrt(kxact*kxact+kyact*kyact)*(listelmd[-1+i].ox-xinter+lambda*kxact)/
   sqrt((listelmd[-1+i].ox-xinter+lambda*kxact)*(listelmd[-1+i].ox-xinter+lambda*kxact)+
   (listelmd[-1+i].oy-yinter+lambda*kyact)*(listelmd[-1+i].oy-yinter+lambda*kyact));
  kyfutur:=-sqrt(kxact*kxact+kyact*kyact)*(listelmd[-1+i].oy-yinter+lambda*kyact)/
   sqrt((listelmd[-1+i].ox-xinter+lambda*kxact)*(listelmd[-1+i].ox-xinter+lambda*kxact)+
   (listelmd[-1+i].oy-yinter+lambda*kyact)*(listelmd[-1+i].oy-yinter+lambda*kyact));
   anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);
   normaleatracer:=false;
  normale2cotes:=false;
   incidentatracer:=false;
 refracteatracer:=false;
  if optionsurfacesonde then cheminsup:=(sqr(xinter-listelmd[-1+i].ox)+sqr(yinter-listelmd[-1+i].oy))/2/
 listelmd[-1+i].focale;
     end; end; end; {des lmd}



      {test sur les miroirs coniques}

     if nombremiroirconique>0 then
     for i:=1 to nombremiroirconique do
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_miroirconique) and
     not(listemiroirconique[-1+i].concave)) then
     begin
     {pour les concaves, le rayon peut avoir plusieurs reflexions successives sur le
     meme miroir; on ne peut donc pas faire le test sur la surface; on avance le point d'une
     quantite petite, suffisante pour que le point de contact precdent ne
     puisse etre recompte}
     if (listemiroirconique[-1+i].concave and
     (indicesurfaceactuelle=i) and   (surface_actuelle=sur_miroirconique)) then begin
     xact:=xact+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     end;
     aaa:=kyact*listemiroirconique[-1+i].parametre+
     kyact*listemiroirconique[-1+i].excentricite*cos(listemiroirconique[-1+i].theta0)*(listemiroirconique[-1+i].fx-xact)-
     kxact*listemiroirconique[-1+i].excentricite*(listemiroirconique[-1+i].fy-yact)*cos(listemiroirconique[-1+i].theta0);
 bbb:=kxact*listemiroirconique[-1+i].parametre+
 kxact*listemiroirconique[-1+i].excentricite*sin(listemiroirconique[-1+i].theta0)*(listemiroirconique[-1+i].fy-yact)-
     kyact*listemiroirconique[-1+i].excentricite*(listemiroirconique[-1+i].fx-xact)*sin(listemiroirconique[-1+i].theta0);
 ccc:=kxact*(listemiroirconique[-1+i].fy-yact)-kyact*(listemiroirconique[-1+i].fx-xact);
     delta:=4*(sqr(bbb)+sqr(aaa)-sqr(ccc));



     if delta>=0  then begin
          if ((aaa+ccc=0) and (bbb<>0))  then begin
     xxx:=(aaa-ccc)/2/bbb;
      tata:=2*arctan(xxx);
      rrr:=listemiroirconique[-1+i].parametre/(1+listemiroirconique[-1+i].excentricite*cos(tata-
      listemiroirconique[-1+i].theta0));
      if abs(kxact)>abs(kyact) then
      lambda:=(listemiroirconique[-1+i].fx+rrr*cos(tata)-xact)/kxact else
      lambda:=(listemiroirconique[-1+i].fy+rrr*sin(tata)-yact)/kyact
        end else

     if ((delta=0) and (aaa+ccc<>0)) then begin
     xxx:=-bbb/(aaa+ccc);
      tata:=2*arctan(xxx);
      if (1+listemiroirconique[-1+i].excentricite*cos(tata-
      listemiroirconique[-1+i].theta0))>0 then begin
      rrr:=listemiroirconique[-1+i].parametre/(1+listemiroirconique[-1+i].excentricite*cos(tata-
      listemiroirconique[-1+i].theta0));
      if abs(kxact)>abs(kyact) then
      lambda:=(listemiroirconique[-1+i].fx+rrr*cos(tata)-xact)/kxact else
      lambda:=(listemiroirconique[-1+i].fy+rrr*sin(tata)-yact)/kyact;
      end else begin
      rrr:=0;
      lambda:=0;
      end;
      end
     else begin
     xxx1:=(-bbb+sqrt(sqr(bbb)+sqr(aaa)-sqr(ccc)))/(aaa+ccc);
     tata1:=2*arctan(xxx1);
     if (1+listemiroirconique[-1+i].excentricite*cos(tata1-
      listemiroirconique[-1+i].theta0))>0 then  begin
      rrr1:=listemiroirconique[-1+i].parametre/(1+listemiroirconique[-1+i].excentricite*cos(tata1-
      listemiroirconique[-1+i].theta0));
      if abs(kxact)>abs(kyact) then
      lambda1:=(listemiroirconique[-1+i].fx+rrr1*cos(tata1)-xact)/kxact else
      lambda1:=(listemiroirconique[-1+i].fy+rrr1*sin(tata1)-yact)/kyact;
      end else begin
      rrr1:=0;
      lambda1:=0;
      end;
      if tata1<0 then tata1:=tata1+2*Pi;
      if tata1>2*pi then tata1:=tata1-2*Pi;

      xxx2:=(-bbb-sqrt(sqr(bbb)+sqr(aaa)-sqr(ccc)))/(aaa+ccc);
     tata2:=2*arctan(xxx2);
     if (1+listemiroirconique[-1+i].excentricite*cos(tata2-
      listemiroirconique[-1+i].theta0))> 0 then begin
      rrr2:=listemiroirconique[-1+i].parametre/(1+listemiroirconique[-1+i].excentricite*cos(tata2-
      listemiroirconique[-1+i].theta0));
      if abs(kxact)>abs(kyact) then
      lambda2:=(listemiroirconique[-1+i].fx+rrr2*cos(tata2)-xact)/kxact else
      lambda2:=(listemiroirconique[-1+i].fy+rrr2*sin(tata2)-yact)/kyact;
      end else begin
      rrr2:=0;
      lambda2:=0;
      end;

      if tata2<0 then tata2:=tata2+2*Pi;
      if tata2>Pi*2 then tata2:=tata2-2*Pi;

     if (
     ((lambda2>0) and (tata2>=listemiroirconique[-1+i].theta1) and (tata2<=listemiroirconique[-1+i].theta2))
     or
      ((lambda2>0) and (tata2+2*Pi>=listemiroirconique[-1+i].theta1) and (tata2+2*Pi<=listemiroirconique[-1+i].theta2))
      )
      then begin
      lambda:=lambda2; rrr:=rrr2;
      tata:=tata2 end  else begin
       lambda:=lambda1;  rrr:=rrr1;
      tata:=tata1;
      end;
       end;

       if (
       ((lambda>0) and (tata>=listemiroirconique[-1+i].theta1) and (tata<=listemiroirconique[-1+i].theta2)) or
        ((lambda>0) and (tata+2*Pi>=listemiroirconique[-1+i].theta1) and (tata+2*Pi<=listemiroirconique[-1+i].theta2))
        )
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
  {nnnx et nnny sont les composantes de la normale dirigee vers l'interieur}
   nnnx:=1/sqrt(1+sqr(listemiroirconique[-1+i].excentricite)+2*listemiroirconique[-1+i].excentricite*cos(tata-
   listemiroirconique[-1+i].theta0))*
   (-listemiroirconique[-1+i].excentricite*sin(tata-listemiroirconique[-1+i].theta0)*sin(tata)-
   (1+listemiroirconique[-1+i].excentricite*cos(tata-listemiroirconique[-1+i].theta0))*cos(tata));
    nnny:=1/sqrt(1+sqr(listemiroirconique[-1+i].excentricite)+2*listemiroirconique[-1+i].excentricite*cos(tata-
    listemiroirconique[-1+i].theta0))*
   (listemiroirconique[-1+i].excentricite*sin(tata-listemiroirconique[-1+i].theta0)*cos(tata)-
   (1+listemiroirconique[-1+i].excentricite*cos(tata-listemiroirconique[-1+i].theta0))*sin(tata));
    if (( (kxact*nnnx+kyact*nnny<0)  and not(listemiroirconique[-1+i].concave) ) or
      ( (kxact*nnnx+kyact*nnny>0)  and listemiroirconique[-1+i].concave )) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_miroirconique;
   indicesurfacefuture:=i;
   kxfutur:=kxact-2*(kxact*nnnx+kyact*nnny)*nnnx;
   kyfutur:=kyact-2*(kxact*nnnx+kyact*nnny)*nnny;
   anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);
   normaleatracer:=true;
  normale2cotes:=false;
  anglepolairenormaleatracer:=donneanglepolairedans02pi(nnnx,nnny);
  if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;
  if listemiroirconique[-1+i].concave then
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact)  else
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact);
 end;
  if  not(listemiroirconique[-1+i].concave) then anglepolairenormaleatracer:=anglepolairenormaleatracer+pi;
     end; end; end; end;
     {on retablit les valeurs d'origine s'il a fallu les modifier}
     if (listemiroirconique[-1+i].concave and
     (indicesurfaceactuelle=i) and   (surface_actuelle=sur_miroirconique)) then begin
     xact:=xact-kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact-kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     end;
     end;{des miroirconique}




     {test sur les miroirs spheriques concaves reels non troues}

     if nombremscore>0 then
     for i:=1 to nombremscore do
     if  not(listemscore[-1+i].trou) then
    { if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscore)) then  }
     begin
     {pour les concaves, le rayon peut avoir plusieurs reflexions successives sur le
     meme miroir; on ne peut donc pas faire le test sur la surface; on avance le point d'une
     quantite petite, suffisante pour que le point de contact precdent ne
     puisse etre recompte}
     if ((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscore)) then begin
     xact:=xact+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     end;
     delta:=4*sqr(kxact*(xact-listemscore[-1+i].cx)+kyact*(yact-listemscore[-1+i].cy))-4*
     (sqr(kxact)+sqr(kyact))*(sqr(xact-listemscore[-1+i].cx)+sqr(yact-listemscore[-1+i].cy)-
     sqr(listemscore[-1+i].rayoncourbure));
     if delta>=0  then begin
     if delta=0 then
     lambda:=(kxact*(xact-listemscore[-1+i].cx)+kyact*(yact-listemscore[-1+i].cy))/
     (sqr(kxact)+sqr(kyact)) else begin
     lambda1:=(-2*(kxact*(xact-listemscore[-1+i].cx)+kyact*(yact-listemscore[-1+i].cy))
     +sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata1:=donneanglepolairedans02pi(lambda1*kxact+xact-listemscore[-1+i].cx,
      lambda1*kyact+yact-listemscore[-1+i].cy);


      lambda2:=(-2*(kxact*(xact-listemscore[-1+i].cx)+kyact*(yact-listemscore[-1+i].cy))
     -sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata2:=donneanglepolairedans02pi(lambda2*kxact+xact-listemscore[-1+i].cx,
       lambda2*kyact+yact-listemscore[-1+i].cy);


     if (
     ((lambda2>0) and (tata2>=listemscore[-1+i].theta1) and (tata2<=listemscore[-1+i].theta2))
     or
      ((lambda2>0) and (tata2+2*Pi>=listemscore[-1+i].theta1) and (tata2+2*Pi<=listemscore[-1+i].theta2))
      )
      then begin
      lambda:=lambda2;
      tata:=tata2 end  else begin
       lambda:=lambda1;
      tata:=tata1;
      end;
       end;

       if (
       ((lambda>0) and (tata>=listemscore[-1+i].theta1) and (tata<=listemscore[-1+i].theta2)) or
        ((lambda>0) and (tata+2*Pi>=listemscore[-1+i].theta1) and (tata+2*Pi<=listemscore[-1+i].theta2))
        )
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
   if (xinter=listemscore[-1+i].cx) then
  if (listemscore[-1+i].cy>yinter) then anglepolairenormale:=Pi/2 else
  anglepolairenormale:=-Pi/2
  else begin
  anglepolairenormale:=arctan((listemscore[-1+i].cy-yinter)/(listemscore[-1+i].cx-xinter));
  if (listemscore[-1+i].cx<xinter) then anglepolairenormale:=anglepolairenormale+Pi;
  end;
  incidence:=-anglepolairenormale+anglepolaireact+Pi;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  if ((incidence>Pi/2) or (incidence<-Pi/2)) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_mscore;
   indicesurfacefuture:=i;
   anglepolairefutur:=anglepolairenormale-incidence;
   normaleatracer:=true;
  normale2cotes:=false;
  anglepolairenormaleatracer:=anglepolairenormale;
   if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;

 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact) ;
 end;
  if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-Pi*2;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
kxfutur:=sqrt(sqr(kxact)+sqr(kyact))*cos(anglepolairefutur);
kyfutur:=sqrt(sqr(kxact)+sqr(kyact))*sin(anglepolairefutur);

     end; end; end; end;
     {on retablit les valeurs d'origine s'il a fallu les modifier}
     if ((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscore)) then begin
     xact:=xact-kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact-kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     end;end;{des mscore}




       {test sur les yeux}
      if nombreoeil>0 then
     for i:=1 to nombreoeil do
        { if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_oeil)) then }
     begin
      tati1:=listeoeil[-1+i].anglepolaire-Pi/6;
      tati2:=listeoeil[-1+i].anglepolaire+Pi/6;
      if tati1<0 then begin
      tati1:=tati1+2*Pi;
      tati2:=tati2+2*Pi;
      end;
     delta:=4*sqr(kxact*(xact-listeoeil[-1+i].cx)+kyact*(yact-listeoeil[-1+i].cy))-4*
     (sqr(kxact)+sqr(kyact))*(sqr(xact-listeoeil[-1+i].cx)+sqr(yact-listeoeil[-1+i].cy)-
     sqr(listeoeil[-1+i].rayoncourbure));
     if delta>=0  then begin
     if delta=0 then
     lambda:=(kxact*(xact-listeoeil[-1+i].cx)+kyact*(yact-listeoeil[-1+i].cy))/
     (sqr(kxact)+sqr(kyact)) else begin
     lambda1:=(-2*(kxact*(xact-listeoeil[-1+i].cx)+kyact*(yact-listeoeil[-1+i].cy))
     +sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata1:=donneanglepolairedans02pi(lambda1*kxact+xact-listeoeil[-1+i].cx,
      lambda1*kyact+yact-listeoeil[-1+i].cy);
            lambda2:=(-2*(kxact*(xact-listeoeil[-1+i].cx)+kyact*(yact-listeoeil[-1+i].cy))
     -sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata2:=donneanglepolairedans02pi(lambda2*kxact+xact-listeoeil[-1+i].cx,
       lambda2*kyact+yact-listeoeil[-1+i].cy);
            if (     ((lambda2>0) and (tata2>=tati1) and (tata2<=tati2))
     or
      ((lambda2>0) and (tata2+2*Pi>=tati1) and (tata2+2*Pi<=tati2))
      )
      then begin
      lambda:=lambda2;
      tata:=tata2 end  else begin
       lambda:=lambda1;
      tata:=tata1;
      end;
       end;

       if (
       ((lambda>0) and (tata>=tati1) and (tata<=tati2)) or
        ((lambda>0) and (tata+2*Pi>=tati1) and (tata+2*Pi<=tati2))
        )
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
   surfaceabsorbanteatteinte:=true;
   surface_future:=sur_oeil;
   indicesurfacefuture:=i;
    end; end;  end;
     end;{des oeil}


      {test sur les yeux, suite}
      if nombreoeil>0 then
     for i:=1 to nombreoeil do
        { if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_oeil)) then }
     begin
      tati1:=listeoeil[-1+i].anglepolaire-Pi/2;
      tati2:=listeoeil[-1+i].anglepolaire-Pi/2+Pi/3+Pi/20;
      if tati1<0 then begin
      tati1:=tati1+2*Pi;
      tati2:=tati2+2*Pi;
      end;
     delta:=4*sqr(kxact*(xact-listeoeil[-1+i].c1x)+kyact*(yact-listeoeil[-1+i].c1y))-4*
     (sqr(kxact)+sqr(kyact))*(sqr(xact-listeoeil[-1+i].c1x)+sqr(yact-listeoeil[-1+i].c1y)-
     sqr(listeoeil[-1+i].rayoncourbure));
     if delta>=0  then begin
     if delta=0 then
     lambda:=(kxact*(xact-listeoeil[-1+i].c1x)+kyact*(yact-listeoeil[-1+i].c1y))/
     (sqr(kxact)+sqr(kyact)) else begin
     lambda1:=(-2*(kxact*(xact-listeoeil[-1+i].c1x)+kyact*(yact-listeoeil[-1+i].c1y))
     +sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata1:=donneanglepolairedans02pi(lambda1*kxact+xact-listeoeil[-1+i].c1x,
      lambda1*kyact+yact-listeoeil[-1+i].c1y);
            lambda2:=(-2*(kxact*(xact-listeoeil[-1+i].c1x)+kyact*(yact-listeoeil[-1+i].c1y))
     -sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata2:=donneanglepolairedans02pi(lambda2*kxact+xact-listeoeil[-1+i].c1x,
       lambda2*kyact+yact-listeoeil[-1+i].c1y);
            if (     ((lambda2>0) and (tata2>=tati1) and (tata2<=tati2))
     or
      ((lambda2>0) and (tata2+2*Pi>=tati1) and (tata2+2*Pi<=tati2))
      )
      then begin
      lambda:=lambda2;
      tata:=tata2 end  else begin
       lambda:=lambda1;
      tata:=tata1;
      end;
       end;

       if (
       ((lambda>0) and (tata>=tati1) and (tata<=tati2)) or
        ((lambda>0) and (tata+2*Pi>=tati1) and (tata+2*Pi<=tati2))
        )
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
   surfaceabsorbanteatteinte:=true;
   surface_future:=sur_oeil;
   indicesurfacefuture:=i;
    end; end;  end;
     end;{des oeil}


    {test sur les yeux, suite et fin }
      if nombreoeil>0 then
     for i:=1 to nombreoeil do
        { if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_oeil)) then }
     begin
      tati1:=listeoeil[-1+i].anglepolaire+Pi/2-Pi/3-Pi/20;
      tati2:=listeoeil[-1+i].anglepolaire+Pi/2;
      if tati1<0 then begin
      tati1:=tati1+2*Pi;
      tati2:=tati2+2*Pi;
      end;
     delta:=4*sqr(kxact*(xact-listeoeil[-1+i].c2x)+kyact*(yact-listeoeil[-1+i].c2y))-4*
     (sqr(kxact)+sqr(kyact))*(sqr(xact-listeoeil[-1+i].c2x)+sqr(yact-listeoeil[-1+i].c2y)-
     sqr(listeoeil[-1+i].rayoncourbure));
     if delta>=0  then begin
     if delta=0 then
     lambda:=(kxact*(xact-listeoeil[-1+i].c2x)+kyact*(yact-listeoeil[-1+i].c2y))/
     (sqr(kxact)+sqr(kyact)) else begin
     lambda1:=(-2*(kxact*(xact-listeoeil[-1+i].c2x)+kyact*(yact-listeoeil[-1+i].c2y))
     +sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata1:=donneanglepolairedans02pi(lambda1*kxact+xact-listeoeil[-1+i].c2x,
      lambda1*kyact+yact-listeoeil[-1+i].c2y);
            lambda2:=(-2*(kxact*(xact-listeoeil[-1+i].c2x)+kyact*(yact-listeoeil[-1+i].c2y))
     -sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata2:=donneanglepolairedans02pi(lambda2*kxact+xact-listeoeil[-1+i].c2x,
       lambda2*kyact+yact-listeoeil[-1+i].c2y);
            if (     ((lambda2>0) and (tata2>=tati1) and (tata2<=tati2))
     or
      ((lambda2>0) and (tata2+2*Pi>=tati1) and (tata2+2*Pi<=tati2))
      )
      then begin
      lambda:=lambda2;
      tata:=tata2 end  else begin
       lambda:=lambda1;
      tata:=tata1;
      end;
       end;

       if (
       ((lambda>0) and (tata>=tati1) and (tata<=tati2)) or
        ((lambda>0) and (tata+2*Pi>=tati1) and (tata+2*Pi<=tati2))
        )
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
   surfaceabsorbanteatteinte:=true;
   surface_future:=sur_oeil;
   indicesurfacefuture:=i;
    end; end;  end;
     end;{des oeil}


      {test sur les miroirs spheriques concaves reels  troues, 1ere partie}

     if nombremscore>0 then
     for i:=1 to nombremscore do
     if  (listemscore[-1+i].trou) then
    { if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscore)) then  }
     begin
     {pour les concaves, le rayon peut avoir plusieurs reflexions successives sur le
     meme miroir; on ne peut donc pas faire le test sur la surface; on avance le point d'une
     quantite petite, suffisante pour que le point de contact precdent ne
     puisse etre recompte}
     if ((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscore)) then begin
     xact:=xact+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     end;
     delta:=4*sqr(kxact*(xact-listemscore[-1+i].cx)+kyact*(yact-listemscore[-1+i].cy))-4*
     (sqr(kxact)+sqr(kyact))*(sqr(xact-listemscore[-1+i].cx)+sqr(yact-listemscore[-1+i].cy)-
     sqr(listemscore[-1+i].rayoncourbure));
     if delta>=0  then begin
     if delta=0 then
     lambda:=(kxact*(xact-listemscore[-1+i].cx)+kyact*(yact-listemscore[-1+i].cy))/
     (sqr(kxact)+sqr(kyact)) else begin
     lambda1:=(-2*(kxact*(xact-listemscore[-1+i].cx)+kyact*(yact-listemscore[-1+i].cy))
     +sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata1:=donneanglepolairedans02pi(lambda1*kxact+xact-listemscore[-1+i].cx,
      lambda1*kyact+yact-listemscore[-1+i].cy);


      lambda2:=(-2*(kxact*(xact-listemscore[-1+i].cx)+kyact*(yact-listemscore[-1+i].cy))
     -sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata2:=donneanglepolairedans02pi(lambda2*kxact+xact-listemscore[-1+i].cx,
       lambda2*kyact+yact-listemscore[-1+i].cy);


     if (
     ((lambda2>0) and (tata2>=listemscore[-1+i].theta1) and (tata2<=listemscore[-1+i].theta1p))
     or
      ((lambda2>0) and (tata2+2*Pi>=listemscore[-1+i].theta1) and (tata2+2*Pi<=listemscore[-1+i].theta1p))
      )
      then begin
      lambda:=lambda2;
      tata:=tata2 end  else begin
       lambda:=lambda1;
      tata:=tata1;
      end;
       end;

       if (
       ((lambda>0) and (tata>=listemscore[-1+i].theta1) and (tata<=listemscore[-1+i].theta1p)) or
        ((lambda>0) and (tata+2*Pi>=listemscore[-1+i].theta1) and (tata+2*Pi<=listemscore[-1+i].theta1p))
        )
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
   if (xinter=listemscore[-1+i].cx) then
  if (listemscore[-1+i].cy>yinter) then anglepolairenormale:=Pi/2 else
  anglepolairenormale:=-Pi/2
  else begin
  anglepolairenormale:=arctan((listemscore[-1+i].cy-yinter)/(listemscore[-1+i].cx-xinter));
  if (listemscore[-1+i].cx<xinter) then anglepolairenormale:=anglepolairenormale+Pi;
  end;
  incidence:=-anglepolairenormale+anglepolaireact+Pi;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  if ((incidence>Pi/2) or (incidence<-Pi/2)) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_mscore;
   indicesurfacefuture:=i;
   anglepolairefutur:=anglepolairenormale-incidence;
   normaleatracer:=true;
  normale2cotes:=false;
  anglepolairenormaleatracer:=anglepolairenormale;
   if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;

 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact) ;
 end;
  if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-Pi*2;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
kxfutur:=sqrt(sqr(kxact)+sqr(kyact))*cos(anglepolairefutur);
kyfutur:=sqrt(sqr(kxact)+sqr(kyact))*sin(anglepolairefutur);

     end; end; end; end;
     {on retablit les valeurs d'origine s'il a fallu les modifier}
     if ((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscore)) then begin
     xact:=xact-kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact-kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     end;end;{des mscore}



      {test sur les miroirs spheriques concaves reels troues, 2eme partie}

     if nombremscore>0 then
     for i:=1 to nombremscore do
     if (listemscore[-1+i].trou) then
    { if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscore)) then  }
     begin
     {pour les concaves, le rayon peut avoir plusieurs reflexions successives sur le
     meme miroir; on ne peut donc pas faire le test sur la surface; on avance le point d'une
     quantite petite, suffisante pour que le point de contact precdent ne
     puisse etre recompte}
     if ((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscore)) then begin
     xact:=xact+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     end;
     delta:=4*sqr(kxact*(xact-listemscore[-1+i].cx)+kyact*(yact-listemscore[-1+i].cy))-4*
     (sqr(kxact)+sqr(kyact))*(sqr(xact-listemscore[-1+i].cx)+sqr(yact-listemscore[-1+i].cy)-
     sqr(listemscore[-1+i].rayoncourbure));
     if delta>=0  then begin
     if delta=0 then
     lambda:=(kxact*(xact-listemscore[-1+i].cx)+kyact*(yact-listemscore[-1+i].cy))/
     (sqr(kxact)+sqr(kyact)) else begin
     lambda1:=(-2*(kxact*(xact-listemscore[-1+i].cx)+kyact*(yact-listemscore[-1+i].cy))
     +sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata1:=donneanglepolairedans02pi(lambda1*kxact+xact-listemscore[-1+i].cx,
      lambda1*kyact+yact-listemscore[-1+i].cy);


      lambda2:=(-2*(kxact*(xact-listemscore[-1+i].cx)+kyact*(yact-listemscore[-1+i].cy))
     -sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata2:=donneanglepolairedans02pi(lambda2*kxact+xact-listemscore[-1+i].cx,
       lambda2*kyact+yact-listemscore[-1+i].cy);


     if (
     ((lambda2>0) and (tata2>=listemscore[-1+i].theta2p) and (tata2<=listemscore[-1+i].theta2))
     or
      ((lambda2>0) and (tata2+2*Pi>=listemscore[-1+i].theta2p) and (tata2+2*Pi<=listemscore[-1+i].theta2))
      )
      then begin
      lambda:=lambda2;
      tata:=tata2 end  else begin
       lambda:=lambda1;
      tata:=tata1;
      end;
       end;

       if (
       ((lambda>0) and (tata>=listemscore[-1+i].theta2p) and (tata<=listemscore[-1+i].theta2)) or
        ((lambda>0) and (tata+2*Pi>=listemscore[-1+i].theta2p) and (tata+2*Pi<=listemscore[-1+i].theta2))
        )
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
  if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
   if (xinter=listemscore[-1+i].cx) then
  if (listemscore[-1+i].cy>yinter) then anglepolairenormale:=Pi/2 else
  anglepolairenormale:=-Pi/2
  else begin
  anglepolairenormale:=arctan((listemscore[-1+i].cy-yinter)/(listemscore[-1+i].cx-xinter));
  if (listemscore[-1+i].cx<xinter) then anglepolairenormale:=anglepolairenormale+Pi;
  end;
  incidence:=-anglepolairenormale+anglepolaireact+Pi;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  if ((incidence>Pi/2) or (incidence<-Pi/2)) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_mscore;
   indicesurfacefuture:=i;
   anglepolairefutur:=anglepolairenormale-incidence;
   normaleatracer:=true;
  normale2cotes:=false;
  anglepolairenormaleatracer:=anglepolairenormale;
   if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;

 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact) ;
 end;
  if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-Pi*2;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
kxfutur:=sqrt(sqr(kxact)+sqr(kyact))*cos(anglepolairefutur);
kyfutur:=sqrt(sqr(kxact)+sqr(kyact))*sin(anglepolairefutur);

     end; end; end; end;
     {on retablit les valeurs d'origine s'il a fallu les modifier}
     if ((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscore)) then begin
     xact:=xact-kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact-kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     end;end;{des mscore}


       {test sur les spheres refractantes}

     if nombresphere>0 then
     for i:=1 to nombresphere do
          begin
     xact:=xact+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;


     delta:=4*sqr(kxact*(xact-listesphere[-1+i].cx)+kyact*(yact-listesphere[-1+i].cy))-4*
     (sqr(kxact)+sqr(kyact))*(sqr(xact-listesphere[-1+i].cx)+sqr(yact-listesphere[-1+i].cy)-
     sqr(listesphere[-1+i].rayon));
     if delta>=0  then begin
     if delta=0 then
     lambda:=(kxact*(xact-listesphere[-1+i].cx)+kyact*(yact-listesphere[-1+i].cy))/
     (sqr(kxact)+sqr(kyact)) else begin
     lambda1:=(-2*(kxact*(xact-listesphere[-1+i].cx)+kyact*(yact-listesphere[-1+i].cy))
     +sqrt(delta))/2/(sqr(kxact)+sqr(kyact));

      lambda2:=(-2*(kxact*(xact-listesphere[-1+i].cx)+kyact*(yact-listesphere[-1+i].cy))
     -sqrt(delta))/2/(sqr(kxact)+sqr(kyact));


     if  (lambda2>0)

      then
      lambda:=lambda2
        else
       lambda:=lambda1;
               end;


       if (lambda>0)
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
 nnx:=(xinter-listesphere[-1+i].cx);
 nny:=(yinter-listesphere[-1+i].cy);
   normaleatracer:=true;
  normale2cotes:=true;
  anglepolairenormaleatracer:=donneanglepolairedans02pi(nnx,nny);
   if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;
 if (nnx*kxact+nny*kyact<0) then
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact)  else
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact);
 end;
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_sphere;
   indicesurfacefuture:=i;

   {rayon entrant}
   if (nnx*kxact+nny*kyact<0) then   begin
     case couleur of
 clred: indiceoptiquefutur:=listesphere[-1+i].indicerouge;
 clgreen: indiceoptiquefutur:=listesphere[-1+i].indicevert;
 clblue: indiceoptiquefutur:=listesphere[-1+i].indicebleu;
 end;


 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*((xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon)+
 kyact*((yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon));
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 kxfutur:=kxact-(kxact*((xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon)+kyact*
 ((yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon))*
 ((xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon)
 -((xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon)*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon)+
kyact*((yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon))*
 ((yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon)-((yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon)
 *sqrt(patate);
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
 if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;
 end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon rentre}


 {rayon sortant}
 if (nnx*kxact+nny*kyact>0) then  begin
 case couleur of
 clred: indiceoptiquefutur:=indice_rouge_par_defaut;
 clgreen: indiceoptiquefutur:=indice_vert_par_defaut;
 clblue: indiceoptiquefutur:=indice_bleu_par_defaut;
 end;

    if nombrepolycercle>0 then
   for iii:=1 to nombrepolycercle do
 if listepolycercle[-1+iii].estou(xinter+(xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon/10000,
 yinter+(yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon/10000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolycercle[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolycercle[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolycercle[-1+iii].indicebleu;
 end;
   if nombrepolyhedre>0 then
   for iii:=1 to nombrepolyhedre do
 if listepolyhedre[-1+iii].estou(xinter+(xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon/10000,
 yinter+(yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon/10000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolyhedre[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolyhedre[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolyhedre[-1+iii].indicebleu;
 end;

 if nombresphere>0 then
   for iii:=1 to nombresphere do
 if listesphere[-1+iii].estou(xinter+(xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon/10000,
 yinter+(yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon/10000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listesphere[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listesphere[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listesphere[-1+iii].indicebleu;
 end;

 if nombreprisme>0 then
   for iii:=1 to nombreprisme do
 if listeprisme[-1+iii].estou(xinter+(xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon/10000,
 yinter+(yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon/10000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listeprisme[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listeprisme[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listeprisme[-1+iii].indicebleu;
 end;


 if nombrelec>0 then
   for iii:=1 to nombrelec do
 if listelec[-1+iii].estou(xinter+(xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon/10000,
 yinter+(yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon/10000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listelec[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listelec[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listelec[-1+iii].indicebleu;
 end;



 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*((xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon)+kyact*
 ((yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon));
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 kxfutur:=kxact-(kxact*((xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon)+kyact*
 ((yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon))*
 ((xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon)+((xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon)*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon)+kyact*
((yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon))*
 ((yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon)+((yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon)*sqrt(patate);
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;
 end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon sort}

if nnx=0 then
if nny>0 then agp:=Pi/2 else agp:=-Pi/2
else
begin
agp:=arctan(nny/nnx);
if nnx<0 then agp:=agp+Pi;
end;


{rayon reflechi dans le cas ou le refracte est entrant}
  if (kxact*((xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon)+
  kyact*((yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon)>0) then
if ((listesphere[-1+i].reflechisortant=toujoursreflechi) or
    (unrefracte and (listesphere[-1+i].reflechisortant=reflechisirefracte)) or
  (not(unrefracte) and (listesphere[-1+i].reflechisortant=reflechisipasrefracte)))
  then begin
  agp:=agp+pi/2;
  surfaceabsorbanteatteinte:=false;
  incidence:=Pi/2-agp+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;

anglepolairefutur:=2*agp-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon reflechi si le refracte est sortant}


    {rayon reflechi dans le cas ou le refracte est entrant}
  if (kxact*((xinter-listesphere[-1+i].cx)/listesphere[-1+i].rayon)+
  kyact*((yinter-listesphere[-1+i].cy)/listesphere[-1+i].rayon)<0) then
if ((listesphere[-1+i].reflechientrant=toujoursreflechi) or
    (unrefracte and (listesphere[-1+i].reflechientrant=reflechisirefracte)) or
  (not(unrefracte) and (listesphere[-1+i].reflechientrant=reflechisipasrefracte)))
  then begin
  surfaceabsorbanteatteinte:=false;
  agp:=agp-pi/2;
  incidence:=Pi/2-agp+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;
anglepolairefutur:=2*agp-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon reflechi si le refracte est entrant}

    end; end; end;
    {on retablit les valeurs d'origine s'il a fallu les modifier}

     xact:=xact-kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact-kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;

     end;{des sphere}



      {test sur les lecs refractantes, 1ere face}

     if nombrelec>0 then
     for i:=1 to nombrelec do
          begin
     xact:=xact+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;


delta:=4*sqr(kxact*(xact-listelec[-1+i].c1x)+kyact*(yact-listelec[-1+i].c1y))-4*
     (sqr(kxact)+sqr(kyact))*(sqr(xact-listelec[-1+i].c1x)+sqr(yact-listelec[-1+i].c1y)-
     sqr(abs(listelec[-1+i].r1)));
     if delta>=0  then begin
     if delta=0 then
     lambda:=(kxact*(xact-listelec[-1+i].c1x)+kyact*(yact-listelec[-1+i].c1y))/
     (sqr(kxact)+sqr(kyact)) else begin
     lambda1:=(-2*(kxact*(xact-listelec[-1+i].c1x)+kyact*(yact-listelec[-1+i].c1y))
     +sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata1:=donneanglepolairedans02pi(lambda1*kxact+xact-listelec[-1+i].c1x,
      lambda1*kyact+yact-listelec[-1+i].c1y);


      lambda2:=(-2*(kxact*(xact-listelec[-1+i].c1x)+kyact*(yact-listelec[-1+i].c1y))
     -sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata2:=donneanglepolairedans02pi(lambda2*kxact+xact-listelec[-1+i].c1x,
       lambda2*kyact+yact-listelec[-1+i].c1y);


     if (
     ((lambda2>0) and (tata2>=listelec[-1+i].theta1_1) and (tata2<=listelec[-1+i].theta2_1))
     or
      ((lambda2>0) and (tata2+2*Pi>=listelec[-1+i].theta1_1) and (tata2+2*Pi<=listelec[-1+i].theta2_1))
      )
      then begin
      lambda:=lambda2;
      tata:=tata2 end  else begin
       lambda:=lambda1;
      tata:=tata1;
      end;
       end;

       if (
       ((lambda>0) and (tata>=listelec[-1+i].theta1_1) and (tata<=listelec[-1+i].theta2_1)) or
        ((lambda>0) and (tata+2*Pi>=listelec[-1+i].theta1_1) and (tata+2*Pi<=listelec[-1+i].theta2_1))
        )
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
 if (kxact*(xinter-listelec[-1+i].c1x)+kyact*(yinter-listelec[-1+i].c1y)<0) then begin
 nnx:=(xinter-listelec[-1+i].c1x);
 nny:=(yinter-listelec[-1+i].c1y);
   end else begin
  nnx:=-(xinter-listelec[-1+i].c1x);
 nny:=-(yinter-listelec[-1+i].c1y);
       end;

   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_lec;
   indicesurfacefuture:=i;
    normaleatracer:=true;
  normale2cotes:=true;
  anglepolairenormaleatracer:=donneanglepolairedans02pi(nnx,nny);
   if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact) ;
 end;
   {rayon entrant}
   if {(nnx*kxact+nny*kyact<0)} listelec[-1+i].estou( xinter+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000,yinter+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000)=Iinterieur then   begin
     case couleur of
 clred: indiceoptiquefutur:=listelec[-1+i].indicerouge;
 clgreen: indiceoptiquefutur:=listelec[-1+i].indicevert;
 clblue: indiceoptiquefutur:=listelec[-1+i].indicebleu;
 end;


 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))+
 kyact*((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1)));
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 if (kxact*(xinter-listelec[-1+i].c1x)+kyact*(yinter-listelec[-1+i].c1y)<0) then begin
 kxfutur:=kxact-(kxact*((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))+kyact*
 ((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1)))*
 ((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))
 -((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))+
kyact*((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1)))*
 ((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1))-((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1))
 *sqrt(patate); end else begin

 kxfutur:=kxact-(kxact*((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))+kyact*
 ((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1)))*
 ((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))
 +((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))+
kyact*((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1)))*
 ((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1))+((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1))
 *sqrt(patate);
 end;
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
 if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;
 end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon rentre}


 {rayon sortant}
 if {(nnx*kxact+nny*kyact>0)} listelec[-1+i].estou( xinter+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000,yinter+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000)=Iexterieur then  begin
    case couleur of
 clred: indiceoptiquefutur:=indice_rouge_par_defaut;
 clgreen: indiceoptiquefutur:=indice_vert_par_defaut;
 clblue: indiceoptiquefutur:=indice_bleu_par_defaut;
 end;
   if nombrepolycercle>0 then
   for iii:=1 to nombrepolycercle do
 if listepolycercle[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolycercle[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolycercle[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolycercle[-1+iii].indicebleu;
 end;
   if nombrepolyhedre>0 then
   for iii:=1 to nombrepolyhedre do
 if listepolyhedre[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolyhedre[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolyhedre[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolyhedre[-1+iii].indicebleu;
 end;

 if nombreprisme>0 then
   for iii:=1 to nombreprisme do
 if listeprisme[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listeprisme[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listeprisme[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listeprisme[-1+iii].indicebleu;
 end;



 if nombresphere>0 then
   for iii:=1 to nombresphere do
 if listesphere[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listesphere[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listesphere[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listesphere[-1+iii].indicebleu;
 end;

 if nombrelec>0 then
   for iii:=1 to nombrelec do
 if listelec[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listelec[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listelec[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listelec[-1+iii].indicebleu;
 end;


 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))+kyact*
 ((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1)));
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 if (kxact*(xinter-listelec[-1+i].c1x)+kyact*(yinter-listelec[-1+i].c1y)<0) then begin
 kxfutur:=kxact-(kxact*((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))+kyact*
 ((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1)))*
 ((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))-((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))+kyact*
((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1)))*
 ((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1))-((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1))*sqrt(patate);
    end else begin
 kxfutur:=kxact-(kxact*((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))+kyact*
 ((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1)))*
 ((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))+((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))+kyact*
((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1)))*
 ((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1))+((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1))*sqrt(patate);
 end;
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;
 end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon sort}

if nnx=0 then
if nny>0 then agp:=Pi/2 else agp:=-Pi/2
else
begin
agp:=arctan(nny/nnx);
if nnx<0 then agp:=agp+Pi;
end;


{rayon reflechi dans le cas ou le refracte est entrant}
  if {(kxact*((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))+
  kyact*((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1))>0)}
  listelec[-1+i].estou( xinter+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000,yinter+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000)=Iinterieur then
if ((listelec[-1+i].reflechisortant=toujoursreflechi) or
    (unrefracte and (listelec[-1+i].reflechisortant=reflechisirefracte)) or
  (not(unrefracte) and (listelec[-1+i].reflechisortant=reflechisipasrefracte)))
  then begin
  agp:=agp+pi/2;
  surfaceabsorbanteatteinte:=false;
  incidence:=Pi/2-agp+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;

anglepolairefutur:=2*agp-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon reflechi si le refracte est sortant}


    {rayon reflechi dans le cas ou le refracte est entrant}
  if {(kxact*((xinter-listelec[-1+i].c1x)/abs(listelec[-1+i].r1))+
  kyact*((yinter-listelec[-1+i].c1y)/abs(listelec[-1+i].r1))<0)}
  listelec[-1+i].estou( xinter+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000,yinter+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000)=Iexterieur then
if ((listelec[-1+i].reflechientrant=toujoursreflechi) or
    (unrefracte and (listelec[-1+i].reflechientrant=reflechisirefracte)) or
  (not(unrefracte) and (listelec[-1+i].reflechientrant=reflechisipasrefracte)))
  then begin
  surfaceabsorbanteatteinte:=false;
  agp:=agp-pi/2;
  incidence:=Pi/2-agp+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;
anglepolairefutur:=2*agp-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon reflechi si le refracte est entrant}

    end; end; end;
    {on retablit les valeurs d'origine s'il a fallu les modifier}

     xact:=xact-kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact-kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;

     end;{des lec, 1ere face}



 {test sur les lecs refractantes, 2eme face}

     if nombrelec>0 then
     for i:=1 to nombrelec do
          begin
     xact:=xact+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;


delta:=4*sqr(kxact*(xact-listelec[-1+i].c2x)+kyact*(yact-listelec[-1+i].c2y))-4*
     (sqr(kxact)+sqr(kyact))*(sqr(xact-listelec[-1+i].c2x)+sqr(yact-listelec[-1+i].c2y)-
     sqr(abs(listelec[-1+i].r2)));
     if delta>=0  then begin
     if delta=0 then
     lambda:=(kxact*(xact-listelec[-1+i].c2x)+kyact*(yact-listelec[-1+i].c2y))/
     (sqr(kxact)+sqr(kyact)) else begin
     lambda1:=(-2*(kxact*(xact-listelec[-1+i].c2x)+kyact*(yact-listelec[-1+i].c2y))
     +sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata1:=donneanglepolairedans02pi(lambda1*kxact+xact-listelec[-1+i].c2x,
      lambda1*kyact+yact-listelec[-1+i].c2y);


      lambda2:=(-2*(kxact*(xact-listelec[-1+i].c2x)+kyact*(yact-listelec[-1+i].c2y))
     -sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata2:=donneanglepolairedans02pi(lambda2*kxact+xact-listelec[-1+i].c2x,
       lambda2*kyact+yact-listelec[-1+i].c2y);


     if (
     ((lambda2>0) and (tata2>=listelec[-1+i].theta1_2) and (tata2<=listelec[-1+i].theta2_2))
     or
      ((lambda2>0) and (tata2+2*Pi>=listelec[-1+i].theta1_2) and (tata2+2*Pi<=listelec[-1+i].theta2_2))
      )
      then begin
      lambda:=lambda2;
      tata:=tata2 end  else begin
       lambda:=lambda1;
      tata:=tata1;
      end;
       end;

       if (
       ((lambda>0) and (tata>=listelec[-1+i].theta1_2) and (tata<=listelec[-1+i].theta2_2)) or
        ((lambda>0) and (tata+2*Pi>=listelec[-1+i].theta1_2) and (tata+2*Pi<=listelec[-1+i].theta2_2))
        )
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
 if (kxact*(xinter-listelec[-1+i].c2x)+kyact*(yinter-listelec[-1+i].c2y)<0) then begin
 nnx:=(xinter-listelec[-1+i].c2x);
 nny:=(yinter-listelec[-1+i].c2y);
   end else begin
  nnx:=-(xinter-listelec[-1+i].c2x);
 nny:=-(yinter-listelec[-1+i].c2y);
       end;
    normaleatracer:=true;
  normale2cotes:=true;
  anglepolairenormaleatracer:=donneanglepolairedans02pi(nnx,nny);
    if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact) ;
 end;
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_lec;
   indicesurfacefuture:=i;

   {rayon entrant}
   if {(nnx*kxact+nny*kyact<0)} listelec[-1+i].estou( xinter+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000,yinter+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000)=Iinterieur then   begin
     case couleur of
 clred: indiceoptiquefutur:=listelec[-1+i].indicerouge;
 clgreen: indiceoptiquefutur:=listelec[-1+i].indicevert;
 clblue: indiceoptiquefutur:=listelec[-1+i].indicebleu;
 end;


 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))+
 kyact*((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2)));
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 if (kxact*(xinter-listelec[-1+i].c2x)+kyact*(yinter-listelec[-1+i].c2y)<0) then begin
 kxfutur:=kxact-(kxact*((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))+kyact*
 ((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2)))*
 ((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))
 -((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))+
kyact*((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2)))*
 ((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2))-((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2))
 *sqrt(patate); end else begin

 kxfutur:=kxact-(kxact*((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))+kyact*
 ((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2)))*
 ((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))
 +((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))+
kyact*((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2)))*
 ((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2))+((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2))
 *sqrt(patate);
 end;
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;
 end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon rentre}


 {rayon sortant}
 if {(nnx*kxact+nny*kyact>0)} listelec[-1+i].estou( xinter+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000,yinter+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000)=Iexterieur then  begin
    case couleur of
 clred: indiceoptiquefutur:=indice_rouge_par_defaut;
 clgreen: indiceoptiquefutur:=indice_vert_par_defaut;
 clblue: indiceoptiquefutur:=indice_bleu_par_defaut;
 end;
    if nombrepolycercle>0 then
   for iii:=1 to nombrepolycercle do
 if listepolycercle[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolycercle[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolycercle[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolycercle[-1+iii].indicebleu;
 end;
   if nombrepolyhedre>0 then
   for iii:=1 to nombrepolyhedre do
 if listepolyhedre[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolyhedre[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolyhedre[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolyhedre[-1+iii].indicebleu;
 end;


 if nombreprisme>0 then
   for iii:=1 to nombreprisme do
 if listeprisme[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listeprisme[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listeprisme[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listeprisme[-1+iii].indicebleu;
 end;

 if nombresphere>0 then
   for iii:=1 to nombresphere do
 if listesphere[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listesphere[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listesphere[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listesphere[-1+iii].indicebleu;
 end;

 if nombrelec>0 then
   for iii:=1 to nombrelec do
 if listelec[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listelec[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listelec[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listelec[-1+iii].indicebleu;
 end;


 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))+kyact*
 ((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2)));
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 if (kxact*(xinter-listelec[-1+i].c2x)+kyact*(yinter-listelec[-1+i].c2y)<0) then begin
 kxfutur:=kxact-(kxact*((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))+kyact*
 ((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2)))*
 ((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))-((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))+kyact*
((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2)))*
 ((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2))-((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2))*sqrt(patate);
    end else begin
 kxfutur:=kxact-(kxact*((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))+kyact*
 ((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2)))*
 ((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))+((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))+kyact*
((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2)))*
 ((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2))+((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2))*sqrt(patate);
 end;
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;
 end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon sort}

if nnx=0 then
if nny>0 then agp:=Pi/2 else agp:=-Pi/2
else
begin
agp:=arctan(nny/nnx);
if nnx<0 then agp:=agp+Pi;
end;


{rayon reflechi dans le cas ou le refracte est entrant}
  if {(kxact*((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))+
  kyact*((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2))>0)}
  listelec[-1+i].estou( xinter+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000,yinter+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000)=Iinterieur then
if ((listelec[-1+i].reflechisortant=toujoursreflechi) or
    (unrefracte and (listelec[-1+i].reflechisortant=reflechisirefracte)) or
  (not(unrefracte) and (listelec[-1+i].reflechisortant=reflechisipasrefracte)))
  then begin
  agp:=agp+pi/2;
  surfaceabsorbanteatteinte:=false;
  incidence:=Pi/2-agp+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;

anglepolairefutur:=2*agp-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon reflechi si le refracte est sortant}


    {rayon reflechi dans le cas ou le refracte est entrant}
  if {(kxact*((xinter-listelec[-1+i].c2x)/abs(listelec[-1+i].r2))+
  kyact*((yinter-listelec[-1+i].c2y)/abs(listelec[-1+i].r2))<0)}
  listelec[-1+i].estou( xinter+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000,yinter+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000)=Iexterieur then
if ((listelec[-1+i].reflechientrant=toujoursreflechi) or
    (unrefracte and (listelec[-1+i].reflechientrant=reflechisirefracte)) or
  (not(unrefracte) and (listelec[-1+i].reflechientrant=reflechisipasrefracte)))
  then begin
  surfaceabsorbanteatteinte:=false;
  agp:=agp-pi/2;
  incidence:=Pi/2-agp+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;
anglepolairefutur:=2*agp-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon reflechi si le refracte est entrant}

    end; end; end;
    {on retablit les valeurs d'origine s'il a fallu les modifier}

     xact:=xact-kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact-kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;

     end;{des lec, 2eme fce}


 {test sur les lecs, bord de la lentille=surface absorbante}

     if nombrelec>0 then
     for i:=1 to nombrelec do
     if Listelec[-1+i].tronque then
     if ((kyact*(Listelec[-1+i].a2x-Listelec[-1+i].a1x)) <>
     (kxact*(Listelec[-1+i].a2y-Listelec[-1+i].a1y  ))  ) then begin
     mu:=(kyact*(xact-Listelec[-1+i].a1x)-kxact*(yact-Listelec[-1+i].a1y))/
     (kyact*(Listelec[-1+i].a2x-Listelec[-1+i].a1x)-
     kxact*(Listelec[-1+i].a2y-Listelec[-1+i].a1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      Listelec[-1+i].a2x-Listelec[-1+i].a1x)
      +Listelec[-1+i].a1x-xact)/kxact else
      lambda:=(mu*(Listelec[-1+i].a2y-Listelec[-1+i].a1y)+
      Listelec[-1+i].a1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=Listelec[-1+i].a1x+mu*(Listelec[-1+i].a2x-Listelec[-1+i].a1x);
yinter:=Listelec[-1+i].a1y+mu*(Listelec[-1+i].a2y-Listelec[-1+i].a1y);
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;       kxfutur:=kxact; kyfutur:=kyact;
  yfutur:=yinter;
  bordureatteinte:=false;      naissance:=false;
     incidentatracer:=false;
 refracteatracer:=false;
  normaleatracer:=false;
  normale2cotes:=false;
   surfaceabsorbanteatteinte:=true;
    end; end; end; {des lecs}

    {test sur les lecs, bord de la lentille=surface absorbante}

     if nombrelec>0 then
     for i:=1 to nombrelec do
     if Listelec[-1+i].tronque then
     if ((kyact*(Listelec[-1+i].b2x-Listelec[-1+i].b1x)) <>
     (kxact*(Listelec[-1+i].b2y-Listelec[-1+i].b1y  ))  ) then begin
     mu:=(kyact*(xact-Listelec[-1+i].b1x)-kxact*(yact-Listelec[-1+i].b1y))/
     (kyact*(Listelec[-1+i].b2x-Listelec[-1+i].b1x)-
     kxact*(Listelec[-1+i].b2y-Listelec[-1+i].b1y  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      Listelec[-1+i].b2x-Listelec[-1+i].b1x)
      +Listelec[-1+i].b1x-xact)/kxact else
      lambda:=(mu*(Listelec[-1+i].b2y-Listelec[-1+i].b1y)+
      Listelec[-1+i].b1y-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=Listelec[-1+i].b1x+mu*(Listelec[-1+i].b2x-Listelec[-1+i].b1x);
yinter:=Listelec[-1+i].b1y+mu*(Listelec[-1+i].b2y-Listelec[-1+i].b1y);
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon))then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;       kxfutur:=kxact; kyfutur:=kyact;
  yfutur:=yinter;
  bordureatteinte:=false;      naissance:=false;
    normaleatracer:=false;
  normale2cotes:=false;
   surfaceabsorbanteatteinte:=true;
   incidentatracer:=false;
 refracteatracer:=false;
  normaleatracer:=false;
  normale2cotes:=false;
    end; end; end; {des lecs}

  {test sur les miroirs spheriques convexes reels non troues}

     if nombremscere>0 then
     for i:=1 to nombremscere do
     if not(listemscere[-1+i].trou) then
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscere)) then
     begin
     delta:=4*sqr(kxact*(xact-listemscere[-1+i].cx)+kyact*(yact-listemscere[-1+i].cy))-4*
     (sqr(kxact)+sqr(kyact))*(sqr(xact-listemscere[-1+i].cx)+sqr(yact-listemscere[-1+i].cy)-
     sqr(listemscere[-1+i].rayoncourbure));
     if delta>=0  then begin
     if delta=0 then
     lambda:=(kxact*(xact-listemscere[-1+i].cx)+kyact*(yact-listemscere[-1+i].cy))/
     (sqr(kxact)+sqr(kyact)) else begin
     lambda1:=(-2*(kxact*(xact-listemscere[-1+i].cx)+kyact*(yact-listemscere[-1+i].cy))
     +sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata1:=donneanglepolairedans02pi(lambda1*kxact+xact-listemscere[-1+i].cx,
       lambda1*kyact+yact-listemscere[-1+i].cy);


      lambda2:=(-2*(kxact*(xact-listemscere[-1+i].cx)+kyact*(yact-listemscere[-1+i].cy))
     -sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata2:=donneanglepolairedans02pi(lambda2*kxact+xact-listemscere[-1+i].cx,
       lambda2*kyact+yact-listemscere[-1+i].cy);


     if (
     ((lambda2>0) and (tata2>=listemscere[-1+i].theta1) and (tata2<=listemscere[-1+i].theta2))
     or
      ((lambda2>0) and (tata2+2*Pi>=listemscere[-1+i].theta1) and (tata2+2*Pi<=listemscere[-1+i].theta2))
      )
      then begin
      lambda:=lambda2;
      tata:=tata2 end  else begin
       lambda:=lambda1;
      tata:=tata1;
      end;
       end;

       if (
       ((lambda>0) and (tata>=listemscere[-1+i].theta1) and (tata<=listemscere[-1+i].theta2)) or
        ((lambda>0) and (tata+2*Pi>=listemscere[-1+i].theta1) and (tata+2*Pi<=listemscere[-1+i].theta2))
        )
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;    naissance:=false;
   if (xinter=listemscere[-1+i].cx) then
  if (listemscere[-1+i].cy>yinter) then anglepolairenormale:=Pi/2 else
  anglepolairenormale:=-Pi/2
  else begin
  anglepolairenormale:=arctan((listemscere[-1+i].cy-yinter)/(listemscere[-1+i].cx-xinter));
  if (listemscere[-1+i].cx<xinter) then anglepolairenormale:=anglepolairenormale+Pi;
  end;
  anglepolairenormale:=anglepolairenormale+Pi;
  incidence:=-anglepolairenormale+anglepolaireact+Pi;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  if ((incidence>Pi/2) or (incidence<-Pi/2)) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_mscere;
   indicesurfacefuture:=i;
   normaleatracer:=true;
  normale2cotes:=false;
  anglepolairenormaleatracer:=anglepolairenormale;
   if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 xact,yact) ;
 end;
   anglepolairefutur:=anglepolairenormale-incidence;
  if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-Pi*2;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
kxfutur:=sqrt(sqr(kxact)+sqr(kyact))*cos(anglepolairefutur);
kyfutur:=sqrt(sqr(kxact)+sqr(kyact))*sin(anglepolairefutur);

     end; end; end; end; end;{des mscere}



     {test sur les miroirs spheriques convexes reels troues, 1ere partie}

     if nombremscere>0 then
     for i:=1 to nombremscere do
     if (listemscere[-1+i].trou) then
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscere)) then
     begin
     delta:=4*sqr(kxact*(xact-listemscere[-1+i].cx)+kyact*(yact-listemscere[-1+i].cy))-4*
     (sqr(kxact)+sqr(kyact))*(sqr(xact-listemscere[-1+i].cx)+sqr(yact-listemscere[-1+i].cy)-
     sqr(listemscere[-1+i].rayoncourbure));
     if delta>=0  then begin
     if delta=0 then
     lambda:=(kxact*(xact-listemscere[-1+i].cx)+kyact*(yact-listemscere[-1+i].cy))/
     (sqr(kxact)+sqr(kyact)) else begin
     lambda1:=(-2*(kxact*(xact-listemscere[-1+i].cx)+kyact*(yact-listemscere[-1+i].cy))
     +sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata1:=donneanglepolairedans02pi(lambda1*kxact+xact-listemscere[-1+i].cx,
       lambda1*kyact+yact-listemscere[-1+i].cy);


      lambda2:=(-2*(kxact*(xact-listemscere[-1+i].cx)+kyact*(yact-listemscere[-1+i].cy))
     -sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata2:=donneanglepolairedans02pi(lambda2*kxact+xact-listemscere[-1+i].cx,
       lambda2*kyact+yact-listemscere[-1+i].cy);


     if (
     ((lambda2>0) and (tata2>=listemscere[-1+i].theta1) and (tata2<=listemscere[-1+i].theta1p))
     or
      ((lambda2>0) and (tata2+2*Pi>=listemscere[-1+i].theta1) and (tata2+2*Pi<=listemscere[-1+i].theta1p))
      )
      then begin
      lambda:=lambda2;
      tata:=tata2 end  else begin
       lambda:=lambda1;
      tata:=tata1;
      end;
       end;

       if (
       ((lambda>0) and (tata>=listemscere[-1+i].theta1) and (tata<=listemscere[-1+i].theta1p)) or
        ((lambda>0) and (tata+2*Pi>=listemscere[-1+i].theta1) and (tata+2*Pi<=listemscere[-1+i].theta1p))
        )
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
 if ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;    naissance:=false;
   if (xinter=listemscere[-1+i].cx) then
  if (listemscere[-1+i].cy>yinter) then anglepolairenormale:=Pi/2 else
  anglepolairenormale:=-Pi/2
  else begin
  anglepolairenormale:=arctan((listemscere[-1+i].cy-yinter)/(listemscere[-1+i].cx-xinter));
  if (listemscere[-1+i].cx<xinter) then anglepolairenormale:=anglepolairenormale+Pi;
  end;
  anglepolairenormale:=anglepolairenormale+Pi;
  incidence:=-anglepolairenormale+anglepolaireact+Pi;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  if ((incidence>Pi/2) or (incidence<-Pi/2)) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_mscere;
   indicesurfacefuture:=i;
   normaleatracer:=true;
  normale2cotes:=false;
  anglepolairenormaleatracer:=anglepolairenormale;
   if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 xact,yact) ;
 end;
   anglepolairefutur:=anglepolairenormale-incidence;
  if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-Pi*2;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
kxfutur:=sqrt(sqr(kxact)+sqr(kyact))*cos(anglepolairefutur);
kyfutur:=sqrt(sqr(kxact)+sqr(kyact))*sin(anglepolairefutur);

     end; end; end; end; end;{des mscere}



     {test sur les miroirs spheriques convexes reels  troues, 2eme partie}

     if nombremscere>0 then
     for i:=1 to nombremscere do
     if (listemscere[-1+i].trou) then
     if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_mscere)) then
     begin
     delta:=4*sqr(kxact*(xact-listemscere[-1+i].cx)+kyact*(yact-listemscere[-1+i].cy))-4*
     (sqr(kxact)+sqr(kyact))*(sqr(xact-listemscere[-1+i].cx)+sqr(yact-listemscere[-1+i].cy)-
     sqr(listemscere[-1+i].rayoncourbure));
     if delta>=0  then begin
     if delta=0 then
     lambda:=(kxact*(xact-listemscere[-1+i].cx)+kyact*(yact-listemscere[-1+i].cy))/
     (sqr(kxact)+sqr(kyact)) else begin
     lambda1:=(-2*(kxact*(xact-listemscere[-1+i].cx)+kyact*(yact-listemscere[-1+i].cy))
     +sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata1:=donneanglepolairedans02pi(lambda1*kxact+xact-listemscere[-1+i].cx,
       lambda1*kyact+yact-listemscere[-1+i].cy);


      lambda2:=(-2*(kxact*(xact-listemscere[-1+i].cx)+kyact*(yact-listemscere[-1+i].cy))
     -sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata2:=donneanglepolairedans02pi(lambda2*kxact+xact-listemscere[-1+i].cx,
       lambda2*kyact+yact-listemscere[-1+i].cy);


     if (
     ((lambda2>0) and (tata2>=listemscere[-1+i].theta2p) and (tata2<=listemscere[-1+i].theta2))
     or
      ((lambda2>0) and (tata2+2*Pi>=listemscere[-1+i].theta2p) and (tata2+2*Pi<=listemscere[-1+i].theta2))
      )
      then begin
      lambda:=lambda2;
      tata:=tata2 end  else begin
       lambda:=lambda1;
      tata:=tata1;
      end;
       end;

       if (
       ((lambda>0) and (tata>=listemscere[-1+i].theta2p) and (tata<=listemscere[-1+i].theta2)) or
        ((lambda>0) and (tata+2*Pi>=listemscere[-1+i].theta2p) and (tata+2*Pi<=listemscere[-1+i].theta2))
        )
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;    naissance:=false;
   if (xinter=listemscere[-1+i].cx) then
  if (listemscere[-1+i].cy>yinter) then anglepolairenormale:=Pi/2 else
  anglepolairenormale:=-Pi/2
  else begin
  anglepolairenormale:=arctan((listemscere[-1+i].cy-yinter)/(listemscere[-1+i].cx-xinter));
  if (listemscere[-1+i].cx<xinter) then anglepolairenormale:=anglepolairenormale+Pi;
  end;
  anglepolairenormale:=anglepolairenormale+Pi;
  incidence:=-anglepolairenormale+anglepolaireact+Pi;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
  if ((incidence>Pi/2) or (incidence<-Pi/2)) then
   surfaceabsorbanteatteinte:=true else begin
   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_mscere;
   indicesurfacefuture:=i;
   normaleatracer:=true;
  normale2cotes:=false;
  anglepolairenormaleatracer:=anglepolairenormale;
   if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
 xact,yact) ;
 end;
   anglepolairefutur:=anglepolairenormale-incidence;
  if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-Pi*2;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
kxfutur:=sqrt(sqr(kxact)+sqr(kyact))*cos(anglepolairefutur);
kyfutur:=sqrt(sqr(kxact)+sqr(kyact))*sin(anglepolairefutur);

     end; end; end; end; end;{des mscere}



  {cas des polyhedres}
     if nombrepolyhedre>0 then
     for i:=1 to nombrepolyhedre do
     for j:=1 to listepolyhedre[-1+i].nombresommet do
       if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_polyhedre) and
       (coteactuel=j)) then
     if ((kyact*(Listepolyhedre[-1+i].messommets[j+1].ax-Listepolyhedre[-1+i].messommets[j].ax)) <>
     (kxact*(Listepolyhedre[-1+i].messommets[j+1].ay-Listepolyhedre[-1+i].messommets[j].ay  ))  ) then begin
     mu:=(kyact*(xact-Listepolyhedre[-1+i].messommets[j].ax)-kxact*(yact-
     Listepolyhedre[-1+i].messommets[j].ay))/
     (kyact*(Listepolyhedre[-1+i].messommets[j+1].ax-
     Listepolyhedre[-1+i].messommets[j].ax)-
     kxact*(Listepolyhedre[-1+i].messommets[j+1].ay-Listepolyhedre[-1+i].messommets[j].ay  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      Listepolyhedre[-1+i].messommets[j+1].ax-Listepolyhedre[-1+i].messommets[j].ax)
      +Listepolyhedre[-1+i].messommets[j].ax-xact)/kxact else
      lambda:=(mu*(Listepolyhedre[-1+i].messommets[j+1].ay-
      Listepolyhedre[-1+i].messommets[j].ay)+
      Listepolyhedre[-1+i].messommets[j].ay-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=Listepolyhedre[-1+i].messommets[j].ax+
mu*(Listepolyhedre[-1+i].messommets[j+1].ax-Listepolyhedre[-1+i].messommets[j].ax);
yinter:=Listepolyhedre[-1+i].messommets[j].ay+
mu*(Listepolyhedre[-1+i].messommets[j+1].ay-Listepolyhedre[-1+i].messommets[j].ay);
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon))
 then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;  naissance:=false;
   surface_future:=sur_polyhedre;
   indicesurfacefuture:=i;  cotefutur:=j;
   normaleatracer:=true;
  normale2cotes:=true;
  anglepolairenormaleatracer:=donneanglepolairedans02pi(listepolyhedre[-1+i].nx[j],listepolyhedre[-1+i].ny[j]);
   if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;

 if (kxact*listepolyhedre[-1+i].nx[j]+kyact*listepolyhedre[-1+i].ny[j]<0) then
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact)  else
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact);
 end;
  {si le rayon sort}
  if (kxact*listepolyhedre[-1+i].nx[j]+kyact*listepolyhedre[-1+i].ny[j]>0) then begin
  {determination de l'indice du milieu de sortie}
   case couleur of
 clred: indiceoptiquefutur:=indice_rouge_par_defaut;
 clgreen: indiceoptiquefutur:=indice_vert_par_defaut;
 clblue: indiceoptiquefutur:=indice_bleu_par_defaut;
 end;
   if nombrepolycercle>0 then
   for iii:=1 to nombrepolycercle do
 if listepolycercle[-1+iii].estou(xinter+listepolyhedre[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listepolyhedre[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolycercle[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolycercle[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolycercle[-1+iii].indicebleu;
 end;
   if nombrepolyhedre>0 then
   for iii:=1 to nombrepolyhedre do
 if listepolyhedre[-1+iii].estou(xinter+listepolyhedre[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listepolyhedre[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolyhedre[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolyhedre[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolyhedre[-1+iii].indicebleu;
 end;
  if nombreprisme>0 then
   for iii:=1 to nombreprisme do
 if listeprisme[-1+iii].estou(xinter+listepolyhedre[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listepolyhedre[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listeprisme[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listeprisme[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listeprisme[-1+iii].indicebleu;
 end;

 if nombresphere>0 then
   for iii:=1 to nombresphere do
 if listesphere[-1+iii].estou(xinter+listepolyhedre[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listepolyhedre[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listesphere[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listesphere[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listesphere[-1+iii].indicebleu;
 end;

 if nombrelec>0 then
   for iii:=1 to nombrelec do
 if listelec[-1+iii].estou(xinter+listepolyhedre[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listepolyhedre[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listelec[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listelec[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listelec[-1+iii].indicebleu;
 end;

 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*listepolyhedre[-1+i].nx[j]+kyact*listepolyhedre[-1+i].ny[j]);
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 kxfutur:=kxact-(kxact*listepolyhedre[-1+i].nx[j]+kyact*listepolyhedre[-1+i].ny[j])*
 listepolyhedre[-1+i].nx[j]+listepolyhedre[-1+i].nx[j]*sqrt(patate);
kyfutur:=kyact-(kxact*listepolyhedre[-1+i].nx[j]+kyact*listepolyhedre[-1+i].ny[j])*
 listepolyhedre[-1+i].ny[j]+listepolyhedre[-1+i].ny[j]*sqrt(patate);
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;
 end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon sort}


  {si le rayon rentre}
  if (kxact*listepolyhedre[-1+i].nx[j]+kyact*listepolyhedre[-1+i].ny[j]<0) then begin
 case couleur of
 clred: indiceoptiquefutur:=listepolyhedre[-1+i].indicerouge;
 clgreen: indiceoptiquefutur:=listepolyhedre[-1+i].indicevert;
 clblue: indiceoptiquefutur:=listepolyhedre[-1+i].indicebleu;
 end;

 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*listepolyhedre[-1+i].nx[j]+kyact*listepolyhedre[-1+i].ny[j]);
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 kxfutur:=kxact-(kxact*listepolyhedre[-1+i].nx[j]+kyact*listepolyhedre[-1+i].ny[j])*
 listepolyhedre[-1+i].nx[j]-listepolyhedre[-1+i].nx[j]*sqrt(patate);
kyfutur:=kyact-(kxact*listepolyhedre[-1+i].nx[j]+kyact*listepolyhedre[-1+i].ny[j])*
 listepolyhedre[-1+i].ny[j]-listepolyhedre[-1+i].ny[j]*sqrt(patate);
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;

end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon rentre}

{rayon reflechi dans le cas ou le refracte est entrant}
  if (kxact*listepolyhedre[-1+i].nx[j]+kyact*listepolyhedre[-1+i].ny[j]>0) then
if ((listepolyhedre[-1+i].reflechisortant=toujoursreflechi) or
    (unrefracte and (listepolyhedre[-1+i].reflechisortant=reflechisirefracte)) or
  (not(unrefracte) and (listepolyhedre[-1+i].reflechisortant=reflechisipasrefracte)))
  then begin
  surfaceabsorbanteatteinte:=false;
  incidence:=Pi/2-Listepolyhedre[-1+i].anglepolaire[j]+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listepolyhedre[-1+i].anglepolaire[j]-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listepolyhedre[-1+i].anglepolaire[j]-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;

anglepolairefutur:=2*Listepolyhedre[-1+i].anglepolaire[j]-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listepolyhedre[-1+i].anglepolaire[j]-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listepolyhedre[-1+i].anglepolaire[j]-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon reflechi si le refracte est sortant}


    {rayon reflechi dans le cas ou le refracte est entrant}
  if (kxact*listepolyhedre[-1+i].nx[j]+kyact*listepolyhedre[-1+i].ny[j]<0) then
if ((listepolyhedre[-1+i].reflechientrant=toujoursreflechi) or
    (unrefracte and (listepolyhedre[-1+i].reflechientrant=reflechisirefracte)) or
  (not(unrefracte) and (listepolyhedre[-1+i].reflechientrant=reflechisipasrefracte)))
  then begin
  surfaceabsorbanteatteinte:=false;
  incidence:=Pi/2-Listepolyhedre[-1+i].anglepolaire[j]+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listepolyhedre[-1+i].anglepolaire[j]-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listepolyhedre[-1+i].anglepolaire[j]-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;
anglepolairefutur:=2*Listepolyhedre[-1+i].anglepolaire[j]-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listepolyhedre[-1+i].anglepolaire[j]-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listepolyhedre[-1+i].anglepolaire[j]-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon reflechi si le refracte est entrant}


      end; end; end; {des polyhedre}








       {cas des prismes}
     if nombreprisme>0 then
     for i:=1 to nombreprisme do
     for j:=1 to listeprisme[-1+i].nombresommet do
       if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_prisme) and
       (coteactuel=j)) then
     if ((kyact*(Listeprisme[-1+i].messommets[j+1].ax-Listeprisme[-1+i].messommets[j].ax)) <>
     (kxact*(Listeprisme[-1+i].messommets[j+1].ay-Listeprisme[-1+i].messommets[j].ay  ))  ) then begin
     mu:=(kyact*(xact-Listeprisme[-1+i].messommets[j].ax)-kxact*(yact-
     Listeprisme[-1+i].messommets[j].ay))/
     (kyact*(Listeprisme[-1+i].messommets[j+1].ax-
     Listeprisme[-1+i].messommets[j].ax)-
     kxact*(Listeprisme[-1+i].messommets[j+1].ay-Listeprisme[-1+i].messommets[j].ay  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      Listeprisme[-1+i].messommets[j+1].ax-Listeprisme[-1+i].messommets[j].ax)
      +Listeprisme[-1+i].messommets[j].ax-xact)/kxact else
      lambda:=(mu*(Listeprisme[-1+i].messommets[j+1].ay-
      Listeprisme[-1+i].messommets[j].ay)+
      Listeprisme[-1+i].messommets[j].ay-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=Listeprisme[-1+i].messommets[j].ax+
mu*(Listeprisme[-1+i].messommets[j+1].ax-Listeprisme[-1+i].messommets[j].ax);
yinter:=Listeprisme[-1+i].messommets[j].ay+
mu*(Listeprisme[-1+i].messommets[j+1].ay-Listeprisme[-1+i].messommets[j].ay);
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon))
 then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;  naissance:=false;
   surface_future:=sur_prisme;
   indicesurfacefuture:=i;  cotefutur:=j;
   normaleatracer:=true;
  normale2cotes:=true;
  anglepolairenormaleatracer:=donneanglepolairedans02pi(listeprisme[-1+i].nx[j],listeprisme[-1+i].ny[j]);
   if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;
 if (kxact*listeprisme[-1+i].nx[j]+kyact*listeprisme[-1+i].ny[j]<0) then
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact)  else
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact);
 end;
  {si le rayon sort}
  if (kxact*listeprisme[-1+i].nx[j]+kyact*listeprisme[-1+i].ny[j]>0) then begin
  {determination de l'indice du milieu de sortie}
   case couleur of
 clred: indiceoptiquefutur:=indice_rouge_par_defaut;
 clgreen: indiceoptiquefutur:=indice_vert_par_defaut;
 clblue: indiceoptiquefutur:=indice_bleu_par_defaut;
 end;
   if nombrepolycercle>0 then
   for iii:=1 to nombrepolycercle do
 if listepolycercle[-1+iii].estou(xinter+listeprisme[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listeprisme[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolycercle[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolycercle[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolycercle[-1+iii].indicebleu;
 end;


    if nombrepolyhedre>0 then
   for iii:=1 to nombrepolyhedre do
 if listepolyhedre[-1+iii].estou(xinter+listeprisme[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listeprisme[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolyhedre[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolyhedre[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolyhedre[-1+iii].indicebleu;
 end;




   if nombreprisme>0  then
   for iii:=1 to nombreprisme do
 if listeprisme[-1+iii].estou(xinter+listeprisme[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listeprisme[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listeprisme[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listeprisme[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listeprisme[-1+iii].indicebleu;
 end;




 if nombresphere>0 then
   for iii:=1 to nombresphere do
 if listesphere[-1+iii].estou(xinter+listeprisme[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listeprisme[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listesphere[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listesphere[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listesphere[-1+iii].indicebleu;
 end;

 if nombrelec>0 then
   for iii:=1 to nombrelec do
 if listelec[-1+iii].estou(xinter+listeprisme[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listeprisme[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listelec[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listelec[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listelec[-1+iii].indicebleu;
 end;

 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*listeprisme[-1+i].nx[j]+kyact*listeprisme[-1+i].ny[j]);
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 kxfutur:=kxact-(kxact*listeprisme[-1+i].nx[j]+kyact*listeprisme[-1+i].ny[j])*
 listeprisme[-1+i].nx[j]+listeprisme[-1+i].nx[j]*sqrt(patate);
kyfutur:=kyact-(kxact*listeprisme[-1+i].nx[j]+kyact*listeprisme[-1+i].ny[j])*
 listeprisme[-1+i].ny[j]+listeprisme[-1+i].ny[j]*sqrt(patate);
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;
 end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon sort}


  {si le rayon rentre}
  if (kxact*listeprisme[-1+i].nx[j]+kyact*listeprisme[-1+i].ny[j]<0) then begin
 case couleur of
 clred: indiceoptiquefutur:=listeprisme[-1+i].indicerouge;
 clgreen: indiceoptiquefutur:=listeprisme[-1+i].indicevert;
 clblue: indiceoptiquefutur:=listeprisme[-1+i].indicebleu;
 end;

 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*listeprisme[-1+i].nx[j]+kyact*listeprisme[-1+i].ny[j]);
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 kxfutur:=kxact-(kxact*listeprisme[-1+i].nx[j]+kyact*listeprisme[-1+i].ny[j])*
 listeprisme[-1+i].nx[j]-listeprisme[-1+i].nx[j]*sqrt(patate);
kyfutur:=kyact-(kxact*listeprisme[-1+i].nx[j]+kyact*listeprisme[-1+i].ny[j])*
 listeprisme[-1+i].ny[j]-listeprisme[-1+i].ny[j]*sqrt(patate);
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;
 end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon rentre}

{rayon reflechi dans le cas ou le refracte est entrant}
  if (kxact*listeprisme[-1+i].nx[j]+kyact*listeprisme[-1+i].ny[j]>0) then
if ((listeprisme[-1+i].reflechisortant=toujoursreflechi) or
    (unrefracte and (listeprisme[-1+i].reflechisortant=reflechisirefracte)) or
  (not(unrefracte) and (listeprisme[-1+i].reflechisortant=reflechisipasrefracte)))
  then begin
  surfaceabsorbanteatteinte:=false;
  incidence:=Pi/2-Listeprisme[-1+i].anglepolaire[j]+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listeprisme[-1+i].anglepolaire[j]-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listeprisme[-1+i].anglepolaire[j]-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;

anglepolairefutur:=2*Listeprisme[-1+i].anglepolaire[j]-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listeprisme[-1+i].anglepolaire[j]-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listeprisme[-1+i].anglepolaire[j]-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon reflechi si le refracte est sortant}


    {rayon reflechi dans le cas ou le refracte est entrant}
  if (kxact*listeprisme[-1+i].nx[j]+kyact*listeprisme[-1+i].ny[j]<0) then
if ((listeprisme[-1+i].reflechientrant=toujoursreflechi) or
    (unrefracte and (listeprisme[-1+i].reflechientrant=reflechisirefracte)) or
  (not(unrefracte) and (listeprisme[-1+i].reflechientrant=reflechisipasrefracte)))
  then begin
  surfaceabsorbanteatteinte:=false;
  incidence:=Pi/2-Listeprisme[-1+i].anglepolaire[j]+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listeprisme[-1+i].anglepolaire[j]-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listeprisme[-1+i].anglepolaire[j]-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;
anglepolairefutur:=2*Listeprisme[-1+i].anglepolaire[j]-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listeprisme[-1+i].anglepolaire[j]-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listeprisme[-1+i].anglepolaire[j]-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon reflechi si le refracte est entrant}


      end; end; end; {des prisme}






 {cas des polycercles}
     if nombrepolycercle>0 then
     for i:=1 to nombrepolycercle do
     for j:=1 to listepolycercle[-1+i].nombresommet do
     if listepolycercle[-1+i].rectiligne[j] then
     {  if not((indicesurfaceactuelle=i) and   (surface_actuelle=sur_polycercle) and
       (coteactuel=j)) then }
     if ((kyact*(Listepolycercle[-1+i].messommets[j+1].ax-Listepolycercle[-1+i].messommets[j].ax)) <>
     (kxact*(Listepolycercle[-1+i].messommets[j+1].ay-Listepolycercle[-1+i].messommets[j].ay  ))  ) then begin
     mu:=(kyact*(xact-Listepolycercle[-1+i].messommets[j].ax)-kxact*(yact-
     Listepolycercle[-1+i].messommets[j].ay))/
     (kyact*(Listepolycercle[-1+i].messommets[j+1].ax-
     Listepolycercle[-1+i].messommets[j].ax)-
     kxact*(Listepolycercle[-1+i].messommets[j+1].ay-Listepolycercle[-1+i].messommets[j].ay  ));
      if (abs(kxact)>abs(kyact)) then lambda:=(mu*(
      Listepolycercle[-1+i].messommets[j+1].ax-Listepolycercle[-1+i].messommets[j].ax)
      +Listepolycercle[-1+i].messommets[j].ax-xact)/kxact else
      lambda:=(mu*(Listepolycercle[-1+i].messommets[j+1].ay-
      Listepolycercle[-1+i].messommets[j].ay)+
      Listepolycercle[-1+i].messommets[j].ay-yact)/kyact;
       if ((mu>=0) and (mu<=1) and (lambda>0)) then
     begin
xinter:=Listepolycercle[-1+i].messommets[j].ax+
mu*(Listepolycercle[-1+i].messommets[j+1].ax-Listepolycercle[-1+i].messommets[j].ax);
yinter:=Listepolycercle[-1+i].messommets[j].ay+
mu*(Listepolycercle[-1+i].messommets[j+1].ay-Listepolycercle[-1+i].messommets[j].ay);
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;  naissance:=false;
   surface_future:=sur_polycercle;
   indicesurfacefuture:=i;  cotefutur:=j;
   normaleatracer:=true;
  normale2cotes:=true;
  anglepolairenormaleatracer:=donneanglepolairedans02pi(listepolycercle[-1+i].nx[j],listepolycercle[-1+i].ny[j]);
   if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;
 if (kxact*listepolycercle[-1+i].nx[j]+kyact*listepolycercle[-1+i].ny[j]<0) then
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact)  else
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact);
 end;
  {si le rayon sort}
  if (kxact*listepolycercle[-1+i].nx[j]+kyact*listepolycercle[-1+i].ny[j]>0) then begin
  {determination de l'indice du milieu de sortie}
  case couleur of
 clred: indiceoptiquefutur:=indice_rouge_par_defaut;
 clgreen: indiceoptiquefutur:=indice_vert_par_defaut;
 clblue: indiceoptiquefutur:=indice_bleu_par_defaut;
 end;

    if nombrepolycercle>0 then
   for iii:=1 to nombrepolycercle do
 if listepolycercle[-1+iii].estou(xinter+listepolycercle[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listepolycercle[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolycercle[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolycercle[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolycercle[-1+iii].indicebleu;
 end;

  if nombrepolyhedre>0 then
   for iii:=1 to nombrepolyhedre do
 if listepolyhedre[-1+iii].estou(xinter+listepolycercle[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listepolycercle[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolyhedre[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolyhedre[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolyhedre[-1+iii].indicebleu;
 end;


  if nombreprisme>0 then
   for iii:=1 to nombreprisme do
 if listeprisme[-1+iii].estou(xinter+listepolycercle[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listepolycercle[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listeprisme[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listeprisme[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listeprisme[-1+iii].indicebleu;
 end;




 if nombresphere>0 then
   for iii:=1 to nombresphere do
 if listesphere[-1+iii].estou(xinter+listepolycercle[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listepolycercle[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listesphere[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listesphere[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listesphere[-1+iii].indicebleu;
 end;

 if nombrelec>0 then
   for iii:=1 to nombrelec do
 if listelec[-1+iii].estou(xinter+listepolycercle[-1+i].nx[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)),yinter+listepolycercle[-1+i].ny[j]/10000*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin)))=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listelec[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listelec[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listelec[-1+iii].indicebleu;
 end;

 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*listepolycercle[-1+i].nx[j]+kyact*listepolycercle[-1+i].ny[j]);
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 kxfutur:=kxact-(kxact*listepolycercle[-1+i].nx[j]+kyact*listepolycercle[-1+i].ny[j])*
 listepolycercle[-1+i].nx[j]+listepolycercle[-1+i].nx[j]*sqrt(patate);
kyfutur:=kyact-(kxact*listepolycercle[-1+i].nx[j]+kyact*listepolycercle[-1+i].ny[j])*
 listepolycercle[-1+i].ny[j]+listepolycercle[-1+i].ny[j]*sqrt(patate);
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;
 end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon sort}


  {si le rayon rentre}
  if (kxact*listepolycercle[-1+i].nx[j]+kyact*listepolycercle[-1+i].ny[j]<0) then begin
 case couleur of
 clred: indiceoptiquefutur:=listepolycercle[-1+i].indicerouge;
 clgreen: indiceoptiquefutur:=listepolycercle[-1+i].indicevert;
 clblue: indiceoptiquefutur:=listepolycercle[-1+i].indicebleu;
 end;

 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*listepolycercle[-1+i].nx[j]+kyact*listepolycercle[-1+i].ny[j]);
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 kxfutur:=kxact-(kxact*listepolycercle[-1+i].nx[j]+kyact*listepolycercle[-1+i].ny[j])*
 listepolycercle[-1+i].nx[j]-listepolycercle[-1+i].nx[j]*sqrt(patate);
kyfutur:=kyact-(kxact*listepolycercle[-1+i].nx[j]+kyact*listepolycercle[-1+i].ny[j])*
 listepolycercle[-1+i].ny[j]-listepolycercle[-1+i].ny[j]*sqrt(patate);
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;
 end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon rentre}

{rayon reflechi dans le cas ou le refracte est entrant}
  if (kxact*listepolycercle[-1+i].nx[j]+kyact*listepolycercle[-1+i].ny[j]>0) then
if ((listepolycercle[-1+i].reflechisortant=toujoursreflechi) or
    (unrefracte and (listepolycercle[-1+i].reflechisortant=reflechisirefracte)) or
  (not(unrefracte) and (listepolycercle[-1+i].reflechisortant=reflechisipasrefracte)))
  then begin
  surfaceabsorbanteatteinte:=false;
  incidence:=Pi/2-Listepolycercle[-1+i].anglepolaire[j]+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listepolycercle[-1+i].anglepolaire[j]-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listepolycercle[-1+i].anglepolaire[j]-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;

anglepolairefutur:=2*Listepolycercle[-1+i].anglepolaire[j]-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listepolycercle[-1+i].anglepolaire[j]-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listepolycercle[-1+i].anglepolaire[j]-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon reflechi si le refracte est sortant}


    {rayon reflechi dans le cas ou le refracte est entrant}
  if (kxact*listepolycercle[-1+i].nx[j]+kyact*listepolycercle[-1+i].ny[j]<0) then
if ((listepolycercle[-1+i].reflechientrant=toujoursreflechi) or
    (unrefracte and (listepolycercle[-1+i].reflechientrant=reflechisirefracte)) or
  (not(unrefracte) and (listepolycercle[-1+i].reflechientrant=reflechisipasrefracte)))
  then begin
  surfaceabsorbanteatteinte:=false;
  incidence:=Pi/2-Listepolycercle[-1+i].anglepolaire[j]+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listepolycercle[-1+i].anglepolaire[j]-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listepolycercle[-1+i].anglepolaire[j]-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;
anglepolairefutur:=2*Listepolycercle[-1+i].anglepolaire[j]-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*Listepolycercle[-1+i].anglepolaire[j]-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*Listepolycercle[-1+i].anglepolaire[j]-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon reflechi si le refracte est entrant}


      end; end; end; {des polycercle, cotes rectilignes}




  {test sur les lpolycercles, faces circulaires}

     if nombrepolycercle>0 then
     for i:=1 to nombrepolycercle do
     for j:= 1 to listepolycercle[-1+i].nombresommet do
     if not(listepolycercle[-1+i].rectiligne[j])  then
          begin
     xact:=xact+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;


delta:=4*sqr(kxact*(xact-listepolycercle[-1+i].mescentres[j].ax)+kyact*(yact-listepolycercle[-1+i].mescentres[j].ay))-4*
     (sqr(kxact)+sqr(kyact))*(sqr(xact-listepolycercle[-1+i].mescentres[j].ax)+sqr(yact-listepolycercle[-1+i].mescentres[j].ay)-
     sqr(abs(listepolycercle[-1+i].rayon[j])));
     if delta>=0  then begin
     if delta=0 then
     lambda:=(kxact*(xact-listepolycercle[-1+i].mescentres[j].ax)+kyact*(yact-listepolycercle[-1+i].mescentres[j].ay))/
     (sqr(kxact)+sqr(kyact)) else begin
     lambda1:=(-2*(kxact*(xact-listepolycercle[-1+i].mescentres[j].ax)+kyact*(yact-listepolycercle[-1+i].mescentres[j].ay))
     +sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata1:=donneanglepolairedans02pi(lambda1*kxact+xact-listepolycercle[-1+i].mescentres[j].ax,
      lambda1*kyact+yact-listepolycercle[-1+i].mescentres[j].ay);


      lambda2:=(-2*(kxact*(xact-listepolycercle[-1+i].mescentres[j].ax)+kyact*(yact-listepolycercle[-1+i].mescentres[j].ay))
     -sqrt(delta))/2/(sqr(kxact)+sqr(kyact));
     tata2:=donneanglepolairedans02pi(lambda2*kxact+xact-listepolycercle[-1+i].mescentres[j].ax,
       lambda2*kyact+yact-listepolycercle[-1+i].mescentres[j].ay);


     if (
     ((lambda2>0) and (tata2>=listepolycercle[-1+i].theta1[j]) and (tata2<=listepolycercle[-1+i].theta2[j]))
     or
      ((lambda2>0) and (tata2+2*Pi>=listepolycercle[-1+i].theta1[j]) and (tata2+2*Pi<=listepolycercle[-1+i].theta2[j]))
      or
      ((lambda2>0) and (tata2-2*Pi>=listepolycercle[-1+i].theta1[j]) and (tata2-2*Pi<=listepolycercle[-1+i].theta2[j]))
      )
      then begin
      lambda:=lambda2;
      tata:=tata2 end  else begin
       lambda:=lambda1;
      tata:=tata1;
      end;
       end;

       if (
       ((lambda>0) and (tata>=listepolycercle[-1+i].theta1[j]) and (tata<=listepolycercle[-1+i].theta2[j])) or
        ((lambda>0) and (tata+2*Pi>=listepolycercle[-1+i].theta1[j]) and (tata+2*Pi<=listepolycercle[-1+i].theta2[j])) or
         ((lambda>0) and (tata-2*Pi>=listepolycercle[-1+i].theta1[j]) and (tata-2*Pi<=listepolycercle[-1+i].theta2[j]))
        )
        then
     begin
xinter:=xact+lambda*kxact;
yinter:=yact+lambda*kyact;
 if  ((sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))<distance*(1-epsilon))
 and (sqrt(sqr(xinter-xpact)+sqr(yinter-ypact))>sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*epsilon)) then begin
    distance:=sqrt(sqr(xinter-xpact)+sqr(yinter-ypact));
  xfutur:=xinter;
  yfutur:=yinter;
  bordureatteinte:=false;   naissance:=false;
 if (kxact*(xinter-listepolycercle[-1+i].mescentres[j].ax)+kyact*(yinter-listepolycercle[-1+i].mescentres[j].ay)<0) then begin
 nnx:=(xinter-listepolycercle[-1+i].mescentres[j].ax);
 nny:=(yinter-listepolycercle[-1+i].mescentres[j].ay);
   end else begin
  nnx:=-(xinter-listepolycercle[-1+i].mescentres[j].ax);
 nny:=-(yinter-listepolycercle[-1+i].mescentres[j].ay);
       end;

   surfaceabsorbanteatteinte:=false;
   surface_future:=sur_polycercle;
   indicesurfacefuture:=i;
    normaleatracer:=true;
  normale2cotes:=true;
  anglepolairenormaleatracer:=donneanglepolairedans02pi(nnx,nny);
   if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=false;
 angleincident.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xact,yact) ;
 end;
   {rayon entrant}
   if {(nnx*kxact+nny*kyact<0)} listepolycercle[-1+i].estou( xinter+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000,yinter+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000)=Iinterieur then   begin
     case couleur of
 clred: indiceoptiquefutur:=listepolycercle[-1+i].indicerouge;
 clgreen: indiceoptiquefutur:=listepolycercle[-1+i].indicevert;
 clblue: indiceoptiquefutur:=listepolycercle[-1+i].indicebleu;
 end;


 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))+
 kyact*((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j])));
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 if (kxact*(xinter-listepolycercle[-1+i].mescentres[j].ax)+kyact*(yinter-listepolycercle[-1+i].mescentres[j].ay)<0) then begin
 kxfutur:=kxact-(kxact*((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))+kyact*
 ((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j])))*
 ((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))
 -((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))+
kyact*((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j])))*
 ((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j]))-((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j]))
 *sqrt(patate); end else begin

 kxfutur:=kxact-(kxact*((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))+kyact*
 ((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j])))*
 ((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))
 +((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))+
kyact*((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j])))*
 ((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j]))+((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j]))
 *sqrt(patate);
 end;
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
 if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;
 end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon rentre}


 {rayon sortant}
 if {(nnx*kxact+nny*kyact>0)} listepolycercle[-1+i].estou( xinter+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000,yinter+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000)=Iexterieur then  begin
    case couleur of
 clred: indiceoptiquefutur:=indice_rouge_par_defaut;
 clgreen: indiceoptiquefutur:=indice_vert_par_defaut;
 clblue: indiceoptiquefutur:=indice_bleu_par_defaut;
 end;

   if nombrepolycercle>0 then
   for iii:=1 to nombrepolycercle do
 if listepolycercle[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolycercle[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolycercle[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolycercle[-1+iii].indicebleu;
 end;


  if nombrepolyhedre>0 then
   for iii:=1 to nombrepolyhedre do
 if listepolyhedre[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listepolyhedre[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listepolyhedre[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listepolyhedre[-1+iii].indicebleu;
 end;

   if nombreprisme>0 then
   for iii:=1 to nombreprisme do
 if listeprisme[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listeprisme[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listeprisme[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listeprisme[-1+iii].indicebleu;
 end;


 if nombresphere>0 then
   for iii:=1 to nombresphere do
 if listesphere[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listesphere[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listesphere[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listesphere[-1+iii].indicebleu;
 end;

 if nombrelec>0 then
   for iii:=1 to nombrelec do
 if listelec[-1+iii].estou(xinter+kxact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000,
 yinter+kyact*sqrt(
 sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxact)+sqr(kyact))/1000)=Iinterieur then
 case couleur of
 clred: indiceoptiquefutur:=listelec[-1+iii].indicerouge;
 clgreen: indiceoptiquefutur:=listelec[-1+iii].indicevert;
 clblue: indiceoptiquefutur:=listelec[-1+iii].indicebleu;
 end;


 patate:=(sqr(indiceoptiquefutur/indiceoptiqueactuel)-1)*(sqr(kxact)+sqr(kyact))
 +sqr(kxact*((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))+kyact*
 ((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j])));
 unrefracte:=patate>0;
 if not(unrefracte) then surfaceabsorbanteatteinte:=true else begin
 surfaceabsorbanteatteinte:=false;
 if (kxact*(xinter-listepolycercle[-1+i].mescentres[j].ax)+kyact*(yinter-listepolycercle[-1+i].mescentres[j].ay)<0) then begin
 kxfutur:=kxact-(kxact*((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))+kyact*
 ((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j])))*
 ((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))-((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))+kyact*
((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j])))*
 ((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j]))-((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j]))*sqrt(patate);
    end else begin
 kxfutur:=kxact-(kxact*((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))+kyact*
 ((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j])))*
 ((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))+((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))*sqrt(patate);
kyfutur:=kyact-(kxact*((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))+kyact*
((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j])))*
 ((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j]))+((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j]))*sqrt(patate);
 end;
 anglepolairefutur:=donneanglepolairedanspipi(kxfutur,kyfutur);

xfutur:=xinter;
yfutur:=yinter;
if optionangles then begin
 incidentatracer:=true;
 refracteatracer:=true;

 anglerefracte.create(xfutur,yfutur,xfutur+cos( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 yfutur+sin( anglepolairenormaleatracer+pi)*
 sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
 xfutur+kxfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2,
 yfutur+kyfutur*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/sqrt(sqr(kxfutur)+sqr(kyfutur))*pourcentagenormale/2) ;
 end;
       end; {du cas ou existe le rayon refracte}
 end;{du cas ou le rayon sort}

if nnx=0 then
if nny>0 then agp:=Pi/2 else agp:=-Pi/2
else
begin
agp:=arctan(nny/nnx);
if nnx<0 then agp:=agp+Pi;
end;


{rayon refpolycerclehi dans le cas ou le refracte est entrant}
  if {(kxact*((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))+
  kyact*((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j]))>0)}
  listepolycercle[-1+i].estou( xinter+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000,yinter+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000)=Iinterieur then
if ((listepolycercle[-1+i].reflechisortant=toujoursreflechi) or
    (unrefracte and (listepolycercle[-1+i].reflechisortant=reflechisirefracte)) or
  (not(unrefracte) and (listepolycercle[-1+i].reflechisortant=reflechisipasrefracte)))
  then begin
  agp:=agp+pi/2;
  surfaceabsorbanteatteinte:=false;
  incidence:=Pi/2-agp+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;

anglepolairefutur:=2*agp-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon refpolycerclehi si le refracte est sortant}


    {rayon refpolycerclehi dans le cas ou le refracte est entrant}
  if {(kxact*((xinter-listepolycercle[-1+i].mescentres[j].ax)/abs(listepolycercle[-1+i].rayon[j]))+
  kyact*((yinter-listepolycercle[-1+i].mescentres[j].ay)/abs(listepolycercle[-1+i].rayon[j]))<0)}
  listepolycercle[-1+i].estou( xinter+kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000,yinter+kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000)=Iexterieur then
if ((listepolycercle[-1+i].reflechientrant=toujoursreflechi) or
    (unrefracte and (listepolycercle[-1+i].reflechientrant=reflechisirefracte)) or
  (not(unrefracte) and (listepolycercle[-1+i].reflechientrant=reflechisipasrefracte)))
  then begin
  surfaceabsorbanteatteinte:=false;
  agp:=agp-pi/2;
  incidence:=Pi/2-agp+anglepolaireact;
  if incidence>Pi then incidence:=incidence-2*Pi;
  if incidence<-Pi then incidence:=incidence+2*Pi;
     if not(unrefracte) then begin
     indiceoptiquefutur:=indiceoptiqueactuel;
     kxfutur:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyfutur:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
xfutur:=xinter; yfutur:=yinter;
anglepolairefutur:=2*agp-anglepolaireact;
if anglepolairefutur>Pi then anglepolairefutur:=anglepolairefutur-2*Pi;
if anglepolairefutur<-Pi then anglepolairefutur:=anglepolairefutur+2*Pi;
  end else   begin
   kxenfant:=sqrt(kxact*kxact+kyact*kyact)*cos(2*agp-anglepolaireact);
kyenfant:=sqrt(kxact*kxact+kyact*kyact)*sin(2*agp-anglepolaireact);
naissance:=true;
xenfant:=xinter+kxenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
yenfant:=yinter+kyenfant/sqrt(sqr(kxenfant)+sqr(kyenfant))/10000*sqrt(
sqr(xxmax-xxmin)+sqr(yymax-yymin));
  end;
    end;    {du rayon refpolycerclehi si le refracte est entrant}

    end; end; end;
    {on retablit les valeurs d'origine s'il a fallu les modifier}

     xact:=xact-kxact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;
     yact:=yact-kyact*sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))/
     sqrt(sqr(kxact)+sqr(kyact))/10000;

     end;{des cercle, 1ere face}








    if abs(kxfutur)<sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin))/1e10 then kxfutur:=0;
 if abs(kyfutur)<sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin))/1e10 then kyfutur:=0;


   if not(optionsurfacesonde) then begin
    retaillepsegment(listesegment,nombretotalsegment,nombretotalsegment+1);
    inc(nombretotalsegment);
    listesegment[-1+nombretotalsegment].create(xact,yact,xfutur,yfutur,anglepolaireact,epaisseur,
    couleur,l_vav[nombresegment+1],l_vaa[nombresegment+1]);
   end;

   if optionsurfacesonde then  begin
   cheminoptique:=cheminoptique+indiceoptiqueactuel*
   sqrt(sqr(xfutur-xact)+sqr(yfutur-yact));
     if cheminoptique>cheminactuelaobtenir then begin
     lambda:=(cheminactuelaobtenir-(cheminoptique-indiceoptiqueactuel*
   sqrt(sqr(xfutur-xact)+sqr(yfutur-yact))))/indiceoptiqueactuel/
    sqrt(sqr(xfutur-xact)+sqr(yfutur-yact));
    if premierpointsurfacesonde then begin
      premierpointsurfacesonde:=false;
       interx1:=xact+lambda*(xfutur-xact);
    intery1:=yact+lambda*(yfutur-yact);
    exit;
    end;
      interx2:=xact+lambda*(xfutur-xact);
    intery2:=yact+lambda*(yfutur-yact);
    retaillepsegment(listesegment,nombretotalsegment,nombretotalsegment+1);
    inc(nombretotalsegment);
    listesegment[-1+nombretotalsegment].create(interx1,intery1,interx2,intery2,
    donneanglepolairedans02pi(interx2-interx1,intery2-intery1),1,
    couleur,false,false);
    interx1:=interx2; intery1:=intery2;
     exit;
     end;
     if ((surface_future=sur_lmc) or  (surface_future=sur_mscopa) or
     (surface_future=sur_lmd) or  (surface_future=sur_mscepa)) then
     cheminoptique:=cheminoptique+cheminsup;
     end;

    if not(optionsurfacesonde) then
    if optionangles then  begin
   if incidentatracer  then begin
   retaillepangle(listeanglesatracer,nombreanglesatracer,nombreanglesatracer+1);
   inc(nombreanglesatracer);
   listeanglesatracer[-1+nombreanglesatracer].create(angleincident.cx,
   angleincident.cy,angleincident.a1x,angleincident.a1y,
   angleincident.a2x,angleincident.a2y);
   end;
   if refracteatracer  then begin
   retaillepangle(listeanglesatracer,nombreanglesatracer,nombreanglesatracer+1);
   inc(nombreanglesatracer);
   listeanglesatracer[-1+nombreanglesatracer].create(anglerefracte.cx,
   anglerefracte.cy,anglerefracte.a1x,anglerefracte.a1y,
   anglerefracte.a2x,anglerefracte.a2y);
   end;
   end;


   if not(optionsurfacesonde) then
   if optionnormale then if normaleatracer then begin
   retaillepsegment(listenormale,nombrenormale,nombrenormale+1);
    inc(nombrenormale);
    if normale2cotes  then listenormale[-1+nombrenormale].create(xfutur+cos(anglepolairenormaleatracer)
    *sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
    yfutur+sin(anglepolairenormaleatracer)
    *sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
    xfutur+cos(anglepolairenormaleatracer+pi)
    *sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,
    yfutur+sin(anglepolairenormaleatracer+pi)
    *sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale/2,anglepolairenormaleatracer,epaisseurnormale,
    couleurnormale,false,false) else
     listenormale[-1+nombrenormale].create(xfutur,
    yfutur,
    xfutur+cos(anglepolairenormaleatracer)
    *sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,
    yfutur+sin(anglepolairenormaleatracer)
    *sqrt(sqr(xxmax-xxmin)+sqr(yymax-yymin))*pourcentagenormale,anglepolairenormaleatracer,epaisseurnormale,
    couleurnormale,false,false);
    end;

   xact:=xfutur; yact:=yfutur; kxact:=kxfutur; kyact:=kyfutur;
   anglepolaireact:=anglepolairefutur; indiceoptiqueactuel:=indiceoptiquefutur;
   surface_actuelle:=surface_future;  coteactuel:=cotefutur;
   indicesurfaceactuelle:=indicesurfacefuture;
    inc(nombresegment);

   if not(optionsurfacesonde) and not(surface_future=sur_reseau) then
   if (naissance and (nombrenaissance<nombremaxenfant)) then begin
   retailleprayon(listerayonenfant,nombreenfant,nombreenfant+1);
   inc(nombreenfant);
      if not(optionsurfacesonde) then
   if not(  listerayonenfant[-1+nombreenfant].createenfant(xenfant,yenfant,kxenfant,kyenfant,couleur,epaisseur,
    vav,vaa,nombremaxenfant-nombrenaissance-1,maxsegment,nombresegment)) then begin
    retailleprayon(listerayonenfant,nombreenfant,nombreenfant-1);
    dec(nombreenfant);
    end else
    inc(nombrenaissance);
    end;


   if not(optionsurfacesonde) and (surface_future=sur_reseau) and (nombreenfantreseau>0) and not(surfaceabsorbanteatteinte) then
   if ((nombrenaissance+nombreenfantreseau<nombremaxenfant)) then begin
   retailleprayon(listerayonenfant,nombreenfant,nombreenfant+nombreenfantreseau);
            for boubou:=1 to nombreenfantreseau do  begin
      listerayonenfant[-1+nombreenfant+boubou].createenfant(xenfantreseau[boubou-1],yenfantreseau[boubou-1],kxenfantreseau[boubou-1],kyenfantreseau[boubou-1],couleur,epaisseur,
    vav,vaa,nombremaxenfant-nombrenaissance-1,maxsegment,nombresegment);
    inc(nombrenaissance);   end;
              nombreenfant:=nombreenfant+nombreenfantreseau;
    end;




    end;  {de la boucle while}

 end;



 procedure CreePtexteaffiche(var TheArray : Ptexteaffiche;
  NumElements : longint);
 begin
  setlength(TheArray,NumElements);
end;


 procedure FreePtexteaffiche(var TheArray : Ptexteaffiche;
  NumElements : longint);
begin
  finalize(TheArray);
end;


 procedure ReTaillePtexteaffiche(var TheArray :Ptexteaffiche;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

procedure Supprime1Ptexteaffiche(var thearray:ptexteaffiche;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdtexteaffiche)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].texteluimeme,
thearray[-1+nbelements].policename,thearray[-1+nbelements].policecharset,
thearray[-1+nbelements].policecolor,thearray[-1+nbelements].policesize,
thearray[-1+nbelements].policepitch,
thearray[-1+nbelements].policefsbold,
thearray[-1+nbelements].policefsitalic,
thearray[-1+nbelements].policefsunderline,
thearray[-1+nbelements].policefsstrikeout,
thearray[-1+nbelements].x,
thearray[-1+nbelements].y);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdtexteaffiche)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retailleptexteaffiche(thearray,nbelements,nbelements-1);
dec(nbelements);

end;


 procedure CreePmiroirplan(var TheArray : Pmiroirplan;
  NumElements : longint);
 begin
  setlength(TheArray,NumElements);
end;

  procedure CreePReseau(var TheArray : PReseau;
  NumElements : longint);
 begin
  setlength(TheArray,NumElements);
end;


 procedure FreePmiroirplan(var TheArray : Pmiroirplan;
  NumElements : longint);
begin
  finalize(TheArray);
end;

 procedure FreePReseau(var TheArray : PReseau;
  NumElements : longint);
begin
  finalize(TheArray);
end;


 procedure ReTaillePmiroirplan(var TheArray :Pmiroirplan;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

  procedure ReTaillePreseau(var TheArray :Preseau;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;


procedure Supprime1PMiroirplan(var thearray:pmiroirplan;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmiroirplan)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui2, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].hachures);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmiroirplan)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepmiroirplan(thearray,nbelements,nbelements-1);
dec(nbelements);

end;





procedure Supprime1PReseau(var thearray:pReseau;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdReseau)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui2, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].pas,
thearray[-1+nbelements].entransmission,
thearray[-1+nbelements].hachures,
thearray[-1+nbelements].ordre_min,
thearray[-1+nbelements].ordre_max);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdReseau)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepReseau(thearray,nbelements,nbelements-1);
dec(nbelements);

end;



 procedure CreePfleche(var TheArray : Pfleche;
  NumElements : longint);
 begin
  setlength(TheArray,  NumElements);
end;


 procedure FreePfleche(var TheArray : Pfleche;
  NumElements : longint);
begin
  finalize(TheArray);
end;


 procedure ReTaillePfleche(var TheArray :Pfleche;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

procedure Supprime1Pfleche(var thearray:pfleche;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdfleche)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui3, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].ext1,
thearray[-1+nbelements].ext1,
thearray[-1+nbelements].styletrait,
thearray[-1+nbelements].taille1,
thearray[-1+nbelements].taille2);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdfleche)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepfleche(thearray,nbelements,nbelements-1);
dec(nbelements);

end;


 procedure CreePmiroirconique(var TheArray : Pmiroirconique;
  NumElements : longint);
 begin
  setlength(TheArray, NumElements);
end;


 procedure FreePmiroirconique(var TheArray : Pmiroirconique;
  NumElements : longint);
begin
  finalize(TheArray);
end;


 procedure ReTaillePmiroirconique(var TheArray :Pmiroirconique;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

procedure Supprime1Pmiroirconique(var thearray:pmiroirconique;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmiroirconique)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui4, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
{thearray[-1+indice].create(thearray[-1+nbelements].fx,
thearray[-1+nbelements].fy,
thearray[-1+nbelements].sx,
thearray[-1+nbelements].sy,
thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].concave,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].couleuraxe,
thearray[-1+nbelements].hachures,
thearray[-1+nbelements].axefocal);}
thearray[-1+indice].create2(thearray[-1+nbelements].fx,
thearray[-1+nbelements].fy,
thearray[-1+nbelements].theta0,
thearray[-1+nbelements].theta1,
thearray[-1+nbelements].theta2,
thearray[-1+nbelements].excentricite,
thearray[-1+nbelements].parametre,
thearray[-1+nbelements].concave,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].couleuraxe,
thearray[-1+nbelements].hachures,
thearray[-1+nbelements].axefocal);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmiroirconique)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepmiroirconique(thearray,nbelements,nbelements-1);
dec(nbelements);

end;


 procedure CreePsphere(var TheArray : Psphere;
  NumElements : longint);
 begin
  setlength(TheArray, NumElements);
end;


 procedure FreePsphere(var TheArray : Psphere;
  NumElements : longint);
begin
   finalize(TheArray);
end;


 procedure ReTaillePsphere(var TheArray :Psphere;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;
procedure Supprime1Psphere(var thearray:psphere;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdsphere)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui5, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].cx,
thearray[-1+nbelements].cy,
thearray[-1+nbelements].rayon,
thearray[-1+nbelements].indicerouge,
thearray[-1+nbelements].indicebleu,
thearray[-1+nbelements].indicevert,
thearray[-1+nbelements].couleurbord,
thearray[-1+nbelements].couleurfond,
thearray[-1+nbelements].reflechientrant,
thearray[-1+nbelements].reflechisortant);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdsphere)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepsphere(thearray,nbelements,nbelements-1);
dec(nbelements);

end;


 procedure CreePEcran(var TheArray : PEcran;
  NumElements : longint);
 begin
  setlength(TheArray,NumElements);
end;


 procedure FreePEcran(var TheArray : PEcran;
  NumElements : longint);
begin
   finalize(TheArray);
end;


 procedure ReTaillePEcran(var TheArray :PEcran;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

procedure Supprime1PEcran(var thearray:pEcran;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdecran)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui6, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].couleur);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdecran)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepEcran(thearray,nbelements,nbelements-1);
dec(nbelements);

end;

 procedure CreePgroupe(var TheArray : Pgroupe;
  NumElements : longint);
 begin
  setlength(TheArray,  NumElements);
end;


 procedure FreePgroupe(var TheArray : Pgroupe;
  NumElements : longint);
begin
   finalize(TheArray);
end;


 procedure ReTaillePgroupe(var TheArray :Pgroupe;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

procedure Supprime1Pgroupe(var thearray:pgroupe;
indice:longint; var nbelements:longint);
var i:integer;
begin
if indice>nbelements then exit;
if indice<=0 then exit;
thearray[-1+indice].create;
for i:=1 to thearray[-1+nbelements].nombreelements do
 thearray[-1+indice].add(thearray[-1+nbelements].listeelements[i].typeelementgroupe,
 thearray[-1+nbelements].listeelements[i].indiceelement);
retaillepgroupe(thearray,nbelements,nbelements-1);
dec(nbelements);

end;

 procedure CreePoeil(var TheArray : Poeil;
  NumElements : longint);
 begin
 setlength(TheArray,  NumElements);
end;


 procedure FreePoeil(var TheArray : Poeil;
  NumElements : longint);
begin
   finalize(TheArray);
end;


 procedure ReTaillePoeil(var TheArray :Poeil;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

procedure Supprime1Poeil(var thearray:poeil;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdoeil)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui7, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].cx,
thearray[-1+nbelements].cy,
thearray[-1+nbelements].ax,
thearray[-1+nbelements].ay,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].couleur);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdoeil)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepoeil(thearray,nbelements,nbelements-1);
dec(nbelements);

end;



 procedure CreePdiaphragme(var TheArray : Pdiaphragme;
  NumElements : longint);
 begin
  setlength(TheArray,  NumElements);
end;


 procedure FreePdiaphragme(var TheArray : Pdiaphragme;
  NumElements : longint);
begin
  finalize(TheArray);
end;


 procedure ReTaillePdiaphragme(var TheArray :Pdiaphragme;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

procedure Supprime1Pdiaphragme(var thearray:pdiaphragme;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mddiaphragme)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui8, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create2(thearray[-1+nbelements].cx,
thearray[-1+nbelements].cy,
thearray[-1+nbelements].anglepolaire,
thearray[-1+nbelements].rint,
thearray[-1+nbelements].rext,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].epaisseur);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mddiaphragme)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepdiaphragme(thearray,nbelements,nbelements-1);
dec(nbelements);

end;


 procedure CreePlsr(var TheArray : Plsr;
  NumElements : longint);
 begin
  setlength(TheArray,NumElements);
end;


 procedure FreePlsr(var TheArray : Plsr;
  NumElements : longint);
begin
   finalize(TheArray);
end;


 procedure ReTaillePlsr(var TheArray :Plsr;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

procedure Supprime1Plsr(var thearray:plsr;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdlsr)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui9, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].couleur);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdlsr)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retailleplsr(thearray,nbelements,nbelements-1);
dec(nbelements);

end;

function angle.create(_cx,_cy,_a1x,_a1y,_a2x,_a2y:extended):boolean;
var ttai:extended;
begin
{if ((_a1x>xxmax) or (_a1x<xxmin) or (_a1y>yymax) or (_a1y<yymin) or
 (_a2x>xxmax) or (_a2x<xxmin) or (_a2y>yymax) or (_a2y<yymin)
  or
 (_cx>xxmax) or (_cx<xxmin) or (_cy>yymax) or (_cy<yymin)) then begin
 create:=false;
 exit;
 end;
 ttai:=sqrt((xxmax-xxmin)*(xxmax-xxmin)+(yymax-yymin)*(yymax-yymin));
 if ((sqrt(sqr(_a1x-_cx)+sqr(_a1y-_cy))<ttai/1e8) or  (sqrt(sqr(_a2x-_cx)+sqr(_a2y-_cy))<ttai/1e8)) then begin
 create:=false;
 exit;
 end;}
 create:=true;
  modifie:=true;
 a1x:=_a1x;
 a1y:=_a1y;
 a2x:=_a2x;
 a2y:=_a2y;  cx:=_cx; cy:=_cy;
 dx:=(a1x+a2x)/2; dy:=(a1y+a2y)/2;
 end;



function metre.create(_a1x,_a1y,_a2x,_a2y:extended):boolean;
begin
if ((_a1x>xxmax) or (_a1x<xxmin) or (_a1y>yymax) or (_a1y<yymin) or
 (_a2x>xxmax) or (_a2x<xxmin) or (_a2y>yymax) or (_a2y<yymin)) then begin
 create:=false;
 exit;
 end;
 create:=true;
  modifie:=true;
 a1x:=_a1x;
 a1y:=_a1y;
 a2x:=_a2x;
 a2y:=_a2y;  cx:=(a1x+a2x)/2; cy:=(a1y+a2y)/2;
 end;




procedure Supprime1Pmetre(var thearray:pmetre;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmetre)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui10, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmetre)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepmetre(thearray,nbelements,nbelements-1);
dec(nbelements);

end;


procedure Supprime1Pangle(var thearray:pangle;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdangle)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui11, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].cx,
thearray[-1+nbelements].cy,
thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdangle)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepangle(thearray,nbelements,nbelements-1);
dec(nbelements);

end;


 procedure CreePsegment(var TheArray : Psegment;
  NumElements : longint);
 begin
  setlength(TheArray, NumElements);
end;


 procedure FreePsegment(var TheArray : Psegment;
  NumElements : longint);
begin
  finalize(TheArray);
end;


 procedure ReTaillePsegment(var TheArray :Psegment;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

 procedure CreePpolyhedre(var TheArray : Ppolyhedre;
  NumElements : longint);
 begin
  setlength(TheArray,  NumElements);
end;


 procedure FreePpolyhedre(var TheArray : Ppolyhedre;
  NumElements : longint);
begin
   finalize(TheArray);
end;


 procedure ReTaillePpolyhedre(var TheArray :Ppolyhedre;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;



procedure CreePprisme(var TheArray : Pprisme;
  NumElements : longint);
 begin
  setlength(TheArray,  NumElements);
end;


 procedure FreePprisme(var TheArray : Pprisme;
  NumElements : longint);
begin
   finalize(TheArray);
end;


 procedure ReTaillePprisme(var TheArray :Pprisme;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;


 procedure CreePpolycercle(var TheArray : Ppolycercle;
  NumElements : longint);
 begin
  setlength(TheArray,  NumElements);
end;


 procedure FreePpolycercle(var TheArray : Ppolycercle;
  NumElements : longint);
begin
   finalize(TheArray);
end;


 procedure ReTaillePpolycercle(var TheArray :Ppolycercle;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;
procedure Supprime1Psegment(var thearray:psegment;
indice:longint; var nbelements:longint);
var i:integer;
begin
if indice>nbelements then exit;
if indice<=0 then exit;
thearray[-1+indice].create(thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].ap,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].virtuelavant,
thearray[-1+nbelements].virtuelarriere);
retaillepsegment(thearray,nbelements,nbelements-1);
dec(nbelements);
end;

procedure Supprime1Prayon(var thearray:prayon;
indice:longint; var nbelements:longint);
var saa,sar:shortstring;
 i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdrayon)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui12, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].ax,
thearray[-1+nbelements].ay,
thearray[-1+nbelements].kx,
thearray[-1+nbelements].ky,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].vav,
thearray[-1+nbelements].vaa,
thearray[-1+nbelements].nombremaxenfant,
thearray[-1+nbelements].maxsegment);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdrayon)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retailleprayon(thearray,nbelements,nbelements-1);
dec(nbelements);

end;


procedure Supprime1Psourceponctuelle(var thearray:psourceponctuelle;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdsourceponctuelle)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui13, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].nombrederayon,
thearray[-1+nbelements].sx,
thearray[-1+nbelements].sy,
thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].ray[1].couleur,
thearray[-1+nbelements].ray[1].epaisseur,
thearray[-1+nbelements].ray[1].vav,
thearray[-1+nbelements].ray[1].vaa,
thearray[-1+nbelements].maxenfantparrayon,
thearray[-1+nbelements].sourcevirtuelle,
thearray[-1+nbelements].tracersurfacesonde,
thearray[-1+nbelements].listechemins,
thearray[-1+nbelements].maxsegment);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdsourceponctuelle)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepsourceponctuelle(thearray,nbelements,nbelements-1);
dec(nbelements);

end;

procedure Supprime1Pondeplane(var thearray:pondeplane;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdondeplane)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui14, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].nombrederayon,
thearray[-1+nbelements].ray[1].bx,
thearray[-1+nbelements].ray[1].by,
thearray[-1+nbelements].ray[1].ax,
thearray[-1+nbelements].ray[1].ay,
thearray[-1+nbelements].ray[thearray[-1+nbelements].nombrederayon].ax,
thearray[-1+nbelements].ray[thearray[-1+nbelements].nombrederayon].ay,
thearray[-1+nbelements].ray[1].couleur,
thearray[-1+nbelements].ray[1].epaisseur,
thearray[-1+nbelements].ray[1].vav,
thearray[-1+nbelements].ray[1].vaa,
thearray[-1+nbelements].maxenfantparrayon,
thearray[-1+nbelements].tracersurfacesonde,
thearray[-1+nbelements].listechemins,
thearray[-1+nbelements].maxsegment);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdondeplane)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepondeplane(thearray,nbelements,nbelements-1);
dec(nbelements);

end;


procedure Supprime1Pmscopa(var thearray:pmscopa;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmscopa)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui15, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create2(thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].focale,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].couleuraxe,
thearray[-1+nbelements].hachures,
thearray[-1+nbelements].axefocal,
thearray[-1+nbelements].trou,
thearray[-1+nbelements].diametretrou);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmscopa)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepmscopa(thearray,nbelements,nbelements-1);
dec(nbelements);

end;


procedure Supprime1Pmscepa(var thearray:pmscepa;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmscepa)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui16, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create2(thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].focale,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].couleuraxe,
thearray[-1+nbelements].hachures,
thearray[-1+nbelements].axefocal,
thearray[-1+nbelements].trou,
thearray[-1+nbelements].diametretrou);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmscepa)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepmscepa(thearray,nbelements,nbelements-1);
dec(nbelements);

end;


procedure Supprime1Pmscore(var thearray:pmscore;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmscore)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui17, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create2(thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].rayoncourbure,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].couleuraxe,
thearray[-1+nbelements].hachures,
thearray[-1+nbelements].axefocal,
thearray[-1+nbelements].aigu,
thearray[-1+nbelements].trou,
thearray[-1+nbelements].diametretrou);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmscore)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepmscore(thearray,nbelements,nbelements-1);
dec(nbelements);

end;



procedure Supprime1Ppolyhedre(var thearray:ppolyhedre;
indice:longint; var nbelements:longint);
var   pp:tableaupointpolyhedre;
 i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdpolyhedre)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui18, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
for i:=1 to thearray[-1+nbelements].nombresommet do begin
pp[i].ax:=thearray[-1+nbelements].messommets[i].ax;
pp[i].ay:=thearray[-1+nbelements].messommets[i].ay;
end;
thearray[-1+indice].create(thearray[-1+nbelements].nombresommet,
pp,
thearray[-1+nbelements].indicerouge,
thearray[-1+nbelements].indicebleu,
thearray[-1+nbelements].indicevert,
thearray[-1+nbelements].couleurbord,
thearray[-1+nbelements].couleurfond,
thearray[-1+nbelements].reflechientrant,
thearray[-1+nbelements].reflechisortant);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdpolyhedre)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retailleppolyhedre(thearray,nbelements,nbelements-1);
dec(nbelements);

end;






procedure Supprime1Pprisme(var thearray:pprisme;
indice:longint; var nbelements:longint);
var   pp:tableaupointpolyhedre;
 i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdprisme)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui19, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
for i:=1 to thearray[-1+nbelements].nombresommet do begin
pp[i].ax:=thearray[-1+nbelements].messommets[i].ax;
pp[i].ay:=thearray[-1+nbelements].messommets[i].ay;
end;
thearray[-1+indice].create(thearray[-1+nbelements].gx,
thearray[-1+nbelements].gy,thearray[-1+nbelements].ax,
thearray[-1+nbelements].ay,thearray[-1+nbelements].bx,
thearray[-1+nbelements].by,
thearray[-1+nbelements].indicerouge,
thearray[-1+nbelements].indicebleu,
thearray[-1+nbelements].indicevert,
thearray[-1+nbelements].couleurbord,
thearray[-1+nbelements].couleurfond,
thearray[-1+nbelements].reflechientrant,
thearray[-1+nbelements].reflechisortant);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdprisme)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepprisme(thearray,nbelements,nbelements-1);
dec(nbelements);

end;






procedure Supprime1Ppolycercle(var thearray:ppolycercle;
indice:longint; var nbelements:longint);
var   pp,ps:tableaupointpolyhedre;  r:tableaurectiligne;
i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdpolycercle)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui20, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
for i:=1 to thearray[-1+nbelements].nombresommet do begin
pp[i].ax:=thearray[-1+nbelements].messommets[i].ax;
pp[i].ay:=thearray[-1+nbelements].messommets[i].ay;
ps[i].ax:=thearray[-1+nbelements].mess[i].ax;
ps[i].ay:=thearray[-1+nbelements].mess[i].ay;
r[i]:=thearray[-1+nbelements].rectiligne[i];
end;
thearray[-1+indice].create(thearray[-1+nbelements].nombresommet,
pp,ps,r,
thearray[-1+nbelements].indicerouge,
thearray[-1+nbelements].indicebleu,
thearray[-1+nbelements].indicevert,
thearray[-1+nbelements].couleurbord,
thearray[-1+nbelements].couleurfond,
thearray[-1+nbelements].reflechientrant,
thearray[-1+nbelements].reflechisortant);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdpolycercle)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retailleppolycercle(thearray,nbelements,nbelements-1);
dec(nbelements);

end;



procedure Supprime1Pmscere(var thearray:pmscere;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmscere)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui21, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create2(thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].rayoncourbure,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].couleuraxe,
thearray[-1+nbelements].hachures,
thearray[-1+nbelements].axefocal,
thearray[-1+nbelements].aigu,
thearray[-1+nbelements].trou,
thearray[-1+nbelements].diametretrou);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdmscere)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retaillepmscere(thearray,nbelements,nbelements-1);
dec(nbelements);

end;



procedure Supprime1Plmc(var thearray:plmc;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdlmc)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui22, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;

thearray[-1+indice].create2(thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].focale,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].couleuraxe,
thearray[-1+nbelements].axefocal);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdlmc)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retailleplmc(thearray,nbelements,nbelements-1);
dec(nbelements);

end;



procedure Supprime1Plec(var thearray:plec;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdlec)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui23, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create(thearray[-1+nbelements].s1x,
thearray[-1+nbelements].s1y,
thearray[-1+nbelements].s2x,
thearray[-1+nbelements].s2y,
thearray[-1+nbelements].r1,
thearray[-1+nbelements].r2,
thearray[-1+nbelements].diametre,
thearray[-1+nbelements].couleurfond,
thearray[-1+nbelements].couleuraxe,
thearray[-1+nbelements].axefocal,
thearray[-1+nbelements].indicerouge,thearray[-1+nbelements].indicebleu,
thearray[-1+nbelements].indicevert,thearray[-1+nbelements].ReflechiEntrant,
thearray[-1+nbelements].ReflechiSortant);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdlec)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retailleplec(thearray,nbelements,nbelements-1);
dec(nbelements);

end;


procedure Supprime1Plmd(var thearray:plmd;
indice:longint; var nbelements:longint);
var i,j:integer;
label 123;
begin
 if indice>nbelements then exit;
if indice<=0 then exit;
123:
if nombregroupe>0 then
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=indice)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdlmd)) then begin
       application.messagebox(pchar(Format(rsLeGroupeNQui24, [inttostr(i)])),
         pchar(rsVotReAttenti),
       mb_ok);
       supprime1pgroupe(listegroupe,i,nombregroupe);
       goto 123;
       end;
thearray[-1+indice].create2(thearray[-1+nbelements].a1x,
thearray[-1+nbelements].a1y,
thearray[-1+nbelements].a2x,
thearray[-1+nbelements].a2y,
thearray[-1+nbelements].focale,
thearray[-1+nbelements].epaisseur,
thearray[-1+nbelements].couleur,
thearray[-1+nbelements].couleuraxe,
thearray[-1+nbelements].axefocal);
 for i:=1 to nombregroupe do
      for j:=1 to listegroupe[-1+i].nombreelements do
      if ((listegroupe[-1+i].listeelements[j].indiceelement=nbelements)
       and   (listegroupe[-1+i].listeelements[j].typeelementgroupe=mdlmd)) then
       listegroupe[-1+i].listeelements[j].indiceelement:=indice;
retailleplmd(thearray,nbelements,nbelements-1);
dec(nbelements);

end;


procedure CreePmscopa(var TheArray : Pmscopa;
  NumElements : longint);
 begin
  setlength(TheArray,  NumElements);
end;


 procedure FreePmscopa(var TheArray : Pmscopa;
  NumElements : longint);
begin
  finalize(TheArray);
end;


 procedure ReTaillePmscopa(var TheArray :Pmscopa;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

procedure CreePmscepa(var TheArray : Pmscepa;
  NumElements : longint);
 begin
 setlength(TheArray,  NumElements);
end;


 procedure FreePmscepa(var TheArray : Pmscepa;
  NumElements : longint);
begin
   finalize(TheArray);
end;


 procedure ReTaillePmscepa(var TheArray :Pmscepa;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

procedure CreePmscore(var TheArray : Pmscore;
  NumElements : longint);
 begin
 setlength(TheArray,  NumElements);
end;


 procedure FreePmscore(var TheArray : Pmscore;
  NumElements : longint);
begin
  finalize(TheArray);
end;


 procedure ReTaillePmscore(var TheArray :Pmscore;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

procedure CreePmscere(var TheArray : Pmscere;
  NumElements : longint);
 begin
  setlength(TheArray,  NumElements);
end;


 procedure FreePmscere(var TheArray : Pmscere;
  NumElements : longint);
begin
   finalize(TheArray);
end;


 procedure ReTaillePmscere(var TheArray :Pmscere;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;



procedure CreePlmc(var TheArray : Plmc;
  NumElements : longint);
 begin
 setlength(TheArray,  NumElements);
end;


 procedure FreePlmc(var TheArray : Plmc;
  NumElements : longint);
begin
  finalize(TheArray);
end;


 procedure ReTaillePlmc(var TheArray :Plmc;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;


procedure CreePlec(var TheArray : Plec;
  NumElements : longint);
 begin
 setlength(TheArray, NumElements);
end;


 procedure FreePlec(var TheArray : Plec;
  NumElements : longint);
begin
  finalize(TheArray);
end;


 procedure ReTaillePlec(var TheArray :Plec;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;

procedure CreePlmd(var TheArray : Plmd;
  NumElements : longint);
 begin
 setlength(TheArray,  NumElements);
end;


 procedure FreePlmd(var TheArray : Plmd;
  NumElements : longint);
begin
   finalize(TheArray);
end;


 procedure ReTaillePlmd(var TheArray :Plmd;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;




procedure CreePrayon(var TheArray : Prayon;
  NumElements : longint);
 begin
 setlength(TheArray,  NumElements);
end;


 procedure FreePrayon(var TheArray : Prayon;
  NumElements : longint);
begin
   finalize(TheArray);
end;


 procedure ReTaillePrayon(var TheArray :Prayon;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;


procedure CreePsourceponctuelle(var TheArray : Psourceponctuelle;
  NumElements : longint);
 begin
 setlength(TheArray,  NumElements);
end;


 procedure FreePsourceponctuelle(var TheArray : Psourceponctuelle;
  NumElements : longint);
begin
 finalize(TheArray);
end;


 procedure ReTaillePsourceponctuelle(var TheArray :Psourceponctuelle;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;



procedure CreePondeplane(var TheArray : Pondeplane;
  NumElements : longint);
 begin
  setlength(TheArray,  NumElements);
end;


 procedure FreePondeplane(var TheArray : Pondeplane;
  NumElements : longint);
begin
  finalize(TheArray);
end;


 procedure ReTaillePondeplane(var TheArray :Pondeplane;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;


procedure CreePmetre(var TheArray : Pmetre;
  NumElements : longint);
 begin
  setlength(TheArray,  NumElements);
end;


 procedure FreePmetre(var TheArray : Pmetre;
  NumElements : longint);
begin
 finalize(TheArray);
end;


 procedure ReTaillePmetre(var TheArray :Pmetre;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;


procedure CreePangle(var TheArray : Pangle;
  NumElements : longint);
 begin
 setlength(TheArray,  NumElements);
end;


 procedure FreePangle(var TheArray : Pangle;
  NumElements : longint);
begin
  finalize(TheArray);
end;


 procedure ReTaillePangle(var TheArray :Pangle;
  OldNumElements : longint;
  NewNumElements : longint);
begin
  setlength(thearray,NewNumElements);
end;



 function  polycercle.estou(x,y:extended):ttypeinterieur;
       var i:integer; A,B,C,delta:extended;
xi,xi1,xi2:extended;
nbe_interceptions:integer;
t,t1,t2:extended;
       label 147,890;
begin
nbe_interceptions:=0;

for i:=1 to nombresommet do begin

{cas rectiligne}
if rectiligne[i] then begin

if  (messommets[i].ay=messommets[i+1].ay) and (y=messommets[i].ay)
and  (x>=min(messommets[i].ax,messommets[i+1].ax)) and
  (x<=max(messommets[i].ax,messommets[i+1].ax)) then begin
  result:=ibord;
  exit;
  end;

 if  (messommets[i].ay=messommets[i+1].ay) and (y=messommets[i].ay)
and (x<min(messommets[i].ax,messommets[i+1].ax)) then
inc(nbe_interceptions,2)

else
 if  (messommets[i].ay=messommets[i+1].ay) and (y=messommets[i].ay)
and (x>max(messommets[i].ax,messommets[i+1].ax)) then
 inc(nbe_interceptions,0)
 else
if  ((y>=min(messommets[i].ay,messommets[i+1].ay)) and
    (y<=max(messommets[i].ay,messommets[i+1].ay))) then
begin
xi:=messommets[i].ax+(y-messommets[i].ay)*(messommets[i+1].ax-messommets[i].ax)/
(messommets[i+1].ay-messommets[i].ay);
 if x=xi then begin
   result:=ibord;
  exit;
 end;
if x<xi then  inc(nbe_interceptions,1);
 end;

end;
{fin cas rectiligne}

{cas circulaire}
if not(rectiligne[i]) then
begin
 A:=1;
 B:=-2*mescentres[i].ax;
 C:=sqr(mescentres[i].ax)+sqr(y-mescentres[i].ay)-sqr(rayon[i]);
 delta:=sqr(B)-4*A*C;
 if delta<0 then
 inc(nbe_interceptions,0)
 else
 if delta=0 then begin
 xi:=-B/2/A;
 t:=donneanglepolairedans02pi(xi-mescentres[i].ax,y-mescentres[i].ay);
 if ( (t>=theta1[i]) and (t<=theta2[i])) or
   ( (t-2*pi>=theta1[i]) and (t-2*pi<=theta2[i])) or
   ( (t+2*pi>=theta1[i]) and (t+2*pi<=theta2[i]))
   then
   if x=xi then
   begin
   result:=ibord;
   exit;
   end else
 if xi>x then inc(nbe_interceptions,2);
 end
 {du cas delta=0}

 else if (delta>0) then begin
 xi1:=(-B+sqrt(delta))/2/A;
 xi2:=(-B-sqrt(delta))/2/A;
 t1:=donneanglepolairedans02pi(xi1-mescentres[i].ax,y-mescentres[i].ay);
 t2:=donneanglepolairedans02pi(xi2-mescentres[i].ax,y-mescentres[i].ay);
 if ( (t1>=theta1[i]) and (t1<=theta2[i])) or
   ( (t1-2*pi>=theta1[i]) and (t1-2*pi<=theta2[i])) or
   ( (t1+2*pi>=theta1[i]) and (t1+2*pi<=theta2[i]))
   then
   if x=xi1 then
   begin
   result:=ibord;
   exit;
   end else
 if xi1>x then inc(nbe_interceptions,1);
  if ( (t2>=theta1[i]) and (t2<=theta2[i])) or
   ( (t2-2*pi>=theta1[i]) and (t2-2*pi<=theta2[i])) or
   ( (t2+2*pi>=theta1[i]) and (t2+2*pi<=theta2[i]))
   then
   if x=xi2 then
   begin
   result:=ibord;
   exit;
   end else
 if xi2>x then inc(nbe_interceptions,1);


 end; {du cas delta>0}


end;
{fin cas circulaire}


end;
{fin boucle sur les cotes}

if nbe_interceptions mod 2=0 then result:=iexterieur else result:=iinterieur;

       end;



 { function polycercle.create2(_nombresommet:integer;
 _MesSommets: TableauPointPolyhedre; _rayon:sommetsreels; _rectiligne,_rentrant,_aigu:tableaurectiligne;
 _indicerouge,_indicebleu,_indicevert:extended; _couleurbord,_couleurfond:tcolor;
 _ReflechiEntrant,_ReflechiSortant:TReflechiPolyhedre;_trigodirect:boolean):boolean;

  var i,j:integer;
 ix,iy,mu,lambda,ecart,totalangle,alpha,alpha1,alpha2,tt,AI,CI,agp,angleaucentre,para,para1,para2,para3,para4:extended;
   aire_signee:extended;
 toto:array[1..2*maxsommet] of pointpolyhedre;
   sens1,sens2,sens3,sens:integer;
   var tol:extended;
 begin
 tol:=1e-10;
 para1:=0; para2:=0;
 ReflechiEntrant:=_ReflechiEntrant;
 ReflechiSortant:=_ReflechiSortant;
  nombresommet:=_nombresommet;
   indicerouge:=_indicerouge;
   indicebleu:=_indicebleu;
    indicevert:=_indicevert;
       couleurbord:=_couleurbord;  couleurfond:=_couleurfond;
       trigodirect:=_trigodirect;
  if ((nombresommet<2) or (nombresommet>maxsommet)) then begin
    create2:=false;
  exit;
  end;

  if ((nombresommet=2) and (_rectiligne[1]) and (_rectiligne[2]))
   then begin
    create2:=false;
    application.MessageBox(pchar(rsCetteStructu),
    pchar(rsImpossible), mb_ok);
  exit;
  end;

  if ((nombresommet=2) and not(_rectiligne[1]) and not(_rectiligne[2]))
   then begin
    create2:=false;
    application.MessageBox(pchar(rsPourCrErUneL2),
    pchar(rsImpossible), mb_ok);
  exit;
  end;


  for i:=1 to nombresommet do begin
  if ((_messommets[i].ax>xxmax) or (_messommets[i].ax<xxmin) or
  (_messommets[i].ay>yymax) or (_messommets[i].ay<yymin)) then begin
  create2:=false;
  exit;
  end;
  MesSommets[i].ax:=_MesSommets[i].ax;
  MesSommets[i].ay:=_MesSommets[i].ay;
  toto[i].ax:=_messommets[i].ax;
  toto[i].ay:=_messommets[i].ay;
  toto[i+nombresommet].ax:=_messommets[i].ax;
  toto[i+nombresommet].ay:=_messommets[i].ay;
  rayon[i]:=abs(_rayon[i]);
  rentrant[i]:=_rentrant[i];
  rectiligne[i]:=_rectiligne[i];
  aigu[i]:=_aigu[i];
  end;
  MesSommets[nombresommet+1].ax:=MesSommets[1].ax;
  MesSommets[nombresommet+1].ay:=MesSommets[1].ay;




    {on verifie que les points ne sont pas trop proches}
    for i:=1 to nombresommet-1 do
    for j:=i+1 to nombresommet do
    if sqrt(sqr(messommets[i].ax-messommets[j].ax)+
    sqr(messommets[i].ay-messommets[j].ay))<form1.taillemini
     then
    begin
    create2:=false;
    exit;
    end;
       create2:=true;

   {on verifie qu'un point n'appartient pas à un autre segment que les 2 dont il est une extremité}


     if nombresommet>3 then
     for i:=1 to nombresommet do begin
     if i>2 then for j:=1 to i-3 do
     if Le_point_est_il_sur_une_droite(messommets[i].ax,messommets[i].ay,
     messommets[j].ax,messommets[j].ay,messommets[j+1].ax,messommets[j+1].ay,para,tol)
     and (para>=-tol) and (para<=1+tol) then begin
     create2:=false;
      exit;
      end;
      if i<nombresommet-1 then for j:=i+1 to nombresommet-1 do
     if Le_point_est_il_sur_une_droite(messommets[i].ax,messommets[i].ay,
     messommets[j].ax,messommets[j].ay,messommets[j+1].ax,messommets[j+1].ay,para,tol)
     and (para>=-tol) and (para<=1+tol) then begin
     create2:=false;
      exit;
      end;
     end;




     {on verifie que 2 segments ne se coupent pas}
    if nombresommet>3 then
    for i:=1  to nombresommet do
    for j:=i+2 to i+nombresommet-2 do
    if (rectiligne[i] and rectiligne[j]) then
        if Les_deux_segments_se_coupent_ils(toto[i].ax,toto[i].ay,toto[i+1].ax,toto[i+1].ay,
    toto[j].ax,toto[j].ay,toto[j+1].ax,toto[j+1].ay)
      then begin
      create2:=false;
      exit;
      end;
    //end;  end;






         {calcul des angles polaires des cotes}
    for i:=1 to nombresommet do
    anglepolaire[i]:=donneanglepolairedanspipi(messommets[i+1].ax-messommets[i].ax,messommets[i+1].ay-messommets[i].ay);


  for i:=1 to nombresommet do if not(rectiligne[i]) then begin
   ix:=(MesSommets[i].ax+MesSommets[i+1].ax)/2;
    iy:=(MesSommets[i].ay+MesSommets[i+1].ay)/2;
    AI:=sqrt(sqr(MesSommets[i].ax-ix)+sqr(MesSommets[i].ay-iy));
    if AI>=rayon[i] then begin
    create2:=false;
    exit;
    end;
    CI:=sqrt(sqr(rayon[i])-sqr(AI));

    {if (   ((trigodirect) and not(rentrant[i])) or
   (not(trigodirect) and (rentrant[i]))
   ) then begin}
   if trigodirect then sens1:=1 else sens1:=-1;
   if aigu[i] then sens2:=1 else sens2:=-1;
   if not(rentrant[i]) then sens3:=1 else sens3:=-1;
   sens:=sens1*sens2*sens3;
   if sens=1 then begin
   mescentres[i].ax:=ix-CI/2/AI*(messommets[i+1].ay-messommets[i].ay);
    mescentres[i].ay:=iy+CI/2/AI*(messommets[i+1].ax-messommets[i].ax);
     end else begin
    mescentres[i].ax:=ix+CI/2/AI*(messommets[i+1].ay-messommets[i].ay);
    mescentres[i].ay:=iy-CI/2/AI*(messommets[i+1].ax-messommets[i].ax);
     end;

     agp:=donneanglepolairedans02pi(ix-mescentres[i].ax,iy-mescentres[i].ay);

     if aigu[i] then begin
  mess[i].ax:=mescentres[i].ax+cos(agp)*rayon[i];
   mess[i].ay:=mescentres[i].ay+sin(agp)*rayon[i];
   end else
   begin
   mess[i].ax:=mescentres[i].ax-cos(agp)*rayon[i];
   mess[i].ay:=mescentres[i].ay-sin(agp)*rayon[i];
   end;



   angleaucentre:=arccos(((MesSommets[i].ax-MesCentres[i].ax)*(MesS[i].ax-MesCentres[i].ax)+
   (MesSommets[i].ay-MesCentres[i].ay)*(MesS[i].ay-MesCentres[i].ay))/sqr(rayon[i]));
  theta1[i]:=donneanglepolairedans02pi(MesS[i].ax-MesCentres[i].ax,
  MesS[i].ay-MesCentres[i].ay)-angleaucentre;
  theta2[i]:=donneanglepolairedans02pi(MesS[i].ax-MesCentres[i].ax,
  MesS[i].ay-MesCentres[i].ay)+angleaucentre;




  thetavrai1[i]:=theta1[i];
  thetavrai2[i]:=theta2[i];





  end else
  rectiligne[i]:=true;





   {normales aux cotes rectilignes}
   for i:=1 to nombresommet do begin
    if trigodirect then nx[i]:=cos(anglepolaire[i]-Pi/2) else
    nx[i]:=cos(anglepolaire[i]+Pi/2);
    if trigodirect then ny[i]:=sin(anglepolaire[i]-Pi/2) else
    ny[i]:=sin(anglepolaire[i]+Pi/2);
    // if rectiligne[i] then  application.MessageBox(pchar(floattostr(nx[i])+'  '+floattostr(ny[i])),'',mb_ok);
    end;





   for i:=1 to nombresommet do
   if rectiligne[i] then begin
   mescentres[i].ax:=0;
   mescentres[i].ay:=0;
   mess[i].ax:=(messommets[i].ax+messommets[i+1].ax)/2;
    mess[i].ay:=(messommets[i].ay+messommets[i+1].ay)/2;
    theta1[i]:=0; theta2[i]:=0;

    end;



 {test d'inter entre cote rectiligne et cote circulaire}
for i:=1  to nombresommet do if rectiligne[i] then begin

if i<nombresommet then    for j:=i+1 to nombresommet do
     if not(rectiligne[j]) then  begin

    if (
        (Le_segment_et_le_cercle_se_coupent_ils(messommets[i].ax,messommets[i].ay,messommets[i+1].ax,messommets[i+1].ay,
    mescentres[j].ax,mescentres[j].ay,rayon[j],theta1[j],theta2[j],para1,para2,para3,para4,tol)=1)
     and
   not(
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   ))

     then begin
     // application.MessageBox(pchar('seg cer create2'+inttostr(i)),pchar(inttostr(j)),mb_ok);
      create2:=false;
      exit;
      end;


    if
    (
    (Le_segment_et_le_cercle_se_coupent_ils(messommets[i].ax,messommets[i].ay,messommets[i+1].ax,messommets[i+1].ay,
    mescentres[j].ax,mescentres[j].ay,rayon[j],theta1[j],theta2[j],para1,para2,para3,para4,tol)=2)
    and
   not
   (
   (
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   )
   and
   (
   ((abs(para3)<tol) or (abs(para3-1)<tol))
   and
   ((abs(para4)<tol) or (abs(para4-1)<tol))
   )
   )
   )
      then begin
    // application.MessageBox(pchar('seg cer  create2'+inttostr(i)),pchar(inttostr(j)),mb_ok);
      create2:=false;
      exit;
      end;
     end; {de j non rectiligne}

if i>1 then for j:=1 to i-1 do
  if  not(rectiligne[j]) then  begin

  if     (
    (Le_segment_et_le_cercle_se_coupent_ils(messommets[i].ax,messommets[i].ay,messommets[i+1].ax,messommets[i+1].ay,
    mescentres[j].ax,mescentres[j].ay,rayon[j],theta1[j],theta2[j],para1,para2,para3,para4,tol)=1)
     and
   not(
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   ))
   then begin
      //application.MessageBox(pchar('seg cer create2 '+inttostr(i)),pchar(inttostr(j)),mb_ok);
      create2:=false;
      exit;
      end;



     if
    (
    (Le_segment_et_le_cercle_se_coupent_ils(messommets[i].ax,messommets[i].ay,messommets[i+1].ax,messommets[i+1].ay,
    mescentres[j].ax,mescentres[j].ay,rayon[j],theta1[j],theta2[j],para1,para2,para3,para4,tol)=2)
    and
   not
   (
   (
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   )
   and
   (
   ((abs(para3)<tol) or (abs(para3-1)<tol))
   and
   ((abs(para4)<tol) or (abs(para4-1)<tol))
   )
   )
   )
      then begin
    //  application.MessageBox(pchar('seg cer create2  '+inttostr(i)),pchar(inttostr(j)),mb_ok);
      create2:=false;
      exit;
      end;
end; {de j non rectiligne}
  end; {de rect circ}


 {test d'inter entre cote circulaire et cote circulaire}
for i:=1  to nombresommet do if not(rectiligne[i]) then begin

if i<nombresommet then    for j:=i+1 to nombresommet do
   if not(rectiligne[j]) then  begin

   if  (
   (Les_deux_cercles_se_coupent_ils(mescentres[i].ax,mescentres[i].ay,mescentres[j].ax,mescentres[j].ay,
   rayon[i],rayon[j],theta1[i],theta2[i],theta1[j],theta2[j],para1,para2,para3,para4)=1)
   and
   not(
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   ))
   then begin
    //  application.MessageBox(pchar('cer cer '+inttostr(i)),pchar(inttostr(j)),mb_ok);
     create2:=false;
     exit;
     end;



   if (
   (Les_deux_cercles_se_coupent_ils(mescentres[i].ax,mescentres[i].ay,mescentres[j].ax,mescentres[j].ay,
   rayon[i],rayon[j],theta1[i],theta2[i],theta1[j],theta2[j],para1,para2,para3,para4)=2)
   and
   not
   (
   (
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   )
   and
   (
   ((abs(para3)<tol) or (abs(para3-1)<tol))
   and
   ((abs(para4)<tol) or (abs(para4-1)<tol))
   )
   )
   )


     then begin
     // application.MessageBox(pchar('cer cer '+inttostr(i)),pchar(inttostr(j)),mb_ok);
     create2:=false;
     exit;
     end;
   end;{de j non rect}

if i>1 then for j:=1 to i-1 do
 if not(rectiligne[j]) then    begin

  if  (
   (Les_deux_cercles_se_coupent_ils(mescentres[i].ax,mescentres[i].ay,mescentres[j].ax,mescentres[j].ay,
   rayon[i],rayon[j],theta1[i],theta2[i],theta1[j],theta2[j],para1,para2,para3,para4)=1)
   and
   not(
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   ))
   then begin
    //  application.MessageBox(pchar('cer cer '+inttostr(i)),pchar(inttostr(j)),mb_ok);
     create2:=false;
     exit;
     end;



   if (
   (Les_deux_cercles_se_coupent_ils(mescentres[i].ax,mescentres[i].ay,mescentres[j].ax,mescentres[j].ay,
   rayon[i],rayon[j],theta1[i],theta2[i],theta1[j],theta2[j],para1,para2,para3,para4)=2)
   and
   not
   (
   (
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   )
   and
   (
   ((abs(para3)<tol) or (abs(para3-1)<tol))
   and
   ((abs(para4)<tol) or (abs(para4-1)<tol))
   )
   )
   )


     then begin
    //  application.MessageBox(pchar('cer cer '+inttostr(i)),pchar(inttostr(j)),mb_ok);
     create2:=false;
     exit;
     end;
 end; {de j non rect}
 end;  {de cerc cerc}





     xiso:=0; yiso:=0;
    for i:=1 to nombresommet do begin
    xiso:=xiso+MesSommets[i].ax;
    yiso:=yiso+MesSommets[i].ay;
    end;
    xiso:=xiso/nombresommet; yiso:=yiso/nombresommet;
     modifie:=true;
        end;
  }




 function polycercle.create(_nombresommet:integer;
 _MesSommets,_MesS: TableauPointPolyhedre; _rectiligne:tableaurectiligne;
 _indicerouge,_indicebleu,_indicevert:extended; _couleurbord,_couleurfond:tcolor;
 _ReflechiEntrant,_ReflechiSortant:TReflechiPolyhedre):boolean;
   var i,j:integer; para,para1,para2,para3,para4:extended;
 ix,iy,mu,lambda,ecart,totalangle,alpha,alpha1,alpha2,tt,angleaucentre,airecalotte:extended;
 ff:textfile;
 toto:array[1..2*maxsommet] of pointpolyhedre;
 aire_signee:extended;
   tol:extended;
   begin
 tol:=1e-10;
 para1:=0; para2:=0;
 ReflechiEntrant:=_ReflechiEntrant;
 ReflechiSortant:=_ReflechiSortant;
  nombresommet:=_nombresommet;
   indicerouge:=_indicerouge;
   indicebleu:=_indicebleu;
    indicevert:=_indicevert;
       couleurbord:=_couleurbord;  couleurfond:=_couleurfond;

  if ((nombresommet<2) or (nombresommet>maxsommet)) then begin
    create:=false;
  exit;
  end;


  if ((nombresommet=2) and (_rectiligne[1]) and (_rectiligne[2]))
   then begin
    create:=false;
    application.MessageBox(pchar(rsCetteStructu),
    pchar(rsImpossible), mb_ok);
  exit;
  end;

  if ((nombresommet=2) and not(_rectiligne[1]) and not(_rectiligne[2]))
   then begin
    create:=false;
    application.MessageBox(pchar(rsPourCrErUneL),
    pchar(rsImpossible), mb_ok);
  exit;
  end;


  for i:=1 to nombresommet do begin
  if ((_messommets[i].ax>xxmax) or (_messommets[i].ax<xxmin) or
  (_messommets[i].ay>yymax) or (_messommets[i].ay<yymin)) then begin
  create:=false;
  exit;
  end;
  MesSommets[i].ax:=_MesSommets[i].ax;
  MesSommets[i].ay:=_MesSommets[i].ay;
  toto[i].ax:=_messommets[i].ax;
  toto[i].ay:=_messommets[i].ay;
  toto[i+nombresommet].ax:=_messommets[i].ax;
  toto[i+nombresommet].ay:=_messommets[i].ay;
  MesS[i].ax:=_MesS[i].ax;
  MesS[i].ay:=_MesS[i].ay;
  rectiligne[i]:=_rectiligne[i];
  end;
  MesSommets[nombresommet+1].ax:=MesSommets[1].ax;
  MesSommets[nombresommet+1].ay:=MesSommets[1].ay;



   for i:=1 to nombresommet do if not(rectiligne[i]) then begin
   ix:=(MesSommets[i].ax+MesSommets[i+1].ax)/2;
    iy:=(MesSommets[i].ay+MesSommets[i+1].ay)/2;
    if   (MesS[i].ax <> ix) or (MesS[i].ay<>iy) then begin

    rayon[i]:=(sqr(MesS[i].ax-ix)+sqr(MesS[i].ay-iy)+sqr(MesSommets[i].ax-ix)+
    sqr(MesSommets[i].ay-iy))/2/sqrt(sqr(MesS[i].ax-ix)+
    sqr(MesS[i].ay-iy));


     lambda:=rayon[i]/sqrt(sqr(MesS[i].ax-ix)+sqr(MesS[i].ay-iy));
  MesCentres[i].ax:=MesS[i].ax-lambda*(MesS[i].ax-ix);
  MesCentres[i].ay:=MesS[i].ay-lambda*(MesS[i].ay-iy);



  aigu[i]:=(
   (  (MesSommets[i].ax-MesCentres[i].ax)*(MesS[i].ax-MesCentres[i].ax)
     +
      (MesSommets[i].ay-MesCentres[i].ay)*(MesS[i].ay-MesCentres[i].ay)  )
      >=0);

  angleaucentre:=arccos(((MesSommets[i].ax-MesCentres[i].ax)*(MesS[i].ax-MesCentres[i].ax)+
   (MesSommets[i].ay-MesCentres[i].ay)*(MesS[i].ay-MesCentres[i].ay))/sqr(rayon[i]));
  theta1[i]:=donneanglepolairedans02pi(MesS[i].ax-MesCentres[i].ax,
  MesS[i].ay-MesCentres[i].ay)-angleaucentre;
  theta2[i]:=donneanglepolairedans02pi(MesS[i].ax-MesCentres[i].ax,
  MesS[i].ay-MesCentres[i].ay)+angleaucentre;



   listetrigodirect[i]:=(MesS[i].ax-MesCentres[i].ax)*(MesSommets[i+1].ay-MesSommets[i].ay)-
  (MesS[i].ay-MesCentres[i].ay)*(MesSommets[i+1].ax-MesSommets[i].ax)>0;
  {faux, ca depend aussi de caractere aigu-obtu}



  end else
  rectiligne[i]:=true;
   end;

   for i:=1 to nombresommet do
   if rectiligne[i] then begin
   mescentres[i].ax:=0;
   mescentres[i].ay:=0;
   mess[i].ax:=(messommets[i].ax+messommets[i+1].ax)/2;
    mess[i].ay:=(messommets[i].ay+messommets[i+1].ay)/2;
    theta1[i]:=0; theta2[i]:=0;

    end;

    {on verifie que les points ne sont pas trop proches}
    for i:=1 to nombresommet-1 do
    for j:=i+1 to nombresommet do
    if sqrt(sqr(messommets[i].ax-messommets[j].ax)+
    sqr(messommets[i].ay-messommets[j].ay))<form1.taillemini
     then
    begin
    create:=false;
    exit;
    end;
       create:=true;

  {on verifie qu'un point n'appartient pas à un autre segment que les 2 dont il est une extremité}


     if nombresommet>3 then
     for i:=1 to nombresommet do begin
     if i>2 then for j:=1 to i-3 do
     if Le_point_est_il_sur_une_droite(messommets[i].ax,messommets[i].ay,
     messommets[j].ax,messommets[j].ay,messommets[j+1].ax,messommets[j+1].ay,para,tol)
     and (para>=-tol) and (para<=1+tol) then begin
     create:=false;
      exit;
      end;
      if i<nombresommet-1 then for j:=i+1 to nombresommet-1 do
     if Le_point_est_il_sur_une_droite(messommets[i].ax,messommets[i].ay,
     messommets[j].ax,messommets[j].ay,messommets[j+1].ax,messommets[j+1].ay,para,tol)
     and (para>=-tol) and (para<=1+tol) then begin
     create:=false;
      exit;
      end;
     end;


     {test intersection cotes rectilignes}
    if nombresommet>3 then
    for i:=1  to nombresommet do
    for j:=i+2 to i+nombresommet-2 do
    if (rectiligne[i] and rectiligne[j]) then

    if Les_deux_segments_se_coupent_ils(toto[i].ax,toto[i].ay,toto[i+1].ax,toto[i+1].ay,
    toto[j].ax,toto[j].ay,toto[j+1].ax,toto[j+1].ay)
      then begin
      create:=false;
      exit;
      end;







         {calcul des angles polaires des cotes}
    for i:=1 to nombresommet do

    anglepolaire[i]:=donneanglepolairedanspipi(messommets[i+1].ax-messommets[i].ax,messommets[i+1].ay-messommets[i].ay);




  {sens trigo direct ?}

  //if nombresommet>2 then begin
  aire_signee:=0;
   for i:=1 to nombresommet do  begin
   aire_signee:=aire_signee+0.5*(messommets[i+1].ax-messommets[i].ax)*(messommets[i+1].ay+
   messommets[i].ay);
   if not(rectiligne[i]) then begin
   angleaucentre:=abs(theta2[i]-theta1[i]);
   airecalotte:=sqr(rayon[i])*(angleaucentre/2-sin(angleaucentre)/2);
   ix:=(MesSommets[i].ax+MesSommets[i+1].ax)/2;
    iy:=(MesSommets[i].ay+MesSommets[i+1].ay)/2;
   if  (messommets[i+1].ax-messommets[i].ax)*(mess[i].ay-iy)-
   (messommets[i+1].ay-messommets[i].ay)*(mess[i].ax-ix)>0 then
    aire_signee:=aire_signee+airecalotte else
    aire_signee:=aire_signee-airecalotte
   end;

   end;
                              trigodirect:=(aire_signee<0);



     {determination du caractere entrant ou sortant des secteurs}
     for i:=1 to nombresommet do
     if not(rectiligne[i]) then begin
     rentrant[i]:=not(
     (trigodirect and ((MesS[i].ax-MesCentres[i].ax)*(MesSommets[i+1].ay-MesSommets[i].ay)-
  (MesS[i].ay-MesCentres[i].ay)*(MesSommets[i+1].ax-MesSommets[i].ax)>0))
  or
  (not(trigodirect) and ((MesS[i].ax-MesCentres[i].ax)*(MesSommets[i+1].ay-MesSommets[i].ay)-
  (MesS[i].ay-MesCentres[i].ay)*(MesSommets[i+1].ax-MesSommets[i].ax)<0))
  );
  agauche[i]:=(  (MesSommets[i+1].ax-MesSommets[i].ax)*(MesS[i].ay-0.5*(MesSommets[i+1].ay+MesSommets[i].ay))
  -(MesSommets[i+1].ay-MesSommets[i].ay)*(MesS[i].ax-0.5*(MesSommets[i+1].ax+MesSommets[i].ax))>0)
  ;
  end;


    {normales aux cotes rectilignes}
   for i:=1 to nombresommet do begin
    if trigodirect then nx[i]:=cos(anglepolaire[i]-Pi/2) else
    nx[i]:=cos(anglepolaire[i]+Pi/2);
    if trigodirect then ny[i]:=sin(anglepolaire[i]-Pi/2) else
    ny[i]:=sin(anglepolaire[i]+Pi/2);
  //if rectiligne[i] then  application.MessageBox(pchar(floattostr(nx[i])+'  '+floattostr(ny[i])),'',mb_ok);
    end;

 {test d'inter entre cote rectiligne et cote circulaire}
for i:=1  to nombresommet do if rectiligne[i] then begin

if i<nombresommet then    for j:=i+1 to nombresommet do
     if not(rectiligne[j]) then   begin

    if (
        (Le_segment_et_le_cercle_se_coupent_ils(messommets[i].ax,messommets[i].ay,messommets[i+1].ax,messommets[i+1].ay,
    mescentres[j].ax,mescentres[j].ay,rayon[j],theta1[j],theta2[j],para1,para2,para3,para4,tol)=1)
     and
   not(
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   ))

     then begin
     //application.MessageBox(pchar('seg cer '+inttostr(i)),pchar(inttostr(j)),mb_ok);
      create:=false;
      exit;
      end;


    if
    (
    (Le_segment_et_le_cercle_se_coupent_ils(messommets[i].ax,messommets[i].ay,messommets[i+1].ax,messommets[i+1].ay,
    mescentres[j].ax,mescentres[j].ay,rayon[j],theta1[j],theta2[j],para1,para2,para3,para4,tol)=2)
    and
   not
   (
   (
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   )
   and
   (
   ((abs(para3)<tol) or (abs(para3-1)<tol))
   and
   ((abs(para4)<tol) or (abs(para4-1)<tol))
   )
   )
   )
      then begin
    //  application.MessageBox(pchar('seg cer '+inttostr(i)),pchar(inttostr(j)),mb_ok);
      create:=false;
      exit;
      end;  end;

if i>1 then for j:=1 to i-1 do
  if  not(rectiligne[j]) then  begin

  if     (
    (Le_segment_et_le_cercle_se_coupent_ils(messommets[i].ax,messommets[i].ay,messommets[i+1].ax,messommets[i+1].ay,
    mescentres[j].ax,mescentres[j].ay,rayon[j],theta1[j],theta2[j],para1,para2,para3,para4,tol)=1)
     and
   not(
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   ))
   then begin
     // application.MessageBox(pchar('seg cer '+inttostr(i)),pchar(inttostr(j)),mb_ok);
      create:=false;
      exit;
      end;



     if
    (
    (Le_segment_et_le_cercle_se_coupent_ils(messommets[i].ax,messommets[i].ay,messommets[i+1].ax,messommets[i+1].ay,
    mescentres[j].ax,mescentres[j].ay,rayon[j],theta1[j],theta2[j],para1,para2,para3,para4,tol)=2)
    and
   not
   (
   (
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   )
   and
   (
   ((abs(para3)<tol) or (abs(para3-1)<tol))
   and
   ((abs(para4)<tol) or (abs(para4-1)<tol))
   )
   )
   )
      then begin
      //application.MessageBox(pchar('seg cer '+inttostr(i)),pchar(inttostr(j)),mb_ok);
      create:=false;
      exit;
      end;
end;        end;



 {test d'inter entre cote circulaire et cote circulaire}
for i:=1  to nombresommet do if not(rectiligne[i]) then begin

if i<nombresommet then    for j:=i+1 to nombresommet do
   if not(rectiligne[j]) then begin

   if  (
   (Les_deux_cercles_se_coupent_ils(mescentres[i].ax,mescentres[i].ay,mescentres[j].ax,mescentres[j].ay,
   rayon[i],rayon[j],theta1[i],theta2[i],theta1[j],theta2[j],para1,para2,para3,para4)=1)
   and
   not(
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   ))
   then begin
    // application.MessageBox(pchar('cer cer '+inttostr(i)),pchar(inttostr(j)),mb_ok);
     create:=false;
     exit;
     end;



   if (
   (Les_deux_cercles_se_coupent_ils(mescentres[i].ax,mescentres[i].ay,mescentres[j].ax,mescentres[j].ay,
   rayon[i],rayon[j],theta1[i],theta2[i],theta1[j],theta2[j],para1,para2,para3,para4)=2)
   and
   not
   (
   (
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   )
   and
   (
   ((abs(para3)<tol) or (abs(para3-1)<tol))
   and
   ((abs(para4)<tol) or (abs(para4-1)<tol))
   )
   )
   )


     then begin
     // application.MessageBox(pchar('cer cer '+inttostr(i)),pchar(inttostr(j)),mb_ok);
     create:=false;
     exit;
     end;         end;

if i>1 then for j:=1 to i-1 do
 if not(rectiligne[j]) then begin

  if  (
   (Les_deux_cercles_se_coupent_ils(mescentres[i].ax,mescentres[i].ay,mescentres[j].ax,mescentres[j].ay,
   rayon[i],rayon[j],theta1[i],theta2[i],theta1[j],theta2[j],para1,para2,para3,para4)=1)
   and
   not(
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   ))
   then begin
    //  application.MessageBox(pchar('cer cer '+inttostr(i)),pchar(inttostr(j)),mb_ok);
     create:=false;
     exit;
     end;



   if (
   (Les_deux_cercles_se_coupent_ils(mescentres[i].ax,mescentres[i].ay,mescentres[j].ax,mescentres[j].ay,
   rayon[i],rayon[j],theta1[i],theta2[i],theta1[j],theta2[j],para1,para2,para3,para4)=2)
   and
   not
   (
   (
   ((abs(para1)<tol) or (abs(para1-1)<tol))
   and
   ((abs(para2)<tol) or (abs(para2-1)<tol))
   )
   and
   (
   ((abs(para3)<tol) or (abs(para3-1)<tol))
   and
   ((abs(para4)<tol) or (abs(para4-1)<tol))
   )
   )
   )


     then begin
    //  application.MessageBox(pchar('cer cer '+inttostr(i)),pchar(inttostr(j)),mb_ok);
     create:=false;
     exit;
     end;
end;     end;

  xiso:=0; yiso:=0;
    for i:=1 to nombresommet do begin
    xiso:=xiso+MesSommets[i].ax;
    yiso:=yiso+MesSommets[i].ay;
    end;
    xiso:=xiso/nombresommet; yiso:=yiso/nombresommet;
     modifie:=true;
        end;

        procedure polycercle.dessine(mc:tmonbitmap);
        var i,j:integer;
        agp,dIS,ix,iy:extended;
        fx1,fx2,fy1,fy2:integer;
        rgn,rgn1,rgn2:hrgn;
        titi:array[1..maxsommet+1] of tpoint;
         sx1,sx2,sy1,sy2,r:extended;
  irx1,irx2,iry1,iry2,isx1,isx2,isy1,isy2,ir:integer;
   tous_rectiligne_ou_sortant:boolean;
    old_pencolor:tcolor;
old_penmode:tpenmode;
 old_penstyle:tpenstyle;
 old_penwidth:integer;
 old_brushcolor:tcolor;
 old_brushstyle:tbrushstyle;
        begin

   old_pencolor:=form1.image1.Picture.Bitmap.Canvas.Pen.Color;
old_penmode:=form1.image1.Picture.Bitmap.Canvas.Pen.Mode;
 old_penstyle:=form1.image1.Picture.Bitmap.Canvas.Pen.Style;
 old_penwidth:=form1.image1.Picture.Bitmap.Canvas.Pen.Width;
 old_brushcolor:=form1.image1.Picture.Bitmap.Canvas.Brush.Color;
 old_brushstyle:=form1.image1.Picture.Bitmap.Canvas.Brush.Style;



 tous_rectiligne_ou_sortant:=true;
 for i:=1 to nombresommet do
 tous_rectiligne_ou_sortant:=
 tous_rectiligne_ou_sortant and (rectiligne[i] or not(rentrant[i]));
  for i:=1 to nombresommet do  begin
  mc.invconvert(titi[i].x,titi[i].y,messommets[i].ax,messommets[i].ay,true);
  end;


    if tous_rectiligne_ou_sortant then begin
  form1.image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond;
  form1.image1.Picture.Bitmap.Canvas.Pen.Color:=couleurfond;
   form1.image1.Picture.Bitmap.Canvas.brush.style:=bsSolid;
  form1.image1.Picture.Bitmap.Canvas.Pen.Mode:=pmcopy;
  form1.image1.Picture.Bitmap.Canvas.Polygon(@titi,nombresommet);
    end else begin
    form1.image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond xor couleurfondsimulation;
  form1.image1.Picture.Bitmap.Canvas.Pen.Color:=couleurfond xor couleurfondsimulation;
   form1.image1.Picture.Bitmap.Canvas.brush.style:=bsSolid;
  form1.image1.Picture.Bitmap.Canvas.Pen.Mode:=pmxor;
  form1.image1.Picture.Bitmap.Canvas.Polygon(@titi,nombresommet);


    end;


        for i:=1 to nombresommet do
   if not(rectiligne[i]) then
   if not(rentrant[i]) then begin
   sx1:=messommets[i].ax;
   sx2:=messommets[i+1].ax;
   sy1:=messommets[i].ay;
   sy2:=messommets[i+1].ay;
   r:=sqrt(sqr(sx1-mescentres[i].ax)+sqr(sy1-mescentres[i].ay));
   mc.invconvert(irx1,iry1,mescentres[i].ax-r,mescentres[i].ay+r,true);
   mc.invconvert(irx2,iry2,mescentres[i].ax+r,mescentres[i].ay-r,true);
   mc.invconvert(isx1,isy1,sx1,sy1,true);
    mc.invconvert(isx2,isy2,sx2,sy2,true);

     form1.image1.Picture.Bitmap.Canvas.brush.style:=bsSolid;
 form1.image1.Picture.Bitmap.Canvas.brush.Color:=couleurfond;
 form1.image1.Picture.Bitmap.Canvas.Pen.Mode:=pmcopy;
  form1.image1.Picture.Bitmap.Canvas.Pen.Color:=couleurfond;
if (trigodirect) then  form1.image1.Picture.Bitmap.Canvas.Chord(irx1,iry1,irx2,iry2,isx1,isy1,isx2,isy2) else
form1.image1.Picture.Bitmap.Canvas.Chord(irx1,iry1,irx2,iry2,isx2,isy2,isx1,isy1);
  end;



         for i:=1 to nombresommet do
   if not(rectiligne[i]) then
   if (rentrant[i]) then begin
   sx1:=messommets[i].ax;
   sx2:=messommets[i+1].ax;
   sy1:=messommets[i].ay;
   sy2:=messommets[i+1].ay;
   r:=sqrt(sqr(sx1-mescentres[i].ax)+sqr(sy1-mescentres[i].ay));
   mc.invconvert(irx1,iry1,mescentres[i].ax-r,mescentres[i].ay+r,true);
   mc.invconvert(irx2,iry2,mescentres[i].ax+r,mescentres[i].ay-r,true);
   mc.invconvert(isx1,isy1,sx1,sy1,true);
    mc.invconvert(isx2,isy2,sx2,sy2,true);
     form1.image1.Picture.Bitmap.Canvas.Brush.Color:=couleurfond xor couleurfondsimulation;
  form1.image1.Picture.Bitmap.Canvas.Pen.Color:=couleurfond xor couleurfondsimulation;
   form1.image1.Picture.Bitmap.Canvas.brush.style:=bsSolid;
  form1.image1.Picture.Bitmap.Canvas.Pen.Mode:=pmxor;
if not(trigodirect) then  form1.image1.Picture.Bitmap.Canvas.Chord(irx1,iry1,irx2,iry2,isx1,isy1,isx2,isy2) else
form1.image1.Picture.Bitmap.Canvas.Chord(irx1,iry1,irx2,iry2,isx2,isy2,isx1,isy1);
  end;


    form1.image1.Picture.Bitmap.Canvas.Pen.Color:=old_pencolor;
form1.image1.Picture.Bitmap.Canvas.Pen.Mode:=old_penmode;
 form1.image1.Picture.Bitmap.Canvas.Pen.Style:=old_penstyle;
 form1.image1.Picture.Bitmap.Canvas.Pen.Width:=old_penwidth;
 form1.image1.Picture.Bitmap.Canvas.Brush.Color:=old_brushcolor;
 form1.image1.Picture.Bitmap.Canvas.Brush.Style:=old_brushstyle;

         form1.image1.Picture.Bitmap.Canvas.brush.style:=bsSolid;
 form1.image1.Picture.Bitmap.Canvas.brush.Color:=couleurfond;

  form1.image1.Picture.Bitmap.Canvas.Pen.Mode:=pmcopy;
  form1.image1.Picture.Bitmap.Canvas.Pen.Color:=couleurbord;


for i:=1 to nombresommet do
         if rectiligne[i] then
         mc.trait(messommets[i].ax,messommets[i].ay,messommets[i+1].ax,
         messommets[i+1].ay,1,couleurbord,pssolid,pmcopy,true) else
         mc.arcdecercle(mescentres[i].ax,mescentres[i].ay,rayon[i],1,theta1[i],theta2[i],
         couleurbord,pmcopy,pssolid,true);


if ((modeinfo or modemodif) and not(modeduplication)) then
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleurpoignees,pmcopy,true);
 if (modemodif or modeduplication) then
  for i:=1 to nombresommet do
  if modemodif then
mc.croixx((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
2,couleurtrans,pmcopy,true) else
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleurpoignees,pmcopy,true);
 if (modemodif and not(modeduplication)) then
 for i:=1 to nombresommet do
 if not(rectiligne[i]) then
 mc.croixx(mess[i].ax,mess[i].ay,3,
2,clyellow,pmcopy,true);

if (modesuppression) then
  for i:=1 to nombresommet do  begin
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleursuppression,pmcopy,true);
 mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleursuppression,pmcopy,true);
if not(rectiligne[i]) then
 mc.cercle(mess[i].ax,mess[i].ay,3,
1,couleursuppression,pmcopy,true);
       end;

   if modegroupement then
mc.croixx(xiso,yiso,3,
2,clpurple,pmcopy,true);
        end;


   procedure polycercle.dessinePS(mc:tmonpostscript);
        var i,j:integer;
        agp,dIS,ix,iy:extended;
        fx1,fx2,fy1,fy2:integer;
        rgn,rgn1,rgn2:hrgn;
        titi:arraypoints;
         sx1,sx2,sy1,sy2,r:extended;
  irx1,irx2,iry1,iry2,isx1,isx2,isy1,isy2,ir:integer;
   tous_rectiligne_ou_sortant:boolean;
    old_pencolor:tcolor;
old_penmode:tpenmode;
 old_penstyle:tpenstyle;
 old_penwidth:integer;
 old_brushcolor:tcolor;
 old_brushstyle:tbrushstyle;
        begin


  mc.tracepolycercle(MesSommets,nombresommet,
 MesCentres,
 rectiligne,rentrant,thetavrai1,thetavrai2,couleurfond,couleurbord,listetrigodirect);
    ps.Pen.Color:=old_pencolor;
ps.Pen.Mode:=old_penmode;
 ps.Pen.Style:=old_penstyle;
 ps.Pen.Width:=old_penwidth;
 ps.Brush.Color:=old_brushcolor;
 ps.Brush.Style:=old_brushstyle;

        ps.brush.style:=bsSolid;
 ps.brush.Color:=couleurfond;

 ps.Pen.Mode:=pmcopy;
  ps.Pen.Color:=couleurbord;


for i:=1 to nombresommet do
         if rectiligne[i] then
         mc.trait(messommets[i].ax,messommets[i].ay,messommets[i+1].ax,
         messommets[i+1].ay,1,couleurbord,pssolid,pmcopy,true) else
         mc.arcdecercleoriente(mescentres[i].ax,mescentres[i].ay,rayon[i],1,thetavrai1[i],thetavrai2[i],
         couleurbord,pmcopy,pssolid,true,listetrigodirect[i]);



if ((modeinfo or modemodif) and not(modeduplication)) then
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleurpoignees,pmcopy,true);
 if (modemodif or modeduplication) then
  for i:=1 to nombresommet do
  if modemodif then
mc.croixx((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
2,couleurtrans,pmcopy,true) else
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleurpoignees,pmcopy,true);
 if (modemodif and not(modeduplication)) then
 for i:=1 to nombresommet do
 if not(rectiligne[i]) then
 mc.croixx(mess[i].ax,mess[i].ay,3,
2,clyellow,pmcopy,true);

if (modesuppression) then
  for i:=1 to nombresommet do  begin
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleursuppression,pmcopy,true);
 mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleursuppression,pmcopy,true);
if not(rectiligne[i]) then
 mc.cercle(mess[i].ax,mess[i].ay,3,
1,couleursuppression,pmcopy,true);
       end;

   if modegroupement then
mc.croixx(xiso,yiso,3,
2,clpurple,pmcopy,true);
        end;







          procedure polycercle.imprime(mc:tmyimprimante);
         var i,j:integer;
        agp,dIS,ix,iy:extended;
        fx1,fx2,fy1,fy2:integer;
        rgn,rgn1,rgn2:hrgn;
        titi:array[1..maxsommet+1] of tpoint;
         sx1,sx2,sy1,sy2,r:extended;
  irx1,irx2,iry1,iry2,isx1,isx2,isy1,isy2,ir:integer;
   tous_rectiligne_ou_sortant:boolean;
        begin



 tous_rectiligne_ou_sortant:=true;
 for i:=1 to nombresommet do
 tous_rectiligne_ou_sortant:=
 tous_rectiligne_ou_sortant and (rectiligne[i] or not(rentrant[i]));
  for i:=1 to nombresommet do  begin
  mc.invconvert(titi[i].x,titi[i].y,messommets[i].ax,messommets[i].ay,true);
  end;


   { if  tous_rectiligne_ou_sortant then begin}
 imprimante.Canvas.Brush.Color:=couleurfond;
  imprimante.Canvas.Pen.Color:=couleurfond;
   imprimante.Canvas.brush.style:=bsSolid;
  imprimante.Canvas.Pen.Mode:=pmcopy;
  imprimante.Canvas.Polygon(@titi,nombresommet);
{  end else begin
   imprimante.Canvas.Brush.Color:=couleurfond xor couleurfondsimulation;
  imprimante.Canvas.Pen.Color:=couleurfond xor couleurfondsimulation;
   imprimante.Canvas.brush.style:=bsSolid;
  imprimante.Canvas.Pen.Mode:=pmxor;
  imprimante.Canvas.Polygon(@titi,nombresommet);
  imprimante.Canvas.Brush.Color:=imprimante.Canvas.Brush.Color xor couleurfondsimulation;
  imprimante.Canvas.Pen.Color:=imprimante.Canvas.Pen.Color xor couleurfondsimulation;
   imprimante.Canvas.Polygon(@titi,nombresommet);

  end; }




        for i:=1 to nombresommet do
   if not(rectiligne[i]) then
   if not(rentrant[i]) then begin
   sx1:=messommets[i].ax;
   sx2:=messommets[i+1].ax;
   sy1:=messommets[i].ay;
   sy2:=messommets[i+1].ay;
   r:=sqrt(sqr(sx1-mescentres[i].ax)+sqr(sy1-mescentres[i].ay));
   mc.invconvert(irx1,iry1,mescentres[i].ax-r,mescentres[i].ay+r,true);
   mc.invconvert(irx2,iry2,mescentres[i].ax+r,mescentres[i].ay-r,true);
   mc.invconvert(isx1,isy1,sx1,sy1,true);
    mc.invconvert(isx2,isy2,sx2,sy2,true);

    imprimante.Canvas.brush.style:=bsSolid;
 imprimante.Canvas.brush.Color:=couleurfond;
 imprimante.Canvas.Pen.Mode:=pmcopy;
 imprimante.Canvas.Pen.Color:=couleurfond;
if (trigodirect) then  imprimante.Canvas.Chord(irx1,iry1,irx2,iry2,isx1,isy1,isx2,isy2) else
imprimante.Canvas.Chord(irx1,iry1,irx2,iry2,isx2,isy2,isx1,isy1);
  end;



         for i:=1 to nombresommet do
   if not(rectiligne[i]) then
   if (rentrant[i]) then begin
   sx1:=messommets[i].ax;
   sx2:=messommets[i+1].ax;
   sy1:=messommets[i].ay;
   sy2:=messommets[i+1].ay;
   r:=sqrt(sqr(sx1-mescentres[i].ax)+sqr(sy1-mescentres[i].ay));
   mc.invconvert(irx1,iry1,mescentres[i].ax-r,mescentres[i].ay+r,true);
   mc.invconvert(irx2,iry2,mescentres[i].ax+r,mescentres[i].ay-r,true);
   mc.invconvert(isx1,isy1,sx1,sy1,true);
    mc.invconvert(isx2,isy2,sx2,sy2,true);
   { imprimante.Canvas.Brush.Color:=couleurfond xor couleurfondsimulation;
  imprimante.Canvas.Pen.Color:=couleurfond xor couleurfondsimulation;
   imprimante.Canvas.brush.style:=bsSolid;
  imprimante.Canvas.Pen.Mode:=pmxor;}
  //le mode pmxor ne fonctionne avec l'imprimante !!!
   imprimante.Canvas.Brush.Color:=couleurfondsimulation;
  imprimante.Canvas.Pen.Color:=couleurfondsimulation;
   imprimante.Canvas.brush.style:=bsSolid;
  imprimante.Canvas.Pen.Mode:=pmcopy;
if not(trigodirect) then  imprimante.Canvas.Chord(irx1,iry1,irx2,iry2,isx1,isy1,isx2,isy2) else
imprimante.Canvas.Chord(irx1,iry1,irx2,iry2,isx2,isy2,isx1,isy1);
    end;




         imprimante.Canvas.brush.style:=bsSolid;
 imprimante.Canvas.brush.Color:=couleurfond;

  imprimante.Canvas.Pen.Mode:=pmcopy;
  imprimante.Canvas.Pen.Color:=couleurbord;


for i:=1 to nombresommet do
         if rectiligne[i] then
         mc.trait(messommets[i].ax,messommets[i].ay,messommets[i+1].ax,
         messommets[i+1].ay,1,couleurbord,pssolid,pmcopy,true) else
         mc.arcdecercle(mescentres[i].ax,mescentres[i].ay,rayon[i],1,theta1[i],theta2[i],
         couleurbord,pmcopy,pssolid,true);

if ((modeinfo or modemodif) and not(modeduplication)) then
  for i:=1 to nombresommet do
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleurpoignees,pmcopy,true);
 if (modemodif or modeduplication) then
  for i:=1 to nombresommet do
  if modemodif then
mc.croixx((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
2,couleurtrans,pmcopy,true) else
  mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleurpoignees,pmcopy,true);
 if (modemodif and not(modeduplication)) then
 for i:=1 to nombresommet do
 if not(rectiligne[i]) then
 mc.croixx(mess[i].ax,mess[i].ay,3,
2,clyellow,pmcopy,true);

if (modesuppression) then
  for i:=1 to nombresommet do  begin
  mc.cercle(messommets[i].ax,messommets[i].ay,3,
1,couleursuppression,pmcopy,true);
 mc.cercle((messommets[i].ax+messommets[i+1].ax)/2,
  (messommets[i].ay+messommets[i+1].ay)/2,3,
1,couleursuppression,pmcopy,true);
if not(rectiligne[i]) then
 mc.cercle(mess[i].ax,mess[i].ay,3,
1,couleursuppression,pmcopy,true);
       end;

   if modegroupement then
mc.croixx(xiso,yiso,3,
2,clpurple,pmcopy,true);
        end;







 function polyhedre.dispersif:boolean;
begin
dispersif:=(indicerouge<>indicevert) or (indicevert<>indicebleu) or (indicerouge<>indicebleu);
end;

function prisme.dispersif:boolean;
begin
dispersif:=(indicerouge<>indicevert) or (indicevert<>indicebleu) or (indicerouge<>indicebleu);
end;

 function prisme.create(_gx,_gy,_ax,_ay,_3x,_3y:extended; _indicerouge,_indicebleu,_indicevert:extended; _couleurbord,_couleurfond:tcolor;
 _ReflechiEntrant,_ReflechiSortant:TReflechiPolyhedre):boolean;
 var i,j:integer;
 mu,lambda,ecart,totalangle,alpha,alpha1,alpha2,hx,hy,aire_signee:extended;
 ff:textfile;
 toto:array[1..2*maxsommet] of pointpolyhedre;


 begin
  ReflechiEntrant:=_ReflechiEntrant;
 ReflechiSortant:=_ReflechiSortant;
  nombresommet:=3;
  gx:=_gx; gy:=_gy; ax:=_ax; ay:=_ay;
  if ((_3x-gx)*(ax-gx)+(_3y-gy)*(ay-gy)>0) then begin
  create:=false;
  exit;
  end;

  hx:=gx-(ax-gx)/2;
  hy:=gy-(ay-gy)/2;
  if ((ax-gx)*(_3y-gy)-(ay-gy)*(_3x-gx))>0 then begin
  bx:=_3x; by:=_3y;
  cx:=-bx+2*hx;
  cy:=-by+2*hy;

  end else begin
  cx:=_3x; cy:=_3y;
  bx:=-cx+2*hx;
  by:=-cy+2*hy;

  end;


  MesSommets[1].ax:=ax;
  MesSommets[1].ay:=ay;
  MesSommets[2].ax:=bx;
  MesSommets[2].ay:=by;
  MesSommets[3].ax:=cx;
  MesSommets[3].ay:=cy;
  MesSommets[4].ax:=ax;
  MesSommets[4].ay:=ay;
  indicerouge:=_indicerouge;
   indicebleu:=_indicebleu;
    indicevert:=_indicevert;
       couleurbord:=_couleurbord;  couleurfond:=_couleurfond;
       {on verifie que les points ne sont pas trop proches}
    for i:=1 to 3-1 do
    for j:=i+1 to 3 do
    if sqrt(sqr(messommets[i].ax-messommets[j].ax)+
    sqr(messommets[i].ay-messommets[j].ay))<form1.taillemini
     then
    begin
    create:=false;
    exit;
    end;
    create:=true;


     hauteur:=3/2*sqrt(sqr(ax-gx)+sqr(ay-gy));
    angle_axe:=donneanglepolairedans02pi(ax-gx,ay-gy);
    angle_sommet:=arccos(((bx-ax)*(cx-ax)+(by-ay)*(cy-ay))/(sqr(bx-ax)+sqr(by-ay)));



     for i:=1 to 3 do begin
  if ((messommets[i].ax>xxmax) or (messommets[i].ax<xxmin) or
  (messommets[i].ay>yymax) or (messommets[i].ay<yymin)) then begin
  create:=false;
  exit;
  end;
  toto[i].ax:=messommets[i].ax;
  toto[i].ay:=messommets[i].ay;
  toto[i+nombresommet].ax:=messommets[i].ax;
  toto[i+nombresommet].ay:=messommets[i].ay;
  end;


    {calcul des angles polaires des cotes}
    for i:=1 to nombresommet-1 do begin
     if ((toto[i+1].ax-toto[i].ax)=0) then
  if ((toto[i+1].ay-toto[i].ay)>0) then anglepolaire[i]:=Pi/2 else anglepolaire[i]:=-Pi/2
  else begin
  anglepolaire[i]:=arctan((toto[i+1].ay-toto[i].ay)/(toto[i+1].ax-toto[i].ax));
  if ((toto[i+1].ax-toto[i].ax)<0) then anglepolaire[i]:=anglepolaire[i]+Pi;
  end;
  if anglepolaire[i]>Pi then anglepolaire[i]:=anglepolaire[i]-Pi*2;
   end;

   if ((toto[1].ax-toto[nombresommet].ax)=0) then
  if ((toto[1].ay-toto[nombresommet].ay)>0) then anglepolaire[nombresommet]:=Pi/2
  else anglepolaire[nombresommet]:=-Pi/2
  else begin
  anglepolaire[nombresommet]:=arctan((toto[1].ay-toto[nombresommet].ay)/
  (toto[1].ax-toto[nombresommet].ax));
  if ((toto[1].ax-toto[nombresommet].ax)<0) then anglepolaire[nombresommet]:=anglepolaire[nombresommet]+Pi;
  end;
  if anglepolaire[nombresommet]>Pi then anglepolaire[nombresommet]:=anglepolaire[i]-Pi*2;



   {senstrigodirect ?}
  {sens de parcours}
      aire_signee:=0;
   for i:=1 to nombresommet do
   aire_signee:=aire_signee+0.5*(messommets[i].ax*messommets[i+1].ay-
   messommets[i].ay*messommets[i+1].ax);
     trigodirect:=(aire_signee>0);
    {calcul des normales sortantes sur chaque cote}
    for i:=1 to nombresommet do begin
    if trigodirect then nx[i]:=cos(anglepolaire[i]-Pi/2) else
    nx[i]:=cos(anglepolaire[i]+Pi/2);
    if trigodirect then ny[i]:=sin(anglepolaire[i]-Pi/2) else
    ny[i]:=sin(anglepolaire[i]+Pi/2);
    end;

    xiso:=gx; yiso:=gy;

     modifie:=true;

     end;







function Polyhedre.create(_nombresommet:integer;
 _MesSommets: TableauPointPolyhedre;
 _indicerouge,_indicebleu,_indicevert:extended; _couleurbord,_couleurfond:tcolor;
 _ReflechiEntrant,_ReflechiSortant:TReflechiPolyhedre):boolean;
 var i,j:integer;
 mu,lambda,ecart,totalangle,alpha,alpha1,alpha2,aire_signee,para,tol:extended;
 ff:textfile;
 toto:array[1..2*maxsommet] of pointpolyhedre;
 begin
 tol:=1e-6;
 ReflechiEntrant:=_ReflechiEntrant;
 ReflechiSortant:=_ReflechiSortant;
  nombresommet:=_nombresommet;
  if ((nombresommet<3) or (nombresommet>maxsommet)) then begin
    create:=false;
  exit;
  end;
  for i:=1 to nombresommet do begin
  if ((_messommets[i].ax>xxmax) or (_messommets[i].ax<xxmin) or
  (_messommets[i].ay>yymax) or (_messommets[i].ay<yymin)) then begin
  create:=false;
  exit;
  end;
  MesSommets[i].ax:=_MesSommets[i].ax;
  MesSommets[i].ay:=_MesSommets[i].ay;
  toto[i].ax:=_messommets[i].ax;
  toto[i].ay:=_messommets[i].ay;
  toto[i+nombresommet].ax:=_messommets[i].ax;
  toto[i+nombresommet].ay:=_messommets[i].ay;
  end;
  MesSommets[nombresommet+1].ax:=_MesSommets[1].ax;
  MesSommets[nombresommet+1].ay:=_MesSommets[1].ay;
  indicerouge:=_indicerouge;
   indicebleu:=_indicebleu;
    indicevert:=_indicevert;
       couleurbord:=_couleurbord;  couleurfond:=_couleurfond;
    {on verifie que les points ne sont pas trop proches}
    for i:=1 to nombresommet-1 do
    for j:=i+1 to nombresommet do
    if sqrt(sqr(messommets[i].ax-messommets[j].ax)+
    sqr(messommets[i].ay-messommets[j].ay))<form1.taillemini
     then
    begin
    create:=false;
    exit;
    end;


      {on verifie qu'un point n'appartient pas à un autre segment que les 2 dont il est une extremité}


     if nombresommet>3 then
     for i:=1 to nombresommet do begin
     if i>2 then for j:=1 to i-3 do
     if Le_point_est_il_sur_une_droite(messommets[i].ax,messommets[i].ay,
     messommets[j].ax,messommets[j].ay,messommets[j+1].ax,messommets[j+1].ay,para,tol)
     and (para>=-tol) and (para<=1+tol) then begin
     create:=false;
      exit;
      end;
      if i<nombresommet-1 then for j:=i+1 to nombresommet-1 do
     if Le_point_est_il_sur_une_droite(messommets[i].ax,messommets[i].ay,
     messommets[j].ax,messommets[j].ay,messommets[j+1].ax,messommets[j+1].ay,para,tol)
     and (para>=-tol) and (para<=1+tol) then begin
     create:=false;
      exit;
      end;
     end;




    if nombresommet>3 then
    for i:=1  to nombresommet do
    for j:=i+2 to i+nombresommet-2 do

    if Les_deux_segments_se_coupent_ils(toto[i].ax,toto[i].ay,toto[i+1].ax,toto[i+1].ay,
    toto[j].ax,toto[j].ay,toto[j+1].ax,toto[j+1].ay)
      then begin
      create:=false;
      exit;
      end;
    //end;  end;





    create:=true;
        {calcul des angles polaires des cotes}
    for i:=1 to nombresommet do

    anglepolaire[i]:=donneanglepolairedanspipi(messommets[i+1].ax-messommets[i].ax,messommets[i+1].ay-messommets[i].ay);




   aire_signee:=0;
   for i:=1 to nombresommet do  begin
   aire_signee:=aire_signee+0.5*(messommets[i+1].ax-messommets[i].ax)*(messommets[i+1].ay+
   messommets[i].ay);
     end;
                              trigodirect:=(aire_signee<0);



    {calcul des normales sortantes sur chaque cote}
    for i:=1 to nombresommet do begin
    if trigodirect then nx[i]:=cos(anglepolaire[i]-Pi/2) else
    nx[i]:=cos(anglepolaire[i]+Pi/2);
    if trigodirect then ny[i]:=sin(anglepolaire[i]-Pi/2) else
    ny[i]:=sin(anglepolaire[i]+Pi/2);
    end;

    xiso:=0; yiso:=0;
    for i:=1 to nombresommet do begin
    xiso:=xiso+MesSommets[i].ax;
    yiso:=yiso+MesSommets[i].ay;
    end;
    xiso:=xiso/nombresommet; yiso:=yiso/nombresommet;
     modifie:=true;
 end;




function  polyhedre.estou(x,y:extended):ttypeinterieur;
var i,intersection:integer; alpha,beta:extended;
pente1,pente2:extended;
pente:array[1..2*maxsommet] of extended;
bonnepente,ux,uy:extended;
poly:array of tpoint;
begin


{le point est-il sur un bord ?}
for i:=1 to nombresommet do
if ((x-messommets[i].ax)*(messommets[i+1].ay-messommets[i].ay)-
(y-messommets[i].ay)*(messommets[i+1].ax-messommets[i].ax)=0) then begin
if abs(messommets[i+1].ax-messommets[i].ax)>abs(messommets[i+1].ay-messommets[i].ay) then
alpha:=(x-messommets[i].ax)/(messommets[i+1].ax-messommets[i].ax) else
alpha:=(y-messommets[i].ay)/(messommets[i+1].ay-messommets[i].ay);
if ((alpha>=0) and (alpha<=1)) then begin
estou:=Ibord;
exit;
end;
end;



if IsPointInPolygon(X,y,messommets,nombresommet+1)=true then estou:=Iinterieur else estou:=Iexterieur;

{for i:=1 to nombresommet do pente[i]:=anglepolaire[i];
for i:=1 to nombresommet do begin
  if ((messommets[i].ax-x)=0) then
  if ((messommets[i].ay-y)>0) then pente[i+nombresommet]:=Pi/2 else pente[i+nombresommet]:=-Pi/2
  else begin
  pente[i+nombresommet]:=arctan((messommets[i].ay-y)/(messommets[i].ax-x));
  if ((messommets[i].ax-x)<0) then pente[i+nombresommet]:=pente[i+nombresommet]+Pi;
  end;
  if pente[i+nombresommet]>Pi then pente[i+nombresommet]:=pente[i+nombresommet]-Pi*2;
   end;

   pente1:=pente[1];   pente2:=pente[1];
   for i:=2 to 2*nombresommet do
   if pente[i]>=pente1 then
   pente1:=pente[i] else
   pente2:=pente[i];

   for i:=1 to 2*nombresommet do
   if ((pente[i]<pente1) and (pente[i]>pente2)) then pente2:=pente[i];

   bonnepente:=(pente1+pente2)/2;
   ux:=cos(bonnepente);
   uy:=sin(bonnepente);
    intersection:=0;
   for i:=1 to nombresommet do begin
   if   (uy*(messommets[i].ax-messommets[i+1].ax)-ux*(messommets[i].ay-messommets[i+1].ay))<>0 then
   beta:=(uy*(messommets[i].ax-x)-ux*(messommets[i].ay-y))/
   (uy*(messommets[i].ax-messommets[i+1].ax)-ux*(messommets[i].ay-messommets[i+1].ay)) else
   if (uy*(messommets[i].ax-x)-ux*(messommets[i].ay-y))>0 then beta:=100 else beta:=-100;
   if abs(ux)>abs(uy) then
   alpha:=(messommets[i].ax-x-beta*(messommets[i].ax-messommets[i+1].ax))/ux else
   alpha:=(messommets[i].ay-y-beta*(messommets[i].ay-messommets[i+1].ay))/uy;
    if ((beta<1) and (beta>0) and (alpha>0)) then inc(intersection);
    end;

    if ((intersection mod 2)=0) then estou:=Iexterieur else estou:=Iinterieur;}

end;



function  prisme.estou(x,y:extended):ttypeinterieur;
var i,intersection:integer; alpha,beta:extended;
pente1,pente2:extended;
pente:array[1..2*maxsommet] of extended;
bonnepente,ux,uy:extended;
begin


{le point est-il sur un bord ?}
for i:=1 to nombresommet do
if ((x-messommets[i].ax)*(messommets[i+1].ay-messommets[i].ay)-
(y-messommets[i].ay)*(messommets[i+1].ax-messommets[i].ax)=0) then begin
if abs(messommets[i+1].ax-messommets[i].ax)>abs(messommets[i+1].ay-messommets[i].ay) then
alpha:=(x-messommets[i].ax)/(messommets[i+1].ax-messommets[i].ax) else
alpha:=(y-messommets[i].ay)/(messommets[i+1].ay-messommets[i].ay);
if ((alpha>=0) and (alpha<=1)) then begin
estou:=Ibord;
exit;
end;
end;


for i:=1 to nombresommet do pente[i]:=anglepolaire[i];
for i:=1 to nombresommet do begin
  if ((messommets[i].ax-x)=0) then
  if ((messommets[i].ay-y)>0) then pente[i+nombresommet]:=Pi/2 else pente[i+nombresommet]:=-Pi/2
  else begin
  pente[i+nombresommet]:=arctan((messommets[i].ay-y)/(messommets[i].ax-x));
  if ((messommets[i].ax-x)<0) then pente[i+nombresommet]:=pente[i+nombresommet]+Pi;
  end;
  if pente[i+nombresommet]>Pi then pente[i+nombresommet]:=pente[i+nombresommet]-Pi*2;
   end;

   pente1:=pente[1];  pente2:=pente[1];
   for i:=2 to 2*nombresommet do
   if pente[i]>=pente1 then
   pente1:=pente[i] else
   pente2:=pente[i];

   for i:=1 to 2*nombresommet do
   if ((pente[i]<pente1) and (pente[i]>pente2)) then pente2:=pente[i];

   bonnepente:=(pente1+pente2)/2;
   ux:=cos(bonnepente);
   uy:=sin(bonnepente);
    intersection:=0;
   for i:=1 to nombresommet do begin
   if   (uy*(messommets[i].ax-messommets[i+1].ax)-ux*(messommets[i].ay-messommets[i+1].ay))<>0 then
   beta:=(uy*(messommets[i].ax-x)-ux*(messommets[i].ay-y))/
   (uy*(messommets[i].ax-messommets[i+1].ax)-ux*(messommets[i].ay-messommets[i+1].ay)) else
   if (uy*(messommets[i].ax-x)-ux*(messommets[i].ay-y))>0 then beta:=100 else beta:=-100;
   if abs(ux)>abs(uy) then
   alpha:=(messommets[i].ax-x-beta*(messommets[i].ax-messommets[i+1].ax))/ux else
   alpha:=(messommets[i].ay-y-beta*(messommets[i].ay-messommets[i+1].ay))/uy;
    if ((beta<1) and (beta>0) and (alpha>0)) then inc(intersection);
    end;

    if ((intersection mod 2)=0) then estou:=Iexterieur else estou:=Iinterieur;

end;

function  lec.estou(x,y:extended):ttypeinterieur;
var d1,d2,daxe,lambda:extended;
begin
d1:=sqrt(sqr(x-c1x)+sqr(y-c1y));
d2:=sqrt(sqr(x-c2x)+sqr(y-c2y));
lambda:=(x-ox)*cos(apaf)+(y-oy)*sin(apaf);
daxe:=sqrt(sqr(ox+lambda*cos(apaf)-x)+sqr(oy+lambda*sin(apaf)-y));
if (daxe>diametre) then begin
estou:=iexterieur;
      exit;
      end;


      if mince then begin
{lentille biconvexe }
if r1*r2<0 then begin

if (  (d1=abs(r1)) and  (d2<=abs(r2))) then begin
estou:=Ibord;
exit;
end;

if (  (d1<=abs(r1)) and  (d2=abs(r2))) then begin
estou:=Ibord;
exit;
end;


if (   (d1<abs(r1)) and (d2<abs(r2))) then begin
estou:=Iinterieur;
exit;
end;

estou:=Iexterieur;
exit;
end;

{lentille concave convexe}
if ((r1>0) and (r2>0)) then begin

if (  (d1>abs(r1))  and (d2<abs(r2))) then begin
estou:=Iinterieur;
exit;
end;

if (  (d1=abs(r1)) and (d2<=abs(r2))) then begin
estou:=Ibord;
exit;
end;

if (  (d1>=abs(r1)) and (d2=abs(r2))) then begin
estou:=Ibord;
exit;
end;

estou:=Iexterieur;
end;
  {convexe concave dans autre sens}
if ((r1<0) and (r2<0)) then begin

if (  (d2>abs(r2))  and (d1<abs(r1))) then begin
estou:=Iinterieur;
exit;
end;

if (  (d1=abs(r1)) and (d2>=abs(r2))) then begin
estou:=Ibord;
exit;
end;

if (  (d1<=abs(r1)) and (d2=abs(r2))) then begin
estou:=Ibord;
exit;
end;

estou:=Iexterieur;
exit;
end;
 end; {du cas lentille mince}

 {lentille epaisse}

 if not(mince) then begin
 {biconcave}
 if (r1*r2<0) then begin
 if ( (d1>abs(r1)) and (d2>abs(r2)) and ((x-c1x)*(s2x-s1x)+(y-c1y)*(s2y-s1y)>=0) and
 ((x-c2x)*(s2x-s1x)+(y-c2y)*(s2x-s1x)<=0)) then begin
   estou:=Iinterieur;
exit;
end;
 if ( (d1=abs(r1)) and (d2>abs(r2)) and ((x-c1x)*(s2x-s1x)+(y-c1y)*(s2y-s1y)>=0) and
 ((x-c2x)*(s2x-s1x)+(y-c2y)*(s2x-s1x)<=0)) then begin
   estou:=Ibord;
exit;
end;
 if ( (d1>abs(r1)) and (d2=abs(r2)) and ((x-c1x)*(s2x-s1x)+(y-c1y)*(s2y-s1y)>=0) and
 ((x-c2x)*(s2x-s1x)+(y-c2y)*(s2x-s1x)<=0)) then begin
   estou:=Ibord;
exit;
end;

estou:=Iexterieur;
exit;
end;  {du cas biconcave}

{convexe concave, 1er cas}
if ((r1>0) and (r2>0)) then begin
if ((d1>abs(r1)) and (d2<abs(r2)) and ((x-c1x)*(s2x-s1x)+(y-c1y)*(s2y-s1y)>=0)) then begin
   estou:=Iinterieur;
exit;
end;

if ((d1=abs(r1)) and (d2<abs(r2)) and ((x-c1x)*(s2x-s1x)+(y-c1y)*(s2y-s1y)>=0)) then begin
   estou:=Ibord;
exit;
end;

if ((d1>abs(r1)) and (d2=abs(r2)) and ((x-c1x)*(s2x-s1x)+(y-c1y)*(s2y-s1y)>=0)) then begin
   estou:=Ibord;
exit;
end;

estou:=Iexterieur;
exit;
end;  {du 1er cas cc}


{convexe concave, 2er cas}
if ((r1<0) and (r2<0)) then begin
if ((d1<abs(r1)) and (d2>abs(r2)) and ((x-c1x)*(s2x-s1x)+(y-c1y)*(s2y-s1y)<=0)) then begin
   estou:=Iinterieur;
exit;
end;

if ((d1=abs(r1)) and (d2>abs(r2)) and ((x-c1x)*(s2x-s1x)+(y-c1y)*(s2y-s1y)<=0)) then begin
   estou:=Ibord;
exit;
end;

if ((d1<abs(r1)) and (d2=abs(r2)) and ((x-c1x)*(s2x-s1x)+(y-c1y)*(s2y-s1y)<=0)) then begin
   estou:=Ibord;
exit;
end;

estou:=Iexterieur;
exit;
end;  {du 2er cas cc}


end; {du as epais}
end;

function lec.dispersif:boolean;
begin
dispersif:=(indicerouge<>indicevert) or (indicevert<>indicebleu) or (indicerouge<>indicebleu);
end;


function polycercle.dispersif:boolean;
begin
dispersif:=(indicerouge<>indicevert) or (indicevert<>indicebleu) or (indicerouge<>indicebleu);
end;


function  sphere.estou(x,y:extended):ttypeinterieur;
begin
if sqrt(sqr(x-cx)+sqr(y-cy))>rayon then begin
estou:=iexterieur;
exit;
end;
 if sqrt(sqr(x-cx)+sqr(y-cy))<rayon then begin
estou:=iinterieur;
exit;
end;
estou:=ibord;
end;

function sphere.create(_cx,_cy,_rayon:extended;
 _indicerouge,_indicebleu,_indicevert:extended; _couleurbord,_couleurfond:tcolor;
 _ReflechiEntrant,_ReflechiSortant:TReflechiPolyhedre):boolean;
 begin
 if (  (_cx+_rayon>=xxmax) or (_cx-_rayon<=xxmin) or
 (_cy+_rayon>=yymax)  or (_cy-_rayon<=yymin)) then begin
 create:=false;
 exit; end;
 create:=true;
 cx:=_cx; cy:=_cy;
 rayon:=_rayon;
 indicerouge:=_indicerouge;
 indicebleu:=_indicebleu;
 indicevert:=_indicevert;
 ReflechiEntrant:=_ReflechiEntrant;
 ReflechiSortant:=_ReflechiSortant;
  couleurbord:=_couleurbord;  couleurfond:=_couleurfond;
   modifie:=true;
 end;

 function sphere.dispersif:boolean;
begin
dispersif:=(indicerouge<>indicevert) or (indicevert<>indicebleu) or (indicerouge<>indicebleu);
end;

procedure sphere.dessine(mc:tmonbitmap);
begin
mc.disque(cx,cy,rayon,couleurbord,couleurfond,false,true);
if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
if ((modemodif or modeinfo) and not(modeduplication)) then begin
if modemodif then
mc.croixx(cx,cy,3,
2,couleurtrans,pmcopy,true) else
mc.cercle(cx,cy,3,
  1,couleurpoignees,pmcopy,true);
  mc.cercle(cx+rayon,cy,3,
 1,couleurpoignees,pmcopy,true);
 mc.cercle(cx-rayon,cy,3,
  1,couleurpoignees,pmcopy,true);
  mc.cercle(cx,cy+rayon,3,
  1,couleurpoignees,pmcopy,true);
  mc.cercle(cx,cy-rayon,3,
  1,couleurpoignees,pmcopy,true);
 end;
 if modeduplication then
  mc.cercle(cx,cy,3,
  1,couleurpoignees,pmcopy,true);

  if (modesuppression) then begin
mc.cercle(cx,cy,3,
  1,couleursuppression,pmcopy,true);
  mc.cercle(cx+rayon,cy,3,
 1,couleursuppression,pmcopy,true);
 mc.cercle(cx-rayon,cy,3,
  1,couleursuppression,pmcopy,true);
  mc.cercle(cx,cy+rayon,3,
  1,couleursuppression,pmcopy,true);
  mc.cercle(cx,cy-rayon,3,
  1,couleursuppression,pmcopy,true);
 end;

end;


procedure sphere.dessinePS(mc:tmonpostscript);
begin
mc.disque(cx,cy,rayon,couleurbord,couleurfond,false,true);
if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
if ((modemodif or modeinfo) and not(modeduplication)) then begin
if modemodif then
mc.croixx(cx,cy,3,
2,couleurtrans,pmcopy,true) else
mc.cercle(cx,cy,3,
  1,couleurpoignees,pmcopy,true);
  mc.cercle(cx+rayon,cy,3,
 1,couleurpoignees,pmcopy,true);
 mc.cercle(cx-rayon,cy,3,
  1,couleurpoignees,pmcopy,true);
  mc.cercle(cx,cy+rayon,3,
  1,couleurpoignees,pmcopy,true);
  mc.cercle(cx,cy-rayon,3,
  1,couleurpoignees,pmcopy,true);
 end;
 if modeduplication then
  mc.cercle(cx,cy,3,
  1,couleurpoignees,pmcopy,true);

  if (modesuppression) then begin
mc.cercle(cx,cy,3,
  1,couleursuppression,pmcopy,true);
  mc.cercle(cx+rayon,cy,3,
 1,couleursuppression,pmcopy,true);
 mc.cercle(cx-rayon,cy,3,
  1,couleursuppression,pmcopy,true);
  mc.cercle(cx,cy+rayon,3,
  1,couleursuppression,pmcopy,true);
  mc.cercle(cx,cy-rayon,3,
  1,couleursuppression,pmcopy,true);
 end;

end;





procedure sphere.imprime(mc:tmyimprimante);
begin
mc.disque(cx,cy,rayon,couleurbord,couleurfond,false,true);
if modegroupement then
mc.croixx(cx,cy,3,
2,clpurple,pmcopy,true);
if ((modemodif or modeinfo) and not(modeduplication)) then begin
if modemodif then
mc.croixx(cx,cy,3,
2,couleurtrans,pmcopy,true) else
mc.cercle(cx,cy,3,
  1,couleurpoignees,pmcopy,true);
  mc.cercle(cx+rayon,cy,3,
 1,couleurpoignees,pmcopy,true);
 mc.cercle(cx-rayon,cy,3,
  1,couleurpoignees,pmcopy,true);
  mc.cercle(cx,cy+rayon,3,
  1,couleurpoignees,pmcopy,true);
  mc.cercle(cx,cy-rayon,3,
  1,couleurpoignees,pmcopy,true);
 end;
 if modeduplication then
  mc.cercle(cx,cy,3,
  1,couleurpoignees,pmcopy,true);

  if (modesuppression) then begin
mc.cercle(cx,cy,3,
  1,couleursuppression,pmcopy,true);
  mc.cercle(cx+rayon,cy,3,
 1,couleursuppression,pmcopy,true);
 mc.cercle(cx-rayon,cy,3,
  1,couleursuppression,pmcopy,true);
  mc.cercle(cx,cy+rayon,3,
  1,couleursuppression,pmcopy,true);
  mc.cercle(cx,cy-rayon,3,
  1,couleursuppression,pmcopy,true);
 end;

end;






initialization
  {$ifndef darwin} application.UpdateFormatSettings:=false; {$endif}
 DefaultFormatSettings.DecimalSeparator:='.';


taillepoint:=3;
stylepoint:=tpcroixp;
couleurpoint:=clblue;
signaler:=true;
 tracergrille:=false;
 attractiongrille:=false;
  grillex:=20; grilley:=20;


 nombrecopies:=1;
 graphepresent:=false;
  tracesegment:=false;
   point1fait:=false;  point2fait:=false; point3fait:=false;  point4fait:=false;
   foyerfait:=false; sourcefaite:=false;
   ajoutrayon:=false; ajoutrayon:=false; ajoutMscopa:=false;
   ajoutMscepa:=false;  ajoutlmc:=false; ajoutlmd:=false; modifencours:=false;
   ajoutMscore:=false; ajoutMscere:=false;    ajoutsphere:=false;
   ajoutsourceponctuelle:=false;  modemodif:=false; modeduplication:=false;
   ajoutondeplane:=false;      modedistance:=false;   modesuppression:=false;
   modegroupement:=false; couleursuppression:=clred;
   couleurreseau:=clblue;   epaisseurreseau:=1;
   couleurmiroirplan:=clblack;   epaisseurmiroirplan:=1;
   couleurmscopa:=clblack;  epaisseurmscopa:=1; couleuraxemscopa:=clblue;
   couleurmscepa:=clblack;  epaisseurmscepa:=1; couleuraxemscepa:=clblue;
   couleurmscore:=clblack;    epaisseurmscore:=1; couleuraxemscore:=clblue;
    couleurmscere:=clblack;   epaisseurmscere:=1;  couleuraxemscere:=clblue;
     couleurlmc:=clblue;      epaisseurlmc:=1;     couleuraxelmc:=clFuchsia;
     couleurlmd:=clblue;      epaisseurlmd:=1;     couleuraxelmd:=clFuchsia;
       couleurlec:=claqua; couleuraxelec:=clred;  epaisseurlec:=1;
    couleurrayon:=clred;    epaisseurrayon:=1;
     couleurondeplane:=clred;  epaisseurondeplane:=1;
     couleursourceponctuelle:=clred;  epaisseursourceponctuelle:=1;
     couleurecran:=clblack;  epaisseurecran:=2;
      couleurlsr:=clblack;   epaisseurlsr:=1;
       couleurpolyhedre:=claqua; epaisseurpolyhedre:=1;
       couleurprisme:=claqua; epaisseurprisme:=1;
       couleurpolycercle:=claqua; epaisseurpolycercle:=1;
   couleursphere:=claqua; epaisseursphere:=1;
    couleurmiroirconique:=clblack; couleuraxemiroirconique:=clblue;
    couleurtexte:=clblack; taillefontetexte:=10;
    couleurdiaphragme:=clblack; epaisseurdiaphragme:=1;
    couleurfleche:=clblack;  epaisseurfleche:=1;
    couleuroeil:=clgreen;   epaisseuroeil:=1;
    couleurangle:=clblack; epaisseurangle:=1;
    couleurmetre:=clblack; epaisseurmetre:=1;



     couleurpoignees:=clblue;
   couleurnormale:=clblack; epaisseurnormale:=1; pourcentagenormale:=0.05;
       optionnormale:=true;   optionangles:=false;
    nombrerayon:=0;  nombremiroirplan:=0;  nombrefleche:=0;  nombrereseau:=0;
    nombreecran:=0;    nombregroupe:=0;
     nombreMscopa:=0;  nombreMscepa:=0; nombrelmc:=0; nombrelmd:=0;
     nombreMscore:=0;  nombreMscere:=0;  nombresourceponctuelle:=0;
     zoomfactor:=1;  nombreondeplane:=0;  nombretotalsegment:=0; nombrenormale:=0;
     nombrepolyhedre:=0;  nombresphere:=0; nombremetre:=0; nombreangle:=0;  nombreprisme:=0;
     nombremiroirconique:=0;  nombreanglesatracer:=0;  nombrepolycercle:=0;
     nombretexte:=0; nombrediaphragme:=0;    respectrapport:=false;
  CreePmiroirplan(listemiroirplan,0); creepfleche(listefleche,0);  CreePreseau(listereseau,0);
   creepecran(listeecran,0);       creepoeil(listeoeil,0);    creepgroupe(listegroupe,0);
  creePMscopa(ListeMscopa,0);         creeplsr(listelsr,0);
  creePMscepa(ListeMscepa,0);   CreePpolyhedre(listepolyhedre,0);
  creeppolycercle(listepolycercle,0);
  creePMscore(ListeMscore,0);  creepsphere(listesphere,0);
  creePMscere(ListeMscere,0);  creepmetre(listemetre,0); creepangle(listeangle,0);
  creePlmc(Listelmc,0); creeplec(listelec,0);       creepangle(listeanglesatracer,0);
  creepmiroirconique(listemiroirconique,0);
  creePlmd(Listelmd,0); creeptexteaffiche(listetexteaffiche,0);
  creePrayon(Listerayon,0);  creepdiaphragme(listediaphragme,0);
  creePSourcePonctuelle(ListeSourcePonctuelle,0);
  creePOndePlane(ListeOndePlane,0);  xxmin:=0; xxmax:=0; yymin:=0; yymax:=0;
  creepsegment(listesegment,0); creepsegment(listenormale,0);
  decimalesangles:=0;
  nomsauvegarde:=''; fantomespresents:=false; listefantomes:='';
  unitelongueur:='mm';    maxrayonsrecherchesurfacesonde:=20;
  couleurtrans:=clgreen;  couleurfondsimulation:=clwhite;

    modifie:=false;
    lastx:=0; lasty:=0;
     positionempennage:=500; tailleempennage:=5;
     couleurglobale:=clblack; couleurglobaleaxe:=clred;
     couleurglobalerayon:=clred; epaisseurglobale:=1;
      longueur_donde_red:=632e-9;
     longueur_donde_blue:=450e-9;
     longueur_donde_green:=520e-9;
end.

