Index: /trunk/SophyaPI/PI/pibwdggen.cc
===================================================================
--- /trunk/SophyaPI/PI/pibwdggen.cc	(revision 504)
+++ /trunk/SophyaPI/PI/pibwdggen.cc	(revision 505)
@@ -100,4 +100,5 @@
 SetDefaultDrawRectangle(0., 0., 1., 1., true);
 SetDefaultDrawerLimits(0., 1., 0., 1., kAxeDirLtoR, kAxeDirUpDown);
+SetDefaultDrawerLogScale(false, false);
 }
 
@@ -316,5 +317,9 @@
 // void  SetDefaultDrawerLimits(double xmin, double xmax, double ymin, double ymax, -
 //                              int axrl=kAxeDirSame, int ayud=kAxeDirSame)
-//	Définition du système de coordonnées par défaut d'un drawer attaché en "autolim=true"
+//	Définition du système de coordonnées par défaut d'un drawer attaché 
+//	en "autolim=true"
+// void  SetDefaultDrawerLogScale(bool logx, bool logy)
+//	Définition d'échelle logarithmique pour le système de coordonnées par défaut
+//	d'un drawer attaché en "autolim=true".
 //
 //--
@@ -336,4 +341,10 @@
 }
 
+/* --Methode-- */
+void PIBaseWdgGen::SetDefaultDrawerLogScale(bool logx, bool logy)
+{
+mDXlog = logx; 
+mDYlog = logy; 
+}
 
 //++
@@ -521,6 +532,8 @@
     }
 // L'ordre des operations ici est importante 
-  if ( (*it).autolim )  
+  if ( (*it).autolim ) {
      (*it).drw->SetLimits(mDrXmin, mDrXmax, mDrYmin, mDrYmax, mDXdir, mDYdir);     
+     (*it).drw->SetLogScale(mDXlog, mDYlog);
+  }
   guc = (*it).drw->SetDrwWdg(this, drx0, dry0, drdx, drdy, g);
   if ((*it).clip)  { g->SetClipRectangle(drx0, dry0, drdx , drdy);  fgc = true; }
@@ -583,6 +596,8 @@
       }
 // L'ordre des operations ici est importante 
-    if ( (*it).autolim ) 
+    if ( (*it).autolim ) {
        (*it).drw->SetLimits(mDrXmin, mDrXmax, mDrYmin, mDrYmax, mDXdir, mDYdir);
+       (*it).drw->SetLogScale(mDXlog, mDYlog);
+    }
     guc = (*it).drw->SetDrwWdg(this, drx0, dry0, drdx, drdy, g);
     if ((*it).clip)  g->SetClipRectangle(drx0, dry0, drdx , drdy);
Index: /trunk/SophyaPI/PI/pibwdggen.h
===================================================================
--- /trunk/SophyaPI/PI/pibwdggen.h	(revision 504)
+++ /trunk/SophyaPI/PI/pibwdggen.h	(revision 505)
@@ -84,4 +84,8 @@
   virtual void       SetDefaultDrawerLimits(double xmin, double xmax, double ymin, double ymax,
                                             int axrl=kAxeDirSame, int ayud=kAxeDirSame); 
+  virtual void	     SetDefaultDrawerLogScale(bool logx, bool logy);
+  inline  bool       isDefaultDrawerLogScaleX() { return(mDXlog); }
+  inline  bool       isDefaultDrawerLogScaleY() { return(mDYlog); }
+
   virtual int        AddDrawer(PIDrawer* drw, PIGrCoord x1, PIGrCoord y1, 
                                PIGrCoord x2, PIGrCoord y2, 
@@ -117,5 +121,5 @@
   double mDrXmin, mDrXmax, mDrYmin, mDrYmax;   // Limites par defaut - UC
   int  mDXdir, mDYdir;                        // Sens des axes par defaut
-
+  bool mDXlog, mDYlog;                        // true -> echelle log - axes par defaut
 };
 
Index: /trunk/SophyaPI/PI/pidrawer.cc
===================================================================
--- /trunk/SophyaPI/PI/pidrawer.cc	(revision 504)
+++ /trunk/SophyaPI/PI/pidrawer.cc	(revision 505)
@@ -43,4 +43,5 @@
   aXdir = false;  // Vrai si Axe X de Droite vers Gauche 
   aYdir = false;  // Vrai si Axe Y de Haut vers Bas
+  aXlog = aYlog = false;   // Vrai -> echelle axe logarithmique
   SetLimits(-1, 1, -1, 1, kAxeDirLtoR, kAxeDirDownUp);
   limitsFixed = 0;
@@ -76,6 +77,10 @@
 //|	kAxeDirLtoR , kAxeDirRtoL  (Axe X)
 //|	kAxeDirDownUp , kAxeDirUpDown (Axe Y)	
+// void  SetLogScale(bool logx, bool logy) 
+//	Définition d'échelle logarithmique pour les axes X,Y.
 // void  GetAxesConfig(int& xa, int& ya) 
 //	Renvoie la configuration des axes.
+// bool  isLogScaleX()   isLogScaleY() 
+//	Renvoie "true" si échelle logarithmique pour axe X , Y
 // double XMin()  XMax()
 //	Limites de l'axe X
@@ -128,4 +133,5 @@
   limitsFixed = 1;
 }
+
 
 void
@@ -280,4 +286,5 @@
   mGrUC = new PIGraphicUC(g, x0, y0, dx, dy);
   mGrUC->SetUCS(xMin, xMax, yMin, yMax, aXFlg, aYFlg);
+  if (aXlog || aYlog) mGrUC->SetLogScale(aXlog, aYlog);
   return(mGrUC);
 }
Index: /trunk/SophyaPI/PI/pidrawer.h
===================================================================
--- /trunk/SophyaPI/PI/pidrawer.h	(revision 504)
+++ /trunk/SophyaPI/PI/pidrawer.h	(revision 505)
@@ -32,4 +32,6 @@
   virtual void       SetLimits(double xmin, double xmax, double ymin, double ymax,
                                int axrl=kAxeDirSame, int ayud=kAxeDirSame);
+  inline void	     SetLogScale(bool logx, bool logy) 
+                             { aXlog = logx; aYlog = logy; }
 
   virtual void       DrawAxes(PIGraphicUC* g);
@@ -48,7 +50,10 @@
   inline double      YMax() const {return yMax;}
 
-  void                GetAxesConfig(int& xa, int& ya);
+  void               GetAxesConfig(int& xa, int& ya);
+  inline bool        isLogScaleX() { return aXlog; }
+  inline bool        isLogScaleY() { return aYlog; }
+
   inline unsigned int GetAxesFlags() { return(axesFlags); }
-  
+
   inline PIGraphicUC*    GetGraphicUC() { return(mGrUC); }
 
@@ -106,4 +111,5 @@
   int xW0, yW0, xWd, yWd;        // Origine/largeur ds la fenetre de trace
   bool   aXdir, aYdir;           // Sens des axes horiz, vertical 
+  bool   aXlog, aYlog;           // Echelle log pour les axes horiz, vertical 
   int aXFlg, aYFlg;
 
Index: /trunk/SophyaPI/PI/pidrwtools.cc
===================================================================
--- /trunk/SophyaPI/PI/pidrwtools.cc	(revision 504)
+++ /trunk/SophyaPI/PI/pidrwtools.cc	(revision 505)
@@ -55,5 +55,5 @@
 
 int wszx = 5*spx+3.5*bsx; 
-int wszy = (7+3*0.85)*(spy+bsy);
+int wszy = (8+3*0.85)*(spy+bsy);
 SetSize(wszx, wszy);
 
@@ -82,13 +82,20 @@
 mCkb[0] = new PICheckBox(this,"X-RtoL", 2000, bsx, bsy, cpx, cpy);
 cpx += spx+bsx; 
-mCkb[1] = new PICheckBox(this,"Y-UpDn", 2000, bsx, bsy, cpx, cpy);
+mCkb[1] = new PICheckBox(this,"Y-UpDn", 2001, bsx, bsy, cpx, cpy);
 cpx += spx+bsx; 
-mCkb[2] = new PICheckBox(this,"Grid", 2000, bsx, bsy, cpx, cpy);
+mCkb[2] = new PICheckBox(this,"Grid", 2002, bsx, bsy, cpx, cpy);
 mCkb[0]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
 mCkb[1]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
 mCkb[2]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
-
 cpy += spy+bsy; 
-cpx = spx+0.25*bsx;;
+cpx = spx+0.25*bsx;
+mCkb[3] = new PICheckBox(this,"LogScale-X", 2003, bsx*1.5, bsy, cpx, cpy);
+cpx += bsx*1.5+3*spx;
+mCkb[4] = new PICheckBox(this,"LogScale-Y", 2004, bsx*1.5, bsy, cpx, cpy);
+mCkb[3]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
+mCkb[4]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
+
+cpy += spy+bsy; 
+cpx = spx+0.25*bsx;
 mBut[0] = new PIButton(this, "SetAxes", 2600, bsx*1.5, bsy, cpx, cpy);
 cpx += bsx*1.5+3*spx;
@@ -257,5 +264,6 @@
   }
 
-for(i=0; i<3; i++) { delete mCkb[i];   delete mButcf[i]; }
+for(i=0; i<5; i++) delete mCkb[i];
+for(i=0; i<3; i++) delete mButcf[i]; 
 delete mButcf[3];
 for(i=0; i<6; i++)  delete mOpt[i];
@@ -306,4 +314,6 @@
 mCkb[1]->SetState(false);
 mCkb[2]->SetState(false);
+mCkb[3]->SetState(false);
+mCkb[4]->SetState(false);
 
 if ((mCurBW != NULL) && ( mCurBW->kind() == PIScDrawWdg::ClassId ) ) {
@@ -318,4 +328,6 @@
   if (ya & kAxeDirUpDown)  mCkb[1]->SetState(true);
   if (scd->GetAxesFlags() & kGridOn) mCkb[2]->SetState(true);
+  mCkb[3]->SetState(scd->isLogScaleX());
+  mCkb[4]->SetState(scd->isLogScaleY());
   }
 else {
@@ -398,4 +410,8 @@
 
   case 2600 :
+    if ( mCurBW->kind() != PIScDrawWdg::ClassId ) {
+      cerr << "PIDrwTools: SetAxes applicable to PIScDrawWdg only ! " << endl;
+      return;
+      }
     sscanf(mText[0]->GetText().c_str(), "%lg %lg" , &xmin, &xmax);
     sscanf(mText[1]->GetText().c_str(), "%lg %lg" , &ymin, &ymax);
@@ -407,6 +423,8 @@
       if (mCkb[2]->GetState()) ((PIScDrawWdg*)mCurBW)->SetAxesFlags(flags | kGridOn);
       else  ((PIScDrawWdg*)mCurBW)->SetAxesFlags(flags & ~kGridOn);
+      ((PIScDrawWdg*)mCurBW)->SetLogScale(mCkb[3]->GetState(),
+                                          mCkb[4]->GetState() );
       }
-    else mCurBW->SetDefaultDrawerLimits(xmin, xmax, ymin, ymax, axrl, ayud);
+    //    else mCurBW->SetDefaultDrawerLimits(xmin, xmax, ymin, ymax, axrl, ayud);
     mCurBW->Refresh();
     break;
Index: /trunk/SophyaPI/PI/pidrwtools.h
===================================================================
--- /trunk/SophyaPI/PI/pidrwtools.h	(revision 504)
+++ /trunk/SophyaPI/PI/pidrwtools.h	(revision 505)
@@ -38,5 +38,5 @@
   PIButton* mBut[2];
   PIText* mText[2];
-  PICheckBox* mCkb[3];
+  PICheckBox* mCkb[5];
 // Pour couleur, fontes, etc 
   PIOptMenu* mOpt[6];
Index: /trunk/SophyaPI/PI/pigraphuc.cc
===================================================================
--- /trunk/SophyaPI/PI/pigraphuc.cc	(revision 504)
+++ /trunk/SophyaPI/PI/pigraphuc.cc	(revision 505)
@@ -60,5 +60,7 @@
   aXdir = false;  // Vrai si Axe X de Droite vers Gauche 
   aYdir = false;  // Vrai si Axe Y de Haut vers Bas
+  aXlog = aYlog = false;   // Vrai -> Echelle log
   SetUCS(0., 1., 0., 1., kAxeDirLtoR, kAxeDirDownUp);
+  SetLogScale(false, false);
   clip = true;  
 }
@@ -111,4 +113,12 @@
 //	Par défaut : "xmin=ymin=0." , "ymin=ymax=0." , "kAxeDirLtoR" , "kAxeDirDownUp"
 // 
+// void  SetLogScale(bool logx, bool logy)
+//	Définition d'échelle logarithmique pour l'axe X,Y (si X,Ymin max > 0).
+//	Si X,Ymin max sont modifiés par SetUCS par la suite, avec des 
+//	valeurs négatives, l'échelle est remise en linéaire.
+// bool  isLogScaleX()  
+// bool  isLogScaleY() 
+//	Renvoie "true" si échelle logarithmique pour l'axe X,Y
+//	
 // void  UC2GrC(double x, double y, double& xpix, double& ypix)
 //	Transformation de coordonnées utilisateur "(x,y)" en coordoonnées 
@@ -176,13 +186,67 @@
   else yOrg   = -yMin * yScale;
   yOrg += yW0;
+  if (aXlog || aYlog) SetLogScale(aXlog, aYlog);
   return;
 }
 
+/* --Methode-- */
+void PIGraphicUC::SetLogScale(bool logx, bool logy)
+{
+if (logx) 
+  if (xMax < 1.e-39) {
+    cerr << "PIGraphicUC::SetLogScale() Warning - XLogScale not valid for XMax ="
+         << xMax << " < 1.e-39" << endl;
+    logx = false;
+  }
+if (logy)
+  if (yMax < 1.e-39) {
+    cerr << "PIGraphicUC::SetLogScale() Warning - YLogScale not valid for YMax ="
+         << yMax << " < 1.e-39" << endl;
+    logy = false;
+  }
+
+aXlog = logx;
+aYlog = logy;
+
+if (aXlog) {     
+  xMinLog = (xMin > 1.e-39) ? xMin : ( (1. < xMax/10.) ? 1. : xMax/10.);
+  xScaleLog = xWd*(xMax-xMinLog)/(xMax-xMin) / (log10(xMax)-log10(xMinLog));
+  if (xScaleLog < 1.e-19)  xScaleLog = 1.e-19;  // Protection 
+  if (aXdir)  { 
+    xScaleLog = -xScaleLog;
+    xOrgLog   = -log10(xMax) * xScaleLog + (xOrg + xMax*xScale);
+  }
+  else xOrgLog   = -log10(xMinLog) * xScaleLog + (xOrg + xMinLog*xScale);
+}
+else {
+  xMinLog = 1.;
+  xScaleLog = xScale;
+  xOrgLog = xW0;
+}
+if (aYlog) {     
+  yMinLog = (yMin > 1.e-39) ? yMin : ( (1. < yMax/10.) ? 1. : yMax/10.);
+  yScaleLog = yWd*(yMax-yMinLog)/(yMax-yMin) / (log10(yMax)-log10(yMinLog));
+  if (yScaleLog < 1.e-19)  yScaleLog = 1.e-19;  // Protection 
+  if (!aYdir) {
+    yScaleLog = -yScaleLog;
+    yOrgLog   = -log10(yMax)  * yScaleLog + (yOrg + yMax*yScale);
+    }
+  else yOrgLog   = -log10(yMinLog) * yScaleLog + (yOrg + yMinLog*yScale);
+}  
+else {
+  yMinLog = 1.;
+  yScaleLog = xScale;
+  yOrgLog = xW0;
+}
+return;
+}
 
 /* --Methode-- */
 void PIGraphicUC::UC2GrC(double x, double y, double& xpix, double& ypix)
 {
-  xpix = (double)(xOrg + x*xScale);  
-  ypix = (double)(yOrg + y*yScale);  
+  if (aXlog && (x > xMinLog))  xpix = xOrgLog + log10(x)*xScaleLog;  
+  else xpix = (double)(xOrg + x*xScale);  
+  if (aYlog && (y > yMinLog))  ypix = yOrgLog + log10(y)*yScaleLog; 
+  else ypix = (double)(yOrg + y*yScale);  
 }
 
@@ -190,6 +254,24 @@
 void PIGraphicUC::GrC2UC(double xpix, double ypix, double& x, double& y)
 {
-  x = (xpix-xOrg)/xScale;
-  y = (ypix-yOrg)/yScale;
+  if (!aXlog)  x = (xpix-xOrg)/xScale;
+  else { 
+    if ( (aXdir && (xpix < (xOrg + xMinLog*xScale))) || 
+         (!aXdir && (xpix > (xOrg + xMinLog*xScale))) )     {
+      x = (xpix-xOrgLog)/xScaleLog;
+      x = pow(10., x);
+    }
+    else x = (xpix-xOrg)/xScale;
+  }
+       
+  if (!aYlog)  y = (ypix-yOrg)/yScale;
+  else { 
+    if ( (aYdir && (ypix > (yOrg + yMinLog*yScale))) || 
+         (!aYdir && (ypix < (yOrg + yMinLog*yScale))) )    {
+      y = (ypix-yOrgLog)/yScaleLog;
+      y = pow(10., y);
+    }
+    else y = (ypix-yOrg)/yScale;
+  }
+
 }
 
Index: /trunk/SophyaPI/PI/pigraphuc.h
===================================================================
--- /trunk/SophyaPI/PI/pigraphuc.h	(revision 504)
+++ /trunk/SophyaPI/PI/pigraphuc.h	(revision 505)
@@ -34,4 +34,8 @@
   virtual void       SetUCS(double xmin, double xmax, double ymin, double ymax,
                             int axrl=kAxeDirSame, int ayud=kAxeDirSame);     
+// Echelle logarithmique
+  virtual void	     SetLogScale(bool logx, bool logy);
+  inline  bool	     isLogScaleX() { return aXlog; }
+  inline  bool	     isLogScaleY() { return aYlog; }
 
 //  Trace graphiques
@@ -113,6 +117,10 @@
   double xOrg, yOrg;             // Position en pixels de (0.0, 0.0)
   double xScale, yScale;         // Pixels par unites graphiques
-  double xW0, yW0, xWd, yWd;        // Origine/largeur ds la fenetre de trace
+  double xMinLog, yMinLog;       // Limite basse (>0,x,yMin) pour echelle log
+  double xOrgLog, yOrgLog;       // Position en pixels de log10(xyMinLog)
+  double xScaleLog, yScaleLog;   // Pixels par unites graphiques Echelle Log
+  double xW0, yW0, xWd, yWd;     // Origine/largeur ds la fenetre de trace
   bool   aXdir, aYdir;           // Sens des axes horiz, vertical 
+  bool   aXlog, aYlog;		 // true-> Echelle logarithmique pour axe X,y 
   bool   clip;
 };
Index: /trunk/SophyaPI/PI/piscdrawwdg.cc
===================================================================
--- /trunk/SophyaPI/PI/piscdrawwdg.cc	(revision 504)
+++ /trunk/SophyaPI/PI/piscdrawwdg.cc	(revision 505)
@@ -142,6 +142,8 @@
                        int axrl, int ayud, bool tmp)
 {
-  if (xmax <= xmin || ymax <= ymin)
-    return; // $CHECK$ exception ?
+  if (xmax <= xmin || ymax <= ymin) {
+    cerr << "PIScDrawWdg::SetLimits() Error - xmax <= xmin or ymax <= ymin !" << endl;
+    return; 
+    }
   SetDefaultDrawerLimits(xmin, xmax, ymin, ymax, axrl, ayud);
   mBDrw->SetLimits(xmin, xmax, ymin, ymax, axrl, ayud);
Index: /trunk/SophyaPI/PI/piscdrawwdg.h
===================================================================
--- /trunk/SophyaPI/PI/piscdrawwdg.h	(revision 504)
+++ /trunk/SophyaPI/PI/piscdrawwdg.h	(revision 505)
@@ -28,4 +28,9 @@
   virtual void       SetLimits(double xmin, double xmax, double ymin, double ymax, 
                                int axrl=kAxeDirSame, int ayud=kAxeDirSame, bool tmp=false);
+  inline  void	     SetLogScale(bool logx, bool logy)	
+                           { SetDefaultDrawerLogScale(logx, logy); }
+  inline  bool       isLogScaleX() { return(mDXlog); }
+  inline  bool       isLogScaleY() { return(mDYlog); }
+
   virtual void	     UpdateLimits();  // Calcule et change les limites a partir de Drawer-No-1 
 
