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;
 
    float buf_norm;
    float minval;
    float maxval;
    bool minmaxvalset;
    bool frozen;
  };
 
  
}
 
#endif