Index: /trunk/SophyaPI/PI/Makefile
===================================================================
--- /trunk/SophyaPI/PI/Makefile	(revision 4082)
+++ /trunk/SophyaPI/PI/Makefile	(revision 4083)
@@ -1,3 +1,3 @@
-include ../BuildMgr/sophyamake.inc
+include ../sophyamake.inc
  
 all: $(SOPHYALIBP)libPI.a
Index: /trunk/SophyaPI/PI/Quartz/pigraphquartz.cpp
===================================================================
--- /trunk/SophyaPI/PI/Quartz/pigraphquartz.cpp	(revision 4082)
+++ /trunk/SophyaPI/PI/Quartz/pigraphquartz.cpp	(revision 4083)
@@ -331,4 +331,5 @@
 void PIGraphicQuartz::DrawMarker(PIGrCoord x0, PIGrCoord y0)
 {
+	printf("PIGraphicQuartz::DrawMarker   NOT IMPLEMENTED\n");
 
 /*
@@ -407,4 +408,5 @@
 void PIGraphicQuartz::DrawMarkers(PIGrCoord *x, PIGrCoord *y, int n)
 {
+	printf("PIGraphicQuartz::DrawMarkers   NOT IMPLEMENTED\n");
 /*
 int i;
@@ -431,4 +433,8 @@
 
 
+void PIGraphicQuartz::DrawPixmap(PIGrCoord, PIGrCoord, PIPixColIdx&, PIColorMap*) {
+	printf("PIGraphicQuartz::DrawPixmap1   NOT IMPLEMENTED\n");
+}
+
 /* --Methode-- */
 void PIGraphicQuartz::DrawPixmap(PIGrCoord x, PIGrCoord y, unsigned char *pix, 
@@ -470,4 +476,5 @@
 XFree(ximg);
 */
+	printf("PIGraphicQuartz::DrawPixmap2   NOT IMPLEMENTED\n");
 return;
 }
@@ -517,4 +524,5 @@
 void PIGraphicQuartz::DrawVerticalString(int x, int y, const char* s, unsigned long pos, bool imgs)
 {
+	printf("PIGraphicQuartz::DrawVerticalString   NOT IMPLEMENTED\n");
 /*
   int fh, fasc, fdes;
@@ -693,4 +701,5 @@
 void PIGraphicQuartz::SelLine(PILineAtt const& att)
 {
+	printf("PIGraphicQuartz::SelLine   NOT IMPLEMENTED\n");
 
 if (att == mLAtt)  return;
Index: /trunk/SophyaPI/PI/Quartz/pigraphquartz.h
===================================================================
--- /trunk/SophyaPI/PI/Quartz/pigraphquartz.h	(revision 4082)
+++ /trunk/SophyaPI/PI/Quartz/pigraphquartz.h	(revision 4083)
@@ -52,4 +52,5 @@
   virtual void       DrawPixmap(PIGrCoord x, PIGrCoord y, unsigned char *pix, 
                                 int sx, int sy, PIColorMap* cmap);
+  virtual void	     DrawPixmap(PIGrCoord, PIGrCoord, PIPixColIdx&, PIColorMap*);
 
 // Modifications attributs graphiques
Index: /trunk/SophyaPI/PI/Tests/xp1.cc
===================================================================
--- /trunk/SophyaPI/PI/Tests/xp1.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/Tests/xp1.cc	(revision 4083)
@@ -10,5 +10,9 @@
 #include PISTDWDG_H 
 #include PIWIN_H
-#include "PIButtonQuartz.h"
+#ifdef __PIWQUARTZ__
+#include <pistdwdgquartz.h>
+#else
+#include <pistdwdgx.h>
+#endif
 
 //  ----- Declaration de la classe ArgsWind : Fenetre de dialogue -------
@@ -48,10 +52,12 @@
 {
 int bsx, bsy;
-
+		printf("ArgsWind::ArgsWind\n");
+	
 // On definit la taille a partir de la taille par defaut des composantes 
 PIApplicationPrefCompSize(bsx, bsy);
 // On redefinit la taille de la fenetre
 SetSize(bsx*4, bsy*4);
-
+	printf("bsx:%d bsy:%d\n",bsx,bsy);
+	
 // Creation de champs "labels"
 mLab[0] = new PILabel(this, "Arg-1:", bsx, bsy, bsx/3, bsy/4); 
@@ -96,4 +102,5 @@
 void ArgsWind::Process(PIMessage msg, PIMsgHandler* /*sender*/, void* /*data*/)
 {
+	printf("ArgsWind::Process\n");
 
 switch (UserMsg(msg))
Index: /trunk/SophyaPI/PI/lut.cc
===================================================================
--- /trunk/SophyaPI/PI/lut.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/lut.cc	(revision 4083)
@@ -12,13 +12,22 @@
 #include "lut.h"
 
-
+//++
+// Class	LUT
+// Lib		PI
+// include	lut.h
+//
+//	Classe Look-Up table : transformation de valeurs (intensite/RGB) en index de couleur
+//--
+//++
+// Links	Voir aussi
+// PIColorMap
+// PIPixmap
+// PIImage
+//--
 /* --Methode-- */
 
-LUT::LUT(double min, double max, unsigned short ncol, int typ, int ntable) 
+LUT::LUT(double min, double max, unsigned short ncol, int typ) 
 {
-int nlev;
-
-bornes=NULL;
-nlev = ncol-2;
+int nlev = ncol-2;
 if (nlev < 1)  nlev = 1;
 bornes = new double[nlev+1];
@@ -26,4 +35,12 @@
 if (bornes == NULL)  return;
 type = typ;  nLevel = nlev;
+int qqq = 1;
+quantum = 1;
+for(quantum=2; quantum<=42; quantum++) {
+  qqq = quantum*quantum*quantum;
+  if (qqq > NCol())  break;
+}
+quantum--;
+
 table = NULL;  
 tablenbin = 0;
@@ -39,22 +56,45 @@
 delete[] table;
 }
+/* --Methode-- */
+void LUT::SetNCol(unsigned short ncol)
+{
+if (ncol == NCol())  return;
+double min = Min();
+double max = Max();
+if (bornes) delete[] bornes;
+int nlev = ncol-2;
+if (nlev < 1)  nlev = 1;
+bornes = new double[nlev+1];
+nLevel = nlev;
+int qqq = 1;
+quantum = 1;
+for(quantum=2; quantum<=42; quantum++) {
+  qqq = quantum*quantum*quantum;
+  if (qqq > NCol())  break;
+}
+quantum--;
+// printf("*DBG*LUT* quantum= %d \n", (int)quantum);
+SetLut(min, max, Type());
+}
 
 /* --Methode-- */
-void LUT::SetLut(double min, double max, int typ, int ntable)
+void LUT::SetLut(double min, double max, int typ)
 {
 
 if(  (typ != kLutType_Lin)  && (typ != kLutType_Log)
-  && (typ != kLutType_Sqrt) && (typ != kLutType_Square)
-  )  typ = kLutType_Lin;
+  && (typ != kLutType_Sqrt) && (typ != kLutType_Square)  
+  && (typ != kLutType_RGB) )  typ = kLutType_Lin;
 type = typ;
 if (max <= min)  max = min+1.;
+mMin = min;  mMax = max;
+mMinI = (int)(min+0.1);  mMaxI = (int)(max+0.1);
 if (nLevel > 0)
   {
   int i;
-  double dx;
-  double dlx;
+  double dx, dlx, fmx;
   switch (typ)
     {
     case kLutType_Lin :
+    case kLutType_RGB :
       dx = (max-min)/(double)nLevel;
       for(i=0; i<nLevel; i++)
@@ -62,7 +102,13 @@
       break;
     case kLutType_Log :
-      dlx = log(max-min) / (double)nLevel;
+      fmx = (max-min)/(exp(1.)-1.);
+      dlx = 1./(double)nLevel;
       for(i=0; i<nLevel; i++)
-        bornes[i] = min+(double)exp((double)i*dlx);
+        bornes[i] = min+((double)exp((double)i*dlx)-1.)*fmx;
+      break;
+    case kLutType_Exp :
+      dlx = (exp(1.)-1.)/(double)nLevel;
+      for(i=0; i<nLevel; i++)
+        bornes[i] = min+(double)log(1.+(double)i*dlx)*(max-min);
       break;
     case kLutType_Sqrt :
@@ -84,5 +130,6 @@
   }
 else  bornes[0] = 0.5*(min+max);
-ComputeTable((ntable > nLevel) ? ntable : tablenbin);
+// ComputeTable((ntable > nLevel) ? ntable : tablenbin);
+if (type != kLutType_RGB) ComputeTable(0);
 return; 
 }
@@ -101,5 +148,5 @@
 
 /* --Methode-- */
-unsigned short LUT::Apply(double x)
+unsigned short LUT::ApplyI(double x)
 {
 int i;
@@ -110,12 +157,32 @@
 
 /* --Methode-- */
+unsigned short LUT::ApplyRGB(double x)
+{
+  long lv = x+0.3;
+  int r = (lv%256);
+  lv /= 256;
+  int g = (lv%256);
+  lv /= 256;
+  int b = (lv%256);
+  return (unsigned short)((Contraste(b)*quantum+Contraste(g))*quantum+Contraste(r));
+}
+
+/* --Methode-- */
 void LUT::ComputeTable(int nt)
 {
-if (nt <= 0) nt = 16*(nLevel+2);
+if (nt <= 0) { 
+  int fm = 16;
+  if ((nLevel+2)>4096) fm = 1;
+  else if ((nLevel+2)>2048) fm = 2;
+  else if ((nLevel+2)>1024) fm = 4;
+  else if ((nLevel+2)>512) fm = 8;
+  nt = fm*(nLevel+2);
+}
 else if (nt < (nLevel+2))  nt = (nLevel+2);
 tablenbin = nt;
+if (table) delete[] table;
 table = new unsigned short [nt-2];
 tablebinwidth = (Max()-Min())/(nt-2);
 double x = Min()+0.5*tablebinwidth;
-for(int i=0; i<nt-2; i++)  { table[i] = Apply(x); x += tablebinwidth; }
+for(int i=0; i<nt-2; i++)  { table[i] = ApplyI(x); x += tablebinwidth; }
 }
Index: /trunk/SophyaPI/PI/lut.h
===================================================================
--- /trunk/SophyaPI/PI/lut.h	(revision 4082)
+++ /trunk/SophyaPI/PI/lut.h	(revision 4083)
@@ -13,5 +13,5 @@
 
 // Type de lut possibles 
-enum {kLutType_Lin=1, kLutType_Log=2, kLutType_Sqrt=3, kLutType_Square=4};
+enum {kLutType_Lin=1, kLutType_Log=2, kLutType_Exp=3, kLutType_Sqrt=4, kLutType_Square=5, kLutType_RGB=11 };
 
 class LUT 
@@ -19,11 +19,36 @@
 public:
   
-  LUT(double min, double max, unsigned short ncol=16, int typ=kLutType_Lin, int ntable=0);
+  LUT(double min, double max, unsigned short ncol=16, int typ=kLutType_Lin);
   ~LUT();
-  void SetLut(double min, double max, int typ=kLutType_Lin, int ntable=0);
+  void SetNCol(unsigned short ncol);
+  void SetLut(double min, double max, int typ=kLutType_Lin);
   void Print();
-  unsigned short Apply(double x);
+
+  inline unsigned short Apply(double x)
+    { 
+    if (type == kLutType_RGB) return ApplyRGB(x); 
+    else return ApplyI(x);	
+    } 
+
   inline unsigned short ApplyFast(double x)
     { 
+    if (type == kLutType_RGB) return ApplyRGB(x); 
+    else return AppFast(x);	
+    } 
+
+
+  inline double Min() { return(bornes[0]); };
+  inline double Max() { return(bornes[nLevel]); };
+  inline double Borne(int k) { return(bornes[k]); };
+  inline int Type() { return(type); };
+  inline int NCol() { return(nLevel+2); };
+
+
+protected:
+  void ComputeTable(int nt);
+  unsigned short ApplyI(double x);
+  unsigned short ApplyRGB(double x);
+  inline unsigned short AppFast(double x)
+    {
     if (x < Min())  return(0);
     if (x >= Max() )  return(nLevel+1);  
@@ -31,16 +56,16 @@
     return(table[k]); 
     } 
-
-  inline double Min() { return(bornes[0]); };
-  inline double Max() { return(bornes[nLevel]); };
-  inline int Type() { return(type); };
-  inline int NCol() { return(nLevel+2); };
-
-protected:
-  void ComputeTable(int nt);
-
+  inline int  Contraste(int ii)   /* for ApplyRGB */
+    {
+    if (ii >= mMaxI) return quantum-1;
+    if (ii <= mMinI) return 0;
+    else return ((ii-mMinI)*(quantum-1)/mMaxI);
+    }	  
   int type;
   int nLevel;
+  int quantum;
   double * bornes;
+  double mMin, mMax;
+  int mMinI, mMaxI;
   int tablenbin;
   unsigned short * table;
Index: /trunk/SophyaPI/PI/parradapter.cc
===================================================================
--- /trunk/SophyaPI/PI/parradapter.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/parradapter.cc	(revision 4083)
@@ -174,4 +174,19 @@
 
 /* --Methode-- */
+double  P2DArrayAdapter::MeanVal(int ix1, int ix2, int jy1, int jy2)
+{
+int ec;
+if (ix1>ix2) { ec=ix1; ix1=ix2; ix2=ec; }
+if (jy1>jy2) { ec=jy1; jy1=jy2; jy2=ec; }    
+// On calcule la somme des pixels dans la zone
+double ss = 0.;
+for(int j=jy1; j<=jy2; j++) 
+  for(int i=ix1; i<=ix2; i++)  ss += Value(i,j);
+
+ss /= (double)((jy2-jy1+1)*(ix2-ix1+1));
+return ss;  
+}   
+
+/* --Methode-- */
 void P2DArrayAdapter::XYfromxy(int ix, int iy, double& x, double& y)
 {
@@ -187,5 +202,5 @@
   double x,y;
   this->Coord(ix, iy, x, y);
-  char * isr = "";
+  const char * isr = "";
   if (ISFunc != NULL)  isr = ISFunc(this, ix, iy);
   sprintf(ibuff,"X= %g Y= %g  Pix= %g %s   ", 
@@ -433,13 +448,11 @@
 
 /* --Methode-- */
-unsigned char * P2DArrayAdapter::ComputePixmap(LUT* lut, int ofx, int ofy, int zm, 
-                int xwsz, int ywsz, unsigned char * opix, int * oxsp, int * oysp)
+void P2DArrayAdapter::ComputePixmap(LUT* lut, int ofx, int ofy, int zm, 
+                                    int xwsz, int ywsz, PIPixColIdx & pixc)
 {
 // TIMEF ; 
-unsigned char *pix, *pp, ucp;
 int zmm=1;
-int npx, npy, nppx, nppy, nszp, oszp;
+int npx, npy, nppx, nppy;
 int i,j,k,l;
-double vpx;
 
 /*
@@ -448,6 +461,7 @@
 */
 
-if ( (XSize() <= 0) || (YSize() <= 0) || (lut == NULL) || (ofx < 0) || (ofy < 0) ) 
-  { *oxsp = *oysp = 0; return(NULL); }
+if ( (XSize() <= 0) || (YSize() <= 0) || (lut == NULL) || (ofx < 0) || (ofy < 0) ) {
+  pixc.DeAlloc();  return; 
+}
 
 npx = XSize()-ofx;
@@ -471,21 +485,18 @@
   }
 
-oszp = (*oxsp)*(*oysp);
-nszp = nppx*nppy;
-if ( oszp != nszp )
-  {
-  if (opix)  delete[] opix;
-  pix = new unsigned char[nppx*nppy];
-  if (pix == NULL)  { *oxsp = *oysp = 0; ; return(NULL); }
-  }
-else  pix = opix;
-*oxsp = nppx; *oysp = nppy;
-
+
+/* printf("Debug_ComputePixmap %d %d %d (%d-%d %d-%d)\n", 
+      ofx, ofy, zm, npx,nppx, npy,nppy); */
+if (lut->NCol() <= 256) {  // On fait un pixmap de type Byte/pixel 
 /*
-printf("Debug_ComputePixmap %d %d %d (%d-%d %d-%d)\n", 
-      ofx, ofy, zm, npx,nppx, npy,nppy);
-*/
-
-pp = pix;
+printf("Debug_ComputePixmap- pixc.AllocateByte() type=%d - %d %d %d - %d %d %d - %d %d %d \n",
+  lut->Type(), 
+  lut->ApplyFast(0.), lut->ApplyFast(1.), lut->ApplyFast(2.), 
+  lut->ApplyRGB(0.), lut->ApplyRGB(1.), lut->ApplyRGB(2.), 
+  lut->Apply(0.), lut->Apply(1.), lut->Apply(2.));
+*/  
+unsigned char *pp, ucp;
+pixc.AllocateByte(nppx, nppy);
+pp = pixc.BytePointer();
 if (eXY) { // Echange Axe X,Y 
   if (zm == 1)  {  // Pas de zoom  
@@ -497,14 +508,10 @@
     }
   else if (zm < -1) {       // Compression 
-    double fv = (double)(zmm*zmm); 
     for(j=ofy; j<ofy+npy; j+=zmm)
-      for(i=ofx; i<ofx+npx; i+=zmm) {
-        vpx = 0;
-        for(l=0; l<zmm; l++)
-          for(k=0; k<zmm; k++)
-            vpx += this->Value( (j+l)*sgnX+offX, (i+k)*sgnY+offY);
-        *pp = (unsigned char) lut->ApplyFast(vpx/fv); 
+      for(i=ofx; i<ofx+npx; i+=zmm) { 
+        *pp = lut->ApplyFast( MeanVal(j*sgnX+offX, (j+zmm-1)*sgnX+offX, 
+                                      i*sgnY+offY, (i+zmm-1)*sgnY+offY) );
         pp++;
-        }
+      }
     }
   else  {      // Agrandissement
@@ -513,5 +520,5 @@
         ucp = (unsigned char) lut->ApplyFast(this->Value(j*sgnX+offX, i*sgnY+offY));
         for(l=0; l<zm; l++)  {
-          pp = pix+((j-ofy)*zm+l)*nppx+((i-ofx)*zm);
+          pp = pixc.BytePointer()+((j-ofy)*zm+l)*nppx+((i-ofx)*zm);
           for(k=0; k<zm; k++)  { *pp = ucp; pp++; }  
 	  }
@@ -528,14 +535,10 @@
     }
   else if (zm < -1) {       // Compression 
-    double fv = (double)(zmm*zmm); 
     for(j=ofy; j<ofy+npy; j+=zmm)
       for(i=ofx; i<ofx+npx; i+=zmm) {
-        vpx = 0;
-        for(l=0; l<zmm; l++)
-          for(k=0; k<zmm; k++)
-            vpx += this->Value( (i+k)*sgnX+offX, (j+l)*sgnY+offY);
-        *pp = (unsigned char) lut->ApplyFast(vpx/fv); 
+        *pp = lut->ApplyFast( MeanVal(i*sgnX+offX, (i+zmm-1)*sgnX+offX, 
+                                      j*sgnY+offY, (j+zmm-1)*sgnY+offY) );
         pp++;
-        }
+      }
     }
   else  {      // Agrandissement
@@ -544,5 +547,5 @@
         ucp = (unsigned char) lut->ApplyFast(this->Value(i*sgnX+offX, j*sgnY+offY));
         for(l=0; l<zm; l++)  {
-          pp = pix+((j-ofy)*zm+l)*nppx+((i-ofx)*zm);
+          pp = pixc.BytePointer()+((j-ofy)*zm+l)*nppx+((i-ofx)*zm);
           for(k=0; k<zm; k++)  { *pp = ucp; pp++; }  
 	  }
@@ -550,5 +553,65 @@
     }
   }
-return(pix);
+}  //  ---- Fin pixmap de type Byte
+else {  // On fait un pixmap de type short/pixel 
+// printf("Debug_ComputePixmap- pixc.AllocateShort() \n");
+unsigned short *pp, ucp;
+pixc.AllocateShort(nppx, nppy);
+pp = pixc.ShortPointer();
+if (eXY) { // Echange Axe X,Y 
+  if (zm == 1)  {  // Pas de zoom  
+    for(j=ofy; j<ofy+npy; j++)
+      for(i=ofx; i<ofx+npx; i++) {
+        *pp = lut->ApplyFast(this->Value(j*sgnX+offX, i*sgnY+offY));  pp++; 
+      }
+    }
+  else if (zm < -1) {       // Compression 
+    for(j=ofy; j<ofy+npy; j+=zmm)
+      for(i=ofx; i<ofx+npx; i+=zmm) { 
+        *pp = lut->ApplyFast( MeanVal(j*sgnX+offX, (j+zmm-1)*sgnX+offX, 
+                                      i*sgnY+offY, (i+zmm-1)*sgnY+offY) );
+        pp++;
+      }
+    }
+  else  {      // Agrandissement
+    for(j=ofy; j<ofy+npy; j++)
+      for(i=ofx; i<ofx+npx; i++)  {
+        ucp = lut->ApplyFast(this->Value(j*sgnX+offX, i*sgnY+offY));
+        for(l=0; l<zm; l++)  {
+          pp = pixc.ShortPointer()+((j-ofy)*zm+l)*nppx+((i-ofx)*zm);
+          for(k=0; k<zm; k++)  { *pp = ucp; pp++; }  
+	  }
+        }
+    }
+  }     // Fin du cas avec echange d'axe X/Y 
+else {
+  if (zm == 1)  {  // Pas de zoom  
+    for(j=ofy; j<ofy+npy; j++)
+      for(i=ofx; i<ofx+npx; i++) {
+        *pp = lut->ApplyFast(this->Value(i*sgnX+offX, j*sgnY+offY));  pp++; 
+      }
+    }
+  else if (zm < -1) {       // Compression 
+    for(j=ofy; j<ofy+npy; j+=zmm)
+      for(i=ofx; i<ofx+npx; i+=zmm) {
+        *pp = lut->ApplyFast( MeanVal(i*sgnX+offX, (i+zmm-1)*sgnX+offX, 
+                                      j*sgnY+offY, (j+zmm-1)*sgnY+offY) );
+        pp++;
+      }
+    }
+  else  {      // Agrandissement
+    for(j=ofy; j<ofy+npy; j++)
+      for(i=ofx; i<ofx+npx; i++)  {
+        ucp = lut->ApplyFast(this->Value(i*sgnX+offX, j*sgnY+offY));
+        for(l=0; l<zm; l++)  {
+          pp = pixc.ShortPointer()+((j-ofy)*zm+l)*nppx+((i-ofx)*zm);
+          for(k=0; k<zm; k++)  { *pp = ucp; pp++; }  
+	  }
+        }
+    }
+  }
+}  //  ---- Fin pixmap de type Byte
+
+return;
 }
 
Index: /trunk/SophyaPI/PI/parradapter.h
===================================================================
--- /trunk/SophyaPI/PI/parradapter.h	(revision 4082)
+++ /trunk/SophyaPI/PI/parradapter.h	(revision 4083)
@@ -9,4 +9,5 @@
 #include "machdefs.h"
 #include "lut.h"
+#include "pipixutils.h"
 
 #include <string> 
@@ -54,5 +55,7 @@
   virtual void    DefineXYCoordinates(double x0, double y0, double dx, double dy);
 // Doit etre defini par les classes derivees
-  virtual double  Value(int ix, int iy) = 0;   
+  virtual double  Value(int ix, int iy) = 0;
+// Peut etre redefini pour les classes derivees, pour une optimisation par exemple     
+  virtual double  MeanVal(int ix1, int ix2, int jy1, int jy2);   
 
   virtual void    XYfromxy(int ix, int iy, double& x, double& y);
@@ -89,7 +92,6 @@
 
 //    Calcul pixmap avec un LUT
-  virtual unsigned char * ComputePixmap(LUT* lut, int ofx, int ofy, int zm, 
-                           int xwsz, int ywsz, unsigned char * opix, 
-                           int * oxsp, int * oysp);
+  virtual void ComputePixmap(LUT* lut, int ofx, int ofy, int zm, 
+                             int xwsz, int ywsz, PIPixColIdx & pixc);
 
 //   Methode de decodage des options - Implementation par defaut ne fait rien
@@ -109,4 +111,6 @@
 };
 
+//  Adaptateur de tableau 1D pour pointeur de type T *
+
 template <class T> 
 class P1DAdapter : public P1DArrayAdapter {
@@ -126,4 +130,5 @@
 
 
+//  Adaptateur de tableau 2D pour pointeur de type T *
 template <class T> 
 class P2DAdapter : public P2DArrayAdapter {
@@ -134,7 +139,19 @@
 
   virtual 	  ~P2DAdapter() { if ( (aDel) && (mData) ) delete[] mData; }
-  virtual double   Value(int ix, int iy) 
+  virtual double  Value(int ix, int iy) 
                     {  if ( (ix < 0)  || (iy < 0) || (ix >= sX) || (iy >= sY) ) return(0.); 
                     return(mData[ix+iy*sX]); }
+  virtual double  MeanVal(int ix1, int ix2, int jy1, int jy2)  
+    {
+    int ec;
+    if (ix1>ix2) { ec=ix1; ix1=ix2; ix2=ec; }
+    if (jy1>jy2) { ec=jy1; jy1=jy2; jy2=ec; }    
+    double ss = 0.;
+    for(int j=jy1; j<=jy2; j++) 
+      for(int i=ix1; i<=ix2; i++)  ss += (double)(mData[i+j*sX]);
+    ss /= (double)((jy2-jy1+1)*(ix2-ix1+1));
+    return ss;  
+    }   
+
 protected :
   bool aDel;
@@ -142,4 +159,42 @@
 };
 
+//  Adaptateur de tableau 2D pour tableau RGB 
+
+class P2DPixRGBAdapter : public P2DArrayAdapter {
+public :
+          P2DPixRGBAdapter(PIPixRGBArray * rgbp, bool ad=false) :
+             P2DArrayAdapter(rgbp->XSize(), rgbp->YSize() )
+                { aDel = ad; mPix = rgbp; }
+  virtual ~P2DPixRGBAdapter() { if ( (aDel) && (mPix) ) delete mPix; }
+
+  virtual double  Value(int ix, int iy) 
+    {  
+    if ( (ix < 0)  || (iy < 0) || (ix >= sX) || (iy >= sY) ) return(0.); 
+    PIPixRGB rgb = (*mPix)(ix, iy);
+    return ( ((double)rgb.blue*256.+(double)rgb.green)*256.+(double)rgb.red );
+    }
+  virtual double  MeanVal(int ix1, int ix2, int jy1, int jy2)  
+    {
+    int ec;
+    if (ix1>ix2) { ec=ix1; ix1=ix2; ix2=ec; }
+    if (jy1>jy2) { ec=jy1; jy1=jy2; jy2=ec; }    
+    int r = 0;
+    int g = 0;
+    int b = 0;
+    for(int j=jy1; j<=jy2; j++) 
+      for(int i=ix1; i<=ix2; i++)  {
+      	PIPixRGB rgb = (*mPix)(i, j);
+      	r += rgb.red;  g += rgb.green;   b += rgb.blue; 
+      }
+    int n = (jy2-jy1+1)*(ix2-ix1+1);   
+    r /= n; g /= n; b /= n;
+    return ( ((double)b*256.+(double)g)*256.+(double)r );  
+    }   
+                    
+protected :
+  bool aDel;
+  PIPixRGBArray* mPix;
+};
+
 
 
Index: /trunk/SophyaPI/PI/pi3dwdg.cc
===================================================================
--- /trunk/SophyaPI/PI/pi3dwdg.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pi3dwdg.cc	(revision 4083)
@@ -224,6 +224,6 @@
   double ymin = mBDrw->ScaleY( mBDrw->YMin3() );
   double ymax = mBDrw->ScaleY( mBDrw->YMax3() );
-  double zmin = mBDrw->ScaleY( mBDrw->ZMin3() );
-  double zmax = mBDrw->ScaleY( mBDrw->ZMax3() );
+  double zmin = mBDrw->ScaleZ( mBDrw->ZMin3() );
+  double zmax = mBDrw->ScaleZ( mBDrw->ZMax3() );
   bool asxy = mBDrw->isAutoScaleXY();
   bool asz = mBDrw->isAutoScaleZ();
Index: /trunk/SophyaPI/PI/piapplgen.cc
===================================================================
--- /trunk/SophyaPI/PI/piapplgen.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/piapplgen.cc	(revision 4083)
@@ -54,4 +54,7 @@
 #include "sopnamsp.h"
 #include "piapplgen.h"
+#include <stdlib.h>
+#include <iostream>
+#include "pidrawer.h"
 
 // Variable qui contient le pointeur de l'application courante
@@ -62,5 +65,17 @@
 :topcont(NULL), menubar(NULL), mState(0)
 {
-curapp = this;   
+  curapp = this;   
+// Si la variable d'environnement PIDEFAFSZFRAC est definie, on modifie 
+// la taille par defaut de AutoFontSizeFrac
+  char *envafsz = getenv("PIDEFAFSZFRAC");
+  if (envafsz) {
+    double fsfr = atof(envafsz);
+    if ((fsfr>0.)&&(fsfr<1.)) {
+      PIDrawer::SetGlDefAutoFontSizeFrac(fsfr);
+      cout << " PIApplicationGen()/Info: getenv(PIDEFAFSZFRAC)=" << envafsz << endl;
+      cout << "  ... Set Global Default PIDrawer AutoFontSizeFrac to " 
+           << PIDrawer::GetGlDefAutoFontSizeFrac() << endl;
+      }
+  }
 }
 
Index: /trunk/SophyaPI/PI/piapplx.cc
===================================================================
--- /trunk/SophyaPI/PI/piapplx.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/piapplx.cc	(revision 4083)
@@ -43,5 +43,5 @@
 class PITopContAppX : public PIContainer {
 public :
-	    	PITopContAppX(PIContainer *par, char *nom, PIWdg* topw,
+	    	PITopContAppX(PIContainer *par, const char *nom, PIWdg* topw,
                           int sx=10, int sy=10, int px=0, int py=0);
    virtual  	~PITopContAppX(); 
@@ -55,5 +55,5 @@
 
 /* --Methode-- */
-PITopContAppX::PITopContAppX(PIContainer *par, char *nom, PIWdg* topw, int sx, int sy, int px, int py)
+PITopContAppX::PITopContAppX(PIContainer *par, const char *nom, PIWdg* topw, int sx, int sy, int px, int py)
         : PIContainer(par, nom, (sx>10)?sx:10, (sy>10)?sy:10, px, py)
 {
@@ -144,6 +144,5 @@
 if (sx < sxt)  sx = sxt;
 if (sy < 10) sy = 10;
-topcont = new PITopContAppX(MBCont(), "TopLevelCont", topwdg, 
-                            sx, sy, 0, msy);
+topcont = new PITopContAppX(MBCont(), "TopLevelCont", topwdg,sx, sy, 0, msy);
 MBCont()->Show();
 //DBG printf("PIApplicationX-DBG2:: MBContSize=%d %d \n", MBCont()->XSize(), MBCont()->YSize());
@@ -289,5 +288,7 @@
 {
 int szf;
+ printf("XtAppContext* PIXtAppCtx :szx=%d szy=%d szf=%d\n",szx,szy,szf);
 PIXtAppCtx(szx, szy, szf);
+ printf("XtAppContext* PIXtAppCtx :szx=%d szy=%d szf=%d\n",szx,szy,szf);
 return;
 }
Index: /trunk/SophyaPI/PI/piaxes.cc
===================================================================
--- /trunk/SophyaPI/PI/piaxes.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/piaxes.cc	(revision 4083)
@@ -11,4 +11,5 @@
 #include <math.h>
 #include "piaxes.h"
+#include "pidrawer.h"
 
 //++
@@ -41,5 +42,5 @@
 {
   ConfigureTicks();
-  ConfigureAutoFontSize();
+  ConfigureAutoFontSize(true, PIDrawer::GetGlDefAutoFontSizeFrac());
   ConfigureAxesCenter();
   setupDone = false;
@@ -53,5 +54,5 @@
 //++
 // void  DrawXYAxes(PIGraphicUC* g, PIGraphicAtt& gratt, \
-//                  unsigned int flags=kAxesDflt, bool afsz=true)
+//                  unsigned int flags, bool afsz, double fszf)
 //	Trace les axes en utilisant les limites de l'objet PIGraphicUC. 
 //	"flags" spécifie les attributs d'axes. Constantes prédéfinies: 
@@ -64,10 +65,18 @@
 //|	      kBoxAxes | kTicks | | kIntTicks | kLabels
 //|	kGridOn, kAxesNone
-//	Si "afsz == true", la taille de fonte est choisie automatiquement.
+//	Si "afsz == true", la taille de fonte est choisie automatiquement avec "fszf" 
+//	representant la taille de fonte en fraction de (ymax-ymin)
+//
+// void DrawXYAxes(PIGraphicUC* g, PIGraphicAtt& gratt, unsigned int flags=kAxesDflt)
+//        Appel de DrawXYAxes avec les parametres "axesAFSz. fontSz" de l'objet.
 //
 // void DrawXYAxes(PIGraphicUC* g, PIGraphicAtt& gratt, \
 //        double xmin, double xmax, double ymin, double ymax, \
-//        unsigned int flags=kAxesDflt, bool afsz=true)
+//        unsigned int flags, bool afsz, double )
 //	Tracé d'axes avec spécification des limites d'axes.
+//
+// void DrawXYAxes(PIGraphicUC* g, PIGraphicAtt& gratt, \
+//        double xmin, double xmax, double ymin, double ymax, unsigned int flags=kAxesDflt) 
+//        Appel de DrawXYAxes avec les parametres "axesAFSz. fontSz" de l'objet.
 //
 // void DrawXCaption(PIGraphicUC* g, string const& xLabel, PIGraphicAtt const& att)
@@ -79,10 +88,10 @@
 /* --Methode-- */
 void PIAxes::DrawXYAxes(PIGraphicUC* g, PIGraphicAtt& gratt, 
-			unsigned int flags, bool afsz)
+			unsigned int flags, bool afsz, double fszf)
 {
   PIGrCoord xmin, xmax, ymin, ymax;
   g->GetGrSpace(xmin, xmax, ymin, ymax);
   DrawXYAxes(g, gratt, (double)xmin, (double)xmax, 
-	     (double)ymin, (double)ymax, flags, afsz);
+	     (double)ymin, (double)ymax, flags, afsz, fszf);
 }
 
@@ -90,5 +99,5 @@
 void PIAxes::DrawXYAxes(PIGraphicUC* g, PIGraphicAtt& gratt, 
 			double xmin, double xmax, double ymin, double ymax,
-			unsigned int flags, bool afsz)
+			unsigned int flags, bool afsz, double fszf)
 
 {
@@ -107,5 +116,5 @@
 
   if(afsz) { 
-    double fsz = (yMax-yMin)*fontSz;
+    double fsz = (yMax-yMin)*fszf;
     g->SelFontSz(fsz);
   }
@@ -314,6 +323,6 @@
 //	(X/Y max-min). Les paramètres ne sont pas changés si des valeurs
 //	négatives ou nulles sont spécifiées.
-// void ConfigureAutoFontSize(double fszf=0.0125)
-//	Configuration de la taille de fonte, en mode AutoFontSize.
+// void ConfigureAutoFontSize(bool afsz=true, double fszf=0.04)
+//	Configuration de la taille de fonte, en mode AutoFontSize ou FixedFontSize.
 //	La taille est exprimée en fraction de la taille totale YMax-Min
 // void  ConfigureAxesCenter(bool fset,double x0,double y0)
@@ -332,6 +341,7 @@
 
 /* --Methode-- */
-void PIAxes::ConfigureAutoFontSize(double fszf)
-{
+void PIAxes::ConfigureAutoFontSize(bool afsz, double fszf)
+{
+  axesAFSz = afsz;
   if (fszf > 1.e-19) fontSz = fszf;
 }
@@ -420,5 +430,10 @@
     //Attention erreur d'arrondi x->0 (on code 5.1698e-26 au lieu de 0)
     double xx = (fabs(xticks[i]/xstep)<1.e-5) ? 0.: xticks[i];
-    sprintf(label,format.c_str(),xx/fac); Arrange_Label(label);
+    double dog = fabs(xx/fac);
+    if ((dog<=1.e-5)||(dog>=1.e5))  
+      sprintf(label,"%le",xx/fac);
+    else 
+      sprintf(label,format.c_str(),xx/fac); 
+    Arrange_Label(label);
     double largeur = g->CalcStringWidth(label);
     g->DUC2GrC(largeur,0.,largpix,dum);
@@ -463,5 +478,10 @@
     if(yticks[i]>yMax) break;
     double yy = (fabs(yticks[i]/ystep)<1.e-5) ? 0.: yticks[i];
-    sprintf(label,format.c_str(),yy/fac); Arrange_Label(label);
+    double dog = fabs(yy/fac);
+    if ((dog<=1.e-5)||(dog>=1.e5))  
+      sprintf(label,"%le",yy/fac);
+    else 
+      sprintf(label,format.c_str(),yy/fac); 
+    Arrange_Label(label);
     g->UC2GrC(x,yticks[i],dum,ypixdeb);   ypixdeb -= hautpix/2.;
     // -- Attention: ypix=0 est en haut de l'ecran
@@ -478,5 +498,5 @@
   if(npuiss!=0) {
     if(aYdir) hauteur = -hauteur; 
-    double ym = (aYdir)? yMin: yMax; ym = g->DeltaUCY(ym,0.5*hauteur);
+    double ym = (aYdir)? yMin: yMax; ym = g->DeltaUCY(ym,0.25*hauteur);
     sprintf(label,"%d",npuiss);
     g->DrawCompString(x,ym,"x 10",label,NULL,PI_VerticalBottom|just);
Index: /trunk/SophyaPI/PI/piaxes.h
===================================================================
--- /trunk/SophyaPI/PI/piaxes.h	(revision 4082)
+++ /trunk/SophyaPI/PI/piaxes.h	(revision 4083)
@@ -40,11 +40,15 @@
 
   virtual void      DrawXYAxes(PIGraphicUC* g, PIGraphicAtt& gratt, 
-			       unsigned int flags=kAxesDflt, bool afsz=true);
+			       unsigned int flags, bool afsz, double fszf);
+  inline  void      DrawXYAxes(PIGraphicUC* g, PIGraphicAtt& gratt, unsigned int flags=kAxesDflt)
+     { DrawXYAxes(g, gratt, flags, axesAFSz, fontSz); }
 
   virtual void      DrawXYAxes(PIGraphicUC* g, PIGraphicAtt& gratt, 
 			       double xmin, double xmax, 
 			       double ymin, double ymax,
-			       unsigned int flags=kAxesDflt, bool afsz=true);
-
+			       unsigned int flags, bool afsz, double fszf);
+  inline void       DrawXYAxes(PIGraphicUC* g, PIGraphicAtt& gratt, 
+			       double xmin, double xmax, double ymin, double ymax, unsigned int flags=kAxesDflt)
+    {   DrawXYAxes(g, gratt, xmin, xmax, ymin, ymax, flags, axesAFSz, fontSz); }
 
   virtual void      DrawXCaption(PIGraphicUC* g, PIGraphicAtt& att, unsigned int flags,
@@ -56,5 +60,6 @@
   void  ConfigureTicks(int ntickx=10, int nticky=12, 
 		       double majtl=0.016, double mintl=0.01);
-  void  ConfigureAutoFontSize(double fszf=0.04);
+  //  Choix de taille automatique de fontes 
+  void  ConfigureAutoFontSize(bool afsz=true, double fszf=0.04);
   void  ConfigureAxesCenter(bool fset=false,double x0=0.,double y0=0.);
 
@@ -91,5 +96,5 @@
   bool   aXdir, aYdir;           // Sens des axes horiz, vertical 
   bool   aXlog, aYlog;           // Echelle log pour les axes horiz, vertical 
-  bool   axesAFSz;
+  bool   axesAFSz;               // true -> AutoFontSize
   
   int xNTicks, yNTicks;             // Nb de ticks en X, Y
Index: /trunk/SophyaPI/PI/piaxestools.cc
===================================================================
--- /trunk/SophyaPI/PI/piaxestools.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/piaxestools.cc	(revision 4083)
@@ -237,5 +237,5 @@
   mCkb[3]->SetState(scd->isLogScaleX());
   mCkb[4]->SetState(scd->isLogScaleY());
-  mCkb[7]->SetState(scd->BaseDrawer()->isAxesAutoFontSize());
+  mCkb[7]->SetState(scd->BaseDrawer()->GetAutoFontSizeState());
   }
 else {
@@ -312,5 +312,5 @@
 
   scd->SetLogScale(mCkb[3]->GetState(), mCkb[4]->GetState() );
-  scd->BaseDrawer()->SetAxesAutoFontSize(mCkb[7]->GetState() );
+  scd->BaseDrawer()->ConfigureAutoFontSize(mCkb[7]->GetState(), -1);
   if (refr) scd->Refresh();
   return;
Index: /trunk/SophyaPI/PI/pibwdgx.cc
===================================================================
--- /trunk/SophyaPI/PI/pibwdgx.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pibwdgx.cc	(revision 4083)
@@ -39,5 +39,5 @@
 CreateXtWdg(nom, piXtBaseWidgetClass, NULL, sx, sy, px, py);
 
-XtSetArg(wargs[0],PIXNobject,this); 
+XtSetArg(wargs[0],const_cast<char*>(PIXNobject),this); 
 XtSetArg(wargs[1],XtNbackground, colpixwhite);  
 XtSetArg(wargs[2],XtNborderWidth, (Dimension)0);  
@@ -72,5 +72,5 @@
 #endif
 Arg  wargs[2];
-XtSetArg(wargs[0],PIXNobject,NULL); 
+ XtSetArg(wargs[0],const_cast<char*>(PIXNobject),NULL); 
 XtSetValues(XtWdg(), wargs, 1);
 }
Index: /trunk/SophyaPI/PI/picmap.cc
===================================================================
--- /trunk/SophyaPI/PI/picmap.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/picmap.cc	(revision 4083)
@@ -6,4 +6,5 @@
 #include "picmap.h"
 #include <iostream>
+
 
 //++
@@ -24,9 +25,10 @@
 //--
 
-#define  MXMAPIDS   30
+#define  MXMAPIDS   34
 static   int    MapNCols[MXMAPIDS] = {
   256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
   256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 
-  256, 256, 256, 256, 256, 256, 256, 256, 256, 256  };
+  256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+  216, 512, 4096, 32768  };
 
 // Tables de couleurs :
@@ -37,4 +39,8 @@
 // 1 Standard PI 64 couleurs differentes
 // 1 Standard PI 16 couleurs
+// 1 Standard PI , 216 couleurs RGB (6x6x6)
+// 1 Standard PI , 512 couleurs RGB (8x8x8)
+// 1 Standard PI , 4096 couleurs RGB (16x16x16)
+// 1 Standard PI , 32768 couleurs RGB (32x32x32)
 
 static   const char*  MapNoms[MXMAPIDS]  = {
@@ -47,5 +53,6 @@
                       "MIDAS_Stairs9","MIDAS_StairCase","MIDAS_Color",
                       "MIDAS_ManyCol","MIDAS_Idl14","MIDAS_Idl15",
-                      "MultiCol16","MultiCol64"};
+ 		      "MultiCol16","MultiCol64",
+                      "RGB216CM","RGB512CM","RGB4096CM","RGB32768CM"};
 
 static   CMapId MapIds[MXMAPIDS] = { 
@@ -58,5 +65,6 @@
                       CMAP_MIDAS_Stairs9, CMAP_MIDAS_StairCase, CMAP_MIDAS_Color, 
                       CMAP_MIDAS_ManyCol, CMAP_MIDAS_Idl14, CMAP_MIDAS_Idl15, 
-                      CMAP_COL16, CMAP_COL64 } ;
+                      CMAP_COL16, CMAP_COL64, 
+                      CMAP_RGB216, CMAP_RGB512, CMAP_RGB4096, CMAP_RGB32768} ;
 
 static   int mColTNums[8192];   // Max 8192 tables differentes pour le moment  
@@ -70,5 +78,6 @@
                                   NULL, NULL, NULL, NULL, NULL,
                                   NULL, NULL, NULL, NULL, NULL, 
-                                  NULL, NULL, NULL, NULL, NULL };
+                                  NULL, NULL, NULL, NULL, NULL,
+                                  NULL, NULL, NULL, NULL };
 
 int  PIColorMap::NumberStandardColorMaps()
@@ -122,6 +131,12 @@
 //|	CMAP_COL64      :  64 Couleurs arcenciel 
 //|	CMAP_OTHER      :  Table non standard 
+//|	CMAP_RGB216     :  216 couleurs, 6x6x6 couleurs en composantes RGB
+//|	CMAP_RGB512     :  512 couleurs, 8x8x8 couleurs en composantes RGB
+//|	CMAP_RGB4096    :  4096 couleurs, 16x16x16 couleurs en composantes RGB
+//|	CMAP_RGB4096    :  32768 couleurs, 32x32x32 couleurs en composantes RGB
+
 //	Toutes les tables de couleurs standard possèdent 256 cellules de couleurs,
-//	contenant 16 ou 32 ou 128 couleurs distinctes.
+//	contenant 16 ou 32 ou 128 (ou 216) couleurs distinctes, 
+//	sauf CMAP_RGB512 , CMAP_RGB4096 et CMAP_RGB32768.
 //
 // PIColorMap(string const& nom, int nCol)
@@ -144,5 +159,6 @@
 
    if (NMaxTableAuto == 0) { //  Il faut allouer les tables de depart
-     if ( TotNbColors() > 4096 ) NMaxTableAuto = MXMAPIDS-1;
+     if ( TotNbColors() >= 4096 ) NMaxTableAuto = MXMAPIDS-2;
+     if ( TotNbColors() >= 65536 ) NMaxTableAuto = MXMAPIDS-1;
      else NMaxTableAuto = 3; 
      //     for(k=0; k<NMaxTableAuto; k++)  { 
@@ -158,5 +174,5 @@
    for(kdx=0; kdx<MXMAPIDS; kdx++)  if (id == MapIds[kdx])  break;
    if (kdx == MXMAPIDS)  { id = MapIds[0];  kdx = 0; }
-   for(k=0; k<NMaxTableAuto; k++) {
+   for(k=0; k<=NMaxTableAuto; k++) {
      if ((MapIds[k] == id) && (mMaps[k] == NULL))  { //  Table pas encore alloue 
        mnom = MapNoms[k]; 
@@ -176,7 +192,12 @@
        if ( mMaps[k] ) {  
          mColTNums[mMaps[k]->mCTId] = 1;  // Je force a liberer les couleurs 
-         delete mMaps[k] ;
+         delete mMaps[k] ;   mMaps[k] = NULL;
+         mnom = MapNoms[k]; 
+         cout << " PIColorMap::PIColorMap(CMapId id) Freeing colors for ColorMap " 
+	      << mnom << " ... " << endl;
        }
        mnom = MapNoms[kdx];
+       cout << " PIColorMap::PIColorMap(CMapId id) Allocating ColorMap " 
+	     << mnom << " ... " << endl;
        mMaps[k] = new PIColorMap(MapIds[kdx],  MapNCols[kdx], mnom); 
      }
@@ -563,4 +584,44 @@
       }
       break;
+
+    case CMAP_RGB216 :
+      i = 0;
+      for(int kb=0; kb<6; kb++) {
+        mycol.blue = (unsigned short)(kb*65535/5);
+        for(int jg=0; jg<6; jg++) { 
+          mycol.green = (unsigned short)(jg*65535/5);
+          for(int ir=0; ir<6; ir++) {
+            mycol.red = (unsigned short)(ir*65535/5);
+            AllocColor(mycol, i);   i++;
+          }
+        }            
+      }
+      mycol.blue = mycol.green =  mycol.red = 65535;
+      for(i=216; i<256; i++)
+        AllocColor(mycol, i);
+      break;
+
+    case CMAP_RGB512 :
+    case CMAP_RGB4096 :
+    case CMAP_RGB32768 :
+      {
+      int nlev = 8;
+      if (mType == CMAP_RGB4096)  nlev = 16;
+      else if (mType == CMAP_RGB32768)  nlev = 32;
+      int drgb = 65535/(nlev-1);
+      i = 0;
+      for(int kb=0; kb<nlev; kb++) {
+        mycol.blue = (unsigned short)(kb*drgb);
+        for(int jg=0; jg<nlev; jg++) { 
+          mycol.green = (unsigned short)(jg*drgb);
+          for(int ir=0; ir<nlev; ir++) {
+            mycol.red = (unsigned short)(ir*drgb);
+            AllocColor(mycol, i);   i++;
+          }
+        }            
+      }
+      }
+      break;
+
 //----------------------------------------------------------
 //----------------------------------------------------------
Index: /trunk/SophyaPI/PI/picmap.h
===================================================================
--- /trunk/SophyaPI/PI/picmap.h	(revision 4082)
+++ /trunk/SophyaPI/PI/picmap.h	(revision 4083)
@@ -47,6 +47,11 @@
 
  //  Table simple a 16/64 couleurs 
- CMAP_COL16       = 998,        // 16 Couleurs arcenciel
- CMAP_COL64       = 999         // 64 Couleurs differentes
+ CMAP_COL16       = 991,        // 16 Couleurs arcenciel
+ CMAP_COL64       = 992,         // 64 Couleurs differentes
+ // Table de couleurs RGB 6x6x6=216 couleurs
+ CMAP_RGB216      = 993,        // 216 couleurs avec toutes les nuances RGB
+ CMAP_RGB512      = 994,        // 512 couleurs avec toutes les nuances RGB
+ CMAP_RGB4096     = 995,        // 4096 couleurs avec toutes les nuances RGB
+ CMAP_RGB32768    = 996         // 32768 couleurs avec toutes les nuances RGB
  };
 
Index: /trunk/SophyaPI/PI/picmapview.cc
===================================================================
--- /trunk/SophyaPI/PI/picmapview.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/picmapview.cc	(revision 4083)
@@ -5,5 +5,7 @@
 #include "sopnamsp.h"
 #include "picmapview.h"
+#include "strutil.h"
 #include <math.h>
+#include <iostream>
 
 //++
@@ -79,5 +81,8 @@
   if ( cmap && (cmp->Type() == cmap->Type()) && (cmp->Type() != CMAP_OTHER)
        && (cmp->IsColorIndexReversed() == cmap->IsColorIndexReversed())
-       && (fabs(vmin-min) < 1.e-69)  && (fabs(vmax-max) > -1.e-69) )  return;
+       && (fabs(vmin-min) < 1.e-69)  && (fabs(vmax-max) > -1.e-69) )  { 
+    if (refr)  Refresh();      
+    return;
+  }
   if (cmap) delete cmap;
   cmap = new PIColorMap(*cmp);
@@ -93,5 +98,8 @@
        (cmap->IsColorIndexReversed() == revidx) &&
        ((vmin-min) < 1.e-69) &&  ((vmin-min) > -1.e-69) &&
-       ((vmax-max) < 1.e-69) &&  ((vmax-max) > -1.e-69) )  return;
+       ((vmax-max) < 1.e-69) &&  ((vmax-max) > -1.e-69) )  { 
+    if (refr)  Refresh();      
+    return;
+  }
   if (cmap) delete cmap;
   cmap = new PIColorMap(cmapid);
@@ -117,9 +125,12 @@
 
   int k;
+  // On limite le nombre de carres de couleurs traces, si trop de couleur ...
+  int dk = cmap->NCol()/128;
+  if (dk<1) dk=1;
   if (sx > sy) {    // horizontal
     int xc, dx;
     xc = 0;
-    for(k=0; k<cmap->NCol(); k++) {
-      dx = (sx-xc)/(cmap->NCol()-k);
+    for(k=0; k<cmap->NCol(); k+=dk) {
+      dx = dk*(sx-xc)/(cmap->NCol()-k);
       g->SelForeground((*cmap), k);
       g->DrawFBox(xc, 0, dx+1, sy);
@@ -130,6 +141,6 @@
     int yc, dy;
     yc = sy;
-    for(k=0; k<cmap->NCol(); k++) {
-      dy = yc/(cmap->NCol()-k);
+    for(k=0; k<cmap->NCol(); k+=dk) {
+      dy = dk*yc/(cmap->NCol()-k);
       yc -= dy;
       g->SelForeground((*cmap), k);
@@ -177,7 +188,103 @@
 }
 
-
-
-
-
-
+//++
+// Class        PICMapDrawer
+// Lib          PI
+// include      picmapview.h
+//
+//      Classe de traceur de colormap 
+//--
+//++
+// Links        Parents
+// PIDrawer
+//--
+//++
+
+
+/* --Methode-- */
+PICMapDrawer::PICMapDrawer(bool fgvert)
+  : fgvert_(fgvert), fgtext_(false), cmapp(NULL), bornes_(5)   
+{
+  SetLimits(0.,1.,0.,1., kAxeDirLtoR, kAxeDirDownUp);
+  SetColMapId(CMAP_GREY32);
+}
+
+/* --Methode-- */
+PICMapDrawer::~PICMapDrawer()
+{
+}
+
+/* --Methode-- */
+void PICMapDrawer::SetBornes(LUT& lut)
+{
+  fgtext_=true;  
+  bornes_[0]=lut.Min();   bornes_[4]=lut.Max(); 
+  bornes_[1]=lut.Borne((lut.NCol()-2)/4);
+  bornes_[2]=lut.Borne((lut.NCol()-2)/2);
+  bornes_[3]=lut.Borne(3*(lut.NCol()-2)/4);
+  return;
+}
+
+/* --Methode-- */
+void PICMapDrawer::SetBornes(double min, double max)
+{
+  fgtext_=true;  
+  bornes_[0]=min;   bornes_[4]=max; 
+  bornes_[1]=min+(max-min)*0.25; 
+  bornes_[2]=min+(max-min)*0.5; 
+  bornes_[3]=min+(max-min)*0.75; 
+  return;
+}
+
+/* --Methode-- */
+void PICMapDrawer::Draw(PIGraphicUC* g, double /*xmin*/, double /*ymin*/, 
+                        double /*xmax*/, double /*ymax*/)
+{
+  PIColorMap* cmp=cmapp;
+  PIColorMap cmapi(cmapid_);
+  if (cmp==NULL)  cmp=&cmapi;
+  PIColorMap& cmap=(*cmp);
+
+  //  cout << " *DBG*PICMapDrawer::Draw() Sz:" << BWdgXSize() << "," << BWdgYSize() 
+  //     << " Pos:" << BWdgXPos() << "," << BWdgYPos() << endl; 
+  // On limite le nombre de carres de couleurs traces, si trop de couleur ...
+  PIPixColIdx pixc;
+  if (fgvert_) {   // vertical
+    pixc.AllocateByte(0.25*BWdgXSize(), BWdgYSize());
+    for(int j=0; j<pixc.YSize(); j++)  {
+      int ci = j*cmap.NCol()/pixc.YSize();
+      int jrev=pixc.YSize()-j-1;
+      for(int i=0; i<pixc.XSize(); i++) pixc.GetByte(i,jrev)=(unsigned char)ci;
+    }
+    g->DrawPixmap(0.,1.,pixc, cmp);
+  }
+  else {    // horizontal
+    pixc.AllocateByte(BWdgXSize(), 0.25*BWdgYSize());
+    for(int i=0; i<pixc.XSize(); i++)  {
+      int ci = i*cmap.NCol()/pixc.XSize();
+      for(int j=0; j<pixc.YSize(); j++) pixc.GetByte(i,j)=(unsigned char)ci;
+    }
+    g->DrawPixmap(0.,0.25,pixc, cmp);
+  }
+
+
+  if (!fgtext_) return;
+  char buff[32];
+  double ps[5]={0.025,0.25,0.5,0.75,0.975};
+  //  g->SelForeground(PI_White);
+  for(int k=0; k<5; k++) {
+    sprintf(buff,"%6.2lg",bornes_[k]);
+    strip(buff,'B',' ');
+    if (fgvert_) {   // vertical
+      g->DrawLine(0.25,ps[k],0.35,ps[k]);
+      g->DrawString(0.7, ps[k], buff, PI_TextDirectionVerticalUp|PI_HorizontalCenter|PI_VerticalCenter);
+    }
+    else {   // horizontal 
+      g->DrawLine(ps[k],0.25,ps[k],0.35);
+      g->DrawString(ps[k], 0.7, buff, PI_VerticalCenter|PI_HorizontalCenter);
+    }
+  }
+  return;
+}
+
+
Index: /trunk/SophyaPI/PI/picmapview.h
===================================================================
--- /trunk/SophyaPI/PI/picmapview.h	(revision 4082)
+++ /trunk/SophyaPI/PI/picmapview.h	(revision 4083)
@@ -11,4 +11,9 @@
 #include PIBWDG_H
 #include PICMAP_H
+
+#include "pidrawer.h"
+#include "lut.h"
+#include <vector>
+
 
 class PICMapView : public PIBaseWdg
@@ -38,4 +43,33 @@
 };
 
+class PICMapDrawer : public PIDrawer
+{
+public:
+                     PICMapDrawer(bool fgvert=false);
+                     ~PICMapDrawer();
+
+  virtual void       Draw(PIGraphicUC* g, double xmin, double ymin, double xmax, double ymax);
+  inline void        SetHorizontal()  { fgvert_=false; }
+  inline void        SetVertical()  { fgvert_=true; }
+
+  inline void        SetColMapId(CMapId cmapid, bool revcidx=false) 
+                     { cmapid_=cmapid;  revcidx_=revcidx;  cmapp=NULL;  return; }
+
+  inline void        SetColMap(PIColorMap* cmp) 
+                     { cmapp=cmp;  return; }
+
+  void               SetBornes(LUT& lut);
+  void               SetBornes(double min, double max);
+
+protected:
+
+  bool fgvert_;  // true -> vertical 
+  bool fgtext_;  // true -> ecriture des valeurs des bornes
+  PIColorMap* cmapp;  
+  CMapId cmapid_;
+  bool revcidx_;  // true -> reverse color map index 
+  vector<double> bornes_;  
+};
+
 
 #endif 
Index: /trunk/SophyaPI/PI/picmapx.cc
===================================================================
--- /trunk/SophyaPI/PI/picmapx.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/picmapx.cc	(revision 4083)
@@ -187,4 +187,5 @@
   mColRGB = new PIColor[mNCol];
   mNewCol = new bool[mNCol];
+  /*   Remplace par memcpy pour performances, Reza, Nov 2008
   for (int i=0; i<mNCol; i++)  
     { mColors[i] = ((PIColorMapX *)x)->mColors[i];
@@ -192,3 +193,8 @@
 // C'est la table de couleur originale qui est responsable de liberer les couleurs - Reza 8/2/98
     mNewCol[i] = false; }  
-}
+  -> memcpy (Nov08) */
+  memcpy(mColors, ((PIColorMapX *)x)->mColors, sizeof(PIXColor)*mNCol);
+  memcpy(mColRGB, ((PIColorMapX *)x)->mColRGB, sizeof(PIColor)*mNCol);
+// C'est la table de couleur originale qui est responsable de liberer les couleurs - Reza 8/2/98
+  for (int i=0; i<mNCol; i++)   mNewCol[i] = false;
+}
Index: /trunk/SophyaPI/PI/picontainergen.h
===================================================================
--- /trunk/SophyaPI/PI/picontainergen.h	(revision 4082)
+++ /trunk/SophyaPI/PI/picontainergen.h	(revision 4083)
@@ -51,6 +51,6 @@
   inline  PILayoutMgr* GetLayoutMgr() { return(layout); }
 
-   virtual void         PSPrint(PSFile *psf, int ofx=0, int ofy=0,
- 			       double scale_x=1., double scale_y=1.);
+  virtual void         PSPrint(PSFile *psf, int ofx=0, int ofy=0,
+			       double scale_x=1., double scale_y=1.);
 
   virtual void         Show();
Index: /trunk/SophyaPI/PI/pidrawer.cc
===================================================================
--- /trunk/SophyaPI/PI/pidrawer.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pidrawer.cc	(revision 4083)
@@ -52,4 +52,15 @@
 //--
 
+// Valeur par defaut global pour TailleFonteAuto 
+double PIDrawer::glDefAFSzFrac = 0.04;
+void PIDrawer::SetGlDefAutoFontSizeFrac(double fszf)
+{
+  if (fszf>1.e-6)  glDefAFSzFrac = fszf;
+}
+double PIDrawer::GetGlDefAutoFontSizeFrac()
+{
+  return glDefAFSzFrac;
+}
+
 PIDrawer::PIDrawer()
 {
@@ -65,5 +76,5 @@
   limitsFixed = false;
   SetAxesFlags(kAxesNone);   // Pas de trace d'axes par defaut 
-  SetAxesAutoFontSize();
+  ConfigureAutoFontSize(true, glDefAFSzFrac);
 
   mDndfg = false;  // Pour controle de l'appel de Detach() si delete
@@ -107,11 +118,19 @@
 
 //++
-// Titre	Gestion des axes et des limites
+// Titre	Gestion des axes, des limites et coordonnees fenetre
 //      Le tracé des axes 2D est pris en charge par la classe PIAxes.
 //--
 //++
+// double BWdgXPos()  BWdgYPos()
+//	Renvoient les positions (X,Y) du drawer dans l'objet PIBaseWdg. Ces positions ne sont 
+//	valables qu'apres appel a SetDrwWdg() - Ne peut donc etre utilise en pratique que dans 
+//	la methode Draw.
+// double  BWdgXSize()  BWdgYSize()
+//	Renvoient les tailles (X,Y) du drawer dans l'objet PIBaseWdg. Meme remarque que pour 
+//	BWdgXPos()  BWdgYPos(). 
+//
 // void  SetLimits(double xmin, double xmax, double ymin, double ymax, -
 //                 int axrl=kAxeDirSame, int ayud=kAxeDirSame)
-//	Définit les limites du système de coordonnées.
+//	Définit les limites du système de coordonnées du Drawer.
 //|	kAxeDirSame , kAxeDirAuto
 //|	kAxeDirLtoR , kAxeDirRtoL  (Axe X)
@@ -143,12 +162,20 @@
 //|	kMajTicks , kMinTicks , kLabels , kGridOn
 //|	kAxesDflt , kAxesNone
-// void SetAxesAutoFontSize(bool fg=true)
-//	Si "fg==true", la taille de la fonte pour les labels d'axes (chiffres) est 
+// void ConfigureAutoFontSize(bool afsz=true, double fszf=0.05)
+//	Si "fg==true", la taille de la fonte par le drawer, est 
 //	choisie automatiquement, en s'adaptant à la taille de la zone de tracé - 
-//	sinon, taille de la fonte de l'objet PIDrawer.
+//	sinon, taille de la fonte de l'objet PIDrawer. Cette taille est donnée par
+//	FontSize=(YMax()-YMin())*(mFontSzF=fszf). "mFontSzF=fszf" n'est mis à jour
+//	que si fszf>0. Le décodage des attributs graphiques par DecodeOptionString() 
+//	("autofontsize=fszf" et "fixedfontsize")  permet de modifier ces attributs de 
+//	choix automtique de fonte. Utilisé en particulier par PIElDrawer pour 
+//	le tracé les labels d'axes (chiffres).
 // unsigned int GetAxesFlags()
 //	Renvoie les attributs de tracé d'axes  
-// bool  isAxesAutoFontSize()
-//	Renvoie la valeur du flag de choix automatique de taille de fonte pour axes.
+// bool  GetAutoFontSizeState() 
+//	Renvoie la valeur du flag de choix automatique de taille de fonte.
+// double  GetAutoFontSizeFraction()
+//	Renvoie la valeur de la fraction de taille ("mFontSzF) pour lee 
+//	choix automatique de taille de fonte.
 // void  DrawAxes(PIGraphicUC* g)
 //	Méthode de tracé des axes (le tracé est pris en charge par la classe *PIAxes*)
@@ -395,9 +422,30 @@
 PIDrawer::DecodeOptionString(vector<string> & opt, bool rmdecop)
 {
-  if (opt.size() < 1)  return(0);  
+  int nopt0 = opt.size();
+  if (nopt0 < 1)  return(0);  
   PIGraphicAtt gratt;
-  int ndec = gratt.DecodeAttStrings(opt, rmdecop);
+  int ndec1 = gratt.DecodeAttStrings(opt, rmdecop);
   UpdateGraphicAtt(gratt);
-  return(ndec);
+  if ((nopt0 - ndec1) < 1) return(ndec1);  // si tout a ete decode
+  vector<string> udopt;
+  unsigned int k = 0;
+  int ndec = opt.size();
+  string opts;
+  for( k=0; k<opt.size(); k++ ) {
+    opts = opt[k];
+    if (opts.substr(0,13) == "autofontsize=") {
+       double fszf = atof(opts.substr(13).c_str());
+       ConfigureAutoFontSize(true, fszf);
+    }
+    else if (opts == "fixedfontsize")
+       ConfigureAutoFontSize(false, -1.);  
+    else {
+      ndec--;
+      if (rmdecop)  udopt.push_back(opts);
+    }
+  }
+
+  if (rmdecop)  opt = udopt;
+  return(ndec+ndec1); 
 }
 
@@ -424,4 +472,7 @@
   info += "   FontAtt: roman, bold, italic, bolditalic  \n";
   info += "   FontSize: 6,8,10,12... (pts) - integer \n";
+  info += ">>> Automatic font size selection : \n";
+  info += "    autofontsize=FontSizeFrac fixedfontsize \n";
+  info += ">>> ColorTables: defcmap  grey32  invgrey32  colrj32  colbr32 \n";
   info += ">>> marker=MarkerType,MarkerSize (MarkerSize: integer 3,5,7... \n";
   info += "   MarkerType: dot, plus, cross, circle, fcircle, box, fbox \n";
@@ -505,5 +556,5 @@
   PIAxes axes;
   axes.DrawXYAxes(g, mGrAtt, XMin(), XMax(), YMin(), YMax(),
-		  axesFlags, axesAFSz); 
+		  axesFlags, mAFSz, mFontSzF); 
   g->Clip();
 }
Index: /trunk/SophyaPI/PI/pidrawer.h
===================================================================
--- /trunk/SophyaPI/PI/pidrawer.h	(revision 4082)
+++ /trunk/SophyaPI/PI/pidrawer.h	(revision 4083)
@@ -30,5 +30,12 @@
 
   virtual void       SetAxesFlags(unsigned int flags=kAxesNone);
-  inline  void       SetAxesAutoFontSize(bool fg=true) { axesAFSz = fg; }
+
+//---- Choix automatique ou pas de taille de fonte
+  inline void        ConfigureAutoFontSize(bool afsz=true, double fszf=0.04)
+    { mAFSz = afsz;  if (fszf>1e-5)  mFontSzF = fszf; }
+//  Valeur par defaut global pour le AutoFontSizeFrac, utilise dans les constructeurs de PIDrawer
+  static  void       SetGlDefAutoFontSizeFrac(double fszf=0.04);
+//  Retourne la valeur globale par defaut de AutoFontSizeFrac
+  static  double     GetGlDefAutoFontSizeFrac();
 
   virtual void       DrawAxes(PIGraphicUC* g);
@@ -53,4 +60,11 @@
   virtual void	     HighLight(bool fgh);  
 
+  // Zone de trace/accrochage dans le BaseWidget 
+  inline int         BWdgXPos() const { return xW0; }
+  inline int         BWdgYPos() const { return yW0; }
+  inline int         BWdgXSize() const { return xWd; }
+  inline int         BWdgYSize() const { return yWd; }
+
+  // Limites et informations sur les coordonnees dans le systeme du Drawer
   inline double      XMin() const {return xMin;}
   inline double      XMax() const {return xMax;}
@@ -63,5 +77,7 @@
 
   inline unsigned int GetAxesFlags() { return(axesFlags); }
-  inline bool         isAxesAutoFontSize() { return axesAFSz; }
+
+  inline bool         GetAutoFontSizeState() { return mAFSz; }
+  inline double       GetAutoFontSizeFraction() { return mFontSzF; }
 
   inline PIGraphicUC*    GetGraphicUC() { return(mGrUC); }
@@ -127,5 +143,9 @@
   bool limitsFixed;
   unsigned int axesFlags;
-  bool axesAFSz;
+
+  bool mAFSz;  // true -> Choix automatique de taille de font en fraction (ymax-ymin)
+  double mFontSzF;   // TailleFonteAuto = mFontSzF*(ymax-ymin)
+  static double glDefAFSzFrac;   // Valeur globale par defaut pour mFontSzF, utilise ds le constructeur
+
   PIBaseWdgGen* mBWdg;
   PIGraphicUC* mGrUC;
Index: /trunk/SophyaPI/PI/pieldrw.cc
===================================================================
--- /trunk/SophyaPI/PI/pieldrw.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pieldrw.cc	(revision 4083)
@@ -575,7 +575,7 @@
       SetAxesFlags(GetAxesFlags() & ~kMinTicks);
     else if (opts == "extticks")
-      SetAxesFlags(GetAxesFlags() & ~kIntTicks |  kExtTicks);
+      SetAxesFlags((GetAxesFlags() & ~kIntTicks) |  kExtTicks);
     else if (opts == "intticks")
-      SetAxesFlags(GetAxesFlags() & ~kExtTicks |  kIntTicks);
+      SetAxesFlags((GetAxesFlags() & ~kExtTicks) |  kIntTicks);
     else if (opts == "extintticks")
       SetAxesFlags(GetAxesFlags() | kIntTicks |  kExtTicks);
@@ -593,13 +593,5 @@
       }
     }
-
-    else if (opts.substr(0,13) == "autofontsize=") {
-      double fszf = atof(opts.substr(13).c_str());
-      ConfigureAxeAutoFontSize(fszf);
-      SetAxesAutoFontSize(true);
-    }
-    else if (opts == "fixedfontsize")
-      SetAxesAutoFontSize(false);
-
+ 
     else if (opts == "title" || opts == "tit") ShowTitles(true);
     else if (opts == "notitle" || opts == "notit") ShowTitles(false);
@@ -639,6 +631,6 @@
   info += "   ticks/noticks minorticks/nominorticks \n";
   info += "   extticks/intticks/extintticks nbticks=X_NbTicks,Y_NbTicks \n";
-  info += "   tickslen=MajorTickLenFrac,MinorTickLenFraC \n";
-  info += " >> Axe label font size: \n";
+  info += "   tickslen=MajorTickLenFrac,MinorTickLenFraC \n"; 
+  info += " >> Axe labels font size: \n";
   info += "    autofontsize=FontSizeFrac fixedfontsize \n";
   info += " >> Up/Down title: title tit notitle notit \n";
@@ -655,5 +647,5 @@
   //  g->NoClip();
   axeDr.DrawXYAxes(g, mGrAtt, XMin(), XMax(), YMin(), YMax(), 
-		   axesFlags, axesAFSz); 
+		   axesFlags, mAFSz, mFontSzF); 
   if (showAxesLabels) { 
     axeDr.DrawXCaption(g, labelAtt, axesFlags, xLabel);
Index: /trunk/SophyaPI/PI/pieldrw.h
===================================================================
--- /trunk/SophyaPI/PI/pieldrw.h	(revision 4082)
+++ /trunk/SophyaPI/PI/pieldrw.h	(revision 4083)
@@ -246,6 +246,4 @@
 				       double majtl=0., double mintl=0.)
      { axeDr.ConfigureTicks(ntickx, nticky, majtl, mintl); }
-  inline void        ConfigureAxeAutoFontSize(double fszf=0.)
-     { axeDr.ConfigureAutoFontSize(fszf); }
 
   inline PIElDrwMgr& ElDrwMgr()    { return eltsMgr; }
Index: /trunk/SophyaPI/PI/pifilechox.cc
===================================================================
--- /trunk/SophyaPI/PI/pifilechox.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pifilechox.cc	(revision 4083)
@@ -120,5 +120,5 @@
 {
 XmString xmstr;
-xmstr = XmStringLtoRCreate((char *)path.c_str(), XmSTRING_DEFAULT_CHARSET);
+xmstr = XmStringLtoRCreate(const_cast<char*>(path.c_str()), const_cast<char*>(XmSTRING_DEFAULT_CHARSET));
 Arg warg[2];
 XtSetArg(warg[0], XmNdirectory, xmstr); 
@@ -132,5 +132,5 @@
 {
 XmString xmstr;
-xmstr = XmStringLtoRCreate((char *)fname.c_str(), XmSTRING_DEFAULT_CHARSET);
+xmstr = XmStringLtoRCreate(const_cast<char*>(fname.c_str()),  const_cast<char*>(XmSTRING_DEFAULT_CHARSET));
 Arg warg[2];
 XtSetArg(warg[0], XmNtextString, xmstr); 
Index: /trunk/SophyaPI/PI/pifontx.cc
===================================================================
--- /trunk/SophyaPI/PI/pifontx.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pifontx.cc	(revision 4083)
@@ -263,19 +263,24 @@
 
 static XtResource resources[] = {
-  { "fontFamilyName", "FontFamilyName", XtRString, sizeof(String),
+  { const_cast<char *>("fontFamilyName"), const_cast<char *>("FontFamilyName"), 
+    XtRString, sizeof(String),
     /*XtOffset(apd, fntFam[0])*/ 0, XtRString, const_cast<char *>("*-courier") } ,
-  { "courierfontFamilyName", "CourierfontFamilyName", XtRString, sizeof(String),
+  { const_cast<char *>("courierfontFamilyName"), const_cast<char *>("CourierfontFamilyName"), 
+    XtRString, sizeof(String),
     sizeof(String) , XtRString, const_cast<char *>("*-courier") } ,
-  { "helveticafontFamilyName", "HelveticafontFamilyName", XtRString, sizeof(String),
+  { const_cast<char *>("helveticafontFamilyName"), const_cast<char *>("HelveticafontFamilyName"), 
+    XtRString, sizeof(String),
     2*sizeof(String) , XtRString, const_cast<char *>("*-helvetica") } ,
-  { "timesfontFamilyName", "TimesfontFamilyName", XtRString, sizeof(String),
+  { const_cast<char *>("timesfontFamilyName"), const_cast<char *>("TimesfontFamilyName"), 
+    XtRString, sizeof(String),
     3*sizeof(String) , XtRString, const_cast<char *>("*-times") } ,
-  { "symbolfontFamilyName", "SymbolfontFamilyName", XtRString, sizeof(String),
+  { const_cast<char *>("symbolfontFamilyName"), const_cast<char *>("SymbolfontFamilyName"), 
+    XtRString, sizeof(String),
     4*sizeof(String) , XtRString, const_cast<char *>("*-symbol") }
 };
  
-static char * fnbi_b[4] = { "medium-r-normal", "bold-r-normal", 
+static const char * fnbi_b[4] = { "medium-r-normal", "bold-r-normal", 
                           "medium-o-normal", "bold-o-normal" };
-static char * fnbo_b[4] = { NULL, NULL, 
+static const char * fnbo_b[4] = { NULL, NULL, 
                           "medium-i-normal", "bold-i-normal" };
 
@@ -289,31 +294,44 @@
   int count,k;
   Display * mdsp = PIXDisplay();
-  char **list;
+  char **list = NULL;
 
   for (k=0; k<5; k++)  {  // Recherche de la fonte pour tailles croissantes
     sprintf(buff,"-%s-%s-*-%d-*-*-*-*-*-*-*", apd.fntFam[kfn], fnbi_b[jat], fntsz[isz]+k);
     list = XListFonts(mdsp, buff, 10, &count);
-    XFreeFontNames(list);
     if ((count <= 0) && (fnbo_b[jat] != NULL)) {
+      if (list) XFreeFontNames(list);  
       sprintf(buff,"-%s-%s-*-%d-*-*-*-*-*-*-*", apd.fntFam[kfn], fnbo_b[jat], fntsz[isz]+k);
       list = XListFonts(mdsp, buff, 10, &count);
-      XFreeFontNames(list);
     }
     if (count > 0)  break;
-    }
+  }
   // certaines fontes n'ont pas de version  bold ou italique
   if ( (count == 0) && (jat > 0) ) {
     for (k=0; k<5; k++)  {  // Recherche de la fonte pour tailles croissantes
+      if (list) XFreeFontNames(list);  
       sprintf(buff,"-%s-%s-*-%d-*-*-*-*-*-*-*", apd.fntFam[kfn], fnbi_b[0], fntsz[isz]+k);
       list = XListFonts(mdsp, buff, 10, &count);
-      XFreeFontNames(list);
       if (count > 0)  break;
-      }
     }
-  if (count > 0) 
-    fntst[isz][jat][kfn] = XLoadQueryFont(mdsp, buff);
-  else
-    { printf("PIFontX::LoadFontSt/ Pb font %s - Using default \n", buff);    
-    fntst[isz][jat][kfn] = defnt; }
+  }
+  if (count > 0) {
+    for (int kkk=0; kkk<count; kkk++) {
+      /*  pour debug 
+      printf("PIFontX::LoadFontSt/DBG - Call to XLoadFont(%s) \n", list[kkk]);
+      Font lfid=XLoadFont(mdsp,list[kkk]);
+      printf("PIFontX::LoadFontSt/DBG - Call to XQueryFont(FID=%ld) \n", (unsigned long)lfid); 
+      fntst[isz][jat][kfn] = XQueryFont(mdsp, lfid);   
+      printf("PIFontX::LoadFontSt/DBG - Call to XLoadQueryFont(%s) \n", list[kkk]); 
+      */
+      fntst[isz][jat][kfn] = XLoadQueryFont(mdsp, list[kkk]);
+      if (fntst[isz][jat][kfn] != NULL) break;
+    }
+    if (list) XFreeFontNames(list);  
+  }
+  else  { 
+    if (list) XFreeFontNames(list);  
+    printf("PIFontX::LoadFontSt/ Pb font %s - Using default \n", buff);    
+    fntst[isz][jat][kfn] = defnt; 
+    }
   }
 
@@ -342,37 +360,47 @@
 XtGetApplicationResources(PIXtTopWdg(), &apd, resources, 
                           XtNumber(resources), NULL, 0);
+// printf("PIFontX::GlInit()-DBG- FontFamily = %s \n",apd.fntFam[0]);
+
 sprintf(buff,"-%s-*-*-*-*-*-*-*-*-*-*-*-*", apd.fntFam[0]);
+list = NULL;
 list = XListFonts(mdsp, buff, 15, &count);
-XFreeFontNames(list);
 if (count < 5)
   { 
   printf("PIFontX::Init %d fonts found for %s , switching to courier\n",
          count, apd.fntFam[0]);
-  apd.fntFam[0] = "*-courier";
+  apd.fntFam[0] = const_cast<char *>("*-courier");
+  if (list) XFreeFontNames(list);
   }
 sprintf(buff,"-%s-%s-*-*-*-*-12-*-*-*-*", apd.fntFam[0], fnbi_b[0]);
 list = XListFonts(mdsp, buff, 10, &count);
-XFreeFontNames(list);
 if (count < 1) {
+  if (list) XFreeFontNames(list);
   sprintf(buff,"-*-fixed-*-*-*-*-12-*-*-*-*-*-*-*");
   list = XListFonts(mdsp, buff, 10, &count);
-  XFreeFontNames(list);
   if (count < 1)   {  
+    if (list) XFreeFontNames(list);
     sprintf(buff,"fixed");
     list = XListFonts(mdsp, buff, 10, &count);
-    XFreeFontNames(list);
   }
   if (count < 1)   {  
+    if (list) XFreeFontNames(list);
     strcpy(buff,"");
     list = XListFonts(mdsp, buff, 10, &count);
-    XFreeFontNames(list);
   }
 }
 if (count < 1) {  
+  if (list) XFreeFontNames(list);
   printf("PIFontX::Init/ Erreur, no font found ... \n");
   defnt = NULL;
-  }
-else defnt = XLoadQueryFont(mdsp, buff);
-
+  //Reza+Bruno, 17 Juin 2008 - Il faut lancer une exception 
+  }
+else { 
+  defnt = NULL;
+  for (int kkk=0; kkk<count; kkk++) {
+    defnt = XLoadQueryFont(mdsp, list[kkk]);
+    if (defnt != NULL) break;
+  }
+  if (list) XFreeFontNames(list);  
+}
 for (i=0; i<NMAXFONTSZ; i++)
   for (j=0; j<NMAXFONTATT; j++)  
@@ -399,6 +427,6 @@
 // HugeFontIndex = NMAXFONTSZ-1;
 
-// printf("PIFontX::Init()-DBG- FontIndex= %d %d %d (SzF=%d) \n", 
-//       SmallFontIndex, NormalFontIndex, BigFontIndex, szf);
+// printf("PIFontX::GlInit()-DBG- FontIndex= %d %d %d (SzF=%d) \n", 
+//       SmallFontIndex, NormalFontIndex, HugeFontIndex, szf);
 
 return;
Index: /trunk/SophyaPI/PI/pigraphgen.h
===================================================================
--- /trunk/SophyaPI/PI/pigraphgen.h	(revision 4082)
+++ /trunk/SophyaPI/PI/pigraphgen.h	(revision 4083)
@@ -17,4 +17,5 @@
 
 #include "pilineatt.h"  // Class PILineAtt
+#include "pipixutils.h"  // classes utilitaires pour pixels/RGB ...
 
 
@@ -118,6 +119,6 @@
 				     bool fgline=true);
 
-  virtual void       DrawPixmap(PIGrCoord x, PIGrCoord y, unsigned char *pix, 
-                                int sx, int sy, PIColorMap* cmap)              = 0;
+  virtual void       DrawPixmap(PIGrCoord x, PIGrCoord y, PIPixColIdx & pix, 
+                                PIColorMap* cmap)                              = 0;
 
 // Modifications attributs graphiques
Index: /trunk/SophyaPI/PI/pigraphps.cc
===================================================================
--- /trunk/SophyaPI/PI/pigraphps.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pigraphps.cc	(revision 4083)
@@ -324,11 +324,16 @@
 
 /* --Methode-- */
-void PIGraphicPS::DrawPixmap(PIGrCoord x, PIGrCoord y, unsigned char *pix, 
-                            int sx, int sy, PIColorMap* cmap)
-{
+void PIGraphicPS::DrawPixmap(PIGrCoord x, PIGrCoord y, PIPixColIdx & pixc, PIColorMap* cmap) 
+{
+int sx = pixc.XSize();
+int sy = pixc.YSize();
 if ( (sx < 1) || (sy < 1) )  return;
-if ((pix == NULL) || (cmap == NULL)) return;
-if(mPSOut) 
-  mPSOut->Image((double)x, (double)y, (double)sx, (double)sy, sx, sy, pix, cmap);
+if (cmap == NULL) return;
+if(mPSOut) {
+  if (pixc.BytePointer()) 
+    mPSOut->Image((double)x, (double)y, (double)sx, (double)sy, sx, sy, pixc.BytePointer(), cmap);
+  else if (pixc.ShortPointer()) 
+    mPSOut->Image((double)x, (double)y, (double)sx, (double)sy, sx, sy, pixc.ShortPointer(), cmap);
+}
 return;
 }
Index: /trunk/SophyaPI/PI/pigraphps.h
===================================================================
--- /trunk/SophyaPI/PI/pigraphps.h	(revision 4082)
+++ /trunk/SophyaPI/PI/pigraphps.h	(revision 4083)
@@ -38,6 +38,5 @@
   virtual void       DrawMarker(PIGrCoord x0, PIGrCoord y0);
   virtual void       DrawMarkers(PIGrCoord *x, PIGrCoord *y, int n);
-  virtual void       DrawPixmap(PIGrCoord x, PIGrCoord y, unsigned char *pix, 
-                                int sx, int sy, PIColorMap* cmap);
+  virtual void       DrawPixmap(PIGrCoord x, PIGrCoord y, PIPixColIdx & pix,  PIColorMap* cmap);
 
 // Modifications attributs graphiques
Index: /trunk/SophyaPI/PI/pigraphuc.cc
===================================================================
--- /trunk/SophyaPI/PI/pigraphuc.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pigraphuc.cc	(revision 4083)
@@ -729,13 +729,12 @@
 
 /* --Methode-- */
-void PIGraphicUC::DrawPixmap(PIGrCoord x, PIGrCoord y, unsigned char *pix,
-                        int sx, int sy, PIColorMap* cmap)
-{
-  if (!mGrC) return;
-  if ( (sx < 1) || (sy < 1) )  return;
-  if ((pix == NULL) || (cmap == NULL)) return; 
+void PIGraphicUC::DrawPixmap(PIGrCoord x, PIGrCoord y, PIPixColIdx & pix, PIColorMap* cmap)
+{
+  if (!mGrC) return;
+  if ( (pix.XSize() < 1) || (pix.YSize() < 1) )  return;
+  if (cmap == NULL) return; 
   double xf,yf;
   UC2GrC(x, y, xf, yf);
-  mGrC->DrawPixmap(xf, yf, pix, sx, sy, cmap);
+  mGrC->DrawPixmap(xf, yf, pix, cmap);
 }
 
Index: /trunk/SophyaPI/PI/pigraphuc.h
===================================================================
--- /trunk/SophyaPI/PI/pigraphuc.h	(revision 4082)
+++ /trunk/SophyaPI/PI/pigraphuc.h	(revision 4083)
@@ -78,6 +78,5 @@
 				     bool fgline=true);
 
-  virtual void       DrawPixmap(PIGrCoord x, PIGrCoord y, unsigned char *pix, 
-                                int sx, int sy, PIColorMap* cmap);
+  virtual void       DrawPixmap(PIGrCoord x, PIGrCoord y, PIPixColIdx & pix, PIColorMap* cmap);
 
 // Modifications attributs graphiques
Index: /trunk/SophyaPI/PI/pigraphx.cc
===================================================================
--- /trunk/SophyaPI/PI/pigraphx.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pigraphx.cc	(revision 4083)
@@ -384,6 +384,5 @@
 
 /* --Methode-- */
-void PIGraphicX::DrawPixmap(PIGrCoord x, PIGrCoord y, unsigned char *pix, 
-                            int sx, int sy, PIColorMap* cmap)
+void PIGraphicX::DrawPixmap(PIGrCoord x, PIGrCoord y, PIPixColIdx & pixc, PIColorMap* cmap) 
 {
 Window xw;
@@ -395,6 +394,7 @@
 XImage * ximg;
 
-if ( (sx < 1) || (sy < 1) )  return;
-if ((pix == NULL) || (cmap == NULL)) return; 
+int sx = pixc.XSize();
+int sy = pixc.YSize();
+if ((sx==0) || (sx==0) || (cmap == NULL)) return; 
 
   
@@ -406,5 +406,5 @@
 pad = (depth > 8) ? 32 : 8;
 ximg = XCreateImage (mdsp,DefaultVisual(mdsp,scr),
-                     depth,ZPixmap,0,NULL, sx, sy, pad,0);
+                     depth,ZPixmap,0,NULL, sx,sy, pad,0);
 if (ximg == NULL)  return;
 ximg->data = new char [sy*ximg->bytes_per_line];
@@ -412,7 +412,20 @@
   { XFree(ximg); return; }
 
-for(j=0; j<sy; j++)
-  for(i=0; i<sx; i++)
-    { XPutPixel(ximg, i, j, cmap->Color(*pix) );  pix++; }
+if (pixc.BytePointer()) {
+  unsigned char * pix = pixc.BytePointer();
+  for(j=0; j<sy; j++)
+    for(i=0; i<sx; i++)
+      { XPutPixel(ximg, i, j, cmap->Color(*pix) );  pix++; }
+}
+else if (pixc.ShortPointer()) {
+  unsigned short * pix = pixc.ShortPointer();
+  for(j=0; j<sy; j++)
+    for(i=0; i<sx; i++)
+      { XPutPixel(ximg, i, j, cmap->Color(*pix) );  pix++; }
+}
+else {
+  for(j=0; j<sy; j++)
+    for(i=0; i<sx; i++)  XPutPixel(ximg, i, j, 0 );  
+}
 
 XPutImage(mdsp, xw, DefGC(), ximg, 0, 0, (int)x, (int)y, sx, sy);
Index: /trunk/SophyaPI/PI/pigraphx.h
===================================================================
--- /trunk/SophyaPI/PI/pigraphx.h	(revision 4082)
+++ /trunk/SophyaPI/PI/pigraphx.h	(revision 4083)
@@ -38,6 +38,5 @@
   virtual void       DrawMarker(PIGrCoord x0, PIGrCoord y0);
   virtual void       DrawMarkers(PIGrCoord *x, PIGrCoord *y, int n);
-  virtual void       DrawPixmap(PIGrCoord x, PIGrCoord y, unsigned char *pix, 
-                                int sx, int sy, PIColorMap* cmap);
+  virtual void       DrawPixmap(PIGrCoord x, PIGrCoord y,  PIPixColIdx & pix,  PIColorMap* cmap);
 
 // Modifications attributs graphiques
Index: /trunk/SophyaPI/PI/piimage.cc
===================================================================
--- /trunk/SophyaPI/PI/piimage.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/piimage.cc	(revision 4083)
@@ -111,4 +111,6 @@
 gvw = NULL;   // widget vue globale
 cmvw = NULL;  // widget ColorMapView
+fgshowcmap = 0;  // 0: Pas de vue ColMap, 1: top, 2:right,  3:bottom, 4:left
+ cmdid = -1;
 // Fenetre transient et Label pour affichage de l'info (texte PixVal)
 int tx, ty;
@@ -128,7 +130,4 @@
 cutscw = NULL; 
 
-gpixm = zpixm = pixm = NULL;
-xsgpxm = xszpxm = xspxm = 0;
-ysgpxm = yszpxm = yspxm = 0;
 lut = NULL; 
 offx = offy = 0;
@@ -145,5 +144,5 @@
 
 mdrw = new PIElDrawer(false);
- mdrw->SetAxesFlags(kAxesNone);
+mdrw->SetAxesFlags(kAxesNone);
 gvdrw = new PIElDrawer();
 AddDrawer(mdrw, true, false, false, false);
@@ -174,15 +173,12 @@
 PIImage::~PIImage()
 {
-if (pixm) delete pixm;
-if (zpixm) delete zpixm;
 if (zow) 
   {
-  zow->SetPixmap(NULL,0,0);
+  zow->SetPixmap(NULL);
   zow->EraseWindow();
   }
-if (gpixm) delete gpixm;
 if (gvw) 
   {
-  gvw->SetPixmap(NULL,0,0);
+  gvw->SetPixmap(NULL);
   gvw->EraseWindow();
   gvw->SetMsg(0); gvw->SetMsgParent(NULL); 
@@ -256,7 +252,5 @@
 xszpav = yszpav = 1;
 img = pim;
-if (gpixm) delete gpixm;
-gpixm = NULL;
-xsgpxm = ysgpxm = 0;
+gpixm.DeAlloc();
 zmgv = 1;
 
@@ -607,7 +601,13 @@
     // Position du centre d'image
     if (opts.substr(0,12) == "imagecenter=") {
-      int xc = XPave();  
-      int yc = YPave();
+      /* Si on ecrit "imagecenter=34.5,55.5" ca ne marche pas CMV 29/01/2011
+      int xc = XPave(), yc = YPave();
       sscanf(opts.substr(12).c_str(),"%d,%d",&xc, &yc);
+      SetPave(xc, yc, false, true);
+      */
+      int xc = XPave(), yc = YPave();
+      double ddxc = xc, ddyc = yc;
+      sscanf(opts.substr(12).c_str(),"%lf,%lf",&ddxc, &ddyc);
+      xc = int(ddxc+0.00001); yc = int(ddyc+0.00001); 
       SetPave(xc, yc, false, true);
       continue;
@@ -633,12 +633,18 @@
       double min = Lut()->Min();
       double max = Lut()->Max();
+      int typlut=kLutType_Lin;      ;
+      if (opts.substr(4,3) == "lin")  typlut=kLutType_Lin;
+      else if (opts.substr(4,3) == "log")  typlut=kLutType_Log;
+      else if (opts.substr(4,3) == "exp")  typlut=kLutType_Exp;
+      else if (opts.substr(4,4) == "sqrt")  typlut=kLutType_Sqrt;
+      else if (opts.substr(4,6) == "square")  typlut=kLutType_Square;
+      else if (opts.substr(4,3) == "rgb")  { 
+        typlut=kLutType_RGB;
+        min = 0;  max = 255;
+      } 
       size_t q = opts.find(',');
       if (q < opts.length()-1)
 	sscanf(opts.substr(q+1).c_str(),"%lg,%lg",&min, &max);
-      int typlut=kLutType_Lin;      ;
-      if (opts.substr(4,3) == "lin")  typlut=kLutType_Lin;
-      else if (opts.substr(4,3) == "log")  typlut=kLutType_Log;
-      else if (opts.substr(4,4) == "sqrt")  typlut=kLutType_Sqrt;
-      else if (opts.substr(4,6) == "square")  typlut=kLutType_Square;
+
       SetLut(AutoLut_No, min, max, typlut, 0, false);
       continue;
@@ -668,9 +674,24 @@
       continue;
     }
+    if (opts == "showcmap")  UpdateCMapDrawer(1);
+    else if (opts == "noshowcmap")  UpdateCMapDrawer(0);
+    else if (opts.substr(0,9) == "showcmap=") {
+      if (opts.substr(9,2) == "no")   UpdateCMapDrawer(0); 
+      else if (opts.substr(9,3) == "top")     UpdateCMapDrawer(1); 
+      else if (opts.substr(9,5) == "right")   UpdateCMapDrawer(2); 
+      else if (opts.substr(9,6) == "bottom")  UpdateCMapDrawer(3); 
+      else if (opts.substr(9,4) == "left")    UpdateCMapDrawer(4); 
+      else if (opts.substr(9,5) == "horiz")   UpdateCMapDrawer(1); 
+      else if (opts.substr(9,4) == "vert")    UpdateCMapDrawer(2); 
+      else UpdateCMapDrawer(0); 
+    }
+
     ndec--;
     udopt.push_back(opts);
   }
   // Set color map if requested
-  if(fgcmapid || revcmapid) SetColMapId(cmapid,revcmapid,false);
+  if(fgcmapid || revcmapid) 
+    SetColMapId(cmapid,revcmapid,false);  
+
   // Configure axes if requested 
   if (confaxes) ChangeAxesConfiguration(invx, invy, exchxy, false);
@@ -691,4 +712,5 @@
       SetLut(t_al, min_al, max_al, Lut()->Type(), ns_al, false);
   }
+
   return(ndec+ndec2);
 }
@@ -724,13 +746,27 @@
 {
 if (!cmp)  return;
+int ncolold = 0;
+if (cmap) ncolold = cmap->NCol();
+bool fgapp = false;
+if (refr && cmp->NCol() != ncolold) {
+  fgapp = true;  refr = false;
+}
 int cmapid = cmp->Type();
 if ( (cmapid == CMAP_GREY32) || (cmapid == CMAP_GREYINV32) || 
      (cmapid == CMAP_GREY128) || (cmapid == CMAP_GREYINV128))  mdrw->GetGraphicAtt().SetColAtt(PI_Red);
 else mdrw->GetGraphicAtt().SetColAtt(PI_Turquoise);
+if (lut) lut->SetNCol(cmp->NCol());
 PIPixmap::SetColMap(cmp, refr);
 if (refr) { xcurs =  ycurs = -1; }
 if (zow)  zow->SetColMap(cmp, refr);
-if (gvw)  gvw->SetColMap(cmp, refr);
+if (gvw)  { 
+    if (cmap->NCol() != ncolold) { 
+    ComputeGloVPixmap();
+    SetGloVPixmap();
+  }
+  else  gvw->SetColMap(cmp, refr);
+}
 if (cmvw) cmvw->SetColMap(cmap, Lut()->Min(), Lut()->Max(), refr);
+if (fgapp)  Apply();
 return;
 }
@@ -739,11 +775,27 @@
 void PIImage::SetColMapId(CMapId cmapid, bool revidx, bool refr)
 {
+int ncolold = 0;
+if (cmap) ncolold = cmap->NCol();
 if ( (cmapid == CMAP_GREY32) || (cmapid == CMAP_GREYINV32) || 
      (cmapid == CMAP_GREY128) || (cmapid == CMAP_GREYINV128))  mdrw->GetGraphicAtt().SetColAtt(PI_Red);
 else mdrw->GetGraphicAtt().SetColAtt(PI_Turquoise);
-PIPixmap::SetColMapId(cmapid, revidx, refr);
+PIPixmap::SetColMapId(cmapid, revidx, false);
+if (refr) { xcurs =  ycurs = -1; }
+bool fgapp = false;
+if (refr && cmap->NCol() != ncolold) {
+  fgapp = true;  refr = false;
+}
+if (lut) lut->SetNCol(GetColMap()->NCol());
+if (refr) Refresh();
 if (zow)  zow->SetColMapId(cmapid, revidx, refr);
-if (gvw)  gvw->SetColMapId(cmapid, revidx, refr);
+if (gvw)  { 
+    if (cmap->NCol() != ncolold) { 
+    ComputeGloVPixmap();
+    SetGloVPixmap();
+  }
+  else  gvw->SetColMapId(cmapid, revidx, refr);
+}
 if (cmvw) cmvw->SetColMapId(cmapid, revidx, Lut()->Min(), Lut()->Max(), refr);
+if (fgapp)  Apply();
 return;
 }
@@ -754,4 +806,8 @@
 {
 if (img == NULL)  return;
+if (fgshowcmap>0)  {
+  cmpd.SetColMap(GetColMap());
+  cmpd.SetBornes(*Lut());
+}
 if (mw)  {  
   ComputePixmap();
@@ -1111,14 +1167,14 @@
 ywsz = YSize();
 
-pixm = img->ComputePixmap(lut, offx, offy, zoom, xwsz, ywsz, pixm, &xspxm, &yspxm);
+img->ComputePixmap(lut, offx, offy, zoom, xwsz, ywsz, pixm);
 int xw1, yw1, xw2, yw2;
-xw1 = (xwsz-xspxm)/2;
+xw1 = (xwsz-pixm.XSize())/2;
 if (xw1 < 0) xw1 = 0;
-yw1 = (ywsz-yspxm)/2;
+yw1 = (ywsz-pixm.YSize())/2;
 if (yw1 < 0) yw1 = 0;
-xw2 = xspxm+xw1;
-yw2 = yspxm+yw1;
+xw2 = pixm.XSize()+xw1;
+yw2 = pixm.YSize()+yw1;
 SetDefaultDrawRectangle(xw1, yw1, xw2, yw2, false);
-// printf("--DBG-- ComputePixmap() %d %d $ %d %d :: %d %d , %d %d \n", xwsz, ywsz, xspxm, yspxm, xw1, yw1, xw2, yw2);
+// printf("--DBG-- ComputePixmap() %d %d $ %d %d :: %d %d , %d %d \n", xwsz, ywsz, pixm.XSize(), pixm.YSize(), xw1, yw1, xw2, yw2);
 int x1,y1, x2,y2;
 ofx = xw1;  ofy = yw1;
@@ -1131,5 +1187,5 @@
 // printf("--DBG2-- ComputePixmap() %g %g  %g %g  \n", fx1, fx2, fy1, fy2);
 xcurs = ycurs = -1;
-SetPixmap(pixm, xspxm, yspxm, true, xw1, yw1); 
+SetPixmap(&pixm, true, xw1, yw1); 
 // Refresh();
 return; 
@@ -1174,7 +1230,7 @@
 if (lofy < 0)  lofy = 0;
 
-zpixm = img->ComputePixmap(lut, lofx, lofy, zm, xwsz, ywsz, zpixm, &xszpxm, &yszpxm);
+img->ComputePixmap(lut, lofx, lofy, zm, xwsz, ywsz, zpixm);
 zow->SetColMap(cmap, false);
-zow->SetPixmap(zpixm, xszpxm, yszpxm); 
+zow->SetPixmap(&zpixm); 
 zow->SetUserData((void *)this, 0);
 // zow->Refresh();
@@ -1203,6 +1259,6 @@
 zmgv = zmx;
 if (zmx > 1)  zmx = -zmx;
-gpixm = img->ComputePixmap(lut, 0, 0, zmx, xwsz, ywsz, gpixm, &xsgpxm, &ysgpxm);
-// printf("DEBUG-ComputeGloVPixmap()  %d-%d , (%d,%d) , %d-%d \n", xwsz, ywsz, zmx, zmy, xsgpxm, ysgpxm);
+img->ComputePixmap(lut, 0, 0, zmx, xwsz, ywsz, gpixm);
+// printf("DEBUG-ComputeGloVPixmap()  %d-%d , (%d,%d) , %d-%d \n", xwsz, ywsz, zmx, zmy, gpixm.XSize(), gpixm.YSize());
 return;
 }
@@ -1215,10 +1271,10 @@
 
 int xw1, yw1, xw2, yw2;
-xw1 = (gvw->XSize()-xsgpxm)/2;
+xw1 = (gvw->XSize()-gpixm.XSize())/2;
 if (xw1 < 0) xw1 = 0;
-yw1 = (gvw->YSize()-ysgpxm)/2;
+yw1 = (gvw->YSize()-gpixm.YSize())/2;
 if (yw1 < 0) yw1 = 0;
-xw2 = xsgpxm+xw1;
-yw2 = ysgpxm+yw1;
+xw2 = gpixm.XSize()+xw1;
+yw2 = gpixm.YSize()+yw1;
 
 if (zoom > 0) zm = zmgv*zoom;
@@ -1242,5 +1298,5 @@
 gvw->AddDrawer(gvdrw, xw1, yw1, xw2, yw2, false); 
 gvw->SetColMap(cmap, false);
-gvw->SetPixmap(gpixm, xsgpxm, ysgpxm, true, xw1, yw1); 
+gvw->SetPixmap(&gpixm, true, xw1, yw1); 
 gvw->SetUserData((void *)this, 0);
 gvw->SetMsg(Msg()+626);
@@ -1348,4 +1404,34 @@
 //printf("UpdateCuts()-DBG X: %d  -> %g  , Y: %d -> %g \n", cutarrx->Size(), cutarrx->Value(0),
 //       cutarry->Size(), cutarry->Value(0));
+}
+
+/* --Methode-- */
+void PIImage::UpdateCMapDrawer(int fgshow)
+{
+  if ((fgshow<0)||(fgshow>4))  fgshow=0;
+  if (fgshow==fgshowcmap) return;
+  fgshowcmap=fgshow;
+  switch (fgshowcmap ) {
+  case 0 :
+    RemoveDrawer(cmdid); 
+    break;
+  case 1 :
+    cmpd.SetHorizontal();
+    cmdid=AddDrawer(&cmpd, 0.10, 0.02, 0.90, 0.10, true, false);
+    break;
+  case 2 :
+    cmpd.SetVertical();
+    cmdid=AddDrawer(&cmpd, 0.90, 0.1, 0.98, 0.9, true, false);
+    break;
+  case 3 :
+    cmpd.SetHorizontal();
+    cmdid=AddDrawer(&cmpd, 0.10, 0.90, 0.90, 0.98, true, false);
+    break;
+  case 4 :
+    cmpd.SetVertical();
+    cmdid=AddDrawer(&cmpd, 0.02, 0.1, 0.10, 0.9, true, false);
+    break;   
+  } 
+  if (fgshowcmap>0) cmpd.GetGraphicAtt().SetColAtt(PI_Turquoise);
 }
 
Index: /trunk/SophyaPI/PI/piimage.h
===================================================================
--- /trunk/SophyaPI/PI/piimage.h	(revision 4082)
+++ /trunk/SophyaPI/PI/piimage.h	(revision 4083)
@@ -135,4 +135,5 @@
   void SetGloVPixmap();
   void UpdateCuts();
+  void UpdateCMapDrawer(int fgshow);
 
   void DrawCursor(PIGraphic* g);
@@ -154,6 +155,5 @@
   bool winovis;   // $CHECK$ Reza A enlever si possible 17/6/96
 // Tableau des pixels principal  
-  unsigned char * pixm;
-  int xspxm, yspxm;
+  PIPixColIdx pixm;
   LUT * lut;
   AutoLutType t_al;   // Si AutoLut et le type lors du dernier appel a SetLut()
@@ -164,14 +164,15 @@
   int zoom;
   PIPixmap * zow;
-  unsigned char * zpixm;
-  int xszpxm, yszpxm;
-// Fenetre pour l'image entiere  
+  PIPixColIdx zpixm;
+// Fenetre pour vue globale de l'image   
   int zmgv;
   PIPixmap * gvw;
-  unsigned char * gpixm;
-  int xsgpxm, ysgpxm;
+  PIPixColIdx gpixm;
   PIElDrawer* gvdrw;
 // Fenetre d'affichage du ColMap
   PICMapView* cmvw;
+  int fgshowcmap;  // 0: Pas de vue ColMap, 1: top, 2:right, 3:bottom, 4:left
+  PICMapDrawer cmpd;
+  int cmdid;
 // Fenetre/champ de texte
   PILabel * trtlb;
Index: /trunk/SophyaPI/PI/piimgtools.cc
===================================================================
--- /trunk/SophyaPI/PI/piimgtools.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/piimgtools.cc	(revision 4083)
@@ -99,7 +99,9 @@
 mOpt[0] = new PIOptMenu(this, "imglut-opt-1", 1.5*bsx, bsy, cpx, cpy);
 mOpt[0]->AppendItem("Linear", 1100);
-mOpt[0]->AppendItem("Log.", 1101);
-mOpt[0]->AppendItem("Sqrt", 1102);
-mOpt[0]->AppendItem("Square", 1103);
+mOpt[0]->AppendItem("Log", 1101);
+mOpt[0]->AppendItem("Exp", 1102);
+mOpt[0]->AppendItem("Sqrt", 1103);
+mOpt[0]->AppendItem("Square", 1104);
+mOpt[0]->AppendItem("RGB", 1105);
 mOpt[0]->SetValue(1100);
 mOpt[0]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
@@ -174,6 +176,7 @@
 mCasc[1] = new PIMenu(mOptzc[0]->Menu(), "PIUniCol32");
 mCasc[2] = new PIMenu(mOptzc[0]->Menu(), "MIDAS-CMap");
-
-int nsct1,nsct2,nsct3,nsct4;
+mCasc[3] = new PIMenu(mOptzc[0]->Menu(), "RGB-CMap");
+
+int nsct1,nsct2,nsct3,nsct4,nsct5;
 //  D'abord les tables standard de PI  32 couleurs
 nsct1 = 5;   // Les 5 premieres tables
@@ -190,12 +193,16 @@
 mOptzc[0]->AppendPDMenu(mCasc[1]);
 //  Apres les tables importees de MIDAS
-nsct4 = PIColorMap::NumberStandardColorMaps()-2; // Les reste jusqu'a l'avant derniere
+nsct4 = PIColorMap::NumberStandardColorMaps()-6; // Les reste jusqu'a l'avant derniere
 for(kcc=nsct3; kcc<nsct4; kcc++) 
   mCasc[2]->AppendItem(PIColorMap::GetStandardColorMapName(kcc).c_str(), 201+kcc);
 mOptzc[0]->AppendPDMenu(mCasc[2]);
-// Les tables qui restent ( Col16 , ... )
-for(kcc=nsct4; kcc<PIColorMap::NumberStandardColorMaps(); kcc++) 
-mOptzc[0]->AppendItem(PIColorMap::GetStandardColorMapName(kcc).c_str(), 201+kcc);
-// On ajoute un CheckItem pour inverser les index de table de couleur
+nsct5 = PIColorMap::NumberStandardColorMaps()-4; // Les reste jusqu'aux tables RGB
+for(kcc=nsct4; kcc<nsct5; kcc++) 
+  mOptzc[0]->AppendItem(PIColorMap::GetStandardColorMapName(kcc).c_str(), 201+kcc);
+// Les tables de couleur RGB  ( RGB216, RGB512 , ... )
+for(kcc=nsct5; kcc<PIColorMap::NumberStandardColorMaps(); kcc++) 
+  mCasc[3]->AppendItem(PIColorMap::GetStandardColorMapName(kcc).c_str(), 201+kcc);
+mOptzc[0]->AppendPDMenu(mCasc[3]);
+  // On ajoute un CheckItem pour inverser les index de table de couleur
 mOptzc[0]->Menu()->AppendSeparator();
 mOptzc[0]->Menu()->AppendCheckItem("Reverse CMap", 299);
@@ -310,5 +317,5 @@
 for(i=0; i<3; i++)  delete mBut[i];
 delete mButR;
-for(i=0; i<2; i++)  delete mCasc[i];
+for(i=0; i<4; i++)  delete mCasc[i];
 for(i=0; i<5; i++)  delete mButsz[i];
 for(i=0; i<3; i++)  delete mButcax[i];
@@ -371,6 +378,8 @@
   if     ( (mpii->Lut())->Type() == kLutType_Lin )    mOpt[0]->SetValue(1100);
   else if( (mpii->Lut())->Type() == kLutType_Log )    mOpt[0]->SetValue(1101);
-  else if( (mpii->Lut())->Type() == kLutType_Sqrt )   mOpt[0]->SetValue(1102);
-  else if( (mpii->Lut())->Type() == kLutType_Square ) mOpt[0]->SetValue(1103);
+  else if( (mpii->Lut())->Type() == kLutType_Exp )    mOpt[0]->SetValue(1102);
+  else if( (mpii->Lut())->Type() == kLutType_Sqrt )   mOpt[0]->SetValue(1103);
+  else if( (mpii->Lut())->Type() == kLutType_Square ) mOpt[0]->SetValue(1104);
+  else if( (mpii->Lut())->Type() == kLutType_RGB )    mOpt[0]->SetValue(1105);
   else                                                mOpt[0]->SetValue(1100);
 }
@@ -388,5 +397,5 @@
 double min, max, del;
 int lauto, typ;
-int typlut[4] = {kLutType_Lin, kLutType_Log, kLutType_Sqrt, kLutType_Square} ; 
+int typlut[6] = {kLutType_Lin, kLutType_Log,  kLutType_Exp, kLutType_Sqrt, kLutType_Square, kLutType_RGB } ; 
 AutoLutType alts[13] = { AutoLut_No, 
 			 AutoLut_MeanSigma, AutoLut_MeanSigma, AutoLut_MeanSigma,
@@ -446,5 +455,5 @@
     if ((lauto < 0) || (lauto > 12))  lauto = 12;
     typ = mOpt[0]->GetValue() - 1100;
-    if ( (typ < 0) || (typ > 3) )  typ = 0;
+    if ( (typ < 0) || (typ > 5) )  typ = 0;
     (PIImage::CurrentPIImage())->SetLut(alts[lauto], min, max, typlut[typ], nsas[lauto]);
     if (msg == 2500) { 
Index: /trunk/SophyaPI/PI/pilistx.cc
===================================================================
--- /trunk/SophyaPI/PI/pilistx.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pilistx.cc	(revision 4083)
@@ -116,9 +116,5 @@
 mNItem++;
 
-#if defined(__DECCXX) || defined(__KCC__) || defined(__aCC__)
-XmString xms = XmStringCreate(const_cast<char *>(item), XmSTRING_DEFAULT_CHARSET);
-#else
-XmString xms = XmStringCreate((char *)(item), XmSTRING_DEFAULT_CHARSET);
-#endif
+XmString xms = XmStringCreate(const_cast<char*>(item), const_cast<char*>(XmSTRING_DEFAULT_CHARSET));
 XmListAddItem(mlist, xms, 0);
 XmStringFree(xms);
Index: /trunk/SophyaPI/PI/pimenux.cc
===================================================================
--- /trunk/SophyaPI/PI/pimenux.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pimenux.cc	(revision 4083)
@@ -386,5 +386,5 @@
   n=0;
   sprintf(acc,"Ctrl/%c", sc[0]);
-  xmstr = XmStringLtoRCreate(acc, XmSTRING_DEFAULT_CHARSET);
+  xmstr = XmStringLtoRCreate(acc, const_cast<char*>(XmSTRING_DEFAULT_CHARSET));
   XtSetArg(warg[n], XmNacceleratorText, xmstr); n++;
   sprintf(acc,"Ctrl<Key>%c", sc[0]);
Index: /trunk/SophyaPI/PI/pipixmapgen.cc
===================================================================
--- /trunk/SophyaPI/PI/pipixmapgen.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pipixmapgen.cc	(revision 4083)
@@ -8,4 +8,5 @@
 #include "sopnamsp.h"
 #include "pipixmapgen.h"
+
 
 // --------- Methodes de la classe PIPixMap  ----------
@@ -43,7 +44,6 @@
 // long  kind() 
 //	Retourne le type ("=PIPixmap::ClassId")
-// void  SetPixmap(unsigned char *pix, int sx, int sy, bool refr=true, int ox=0, int oy=0)
-//	Associe un tableau d'index "pix" de taille "sx * sy".
-//	(ox,oy)" définissent  l'offset d'affichage.
+// void  SetPixmap(PIPixColIdx *pixidx, int sx, int sy, bool refr=true, int ox=0, int oy=0)
+//	Associe un tableau d'index de couleur "pixidx". (ox,oy)" définissent  l'offset d'affichage.
 //	Si "refr=true", la méthode "Refresh()" est appelée.
 //--
@@ -87,5 +87,5 @@
 {
 pixmap = NULL;
-nx = ny = 0;
+fgownpmap = false;
 ofx = ofy = 0;
 mPpos[0] = mPpos[0] = 0;
@@ -99,21 +99,41 @@
 {
 delete cmap;
+if (fgownpmap && pixmap) delete pixmap;
 }
 
 /* --Methode-- */
-void PIPixmapGen::SetPixmap(unsigned char *pix, int sx, int sy, bool refr, int ox, int oy)
+void PIPixmapGen::SetPixmap(PIPixColIdx *pixidx, bool refr, int ox, int oy)
 {
-pixmap = pix; 
-if (pixmap)
-  {
-  if (sx < 0)  sx = 0;
-  if (sy < 0)  sy = 0;
-  if (ox < 0)  ox = 0;
-  if (oy < 0)  oy = 0;
-  nx = sx; ny = sy;
-  ofx = ox;  ofy = oy;
+if (fgownpmap && pixmap) delete pixmap;
+fgownpmap = false;
+pixmap = pixidx; 
+if (ox < 0)  ox = 0;
+if (oy < 0)  oy = 0;
+ofx = ox;  ofy = oy;
+if (refr) Refresh();   
+}
+
+/* --Methode-- */
+void PIPixmapGen::SetRGBArray(PIPixRGBArray *rgba, CMapId cmapid, bool refr, int ox, int oy)
+{
+if (rgba == NULL) return;
+int quantum = 8;
+if (cmapid == CMAP_RGB216)  quantum = 6;
+else if (cmapid == CMAP_RGB4096) quantum = 16;
+else cmapid = CMAP_RGB512;
+SetColMapId(cmapid, false);
+PIPixColIdx * pixc = new PIPixColIdx;
+pixc->AllocateByte(rgba->XSize(), rgba->YSize());
+for(int j=0; j<rgba->YSize(); j++) 
+  for(int i=0; i<rgba->XSize(); i++) {
+  	PIPixRGB vv = (*rgba)(i,j);
+  	int r = (int)vv.red*quantum/256;
+  	int g = (int)vv.green*quantum/256;
+  	int b = (int)vv.blue*quantum/256;
+    pixc->GetShort(i,j) = (unsigned short)((b*quantum+g)*quantum+r);
   }
-else { ofx = ofy = nx = ny = 0; }
-if (refr) Refresh();   
+SetPixmap(pixc, refr, ox, oy);
+fgownpmap = true;
+return;  
 }
 
Index: /trunk/SophyaPI/PI/pipixmapgen.h
===================================================================
--- /trunk/SophyaPI/PI/pipixmapgen.h	(revision 4082)
+++ /trunk/SophyaPI/PI/pipixmapgen.h	(revision 4083)
@@ -9,5 +9,8 @@
 #include PICMAP_H
 
+#include "pipixutils.h"
+
 #include <list>
+
 
 class PIPixmapGen : public PIBaseWdg
@@ -22,6 +25,7 @@
   virtual long  kind() {return ClassId; }
 
-  virtual void  SetPixmap(unsigned char *pix, int sx, int sy, 
-                          bool refr=true, int ox=0, int oy=0);
+  virtual void  SetPixmap(PIPixColIdx *pixidx, bool refr=true, int ox=0, int oy=0);
+  virtual void  SetRGBArray(PIPixRGBArray *rgba, CMapId cmapid=CMAP_RGB512, 
+                            bool refr=true, int ox=0, int oy=0);
 
   virtual void  SetColMap(PIColorMap* cmp, bool refr=true);
@@ -39,7 +43,7 @@
 
 protected:
-  unsigned char *pixmap;
-  int nx, ny;
-  int ofx, ofy;
+  PIPixColIdx *pixmap;   // Pointeur d'objet PIPixCoIdx, tableau d'index de couleurs, peut etre NULL
+  bool fgownpmap;  // si true -> possede le pixmap et doit le deleter si besoin
+  int ofx, ofy;       // Offset d'affichage 
   PIColorMap* cmap;
 
Index: /trunk/SophyaPI/PI/pipixmapx.cc
===================================================================
--- /trunk/SophyaPI/PI/pipixmapx.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pipixmapx.cc	(revision 4083)
@@ -7,4 +7,7 @@
 #include "sopnamsp.h"
 #include "pipixmapx.h"
+#include <iostream>
+
+using namespace std;
 
 static  GC    mygc;
@@ -31,20 +34,37 @@
 {
 int i,j;
-unsigned char *pp;
-
-if (pixmap)
-  {
-  for(j=0; j<ny; j++)
-    {
-    pp = pixmap+j*nx;
-    for(i=0; i<nx; i++)
-      { XPutPixel(myximg, i, j, cmap->Color(*pp) );  pp++; }
+int nx = 0;
+int ny = 0;
+if (pixmap!=NULL) {
+  nx = pixmap->XSize();
+  if (nx > XSize())  nx = XSize();
+  ny = pixmap->YSize();
+  if (ny > YSize())  ny = YSize();
+  if (pixmap->BytePointer()!=NULL) {
+    unsigned char *pp = pixmap->BytePointer();
+    for(j=0; j<ny; j++) {
+      pp = pixmap->BytePointer()+j*pixmap->XSize();
+      for(i=0; i<nx; i++)
+        { XPutPixel(myximg, i, j, cmap->Color(*pp) );  pp++; }
+      }
+  }
+  else if (pixmap->ShortPointer()!=NULL) {
+    unsigned short *pp = pixmap->ShortPointer();
+    for(j=0; j<ny; j++) {
+      pp = pixmap->ShortPointer()+j*pixmap->XSize();
+      for(i=0; i<nx; i++)  
+        { XPutPixel(myximg, i, j, cmap->Color(*pp) );  pp++; }
     }
   }
-
+}
+/* ----- On peut laisser le reste - ce n'est pas utilise dans le Draw
+// On remplit le restant 
+for(j=0; j<YSize(); j++)
+  for(i=nx; i<XSize(); i++)
+       XPutPixel(myximg, i, j, 0 );
 for(j=ny; j<YSize(); j++)
-  for(i=nx; i<XSize(); i++)
+  for(i=0; i<XSize(); i++)
      XPutPixel(myximg, i, j, 0 );
-
+------- */
 PIBaseWdgX::Refresh();
 }
@@ -66,5 +86,5 @@
 if (!g) return; 
 if (g->kind() == PI_PSFileGraphics ) {
-    g->DrawPixmap(ofx, ofy, pixmap, nx, ny, cmap);
+    g->DrawPixmap(ofx, ofy, pixmap, cmap);
     //  Il faut faire quelque chose Sinon ??! 
   }
@@ -78,19 +98,26 @@
 
 if (!g) return; 
-if ((myximg == NULL) || (cmap == NULL)) return;
 
 if (g->kind() == PI_PSFileGraphics ) {
-  if (pixmap) g->DrawPixmap(ofx, ofy, pixmap, nx, ny, cmap);
+  g->DrawPixmap(ofx, ofy, (*pixmap), cmap);
   return;
   }
+  
 
 Window xw = XtWindow(XtWdg());
 Display * mdsp = PIXDisplay();
 
+if ((myximg == NULL) || (cmap == NULL) || (pixmap == NULL) ||
+    (pixmap->XSize()<=0) || (pixmap->YSize()<=0) ) {
+  XClearArea(mdsp, xw, x0, y0, dx, dy, False);  return; 
+}
+
 int mx, my, ox, oy;
 
 if (x0 < 0)  x0 = 0;
 if (y0 < 0)  y0 = 0;
-mx = nx+ofx;   my = ny+ofy;
+
+mx = pixmap->XSize()+ofx;   my = pixmap->YSize()+ofy;
+
 if (dx > (XSize()-x0)) dx = XSize()-x0;
 if (dy > (YSize()-y0)) dy = YSize()-y0;
@@ -101,5 +128,4 @@
 
 ox = oy = 0;  
-
 if (ofx > x0)
   { XClearArea(mdsp, xw, x0, y0, ofx-x0, dy, False);   
@@ -115,5 +141,26 @@
 if (my < (y0+dy))
   { XClearArea(mdsp, xw, x0, my, dx, y0+dy-my, False);  dy = my-y0; }
+
+/*
+if (ofx > x0)
+  XClearArea(mdsp, xw, x0, y0, ofx-x0, dy, False);   
+if (ofy > y0)
+  XClearArea(mdsp, xw, x0, y0, dx, ofy-y0, False);  
  
+if (mx < (x0+dx))
+  XClearArea(mdsp, xw, mx, y0, x0+dx-mx, dy, False); 
+if (my < (y0+dy))
+  XClearArea(mdsp, xw, x0, my, dx, y0+dy-my, False);  
+
+if (ofx > x0)
+  { dx -= (ofx-x0);  x0 = ofx;  ox = 0; }
+else  ox = x0-ofx;
+if (ofy > y0)
+  { dy -= (ofy-y0);  y0 = ofy;  oy = 0; }
+else  oy = y0-ofy;
+if (mx < (x0+dx))  dx = mx-x0;
+if (my < (y0+dy))  dy = my-y0;
+*/
+  
 XPutImage(mdsp, xw, mygc, myximg, ox, oy, x0, y0, dx, dy);
 XFlush(mdsp);
Index: /trunk/SophyaPI/PI/piscdrawwdg.cc
===================================================================
--- /trunk/SophyaPI/PI/piscdrawwdg.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/piscdrawwdg.cc	(revision 4083)
@@ -248,4 +248,18 @@
   bool fglogy = isLogScaleY();
 
+  // Flag declenchant SetLimits
+  bool fgsaxel = false;
+  // Limites et sens d'axe
+  double xmin = XMin();
+  double ymin = YMin();
+  double xmax = XMax();
+  double ymax = YMax();
+  int axrl = kAxeDirLtoR;
+  int ayud = kAxeDirDownUp;
+  int xac, yac;
+  GetAxesConfig(xac, yac);
+  if (xac & kAxeDirRtoL) axrl = kAxeDirRtoL;
+  if (yac & kAxeDirUpDown) ayud = kAxeDirUpDown;
+
   for( k=0; k<opt.size(); k++ ) {
     string opts = opt[k];
@@ -259,10 +273,6 @@
     // Limites en x,y
     if (opts.substr(0,9) == "xylimits=") {
-      double xmin = XMin();
-      double ymin = YMin();
-      double xmax = XMax();
-      double ymax = YMax();
       sscanf(opts.substr(9).c_str(),"%lg,%lg,%lg,%lg",&xmin, &xmax,&ymin,&ymax);
-      SetLimits(xmin, xmax, ymin, ymax);
+      fgsaxel = true;
       continue;
     }
@@ -292,6 +302,22 @@
       continue;
     }
-
-// Les attributs d'axes (stdaxes boxaxesgrid ...) sont decodes par PIElDrawer
+    if ((opts == "revax") || (opts == "axerl") ) {
+      fgsaxel = true;  axrl = kAxeDirRtoL;
+      continue;
+    }
+    if ((opts == "revay") || (opts == "axeud") ) {
+      fgsaxel = true;  ayud = kAxeDirUpDown;
+      continue;
+    }
+    if (opts == "axelr") {
+      fgsaxel = true;  axrl = kAxeDirLtoR;
+      continue;
+    }
+    if (opts == "axedu") {
+      fgsaxel = true;  ayud = kAxeDirDownUp;
+      continue;
+    }
+
+// Les autres attributs d'axes (stdaxes boxaxesgrid ...) sont decodes par PIElDrawer
 
     ndec--;
@@ -299,4 +325,5 @@
   }  
 
+  if (fgsaxel)  SetLimits(xmin, xmax, ymin, ymax, axrl, ayud);
   if (fglinlog) SetLogScale(fglogx, fglogy);
 
Index: /trunk/SophyaPI/PI/pistdwdgx.cc
===================================================================
--- /trunk/SophyaPI/PI/pistdwdgx.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pistdwdgx.cc	(revision 4083)
@@ -51,5 +51,5 @@
 {
 XmString xmstr;
-xmstr = XmStringLtoRCreate((char *)lab.c_str(), XmSTRING_DEFAULT_CHARSET);
+xmstr = XmStringLtoRCreate(const_cast<char*>(lab.c_str()), const_cast<char*>(XmSTRING_DEFAULT_CHARSET));
 int n=0;
 Arg warg[2];
@@ -149,5 +149,5 @@
 {
 XmString xmstr;
-xmstr = XmStringLtoRCreate((char *)lab.c_str(), XmSTRING_DEFAULT_CHARSET);
+xmstr = XmStringLtoRCreate(const_cast<char*>(lab.c_str()), const_cast<char*>(XmSTRING_DEFAULT_CHARSET));
 int n=0;
 Arg warg[2];
Index: /trunk/SophyaPI/PI/pitherm.cc
===================================================================
--- /trunk/SophyaPI/PI/pitherm.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pitherm.cc	(revision 4083)
@@ -24,5 +24,5 @@
 //--
 //++
-//  PIThermometer(PIContainerGen *par, char *nom, int sx=256, int sy=10, int px=0, int py=0)
+//  PIThermometer(PIContainerGen *par, const char *nom, int sx=256, int sy=10, int px=0, int py=0)
 //	Constructeur - Le choix d'affichage (vertical ou horizontal) dépend
 //	du rapport des tailles "sx", "sy"
@@ -31,5 +31,5 @@
 
 /* --Methode-- */
-PIThermometer::PIThermometer(PIContainerGen *par, char *nom,
+PIThermometer::PIThermometer(PIContainerGen *par, const char *nom,
                        int sx, int sy, int px, int py) 
 : PIBaseWdg(par, nom, sx, sy, px, py)
@@ -139,4 +139,5 @@
 void PIThermometer::Draw(PIGraphicGen* g, int /*x0*/, int /*y0*/, int /*dx*/, int /*dy*/)
 {
+  if (!IsVisible())  return;
   double delta = (max_-min_);
   if (delta < 1.e-39) delta = 1.e-39;
Index: /trunk/SophyaPI/PI/pitherm.h
===================================================================
--- /trunk/SophyaPI/PI/pitherm.h	(revision 4082)
+++ /trunk/SophyaPI/PI/pitherm.h	(revision 4083)
@@ -16,5 +16,5 @@
   enum {ClassId = 5220};
 
-                  PIThermometer(PIContainerGen *par, char *nom,
+                  PIThermometer(PIContainerGen *par, const char *nom,
                                 int sx=256, int sy=10, int px=0, int py=0);
   virtual         ~PIThermometer();
Index: /trunk/SophyaPI/PI/piversion.h
===================================================================
--- /trunk/SophyaPI/PI/piversion.h	(revision 4082)
+++ /trunk/SophyaPI/PI/piversion.h	(revision 4083)
@@ -2,5 +2,5 @@
 #define PIVERSION_H_SEEN
 
-#define PI_VERSIONNUMBER  4.11
+#define PI_VERSIONNUMBER  4.20
 
 #endif
Index: /trunk/SophyaPI/PI/piwdggen.cc
===================================================================
--- /trunk/SophyaPI/PI/piwdggen.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/piwdggen.cc	(revision 4083)
@@ -57,7 +57,4 @@
 //--
 //++
-// void  PSPrint(PSFile *psf, int ofx=0, int ofy=0)
-//	Méthode virtuelle qui doit être redéfinie pour chacune des classes filles.
-//	produit une représentation graphique de l'objet en Postscript.
 // SetSize(int sx, int sy)
 //	Modifie la taille de l'objet.
@@ -181,4 +178,16 @@
 // int  UserFlag()
 //	Renvoie la valeur "int" user de l'objet.
+//--
+
+//++
+// Titre	Export postscript et format RGB
+//--
+//++
+// void  PSPrint(PSFile *psf, int ofx=0, int ofy=0)
+//	Méthode virtuelle qui doit être redéfinie pour chacune des classes filles.
+//	produit une représentation graphique de l'objet en Postscript.
+// void  ExportToRGB(PIPixRGBArray & rgba)
+//	Méthode virtuelle qui doit être redéfinie pour chaque architecture.
+//	Remplit un tableau PIPixRGBArray le contenu pixels du widget en couleurs RGB. 
 //--
 
@@ -309,4 +318,10 @@
 }
 
+/* --Methode-- */
+void PIWdgGen::ExportToRGB(PIPixRGBArray & rgba)
+{
+return;
+}
+
 //++
 // Titre	Gestion des Draw/Event Handler
Index: /trunk/SophyaPI/PI/piwdggen.h
===================================================================
--- /trunk/SophyaPI/PI/piwdggen.h	(revision 4082)
+++ /trunk/SophyaPI/PI/piwdggen.h	(revision 4083)
@@ -10,4 +10,5 @@
 #include "pimsghandler.h"
 #include "picolist.h"
+#include "pipixutils.h"
 
 #include <string>
@@ -107,6 +108,10 @@
   virtual bool           IfSensitive()=0;
 
+//  Pour exporter le contenu d'un widget (dessin vectoriel) en postscript
   virtual void           PSPrint(PSFile *psf, int ofx=0, int ofy=0,
 				 double scale_x=1., double scale_y=1.);
+// Pour exporter le tableau des pixels du widget en classe  PIPixRGBArray
+// L'implementation par defaut ne fait rien 
+  virtual void           ExportToRGB(PIPixRGBArray & rgba);
 
 //  Gestion de copier-coller
Index: /trunk/SophyaPI/PI/piwdgx.cc
===================================================================
--- /trunk/SophyaPI/PI/piwdgx.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/piwdgx.cc	(revision 4083)
@@ -20,9 +20,5 @@
 #include "pigraphx.h"
 
-#ifdef SANS_EVOLPLANCK
-#include "perrors.h"
-#else
 #include "pexceptions.h"
-#endif
 
 
@@ -50,4 +46,5 @@
 szx = appSzX;  szy = appSzY;
 szf = appSzFont;
+ printf("XtAppContext* PIXtAppCtx :szx=%d szy=%d szf=%d",szx,szy,szf);
 return(&appctx);
 }
@@ -627,30 +624,30 @@
 // Ressources X si non definis 
 static const String fallback_res[26] = {
-"PeidaInt*default*background:                 LightGrey" ,
-"PeidaInt*background:                         LightGrey" ,
-"PeidaInt*Foreground:                         Black",
-"PeidaInt*default*Foreground:                 Black",
-"PeidaInt*default*bottomShadowColor:          Black",
-"PeidaInt*bottomShadowColor:                  Black",
-"PeidaInt*default*topShadowColor:             White",
-"PeidaInt*topShadowColor:                     White",
-"PeidaInt*borderColor:                        Black",
-"PeidaInt*XmLabel.borderWidth:                0",
-"PeidaInt*XmDrawingArea*background:           Black",
-"PeidaInt*XmPushButton*borderWidth:           0",
-"PeidaInt*XmText*shadowThickness:             2",
-"PeidaInt*XmText*highlightThickness:          0",
-"PeidaInt*XmText*marginHeigt:                 0",
-"PeidaInt*XmText*marginWidth:                 2",
-// "PeidaInt*DefMenubar*XtNwidth:                250",
-// "PeidaInt*DefMenubar*XtNheight:               30",
-"PeidaInt*fontList:           -*-courier-bold-r-normal-*-12-*-*-*-*-*-ISO8859-1",
-"PeidaInt*default*fontList:   -*-courier-bold-r-normal-*-12-*-*-*-*-*-ISO8859-1",
-"PeidaInt*fontFamilyName:                     *-courier",    // Pas de blanc apres le nom de font
-"PeidaInt*courierfontFamilyName:              *-courier",    //           "        " 
-"PeidaInt*helveticafontFamilyName:            *-helvetica",  //           "        " 
-"PeidaInt*timesfontFamilyName:                *-times",      //           "        " 
-"PeidaInt*symbolfontFamilyName:               *-symbol",     //           "        " 
-"PeidaInt*XmToggleButton*selectColor:         Red",
+const_cast<char*>("PeidaInt*default*background:                 LightGrey") ,
+const_cast<char*>("PeidaInt*background:                         LightGrey") ,
+const_cast<char*>("PeidaInt*Foreground:                         Black"),
+const_cast<char*>("PeidaInt*default*Foreground:                 Black"),
+const_cast<char*>("PeidaInt*default*bottomShadowColor:          Black"),
+const_cast<char*>("PeidaInt*bottomShadowColor:                  Black"),
+const_cast<char*>("PeidaInt*default*topShadowColor:             White"),
+const_cast<char*>("PeidaInt*topShadowColor:                     White"),
+const_cast<char*>("PeidaInt*borderColor:                        Black"),
+const_cast<char*>("PeidaInt*XmLabel.borderWidth:                0"),
+const_cast<char*>("PeidaInt*XmDrawingArea*background:           Black"),
+const_cast<char*>("PeidaInt*XmPushButton*borderWidth:           0"),
+const_cast<char*>("PeidaInt*XmText*shadowThickness:             2"),
+const_cast<char*>("PeidaInt*XmText*highlightThickness:          0"),
+const_cast<char*>("PeidaInt*XmText*marginHeigt:                 0"),
+const_cast<char*>("PeidaInt*XmText*marginWidth:                 2"),
+// const_cast<char*>("PeidaInt*DefMenubar*XtNwidth:                250"),
+// const_cast<char*>("PeidaInt*DefMenubar*XtNheight:               30"),
+const_cast<char*>("PeidaInt*fontList:           -*-courier-bold-r-normal-*-12-*-*-*-*-*-ISO8859-1"),
+const_cast<char*>("PeidaInt*default*fontList:   -*-courier-bold-r-normal-*-12-*-*-*-*-*-ISO8859-1"),
+const_cast<char*>("PeidaInt*fontFamilyName:                     *-courier"),    // Pas de blanc apres le nom de font
+const_cast<char*>("PeidaInt*courierfontFamilyName:              *-courier"),    //           "        " 
+const_cast<char*>("PeidaInt*helveticafontFamilyName:            *-helvetica"),  //           "        " 
+const_cast<char*>("PeidaInt*timesfontFamilyName:                *-times"),      //           "        " 
+const_cast<char*>("PeidaInt*symbolfontFamilyName:               *-symbol"),     //           "        " 
+const_cast<char*>("PeidaInt*XmToggleButton*selectColor:         Red"),
 NULL
 };
@@ -681,18 +678,10 @@
 if (top == NULL) {
   fprintf(stderr, "PIWdgX::InitXt()/ Error XtVaAppInitialize()\n");
-#ifdef SANS_EVOLPLANCK
-  throw notFoundErr;
-#else
-  throw NotFoundExc("PIWdgX::InitXt()/ Error XtVaAppInitialize()");
-#endif
+  throw PError("PIWdgX::InitXt()/ Error XtVaAppInitialize()");
   }
 dpy = XtDisplay(top);
 if (dpy == NULL)  {
   fprintf(stderr, "PIWdgX::InitXt()/ Error XtVaAppInitialize()/DisplayConnection\n");
-#ifdef SANS_EVOLPLANCK
-  throw notFoundErr;
-#else
-  throw NotFoundExc("PIWdgX::InitXt()/ Error XtVaAppInitialize()/DisplayConnection");
-#endif
+  throw PError("PIWdgX::InitXt()/ Error XtVaAppInitialize()/DisplayConnection");
   }
 
@@ -734,5 +723,5 @@
   }
 stdfnt = XLoadQueryFont(dpy, buff);
-char * myfntname = "???";
+const char * myfntname = "???";
 // Recherche du champ taille en pixel de la fonte : apres le 7eme tiret
 int mySzFont = 12;
@@ -831,4 +820,56 @@
 }
 
+
+// Pour exporter le tableau des pixels du widget en classe  PIPixRGBArray
+inline void _col2_fcol_(unsigned long & col, unsigned long & fcol)
+{
+  if (col > 0x00FFFFFF)  fcol = 0x01000000;
+  else if  (col > 0x0000FFFF)  fcol = 0x000010000;
+  else if (col > 0x000000FF) fcol = 0x00000100;
+  else fcol = 1;  
+}   
+/* --Methode-- */
+void PIWdgX::ExportToRGB(PIPixRGBArray & rgba)
+{
+Display* mdsp = PIXDisplay();
+int scr = XDefaultScreen(mdsp);
+int depth = DefaultDepth(mdsp,scr);
+Window xw = XtWindow(XtWdg());
+unsigned long plane_mask = ~0;  // tous les bits a 1
+XImage * ximg = XGetImage(mdsp, xw, 0, 0, XSize(), YSize(), plane_mask, ZPixmap);
+//DBG  cout << " Resultat XGetImage -> " << hex << ximg << dec << endl;
+if (ximg == NULL)  return;	
+                            
+unsigned long red,green,blue;
+unsigned long fred,fgreen,fblue;
+XColor col;
+Colormap  cmap = XDefaultColormap (mdsp, scr);
+red = 0x000000FF; 
+green = 0x0000FF00;
+blue = 0x00FF0000;
+unsigned short maxrgb = ~0;
+col.red = maxrgb;  col.green = col.blue = 0;
+if (XAllocColor(mdsp, cmap, &col)) red = col.pixel; 
+col.green = maxrgb;  col.red = col.blue = 0;
+if (XAllocColor(mdsp, cmap, &col)) green = col.pixel;      
+col.blue = maxrgb;  col.red = col.green = 0;
+if (XAllocColor(mdsp, cmap, &col)) blue = col.pixel;      
+_col2_fcol_(red, fred);
+_col2_fcol_(green, fgreen);
+_col2_fcol_(blue, fblue);
+rgba.SetSize(XSize(), YSize());
+unsigned long pixel;
+PIPixRGB rgb;
+for(int j=0; j<YSize(); j++)
+  for(int i=0; i<XSize(); i++) {
+    pixel = XGetPixel(ximg, i, j);
+    rgb.red = (pixel&red)/fred;
+    rgb.green = (pixel&green)/fgreen;
+    rgb.blue = (pixel&blue)/fblue;
+    rgba(i,j) = rgb;
+  }
+  XDestroyImage(ximg);
+  return;  
+}
 
 
Index: /trunk/SophyaPI/PI/piwdgx.h
===================================================================
--- /trunk/SophyaPI/PI/piwdgx.h	(revision 4082)
+++ /trunk/SophyaPI/PI/piwdgx.h	(revision 4083)
@@ -63,4 +63,7 @@
   virtual void           SetUnSensitive();
   virtual bool           IfSensitive();
+
+// Pour exporter le tableau des pixels du widget en classe  PIPixRGBArray
+  virtual void           ExportToRGB(PIPixRGBArray & rgba);
 
 //  Gestion de copier-coller
Index: /trunk/SophyaPI/PI/piwindowgen.h
===================================================================
--- /trunk/SophyaPI/PI/piwindowgen.h	(revision 4082)
+++ /trunk/SophyaPI/PI/piwindowgen.h	(revision 4083)
@@ -22,6 +22,6 @@
   virtual long      kind() {return ClassId; }
 
-   virtual void      PSPrint(PSFile *psf, int ofx=0, int ofy=0,
- 			    double scale_x=1., double scale_y=1.);
+  virtual void      PSPrint(PSFile *psf, int ofx=0, int ofy=0,
+			    double scale_x=1., double scale_y=1.);
 
   inline  void      AutoHideOnClose(bool ahc=true) { mAHC = ahc; }
Index: /trunk/SophyaPI/PI/piwindowx.cc
===================================================================
--- /trunk/SophyaPI/PI/piwindowx.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/piwindowx.cc	(revision 4083)
@@ -152,7 +152,9 @@
 //if (mWtyp == PIWK_transient)  
   XRaiseWindow(mdsp, XtWindow(pwm->XtWdg()));
+  // cmv+rz Fevrier 2009 (retour Moriond) - Suppression de XFlush() / usleep  
+  // Probleme regle par gestion VisibilityChange event ds pixtbase.cc
   // cmv+rz 09/08/2007 Ajout XFlush() + usleep 
   // pour regler le probleme de  perte d'evenement expose a la creation
-  XFlush(mdsp);   usleep(5000);
+  //  XFlush(mdsp);   usleep(5000);
 return;
 }
Index: /trunk/SophyaPI/PI/pixtbase.cc
===================================================================
--- /trunk/SophyaPI/PI/pixtbase.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/pixtbase.cc	(revision 4083)
@@ -46,5 +46,5 @@
 
 static XtResource resources[] ={
-  {PIXNobject ,(char *)"Object", XtRPointer, sizeof(XtRPointer),
+  {const_cast<char*>(PIXNobject) ,const_cast<char*>("Object"), XtRPointer, sizeof(XtRPointer),
    XtOffset(PIXtBaseWidget,  pixtbase.objet), XtRImmediate, (XtPointer)0},
 };
@@ -143,4 +143,24 @@
 }
 
+// Pour traiter les etats de changements de visibilite de la fenetre
+/* Nouvelle-Fonction */
+void visibchange_handler_pixtbase (Widget wdgp, XtPointer /*closure*/, 
+                             XEvent* evt, Boolean* cont)
+{
+#ifdef DEBUG_PIXTB
+printf("Debug_visibchange_handler_pixtbase: Wdg= %lx Object= %lx  fgvis_expose= %d (EvtType=%d VisSt=%d)\n", 
+  (long)wdgp, (long)(((PIXtBaseWidget)wdgp)->pixtbase.objet),
+  ((PIXtBaseWidget)wdgp)->pixtbase.vis_expose_fg, (int)evt->type,(int)evt->xvisibility.state);
+#endif
+PIXtBaseWidget bwdg = (PIXtBaseWidget)wdgp;
+if (bwdg->pixtbase.vis_expose_fg != 1) return;
+if (evt->xvisibility.state == VisibilityFullyObscured)  return;
+int x0, y0, dx, dy;
+x0 = y0 = 0;
+dx = wdgp->core.width;  dy = wdgp->core.height;
+(bwdg->pixtbase.objet)->eXposeProcess(x0, y0, dx, dy);
+bwdg->pixtbase.vis_expose_fg = 0;
+}
+
 /* Nouvelle-Fonction */
 static void init_pixtbase (Widget request, Widget wdg,
@@ -154,12 +174,16 @@
 // get_GCs (wdgp);
 #ifdef DEBUG_PIXTB
-printf("Debug_init_pixtbase: Wdg=%lx Object= %lx  narg=%d \n", 
-(long)wdgp, (long)(wdgp->pixtbase.objet), (int)(*narg));
-#endif
-return;
-}
-
-/* Nouvelle-Fonction */
-static void destroy_pixtbase (Widget /*wdgp*/)
+printf("Debug_init_pixtbase: Wdg=%lx Object= %lx  \n", 
+(long)wdgp, (long)(wdgp->pixtbase.objet));
+#endif
+
+// Pour gerer les exposes event avec fenetre non visible ...
+wdgp->pixtbase.vis_expose_fg = 0;
+XtAddEventHandler(wdg, VisibilityChangeMask, FALSE, visibchange_handler_pixtbase, NULL);
+return;
+}
+
+/* Nouvelle-Fonction */
+static void destroy_pixtbase (Widget wdgp)
 {
 #ifdef DEBUG_PIXTB
@@ -194,14 +218,23 @@
 (long)(((PIXtBaseWidget)wdgp)->pixtbase.objet) );
 #endif
-if (!(wdgp->core.visible))  return;
-if ( ((PIXtBaseWidget)wdgp)->pixtbase.objet ) 
-  {
+if (!(wdgp->core.visible))  { 
+  ((PIXtBaseWidget)wdgp)->pixtbase.vis_expose_fg = 1;
+  return;
+}
+if ( ((PIXtBaseWidget)wdgp)->pixtbase.objet ) {
   XRectangle  xrec;
   int x0, y0, dx, dy;
-  XClipBox(region, &xrec);
-  x0 = xrec.x;  y0 = xrec.y;
-  dx = xrec.width;  dy = xrec.height;
+  if (region) {
+    XClipBox(region, &xrec);
+    x0 = xrec.x;  y0 = xrec.y;
+    dx = xrec.width;  dy = xrec.height;
+  }
+  else {
+    x0 = y0 = 0;
+    dx = wdgp->core.width;  dy = wdgp->core.height;
+  }
   (((PIXtBaseWidget)wdgp)->pixtbase.objet)->eXposeProcess(x0, y0, dx, dy);
-  }
+  ((PIXtBaseWidget)wdgp)->pixtbase.vis_expose_fg = 0;
+}
 return;
 }
Index: /trunk/SophyaPI/PI/pixtbaseP.h
===================================================================
--- /trunk/SophyaPI/PI/pixtbaseP.h	(revision 4082)
+++ /trunk/SophyaPI/PI/pixtbaseP.h	(revision 4083)
@@ -24,4 +24,5 @@
 PIBaseWdgX  * objet; 
 unsigned long myeventmask;
+unsigned int vis_expose_fg;   // Gestion des expose_event avec fenetre non visible
 } PIXtBasePart;
 
Index: /trunk/SophyaPI/PI/psfile.cc
===================================================================
--- /trunk/SophyaPI/PI/psfile.cc	(revision 4082)
+++ /trunk/SophyaPI/PI/psfile.cc	(revision 4083)
@@ -682,5 +682,5 @@
 	}
 	/* Portrait ou Landscape ? */
-	if(orientation == PI_Auto) 
+	if(orientation == PI_Auto)  {
 	    if( ((tw < th) && (Dx < 1.2*Dy)) ||
 		((tw > th) && (Dx > Dy) )) 
@@ -688,5 +688,5 @@
 	    else 
 		currentPage->orientation = PI_Landscape ;
-
+	}
 	if(currentPage->orientation == PI_Portrait) {
 	  //	    if( (tw/Dx) < (th/Dy) ) 
@@ -1367,6 +1367,46 @@
     for(i = 0; i < Ny; i++) {
 	for(j = 0; j<Nx-1; j++ )
-	    fprintf(mPSFile, "%02X", Pict[i*Nx+j]);
-    fprintf(mPSFile, "%02X\n", Pict[i*Nx+j]);
+	    fprintf(mPSFile, "%02X", (int)Pict[i*Nx+j]);
+    fprintf(mPSFile, "%02X\n", (int)Pict[i*Nx+j]);
+    }
+    /* Un petit grestore ...*/
+    fprintf(mPSFile, "gr\n");
+}
+
+void PSFile::Image(double x0, double y0, double Tx, double Ty,
+		   int Nx, int Ny,
+		   unsigned short *Pict, 
+		   PIColorMap *mMap) {
+
+    int i, j;
+
+    /* Buffers PostScript */
+    fprintf(mPSFile, "/Taille %d def\n", Nx);
+    fprintf(mPSFile, "/ImStr Taille string def\n");
+    fprintf(mPSFile, "/RGBStr Taille 3  mul string def\n");
+
+    /* Ecriture ColorMap */
+    fprintf(mPSFile, "/ColorMap %05d array def\n", mMap->NCol() );
+    for(i = 0; i < mMap->NCol(); i++) {
+	fprintf(mPSFile, "ColorMap %d [16#%02X 16#%02X 16#%02X] put\n",
+		i,
+		(int)(mMap->GetColor(i).red/256),
+		(int)(mMap->GetColor(i).green/256),
+		(int)(mMap->GetColor(i).blue/256));
+    }
+    /* Emplacement de l'image */
+    fprintf(mPSFile, "gs %.2f Ux %.2f Uy tr %.2f Ux %.2f Uy sc\n", x0, y0, Tx, Ty);
+    /* Nbr pix-X, Nbr pix-Y bits/pixels */
+    fprintf(mPSFile, "%d %d 16\n", Nx, Ny);
+    /* Matrice de passage */
+    fprintf(mPSFile, "[%d 0 0 %d 0 0]", Nx, Ny);
+    /* Fonction colorimage */
+    fprintf(mPSFile, "{currentfile ImStr readhexstring pop GetRGB}\
+false 3 colorimage\n\n");
+    /* Data */
+    for(i = 0; i < Ny; i++) {
+	for(j = 0; j<Nx-1; j++ )
+	    fprintf(mPSFile, "%04X", (int)Pict[i*Nx+j]);
+    fprintf(mPSFile, "%04X\n", (int)Pict[i*Nx+j]);
     }
     /* Un petit grestore ...*/
Index: /trunk/SophyaPI/PI/psfile.h
===================================================================
--- /trunk/SophyaPI/PI/psfile.h	(revision 4082)
+++ /trunk/SophyaPI/PI/psfile.h	(revision 4083)
@@ -165,4 +165,8 @@
 			unsigned char *pict,
 			PIColorMap *mColorMap);
+    virtual void  Image(double x0, double y0, double Tx, double Ty,
+			int Nx, int Ny,
+			unsigned short *pict,
+			PIColorMap *mColorMap);
 
 // Declarations en public - sinon certains compilateurs cxx , aCC, xlC ont des problemes
