zqb_natgroup.hpp

/* zqb_natgroup.hpp */
/* $Id: zqb_natgroup.hpp 20080 2009-12-15 15:57:52Z vlad $ */
#ifndef __zqb_natgroup_hpp
#define __zqb_natgroup_hpp

#include <vector>

#include "zqb_macros.h"
#include "zqb_autoname.hpp"
#include "zqb_pixgroup.hpp"
#include "zqb_natgrpmember.hpp"


class ZqbNatGroup : virtual public ZqbAutoName
{
  friend class ZqbNatGrpMember;

public:

  ZqbNatGroup (const char* szName = NULL);


  /*
   *  Group service
   */

  virtual void      getCoords (double c[2]) const;

  virtual bool      setCoords (double c[2], bool bForce = false);
  
  bool          setCoordsSameOrder (double c[2],
                        bool bForce = false) {
    double  prev_c[2], new_c[2];
    getCoords(prev_c);

    if(prev_c[0] < prev_c[1])
      {
    new_c[0] = ZqbMIN(c[0], c[1]);
    new_c[1] = ZqbMAX(c[0], c[1]);
      }
    else /* prev_c[0] >= prev_c[1] */
      {
    new_c[0] = ZqbMAX(c[0], c[1]);
    new_c[1] = ZqbMIN(c[0], c[1]);
      }
    return setCoords(new_c, bForce);
  }

  bool          setCoords (double c1, double c2,
                   bool bForce = false) {
    double  c[2];
    c[0] = c1;
    c[1] = c2;
    return setCoords(c, bForce);
  }

  bool          setCoordsSameOrder (double c1, double c2,
                   bool bForce = false) {
    double  c[2];
    c[0] = c1;
    c[1] = c2;
    return setCoordsSameOrder(c, bForce);
  }

  bool          isVisible (double c) const {
    double  range[2];
    getCoords(range);
    if(range[0] < range[1])
      return range[0] <= c && c <= range[1];
    /* else
       range[0] >= range[1] */
    return range[0] >= c && c >= range[1];
  }


  virtual void      zoomAll ();


  virtual void      unifyBounds ();

  virtual void      unsetBounds ();

  virtual void      setBounds (double b[2]);

  void          setBounds (double b1, double b2) {
    double  b[2];
    b[0] = b1;
    b[1] = b2;
    setBounds(b);
  }
  
  virtual bool      getBounds (double b[2] = NULL) const;


  /*
   *  Ticks service for scales and grids.
   */

  virtual void      setAutoTickMode (bool bAuto);

  virtual bool      getAutoTickMode () const;


  virtual void      setMainTickStep (double fStep);

  virtual double    getMainTickStep () const;

  virtual int       getMainTickPrec () const;


  virtual void      setSubTickFreq (int nTicks);

  virtual int       getSubTickFreq () const;


  struct Tick {
    double  m_fCoord;   
    bool    m_bMain;    
    Tick () : m_fCoord(0.0), m_bMain(false) {}
    bool    operator< (const Tick& t) const {
      return m_fCoord < t.m_fCoord;
    }
    bool    operator== (const Tick& t) const {
      return m_fCoord == t.m_fCoord;
    }
    bool    operator!= (const Tick& t) const {
      return !operator==(t);
    }
  };

  typedef std::vector<Tick> Ticks;

  virtual void      calcTicks (Ticks& ticks) const;

  virtual double    calcMainTickStep (int* pMainTicksPrec = NULL) const;


  /*
   *  Pixel vs. natural coordinate translation service.
   */

  virtual bool      n2p (ZqbPixGroup& pg, double nc, int& pc);

  virtual bool      p2n (ZqbPixGroup& pg, int pc, double& nc);


  /*
   *  Membership service
   */

  virtual bool      isEmpty ();

protected:/* methods for ZqbNatGrpMember */

  virtual bool      addMember (ZqbNatGrpMember* pMember);

  virtual bool      removeMember (ZqbNatGrpMember* pMember);


protected:/* data */

  ZqbNatGrpMembers  m_Members;

  bool          m_bKnownBounds;

  double        m_fBounds[2];

  double        m_fCoords[2];

  bool          m_bAutoCalcFreq;

  double        m_fMainTicksStep;

  int           m_nMainTicksPrec;

  int           m_nSubTicks;

private:
  
  static int        m_iNameCounter;
  
};


#endif /* zqb_natgroup.hpp */