PlotScale.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2006 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Plotting/Pulsar/PlotScale.h
 
#ifndef __Pulsar_PlotScale_h
#define __Pulsar_PlotScale_h
 
#include "Pulsar/PlotEdge.h"
 
namespace Pulsar {
 
  class Archive;

  class PlotScale : public PlotEdge {
 
  public:

    PlotScale ();
 
    // Text interface to the PlotScale class
    class Interface : public TextInterface::To<PlotScale>
    {
    public:
      Interface (PlotScale* = 0);
    };
 
    virtual TextInterface::Parser* get_interface () 
    { return new Interface(this); }

    virtual void init (const Archive*);

    void copy (PlotScale* other);
    
    void include (PlotScale* other);

    virtual std::string get_label () const { return ""; }

    void set_minmax (float min, float max);

    bool get_minmaxset () const { return minmaxvalset; }

    void get_minmax (float& min, float& max) const;

    void update_minmax (float min, float max);

    std::pair<float,float> get_minmax () const;

    void get_range (float& min, float& max) const;

    void get_indeces (unsigned n, unsigned& imin, unsigned& imax, bool cyclic = false) const;

    void get_axis_indeces (unsigned n, float& imin, float& imax, bool cyclic = false) const;

    void get_range_external (float& min, float& max) const;

    void set_range_norm (const std::pair<float,float>& f);

    std::pair<float,float> get_range_norm () const { return range_norm; }

    void set_range_norm (float min, float max) 
    { set_range_norm (std::pair<float,float>(min, max)); }

    void set_buf_norm (float f) { buf_norm = f; }

    float get_buf_norm () const { return buf_norm; }

    void set_world (const std::pair<float,float>& f);

    std::pair<float,float> get_world () const { return world; }

    void set_world_external (const std::pair<float,float>& f);

    std::pair<float,float> get_world_external () const;

    void set_index_range ( const std::pair<unsigned,unsigned>& index );
    std::pair<unsigned,unsigned> get_index_range () const;
 
    unsigned get_num_indeces () const { return num_indeces; }
 
    std::pair<float,float> viewport_to_world (const std::pair<float,float>&);
    double viewport_to_world (const double);

    virtual void freeze (bool f = true) { frozen = f; }
 
  protected:
 
    std::pair<float,float> world;
 
    std::pair<float,float> range_norm;
 
    std::pair<float,float> world_external;
 
    std::pair<unsigned, unsigned> index_range;
 
    unsigned num_indeces = 0;
    float buf_norm = 0.0;
    float minval = 0.0;
    float maxval = 1.0;
    bool minmaxvalset = false;
    bool frozen = false;
  };
 
  
}
 
#endif