xpgplotxx.h

Go to the documentation of this file.

// include guard
#ifndef TF_XPGPLOTCPP_H_VERSION

#define TF_XPGPLOTCPP_H_VERSION \
  "TF_XPGPLOTCPP_H   V1.7   (17-03-2015)"

#include<pgplotxx/pgplotxx.h>

namespace pgplot {


  class Tlinestyle {
    public:
      enum Eflags {
        Fnone=0, Fls=1, Flw=2, Fci=4, Frgb=8, Fhls=16
      };
      Tlinestyle():
        Mls(1), Mci(1), Mlw(1), Mflags(Fnone) { }
      Tlinestyle(const int& lw):
        Mls(1), Mci(1), Mlw(lw), Mflags(Flw) { }
      Tlinestyle(const int& lw, const int& ls):
        Mls(ls), Mci(1), Mlw(lw), Mflags(Flw|Fls) { }
      Tlinestyle(const int& lw, const int& ls, const int& ci):
        Mls(ls), Mci(ci), Mlw(lw), Mflags(Flw|Fls|Fci) { }

      Tlinestyle& setlw(const int& lw)
      { Mflags=(Mflags | Flw); Mlw=lw; return(*this); }
      Tlinestyle& setls(const int& ls)
      { Mflags=(Mflags | Fls); Mls=ls; return(*this); }
      Tlinestyle& setci(const int& ci)
      { Mflags=(Mflags | Fci); Mci=ci; return(*this); }
      Tlinestyle& sethls(const Tcol& hls);
      Tlinestyle& setrgb(const Tcol& rgb);
      Tlinestyle& clw() { Mflags &= (!Flw); return(*this); }
      Tlinestyle& cls() { Mflags &= (!Fls); return(*this); }
      Tlinestyle& cci() { Mflags &= (!Fci); return(*this); }
      Tlinestyle& ccr() { Mflags &= (!(Frgb|Fhls)); return(*this); }
      
      bool operator!=(const Tlinestyle& ls) const;
        
      template<class T>
      T& operator()(T& dev) const
      { apply(dev); return(dev); }
    private:
      void apply(basic_device& dev) const;

      int Mls;
      int Mci;
      int Mlw;
      int Mflags;
      Tcol Mcol;
  }; // class Tlinestyle

  inline bool operator==(const Tlinestyle& a, const Tlinestyle& b) 
  { return(!(a!=b)); }

  /*----------------------------------------------------------------------*/

  class Ttiledpanels;

  class Tpanel { 
    friend class Ttiledpanels;
    public:
      Tpanel(const Trect& win, 
             const Trect& tvp=Trect(0.,1.,0.,1.),
             const Trect& vp=Trect(0.1,0.9,0.1,0.9)):
        Mvp(tvp), Mtvp(tvp), Mwin(win) 
        { setvp(vp); }
      Tpanel(const Tpanel& ref,
             const Trect& win, 
             const Trect& tvp=Trect(0.,1.,0.,1.),
             const Trect& vp=Trect(0.1,0.9,0.1,0.9)):
        Mvp(ref.Mtvp), Mtvp(ref.Mtvp), Mwin(win) 
        { Mtvp.shrinkf(tvp); Mvp=Mtvp; setvp(vp); }
      Tpanel& setvp(const Trect& vp)
      { Mvp=Mtvp; Mvp.shrinkf(vp); return(*this); }
      Tpanel& settvp(const Trect& tvp)
      { Mtvp=tvp; return(*this); }
      Tpanel& setwin(const Trect& win)
      { Mwin=win; return(*this); }
      Trect getvp() const { return(Mvp); }
      Trect gettvp() const { return(Mtvp); }
      Trect getwin() const { return(Mwin); }
      template <class T>
      T& operator()(T& dev) const 
      {
        dev.svp(Mvp);
        dev.swin(Mwin);
        return(dev);
      }
      template <class T>
      T& erase(T& dev) const
      {
        dev.svp(Mtvp);
        int fs=dev.qfs();
        int ci=dev.qci();
        dev.sfs(1);
        dev.sci(0);
        dev.rect(Mwin);
        dev.sfs(fs);
        dev.sci(ci);
        return(this->operator()(dev));
      }
    protected:
      Tpanel():
        Mvp(Trect(0.,1.,0.,1.)), Mtvp(Trect(0.,1.,0.,1.)),
        Mwin(Trect(0.,1.,0.,1.))
        { }
    // private:
      Trect Mvp;
      Trect Mtvp;
      Trect Mwin;
  }; // class Tpanel

  /*----------------------------------------------------------------------*/

  class Ttiledpanels {
    public:
      Ttiledpanels(const Tpanel& panel, const Trect& svp, const Trect& win,
                   const int& nx, const int& ny):
        Mvp(panel.Mtvp), Mnx(nx), Mny(ny), Mpanels(0) 
        { this->setup(svp, win, nx, ny); }
      Ttiledpanels(const Trect& vp, const Trect& svp, const Trect& win,
                  const int& nx, const int& ny):
        Mvp(vp), Mnx(nx), Mny(ny), Mpanels(0) 
        { this->setup(svp, win, nx, ny); }
      Ttiledpanels(const Ttiledpanels& panels);
      ~Ttiledpanels();
      int nxsub() const { return(Mnx); }
      int nysub() const { return(Mny); }
      Tpanel& operator()(const int& ix, const int& iy);
      Ttiledpanels& operator=(const Ttiledpanels& panels);
    private:
      void setup(const Trect& svp, const Trect& win,
                 const int& nx, const int& ny);
      Trect Mvp;
      int Mnx, Mny;
      Tpanel* Mpanels;
  }; // class Ttiledpanels

  /*----------------------------------------------------------------------*/

  namespace boxflags {
    enum Eelem { Fnone=0,
      Fframe=1,
      Faxis=2,
      Fgrid=4,
      Fxticks=8,
      Fyticks=16,
      Fticks=Fxticks|Fyticks,
      Fxlabels=32,
      Fylabels=64,
      Flabels=Fxlabels|Fylabels,
      Fxtime=128,
      Fytime=256
    }; // enum Eelem

    enum Emodes { 

      Fselect=1, Fxselect=1, Fhselect=1, Flselect=1,
      Fyselect=2, Fvselect=2, Frselect=2,
      Ftselect=4,
      Fbselect=8,
      Frltbselect=Flselect|Frselect|Ftselect|Fbselect,
      Fxyselect=Fxselect|Fyselect, Fhvselect=Fxyselect,


      Fticksinvert=16,
      Fticksextend=32,
      Fticksmajor=64,
      Fticksminor=128,


      Flabelopp=16,
      Flabelvert=32,
      Flabeldec=64,
      Flabelexp=128,
      Flabellog=256,


      Ftimenoday=16,
      Ftimemod24=32,
      Ftimesuper=64,
      Ftimedegrees=128,
      Ftimeomitfirst=256,
      Ftimeomitzeros=512,

      Fall=~Fnone
    }; // enum Emodes
  } // namespace boxflags

  class Tboxstyle {
    public:
      Tboxstyle(const bool& tbox=false);


      Tboxstyle& setmode(const int& elem, const int& modes, 
                         const bool& set=true);
      Tboxstyle& setstyle(const int& elem, const Tlinestyle& style);
      Tboxstyle& setxtickint(const int& minor=0, const float& major=0.)
      { Mxtick=major; Mxticksub=minor; return(*this); }
      Tboxstyle& setytickint(const int& minor=0, const float& major=0.)
      { Mytick=major; Myticksub=minor; return(*this); }
        
      template<class T>
      T& operator()(T& dev) const
      { apply(dev); return(dev); }
    private:
      void apply(basic_device& dev) const;
      void issuecommand(basic_device& dev,
                        const Tlinestyle& linestyle,
                        const char* xopt,
                        const char* yopt) const;


      int Mgridflags;
      Tlinestyle Mgridstyle;
      

      int Mframeflags;
      Tlinestyle Mframestyle;
      

      int Maxisflags;
      Tlinestyle Maxisstyle;
      

      int Mxtickflags, Mytickflags;
      float Mxtick, Mytick;
      int Mxticksub, Myticksub;
      Tlinestyle Mticksstyle;
      

      int Mxlabelflags, Mylabelflags;
      Tlinestyle Mlabelstyle;
      

      bool Mtbox;
      int Mxtimeflags, Mytimeflags;
  }; // class Tboxstyle

  /*----------------------------------------------------------------------*/

  class Ttext {
    public:
      Ttext(): Mxref(0.), Myref(0.), Mangle(0.), Mjust(0.),
               Mxnl(0.), Mynl(0.), Minline(false) { }
      Ttext(const float& x, const float& y, const float& angle=0.,
            const float& just=0.): 
        Mxref(x), Myref(y), Mangle(angle), Mjust(just), Mxnl(0.), 
        Mynl(0.), Minline(false), Merase(false) { }
      Ttext& print(basic_device& dev, const char* txt, 
                   const bool& nl=false, const float& sep=0.025);
      Tbbox bbox() const { return(Mbbox); }
      void erase() { Merase=true; }
      void noerase() { Merase=false; }
      Ttext& space(basic_device& dev);
    private:
      void advance(const float* xbox,
                   const float* ybox,
                   const bool& nl,
                   const float& sep);
      float Mxref, Myref; 
      float Mangle, Mjust; 
      float Mxnl, Mynl; 
      bool Minline; 
      Tbbox Mbbox; 
      bool Merase; 
  }; // class Ttext

  
  //*======================================================================*/
  /* \name constants
   *
   */
  extern Trange c_range01;
  extern Trange c_range19;
  extern Trect c_rect0101;
  extern Trect c_rect1919;

  /*======================================================================*/
  /* \name extension functions
   *
   * Functions extending the PGPLOT functionality
   */

  template<class S>
  Trange find_series_range(const S& series)
  {
    typename S::BrowserT iter=series;
    float value(*iter);
    Trange result(value,value);
    while (iter.hot()) 
    {
      value=(*iter);
      result.min=(result.min > value ? value : result.min);
      result.max=(result.max < value ? value : result.max);
      ++iter;
    }
    return(result);
  }

  template<class T, class SX, class SY>
  T& series_line(T& dev, const SX& x, const SY& y)
  {
    typename SX::BrowserT ix=x;
    typename SY::BrowserT iy=y;
    float fx=float(*ix);
    float fy=float(*iy);
    dev.move(fx, fy);
    while ((ix.hot()) && (iy.hot()))
    { fx=float(*ix); fy=float(*iy); dev.draw(fx, fy); ++ix; ++iy; }
    return(dev);
  }

  enum Eerrdir {
    Fdirright=1,
    Fdirtop=2,
    Fdirleft=3,
    Fdirbottom=4,
    Fdirhor=5,
    Fdirver=6
  };

  template<class T, class SX, class SY, class SE>
  T& series_errb(T& dev, const SX& x, const SY& y, const SE& e, 
                 const Eerrdir& dir=Fdirver, const float& t=1.)
  {
    typename SX::BrowserT ix=x;
    typename SY::BrowserT iy=y;
    typename SE::BrowserT ie=e;
    float fx=float(*ix);
    float fy=float(*iy);
    float fe=float(*ie);
    int idir=int(dir);
    while ((ix.hot()) && (iy.hot()) && (ie.hot()))
    { fx=float(*ix); fy=float(*iy); fe=float(*ie);
      dev.err1(idir, fx, fy, fe, t); ++ix; ++iy; ++ie; }
    return(dev);
  }
  
} // namespace pgplot

#endif // TF_XPGPLOTCPP_H_VERSION (includeguard)

/* ----- END OF xpgplotxx.h ----- */