// $Id: fgl_xyframe.h $
// =================================================================
//  This code is distributed under the terms and conditions of the
//  CCP4 Program Suite Licence Agreement as 'Part 2' (Annex 2)
//  software. A copy of the CCP4 licence can be obtained by writing
//  to CCP4, Research Complex at Harwell, Rutherford Appleton
//  Laboratory, Didcot OX11 0FA, UK, or from
//  http://www.ccp4.ac.uk/ccp4license.php.
// =================================================================
//
//    29.08.13   <--  Date of Last Modification.
//                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//  ----------------------------------------------------------------
//
//  **** Module  :  fgl_xyframe <interface>
//       ~~~~~~~~~
//  **** Project :  QtLibs/FGL - plotting in Qt
//       ~~~~~~~~~
//  **** Classes :  fgl::XYFrame
//       ~~~~~~~~~
//
//  (C) E. Krissinel 2012-2013
//
// =================================================================
//

#ifndef FGL_XYFRAME_H
#define FGL_XYFRAME_H

#include <QtGlobal>
#include <QFont>
#include <QRectF>
#include <QColor>

#include "fgl_axisdata.h"

namespace fgl  {

  class Scene;
  class Plot;

  class XYFrame  {

    public:

      XYFrame ( Plot *p );
      ~XYFrame();

      inline Plot *getPlot() { return plot; }

      /// Sets frame dimensions (logical ranges). All relative sizes
      /// are calibrated for w,h ~ 100 . Logical ranges are converted
      /// into screen coordinates by fgl::Scene.
      void setFrameRect ( qreal x, qreal y, qreal w, qreal h );

      /// Sets frame dimensions (logical ranges). All relative sizes
      /// are calibrated for w,h ~ 100 . Logical ranges are converted
      /// into screen coordinates by fgl::Scene.
      void setFrameRect ( const QRectF & rect );

      QRectF getFrameRect();
      QRectF getClipRect ();

      /// Sets physical ranges for x- and y- axes
      void setXYRange ( const qreal x1, const qreal x2,
                        const qreal y1, const qreal y2 );
      /// Sets physical range for x- axis
      void setXRange  ( const qreal x1, const qreal x2 );
      /// Sets physical range for y- axis
      void setYRange  ( const qreal y1, const qreal y2 );
      /// Sets physical range for z- axis
      void setZRange  ( const qreal z1, const qreal z2 );

      void setAxes    ( bool left, bool right, bool top, bool bottom );
      void setScales  ( bool left, bool right, bool top, bool bottom );
      void setGaps    ( bool left, bool right, bool top, bool bottom );

      /// Set physical limits for axes
      inline void setXMin      ( const qreal   x  ) { X.setQ1(x);  }
      inline void setXMax      ( const qreal   x  ) { X.setQ2(x);  }
      inline void setYMin      ( const qreal   y  ) { Y.setQ1(y);  }
      inline void setYMax      ( const qreal   y  ) { Y.setQ2(y);  }
      inline void setZMin      ( const qreal   z  ) { Z.setQ1(z);  }
      inline void setZMax      ( const qreal   z  ) { Z.setQ2(z);  }

      inline void setXAxisData ( AxisData   *axis ) { X.Copy(axis); }
      inline void setYAxisData ( AxisData   *axis ) { Y.Copy(axis); }
      inline void setZAxisData ( AxisData   *axis ) { Z.Copy(axis); }

      inline AxisData * getXAxisData()  { return &X; }
      inline AxisData * getYAxisData()  { return &Y; }
      inline AxisData * getZAxisData()  { return &Z; }

      inline void setFont      ( const QFont  & f ) { font       = f;  }
      inline void setColor     ( const QColor & c ) { color      = c;  }
      inline void setLineWidth ( const qreal   lw ) { lineWidth  = lw; }
      inline void setCharSize  ( const qreal   cs ) { charSize   = cs; }
      inline void setLogScaleX ( const bool    ls )
        { X.setScaleKey ( ls?AxisData::SCALE_Log:AxisData::SCALE_Native ); }
      inline void setLogScaleY ( const bool    ls )
        { Y.setScaleKey ( ls?AxisData::SCALE_Log:AxisData::SCALE_Native ); }
      inline void setLogScaleZ ( const bool    ls )
        { Z.setScaleKey ( ls?AxisData::SCALE_Log:AxisData::SCALE_Native ); }
      inline void setScaleX    ( const AxisData::Scale key )
                                                { X.setScaleKey(key); }
      inline void setScaleY    ( const AxisData::Scale key )
                                                { Y.setScaleKey(key); }
      inline void setScaleZ    ( const AxisData::Scale key )
                                                { Z.setScaleKey(key); }
      inline void setHashX     ( const AxisData::LabelHash key )
                                                { X.setHashLabel(key); }
      inline void setHashY     ( const AxisData::LabelHash key )
                                                { Y.setHashLabel(key); }
      inline void setHashZ     ( const AxisData::LabelHash key )
                                                { Z.setHashLabel(key); }
      inline void setLogBreakX ( const qreal lb ) { X.setLogBreak(lb); }
      inline void setLogBreakY ( const qreal lb ) { Y.setLogBreak(lb); }
      inline void setLogBreakZ ( const qreal lb ) { Z.setLogBreak(lb); }

      /// Retrieves physical ranges for x- and y- axes
      void getXYRange ( qreal & x1, qreal & x2, qreal & y1, qreal & y2 );
      /// Retrieves physical range for x- axis
      void getXRange  ( qreal & x1, qreal & x2 );
      /// Retrieves physical range for y- axis
      void getYRange  ( qreal & y1, qreal & y2 );
      /// Retrieves physical range for z- axis
      void getZRange  ( qreal & z1, qreal & z2 );

      inline qreal  getXMin        ()  { return X.getQ1();    }
      inline qreal  getXMax        ()  { return X.getQ2();    }
      inline qreal  getYMin        ()  { return Y.getQ1();    }
      inline qreal  getYMax        ()  { return Y.getQ2();    }
      inline qreal  getZMin        ()  { return Z.getQ1();    }
      inline qreal  getZMax        ()  { return Z.getQ2();    }

      inline qreal  getSX1         ()  { return X.getS1();    }
      inline qreal  getSX2         ()  { return X.getS2();    }
      inline qreal  getSY1         ()  { return Y.getS1();    }
      inline qreal  getSY2         ()  { return Y.getS2();    }
      inline qreal  getSZ1         ()  { return Z.getS1();    }
      inline qreal  getSZ2         ()  { return Z.getS2();    }

      inline QFont  getFont        ()  { return font;         }
      inline QColor getColor       ()  { return color;        }
      inline qreal  getLineWidth   ()  { return lineWidth;    }
      inline qreal  getCharSize    ()  { return charSize;     }
      inline bool   getLogScaleX   ()
                  { return (X.getScaleKey()==AxisData::SCALE_Log); }
      inline bool   getLogScaleY   ()
                  { return (Y.getScaleKey()==AxisData::SCALE_Log); }
      inline bool   getLogScaleZ   ()
                  { return (Z.getScaleKey()==AxisData::SCALE_Log); }
      inline AxisData::Scale getScaleX() { return X.getScaleKey(); }
      inline AxisData::Scale getScaleY() { return Y.getScaleKey(); }
      inline AxisData::Scale getScaleZ() { return Z.getScaleKey(); }
      inline qreal  getLogBreakX   ()  { return X.getLogBreak();   }
      inline qreal  getLogBreakY   ()  { return Y.getLogBreak();   }
      inline qreal  getLogBreakZ   ()  { return Z.getLogBreak();   }
      inline QRectF getBoundingRect()  { return boundingRect; }
      inline qreal  getNumbCharSize()  { return csf_minor;    }
      inline qreal  getLWidthFactor()  { return lwf_major;    }

      void makeFrame ( Scene *scene );

      inline qreal toXScale   ( qreal u ) { return X.toScale  (u); }
      inline qreal toYScale   ( qreal v ) { return Y.toScale  (v); }
      inline qreal toZScale   ( qreal w ) { return Z.toScale  (w); }
      inline qreal fromXScale ( qreal u ) { return X.fromScale(u); }
      inline qreal fromYScale ( qreal v ) { return Y.fromScale(v); }
      inline qreal fromZScale ( qreal w ) { return Z.fromScale(w); }

      /// Returns screen's x-coordinate for given physical coordinate
      inline qreal screenX ( qreal u ) { return X.coord(X.toScale(u)); }
      /// Returns screen's y-coordinate for given physical coordinate
      inline qreal screenY ( qreal v ) { return Y.coord(Y.toScale(v)); }
      /// Returns screen's z-coordinate for given physical coordinate
      inline qreal screenZ ( qreal w ) { return Z.coord(Y.toScale(w)); }

      /// Returns screen's x-coordinate for given physical scaled
      /// (e.g. logarithmic) coordinate
      inline qreal screenScaledX ( qreal u ) { return X.coord(u); }
      /// Returns screen's y-coordinate for given physical coordinate
      inline qreal screenScaledY ( qreal v ) { return Y.coord(v); }
      /// Returns screen's z-coordinate for given physical coordinate
      inline qreal screenScaledZ ( qreal w ) { return Z.coord(w); }

      /// Returns physical x-value for given screen's x-coordinate
      inline qreal valueX ( qreal sx )
                              { return X.fromScaleToHash(X.value(sx)); }
      /// Returns physical y-value for given screen's y-coordinate
      inline qreal valueY ( qreal sy )
                              { return Y.fromScaleToHash(Y.value(sy)); }
      /// Returns physical z-value for given screen's y-coordinate
      inline qreal valueZ ( qreal sz )
                              { return Z.fromScaleToHash(Y.value(sz)); }

      inline void getBaseDigits ( int & digBaseX, int & digBaseY )
         { digBaseX = X.getFormatBase(); digBaseY = Y.getFormatBase(); }

    protected:

      AxisData  X;  //!< properties of x-axis
      AxisData  Y;  //!< properties of y-axis
      AxisData  Z;  //!< properties of z-axis (for xyzdata)
      QRectF    boundingRect; //!< bounding screen rect of the frame

      QFont  font;         //!< frame font
      QColor color;        //!< frame color

      qreal  lineWidth;    //!< relative line width
      qreal  charSize;     //!< relative char size

      bool   axis  [4];    //!< flags to paint axis with ticks
      bool   number[4];    //!< flags to put numbers on axis
      bool   gap   [4];    //!< flags to put "gap" endings

      bool   adjustTicks;  //!< flag to allow for tick adjustment

      void makeVerticalAxes   ( Scene *scene );
      void makeHorizontalAxes ( Scene *scene );

    private:
      Plot  *plot;
      qreal  lwf_major;    //!< line width factor for major lines
      qreal  lwf_minor;    //!< line width factor for minor ticks
      qreal  csf_minor;    //!< char size factor for numbers
      qreal  tsf_major;    //!< tick size factor for major ticks
      qreal  tsf_minor;    //!< tick size factor for minor ticks
      qreal  nx_shift;     //!< shift factor for x-axis numbers
      qreal  ny_shift;     //!< shift factor for y-axis numbers

      qreal  lw_major,lw_minor;
      qreal  cs_minor;
      qreal  ts_major,ts_minor;
      qreal  charWidth,charHeight; //!< approximate char dimensions

  };

}

#endif // FGL_XYFRAME_H