AxisModelBase.cxx

Go to the documentation of this file.
00001 
00012 // for dll interface warning
00013 #ifdef _MSC_VER
00014 #include "msdevstudio/MSconfig.h"
00015 #endif
00016 
00017 #include "AxisModelBase.h"
00018 #include "AxisTick.h"
00019 
00020 #include <algorithm>
00021 
00022 #include <cassert>
00023 
00024 using std::string;
00025 using std::vector;
00026 
00027 namespace hippodraw {
00028 
00029 AxisModelBase::AxisModelBase ( AxisLoc label, AxisLoc scale )
00030   : m_range( 0.0, 1.0 ),
00031     m_start_range ( -1.0, 1.0 ),
00032     m_is_dragging ( false ),
00033     m_auto_range ( true ),
00034     m_empty( true ),
00035     m_scale_factor ( 1.0 ),
00036     m_scaling_on ( false ),
00037     m_first_tick( 0.0 ),
00038     m_max_ticks( 20 ), 
00039     m_num_minor_ticks( 0 ),
00040     m_label_location( label ),
00041     m_scale_location( scale ),
00042     m_pmag( 0.0 ),
00043     m_use_pmag( false ),
00044     m_ticks( m_max_ticks ),
00045     m_ticks_in_range(m_max_ticks),
00046     m_auto_ticks ( true )
00047 {
00048 }
00049 
00050 AxisModelBase::AxisModelBase( const AxisModelBase & axis_model )
00051   : m_range( axis_model.m_range ),
00052     m_start_range ( 0.0, 1.0 ),
00053     m_is_dragging ( false ),
00054     m_auto_range( axis_model.m_auto_range ),
00055     m_empty( axis_model.m_empty ),
00056     m_scale_factor( axis_model.m_scale_factor ),
00057     m_scaling_on ( axis_model.m_scaling_on ),
00058     m_first_tick( axis_model.m_first_tick ),
00059     m_tick_step( axis_model.m_tick_step ),
00060     m_max_ticks( 20 ),
00061     m_num_minor_ticks( axis_model.m_num_minor_ticks ),
00062     m_label_location( axis_model.m_label_location ),
00063     m_scale_location( axis_model.m_scale_location ),
00064     m_pmag( axis_model.m_pmag ), 
00065     m_use_pmag( axis_model.m_use_pmag ),
00066     m_ticks( axis_model.m_ticks ),
00067     m_ticks_in_range( axis_model.m_ticks_in_range),
00068     m_auto_ticks ( axis_model.m_auto_ticks )
00069 {
00070 }
00071 
00072 AxisModelBase::~AxisModelBase()
00073 {
00074 }
00075 
00076 void AxisModelBase::setTickStep( const double & t_step ) 
00077 {
00078   m_tick_step = t_step;
00079 }
00080 
00081 double AxisModelBase::getTickStep() const
00082 {
00083   return m_tick_step;
00084 }
00085 
00086 void AxisModelBase::setFirstTick( const double & first_tick ) 
00087 {
00088   m_first_tick = first_tick;
00089 }
00090 
00091 double AxisModelBase::getFirstTick() const
00092 {
00093   return m_first_tick; 
00094 }
00095 
00096 double AxisModelBase::getMaxTicks() const
00097 {
00098   return m_max_ticks; 
00099 }
00100 
00101 void AxisModelBase::setRMag( const double & rmag ) 
00102 {
00103   m_rmag = rmag;
00104 }
00105 
00106 double AxisModelBase::getRMag() const
00107 {
00108   return m_rmag;
00109 }
00110 
00111 void AxisModelBase::setPMag( const double & pmag ) 
00112 {
00113   m_pmag = pmag;
00114 }
00115 
00116 double AxisModelBase::getPMag() const
00117 {
00118   return m_pmag;
00119 }
00120 
00121 bool AxisModelBase::needPMag() const
00122 {
00123   return m_use_pmag;
00124 }
00125 
00126 void AxisModelBase::setUsePMag( const bool & use_p_mag )
00127 {
00128   m_use_pmag = use_p_mag;
00129 }
00130 
00131 AxisLoc AxisModelBase::getLabelLocation() const
00132 {
00133   return m_label_location;
00134 }
00135 
00136 AxisLoc AxisModelBase::getScaleLocation() const
00137 {
00138   return m_scale_location;
00139 }
00140 
00141 void
00142 AxisModelBase::
00143 setAutoTicks ( bool yes )
00144 {
00145   m_auto_ticks = yes;
00146   if (!m_auto_ticks) adjustTicks();
00147 }
00148 
00149 bool
00150 AxisModelBase::
00151 isAutoTicks ( ) const
00152 {
00153   return m_auto_ticks;
00154 }
00155 
00156 void
00157 AxisModelBase::
00158 setTicks ( const std::vector < AxisTick > & ticks)
00159 {
00160   m_ticks = ticks;
00161   if (!m_auto_ticks) adjustTicks();
00162 }
00163 
00164 const vector<AxisTick> &
00165 AxisModelBase::getTicks() const
00166 {
00167   if ( m_auto_ticks ) return m_ticks;
00168   else return m_ticks_in_range;
00169   
00170 }
00171 
00172 void 
00173 AxisModelBase::
00174 adjustTicks()
00175 {
00176   /* Need pre-processing to keep ticks in range. */
00177   m_ticks_in_range.clear();
00178   
00179   /* Only ticks within the range are useful. */
00180   unsigned int size = m_ticks.size();
00181   double range_high = m_range.high();
00182   double range_low = m_range.low();
00183   for ( unsigned int i = 0; i<size; i++ ) {
00184     if (( m_ticks[i].value()< range_high ) &&
00185         ( m_ticks[i].value()> range_low ))
00186       m_ticks_in_range.push_back(m_ticks[i]);
00187     }
00188 }
00189 
00190 
00191 void AxisModelBase::setRange ( double low, double high, double pos )
00192 {
00193   if ( low > high ) std::swap ( low, high );
00194   m_range.setRange ( low, high, pos );
00195 
00196   if (!m_auto_ticks) adjustTicks();
00197 }
00198 
00199 void AxisModelBase::setRange( const Range & range, bool scaled )
00200 {
00201   /*  Comment out this for now to enable very small range ( range < 1e-16 );
00202 
00203   if ( range.length () < DBL_EPSILON ) {
00204     return;
00205   }
00206 
00207   */
00208   Range myrange = range;
00209   if( scaled ){
00210     Range newrange( range.low() / m_scale_factor,
00211                    range.high() / m_scale_factor,
00212                    range.pos() );
00213     myrange = newrange;
00214   }
00215   
00216   m_range = myrange;
00217 
00218   // I could just call adjustLogValues() without a check, since linear
00219   // does nothing in that function.  However, this assures that the
00220   // graph actually has content, which may or may not be important in
00221   // adjustLogValues(), so I'm playing it on the safe side.
00222   // Note that this causes problems in binned axes, because this has
00223   // already bypassed the binner's dialogue. Therefore, this is only a
00224   // secondary backup, as adjustLogValues() would have already been
00225   // called for binned axes through the projector.
00226   if( isLog() ) adjustLogValues();
00227 
00228   m_empty = false;
00229 
00230   if (!m_auto_ticks) adjustTicks();
00231 
00232 }
00233 
00234 void AxisModelBase::setIntersectRange ( const Range & r1, const Range & r2 )
00235 {
00236   m_range = r1;
00237   m_range.setIntersect ( r2 );
00238 }
00239 
00240 void
00241 AxisModelBase::
00242 setRangePos ( double pos )
00243 {
00244   assert( pos > 0.0 );
00245   m_range.setPos( pos );
00246 }
00247 
00248 void AxisModelBase::setUnionRange ( const Range & range )
00249 {
00250   if( m_empty ) {
00251     m_range = range;
00252     m_range.setEmpty ( false );
00253     m_empty = false;
00254   }
00255   else {
00256     m_range.setUnion( range );
00257   }
00258 }
00259 
00260 void AxisModelBase::setEmpty()
00261 {
00262   m_empty = true;
00263 }
00264 
00265 const Range & AxisModelBase::getRange(bool scaled) const
00266 {
00267 
00268   if(!scaled)
00269     return m_range;
00270   
00271   double low = m_range.low() * m_scale_factor;
00272   double high = m_range.high() * m_scale_factor;
00273 
00274   Range range ( low, high );
00275   m_scaled_range = range;
00276 
00277   return m_scaled_range;
00278 }
00279 
00280 void AxisModelBase::setAutoRanging ( bool flag )
00281 {
00282   m_auto_range = flag;
00283 }
00284 
00285 bool AxisModelBase::isAutoRanging () const
00286 {
00287   return m_auto_range;
00288 }
00289 
00290 void AxisModelBase::setScaleFactor ( double sf )
00291 {
00292   m_scale_factor = sf;
00293   m_scaling_on = true;
00294 }
00295 
00296 double AxisModelBase::getScaleFactor () const
00297 {
00298   if ( m_scaling_on == false ) return 1.0;
00299   // else
00300   return m_scale_factor;
00301 }
00302 
00303 bool AxisModelBase:: isScaling ( ) const
00304 {
00305   return m_scaling_on;
00306 }
00307 
00308 void AxisModelBase:: setScaling ( bool on )
00309 {
00310   m_scaling_on = on;
00311   if ( on == false ) m_scale_factor = 1.0;
00312 }
00313 
00314 void AxisModelBase::startDragging ( bool dragging )
00315 {
00316   if ( m_is_dragging == false  ) {
00317     m_start_range = m_range;
00318   }
00319   m_is_dragging = dragging;
00320 }
00321 
00322 } // namespace hippodraw

Generated for HippoDraw Class Library by doxygen