AxisRepBase.cxx

Go to the documentation of this file.

// for truncation warning
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#define finite _finite
#endif

#include "AxisRepBase.h"

#include "axes/AxisModelBase.h"
#include "axes/AxisTick.h"
#include "graphics/Color.h"
#include "graphics/ViewBase.h"
#include "transforms/PeriodicBinaryTransform.h"

#include <cmath>
#include <cassert>

using std::max;
using std::min;
using std::string;
using std::vector;
#ifdef __USE_ISOC99
using std::isfinite;
#endif

namespace {
  inline float XPADDING( ViewBase & view )
  {
    return ( view.getDrawRect().getWidth() * 0.01 );
  }

  inline float YPADDING( ViewBase & view )
  {
    return ( view.getDrawRect().getHeight() * 0.01 );
  }
}

using namespace hippodraw;

AxisRepBase::AxisRepBase()
  : m_axis_x_origin (0.),
    m_axis_y_origin ( 0.0),
    m_axis_width ( 0.0 ),
    m_axis_height ( 0.0 ),
    m_font_size( 1.0 ), 
    m_x_font_size( 1.0 ), 
    m_y_font_size( 1.0 ),
    m_xLabelFont( 0 ),
    m_yLabelFont( 0 ),
    m_zLabelFont( 0 ),
    m_titleFont( 0 ),
    m_draw_axes( true ), 
    m_draw_titles( true )
{
}

AxisRepBase::AxisRepBase( const AxisRepBase & axis_rep )
  : m_axis_x_origin( axis_rep.m_axis_x_origin ),
    m_axis_y_origin( axis_rep.m_axis_y_origin ),
    m_axis_width( axis_rep.m_axis_width ),
    m_axis_height( axis_rep.m_axis_height ),
    m_font_size( axis_rep.m_font_size ),
    m_x_font_size( axis_rep.m_x_font_size ),
    m_y_font_size( axis_rep.m_y_font_size ),
    m_xLabelFont( axis_rep.m_xLabelFont ),
    m_yLabelFont( axis_rep.m_yLabelFont ),
    m_zLabelFont( axis_rep.m_zLabelFont ),
    m_titleFont( axis_rep.m_titleFont ),
    m_draw_axes( axis_rep.m_draw_axes ),
    m_draw_titles( axis_rep.m_draw_titles )
{
}

AxisRepBase::~AxisRepBase()
{
  delete m_xLabelFont;
  delete m_yLabelFont;
  delete m_zLabelFont;
  delete m_titleFont;
}

void
AxisRepBase::
initAxisRect( ViewBase & view )
{
  const HippoRectangle & rect = view.getUserRect();

  m_axis_x_origin = rect.getX();
  m_axis_y_origin = rect.getY();
  m_axis_width = rect.getWidth();
  m_axis_height = rect.getHeight();
}

void AxisRepBase::setDrawAxes( bool set )
{
  m_draw_axes = set;
}

void
AxisRepBase::
beginPlot( ViewBase & view )
{
  initAxisRect( view );
}

void AxisRepBase::setDrawTitles( bool set )
{
  m_draw_titles = set;
}

void
AxisRepBase::
drawTitle ( ViewBase & view, const std::string & title )
{
  float x, y;
  
  HippoRectangle drawRect = view.getDrawRect();
  HippoRectangle marginRect = view.getMarginRect();

  float dh = drawRect.getHeight();

  float mx = marginRect.getX();
  float mw = marginRect.getWidth();

  float y_font_size = 0.05 * dh;
  float x_font_size = ( mw * 2 ) / title.size();

  m_font_size = min ( x_font_size, y_font_size );
  double one = 1.0;
  m_font_size = max ( m_font_size, one );

  x = mx + 0.5 * mw;
  y = YPADDING( view ); 
 
  if ( m_titleFont != 0 ) {
    view.drawText ( title, x, y, 0.0, 0.0, 'c', 't', false,
                    m_titleFont );
  } else {
    view.drawText ( title, x, y, m_font_size, 0.0, 'c', 't', false );
  }
}

void
AxisRepBase::
setXFontSize ( const AxisModelBase & axisModel,
               ViewBase & view )
{
  AxisLoc location = axisModel.getScaleLocation();
  
  if ( location == PLOTBOTTOM )
    {
      m_x_font_size = min( (double)m_font_size,
                           ( m_axis_y_origin -
                             view.getDrawRect().getY() ) / 2.0 );
    }
  else if ( location == PLOTTOP )
    {
      m_x_font_size = min( (double)m_font_size,
                           ( view.getDrawRect().getHeight() -
                             m_axis_height -
                             ( m_axis_y_origin
                               - view.getDrawRect().getY() ) ) /2.0 );
    }
}

void
AxisRepBase::
setYFontSize ( const AxisModelBase & axisModel,
               ViewBase & view )
{
  const vector<AxisTick> & labels = axisModel.getTicks ( );
  if ( labels.empty () == true ) return;

  if ( axisModel.getScaleLocation() & PLOTLEFT )
    {
      float yr;
      
      if ( m_draw_titles && 
           axisModel.getLabelLocation() & PLOTLEFT ) {
        yr = 14;
      } 
      else {
        yr = 0;
      }
      const AxisTick & tick = labels.back ( );
      m_y_font_size = min ( m_font_size, 
                           ( m_axis_x_origin -
                             view.getDrawRect().getX() - yr )
                           / tick.content().size() );
    }
  else if ( axisModel.getScaleLocation() & PLOTRIGHT )
    {
      // Estimates the space needed for the Y axis label.
      float yr;
      if ( m_draw_titles && 
           axisModel.getLabelLocation() & PLOTRIGHT ) {
        yr = 14;
      } else {
        yr = 0;
      }
      m_y_font_size = min( m_font_size, 
                           ( view.getDrawRect().getWidth() - 
                             m_axis_width - 
                             ( m_axis_x_origin - 
                               view.getDrawRect().getX() ) - yr )
                           / labels[labels.size() - 1].content().size() );
    }
}

void
AxisRepBase::
setZFontSize ( const AxisModelBase & axisModel,
               ViewBase & view )
{
  AxisLoc location = axisModel.getScaleLocation();
  
  if ( location == PLOTBOTTOM )
    {
      m_z_font_size = min( (double)m_font_size,
                           ( m_axis_y_origin -
                             view.getDrawRect().getY() ) / 2.0 );
    }
  else if ( location == PLOTTOP )
    {
      m_z_font_size = min( (double)m_font_size,
                           ( view.getDrawRect().getHeight() -
                             m_axis_height -
                             ( m_axis_y_origin
                               - view.getDrawRect().getY() ) ) /2.0 );
    }
}

void
AxisRepBase::
drawXLabels ( const AxisModelBase & axisModel,
              ViewBase & view, const std::string & x_label )
{
  float x, y;
  HippoRectangle draw_rect = view.getDrawRect ();
  float draw_h = draw_rect.getHeight ();
  float draw_w = draw_rect.getWidth ();

  HippoRectangle margin_rect = view.getMarginRect ();
  float margin_x = margin_rect.getX ();
  float margin_w = margin_rect.getWidth ();

  x = margin_x + 0.5 * margin_w;

  float tmp = min ( 0.05 * draw_w, 0.05 * draw_h );
  tmp = max ( tmp, 1.0f );
  m_x_font_size = min ( tmp, static_cast<float>( 18.0 ) );

  double ratio = draw_w / ( x_label.size() ) * 2;
  m_x_font_size = min ( m_x_font_size, ratio );
  double one = 1.0;
  m_x_font_size = max ( m_x_font_size, one );

  if ( axisModel.getLabelLocation() & PLOTBOTTOM )
    {
      y = draw_h - 0.75 * YPADDING ( view ) - m_x_font_size;
      if ( m_xLabelFont != 0 ) {
        view.drawText ( x_label, x, y, 0., 0.0, 'c', 't',
                        false, m_xLabelFont );
      } else {
        view.drawText ( x_label, x, y, m_x_font_size, 0.0, 'c', 't', false );
      }
    }
  else if ( axisModel.getLabelLocation() & PLOTTOP )
    {
      y = YPADDING ( view );
      if ( m_xLabelFont != 0 ) {
        view.drawText ( x_label, x, y, 0.0, 0.0, 'c', 't',
                        false, m_xLabelFont );
      } else {
        view.drawText ( x_label, x, y, m_x_font_size, 0.0, 'c', 't', false );
      }
    }
}

void
AxisRepBase::
drawYLabels ( const AxisModelBase & axisModel,
              ViewBase & view, const std::string & y_label )
{
  float x, y;
  AxisLoc location = axisModel.getLabelLocation();
  
  float tmp = min ( view.getDrawRect().getWidth() * 0.05,
                    view.getDrawRect().getHeight() * 0.05 );
  m_y_font_size = min( tmp, static_cast<float>( 18.0 ) );
  m_y_font_size = min( m_y_font_size, view.getDrawRect().getHeight()
                       / ( y_label.size() ) * 2 );
  double one = 1.0;
  m_y_font_size = max ( m_y_font_size, one );
  y = view.getMarginRect().getY() + 
    view.getMarginRect().getHeight() / 2.0;

  if ( location & PLOTLEFT )
    {
      x = XPADDING( view );
      if ( m_yLabelFont != 0 ) {
        view.drawText ( y_label, x, y, 0.0, 90.0, 'c', 't',
                        false, m_yLabelFont );
      } else {
        view.drawText ( y_label, x, y, m_y_font_size, 90.0, 'c', 't', false );
      }
    }
  else if ( location & PLOTRIGHT )
    {
      x = view.getDrawRect().getWidth() 
        - XPADDING( view );
      if ( m_yLabelFont != 0 ) {
        view.drawText ( y_label, x, y, 0.0, -90.0, 'c', 't',
                        false, m_yLabelFont );
      } else {
        view.drawText ( y_label, x, y, m_y_font_size, -90.0, 'c', 't', false );
      }
    }
}

void AxisRepBase::drawYMag ( const AxisModelBase & axisModel,
                             ViewBase & view )
{
  const HippoRectangle view_rect = view.getDrawRect ();
  float x = view_rect.getX();

  if ( axisModel.getScaleLocation() & PLOTLEFT ) {
    x += m_font_size;
  }
  else {
    x -= m_font_size;
  }

  const HippoRectangle margin_rect = view.getMarginRect ();

  float y = view_rect.getY() + margin_rect.getY() - m_font_size;
  double pmag = axisModel.getPMag();

  view.drawMag ( x, y, static_cast< int > ( pmag ), m_font_size * 0.75 );
}

void
AxisRepBase::
drawAxesLines ( TransformBase & transform, 
                ViewBase & view, 
                const Range & x_range,
                const Range & y_range)
{
  const BinaryTransform & t
    = dynamic_cast< const BinaryTransform & > ( transform );
  vector< double > xv ( 100 );
  vector< double > yv ( 100 );
  Color black ( 0, 0, 0 );

  xv[0] = x_range.low( );
  yv[0] = y_range.low( );
  for( int i = 1; i < 100; i++)
    {
      xv[i] = xv[i-1] + ( x_range.high() - x_range.low() )/99; 
      yv[i] = yv[i-1];
    }
  t.transform( xv, yv );
  view.drawPolyLine ( xv, yv, Line::Solid, black, 1 );

  
  xv[0] = x_range.high( );
  yv[0] = y_range.low( );
  for( int i = 1; i < 100; i++)
    {
      xv[i] = xv[i-1]; 
      yv[i] = yv[i-1] + ( y_range.high() - y_range.low() )/99; ;
    }
  t.transform( xv, yv );
  view.drawPolyLine ( xv, yv, Line::Solid, black, 1 );


  xv[0] = x_range.low( );
  yv[0] = y_range.high( );
  for( int i = 1; i < 100; i++)
    {
      xv[i] = xv[i-1] + ( x_range.high() - x_range.low() )/99;  
      yv[i] = yv[i-1];
    }
  
  t.transform( xv, yv );
  view.drawPolyLine ( xv, yv, Line::Solid, black, 1 );


  xv[0] = x_range.low( );
  yv[0] = y_range.low( );
  for( int i = 1; i < 100; i++)
    {
      xv[i] = xv[i-1];
      yv[i] = yv[i-1]  + ( y_range.high() - y_range.low() )/99;  
    }
  
  t.transform( xv, yv );
  view.drawPolyLine ( xv, yv, Line::Solid, black, 1 );

  
}



void AxisRepBase::drawGridLines( const AxisModelBase & axisModelX,
                                 const AxisModelBase & axisModelY,
                                 TransformBase & transform,
                                 ViewBase & view )
{
  Range x_range = axisModelX.getRange( false );
  Range y_range = axisModelY.getRange( false );
  
    
  const vector< AxisTick > & x_ticks = axisModelX.getTicks();
  const vector< AxisTick > & y_ticks = axisModelY.getTicks();
  
  unsigned int nxpoints = 100;
  unsigned int nypoints = 100;
  vector< double > xv(100), yv(100);
  
  double user_x, user_y;
  Color grey( 180, 180, 180 );
    
  BinaryTransform & t
    = dynamic_cast< BinaryTransform & > ( transform );

  t.validate( x_range, y_range );

  if ( x_ticks.empty () == true || y_ticks.empty () == true ) 
    return;

  
  double dx = ( x_range.high() - x_range.low() ) / ( nxpoints - 1 );
  double dy = ( y_range.high() - y_range.low() ) / ( nypoints - 1 ) ;
  
    
  // Drawing the   coordinates of the aligned along y-Axis 
  // i.e.curves for which  x = const
  for ( unsigned int i = 0; i < x_ticks.size(); i++ )
    {
      user_x = x_ticks[ i ].value();
      
      for ( unsigned int j = 0; j < nypoints; j++ )
        {
          user_y = y_range.low() + j * dy;
                  
          xv[ j ] = user_x;
          yv[ j ] = user_y;
          
        }
      
      t.transform( xv, yv );
      view.drawPolyLine ( xv, yv, Line::Solid, grey, 0 );
      
    }
  
  
  // Drawing the   coordinates of the aligned along x-Axis 
  // i.e.curves for which  y = const
  for ( unsigned int j = 0; j < y_ticks.size(); j++ )
    {
      user_y = y_ticks[ j ].value();
      
      for ( unsigned int i = 0; i < nxpoints; i++ )
        {
          user_x = x_range.low() + i * dx;
        
          xv[ i ] = user_x ;
          yv[ i ] = user_y ;
        }

      t.transform( xv, yv ); 
      view.drawPolyLine( xv, yv, Line::Solid, grey, 0 );
    }
   
   return;
}

void
AxisRepBase::
drawXTickLines( const AxisModelBase & axisModelX,
                const AxisModelBase & axisModelY,
                const TransformBase & transform,
                ViewBase & view )
{
  AxisLoc loc = axisModelX.getLabelLocation();
  assert( loc == PLOTBOTTOM || PLOTTOP );
  
  const vector< AxisTick > & ticks = axisModelX.getTicks();
  if ( ticks.empty() == true ) return;
  
  vector< double > xv;
  vector< double > yv;

  unsigned int size = 4 * ticks.size();
  xv.reserve( size );
  yv.reserve( size );

  const BinaryTransform & t
    = dynamic_cast< const BinaryTransform & > ( transform );

  const HippoRectangle view_rect = view.getMarginRect();
  double tick_length = 0.05 * view_rect.getHeight();
  
  Range yrange = axisModelY.getRange( false );
  
  for ( unsigned int i = 0; i < ticks.size(); i++ )
    {
      // In first stage we calculate just the tick without giving
      // in consideration about its length in the view space. This
      // shall help us get the direction of the tick and using it
      // we later adjust the tick length to be "tick_length" in draw
      // space.
      double user_x_start = ticks[i].value ();
      double user_x_temp = user_x_start;

      double user_by_start = yrange.low();
      double user_ty_start = yrange.high();
      
      // transform will change the x value, so we need the temp
      t.transform( user_x_start, user_by_start );
      t.transform( user_x_temp, user_ty_start );
      
      double view_x_start = view.userToDrawX( user_x_start );
      double view_by_start = view.userToDrawY( user_by_start );
      double view_ty_start = view.userToDrawY( user_ty_start );
      
      double user_x_end = ticks[i].value ();
      user_x_temp = user_x_end;
      double user_by_end 
        = yrange.low() + .05 * ( yrange.high() - yrange.low() );
      double user_ty_end 
        = yrange.high() - .05 * ( yrange.high() - yrange.low() );
      
      // transform will change the x value, so we need the temp
      t.transform( user_x_end,  user_by_end );
      t.transform( user_x_temp, user_ty_end );
      
      double view_x_end = view.userToDrawX( user_x_end );
      double view_by_end = view.userToDrawY( user_by_end );
      double view_ty_end = view.userToDrawY( user_ty_end );

      // Calculating the unit vector (ux,uy) in the direction of the tick
      double dx = view_x_end - view_x_start;
      double dy = view_by_end - view_by_start;
      
      double ux = dx / sqrt( dx * dx + dy * dy );
      double uy = dy / sqrt( dx * dx + dy * dy );

      // Now calculate the x coord of the end point of the tick by 
      // moving a distance "tick_length" starting from view_x_start 
      // in the direction of ux. Similarly for y coordinate.
      view_x_end = view_x_start + ux * tick_length;
      view_by_end = view_by_start + uy * tick_length;
      view_ty_end = view_ty_start - uy * tick_length;

#ifdef __USE_ISOC99
      if( isfinite( view_x_start ) &&
          isfinite( view_by_start ) &&
          isfinite( view_ty_start ) &&
          isfinite( view_x_start ) &&
          isfinite( view_by_end   ) )
#else
      if( finite( view_x_start ) &&
          finite( view_by_start ) &&
          finite( view_ty_start ) &&
          finite( view_x_start ) &&
          finite( view_by_end   ) )
#endif
        {
          xv.push_back( view_x_start );
          yv.push_back( view_by_start );
          xv.push_back( view_x_end );
          yv.push_back( view_by_end );

          xv.push_back( view_x_start );
          yv.push_back( view_ty_start );
          xv.push_back( view_x_end );
          yv.push_back( view_ty_end );
        }
    }
  
  view.drawViewLines ( xv, yv, Line::Solid, false, 1 );
}

void 
AxisRepBase::
drawYTickLines ( const AxisModelBase & axisModelX,
                 const AxisModelBase & axisModelY,
                 const TransformBase & transform,
                 ViewBase & view )
{
  AxisLoc loc = axisModelY.getLabelLocation ();
  assert ( loc == PLOTLEFT || loc == PLOTRIGHT );

  const HippoRectangle draw_rect = view.getMarginRect ();

  double tick_length = 0.05 * draw_rect.getWidth ();

  vector< double > xv;
  vector< double > yv; 

  const vector< AxisTick > & ticks = axisModelY.getTicks ();
  unsigned int size = ticks.size ();

  if ( size == 0 ) return;

  size *= 4;

  xv.reserve ( size );
  yv.reserve ( size );

  const BinaryTransform & t 
    = dynamic_cast< const BinaryTransform & > ( transform );

  Range xrange = axisModelX.getRange( false );
  
  for ( unsigned int i = 0; i < ticks.size(); i++ )
    {
      // In first stage we calculate just the tick without giving
      // in consideration about its length in the view space. This
      // shall help us get the direction of the tick and using it
      // we later adjust the tick length to be "tick_length" in draw
      // space.
      double user_lx_start = xrange.low();
      double user_rx_start = xrange.high();
      double user_y_start = ticks[i].value();
      double user_y_temp = user_y_start; // for second call to transform

      // transform modifies its argument, thus we need 2 separate y's
      t.transform( user_lx_start, user_y_start );
      t.transform( user_rx_start, user_y_temp );
      
      double view_lx_start = view.userToDrawX( user_lx_start );
      double view_rx_start = view.userToDrawX( user_rx_start );
      double view_y_start = view.userToDrawY( user_y_start );
      
      double user_lx_end 
        = xrange.low() + .05 * ( xrange.high() - xrange.low() );
      double user_rx_end 
        = xrange.high() - .05 * ( xrange.high() - xrange.low() );
      double user_y_end = ticks[i].value ();
      user_y_temp = user_y_end;

      t.transform( user_lx_end, user_y_end );
      t.transform( user_rx_end, user_y_temp );
      
      double view_lx_end = view.userToDrawX( user_lx_end );
      double view_rx_end = view.userToDrawX( user_rx_end );
      double view_y_end = view.userToDrawY( user_y_end );

      // Calculating the unit vector (ux,uy) in the direction of the tick
      double dx = view_lx_end - view_lx_start;
      double dy = view_y_end - view_y_start;
      
      double ux = dx / sqrt( dx * dx + dy * dy );
      double uy = dy / sqrt( dx * dx + dy * dy );

      // Now calculate the x coord of the end point of the tick by 
      // moving a distance "tick_length" starting from view_lx_start 
      // in the direction of ux. Similarly for y coordinate.
      view_lx_end = view_lx_start + ux * tick_length;
      view_rx_end = view_rx_start - ux * tick_length;
      view_y_end = view_y_start + uy * tick_length;

#ifdef __USE_ISOC99
      if( isfinite( view_lx_start ) &&
          isfinite( view_y_start ) &&
          isfinite( view_lx_start ) &&
          isfinite( view_y_end   ) )
#else
      if( finite( view_lx_start ) &&
          finite( view_y_start ) &&
          finite( view_lx_start ) &&
          finite( view_y_end   ) )
#endif
        {
          xv.push_back( view_lx_start );
          yv.push_back( view_y_start );
          xv.push_back( view_lx_end );
          yv.push_back( view_y_end );

          xv.push_back( view_rx_start );
          yv.push_back( view_y_start );
          xv.push_back( view_rx_end );
          yv.push_back( view_y_end );
        }
    }
  
  view.drawViewLines ( xv, yv, Line::Solid, false, 1 );
}

void
AxisRepBase::
setFontSize( const AxisModelBase * xAxisModel,
             const AxisModelBase * yAxisModel,
             const AxisModelBase * zAxisModel,
             ViewBase & view )
{
  m_font_size = min( ( view.getDrawRect().getWidth() ) * 0.040, 12.0 );
  double one = 1.0;
  m_font_size = max ( m_font_size, one );
  setXFontSize ( *xAxisModel, view );
  setYFontSize ( *yAxisModel, view );
  if ( zAxisModel != 0 ) setZFontSize ( *zAxisModel, view );
}

void
AxisRepBase::
drawXTickLabels ( const AxisModelBase & axisModelX,
                  const AxisModelBase & axisModelY,
                  const TransformBase & transform, 
                  ViewBase & view )
{
  double xpadding = XPADDING ( view );
  double ypadding = YPADDING ( view );
  double padding  = sqrt( xpadding * xpadding + ypadding * ypadding );
  
  vector < double > xv;  
  vector < double > yv;  
  
  const vector < AxisTick > & ticks = axisModelX.getTicks ();
  unsigned int size = ticks.size ();
  if ( size == 0 ) return;
  
  xv.reserve ( size );
  yv.reserve ( size );
  
  Range yrange = axisModelY.getRange( false );
  
  for ( unsigned int i = 0; i < size; i++ ){
    xv.push_back ( ticks[i].value () );
    yv.push_back ( yrange.low() ); 
  }
  
  const BinaryTransform & t 
    = dynamic_cast< const BinaryTransform & > ( transform );
  t.transform ( xv, yv );
  
  // Calculate the Y position in view coordinates.
  const HippoRectangle & margin = view.getMarginRect ();
  float y = margin.getY ();
  float x;
  char yp = 'b';
  char xp = 'c';
  
  if ( axisModelX.getScaleLocation() & PLOTBOTTOM ) {
    y = margin.getY () + margin.getHeight ();
    yp = 't';
  }

  
  for ( unsigned int i = 0; i < ticks.size(); i++ )
    {
      // In first stage we calculate the tick. This shall help us get
      // the direction of the tick and using it we shall locate where
      // to draw the tick labels.
      double user_x_start = ticks[i].value();
      double user_y_start = yrange.low();
            
      t.transform( user_x_start, user_y_start );
      
      double view_x_start = view.userToDrawX( user_x_start );
      double view_y_start = view.userToDrawY( user_y_start );
      
      double user_x_end = ticks[i].value ();
      double user_y_end = 
        yrange.low() + .05 * ( yrange.high() - yrange.low() );
      
      t.transform( user_x_end, user_y_end );
      
      double view_x_end = view.userToDrawX( user_x_end );
      double view_y_end = view.userToDrawY( user_y_end );
      
      // Calculating the unit vector (ux,uy) in the direction of the tick
      double dx = view_x_end - view_x_start;
      double dy = view_y_end - view_y_start;
      
      double ux = dx / sqrt( dx * dx + dy * dy );
      double uy = dy / sqrt ( dx * dx + dy * dy );
      
      // Now calculate the x coord of the end point of the tick by 
      // moving a distance "tick_length" starting from view_x_start 
      // in the direction of ux. Similarly for y coordinate.
      x = view_x_start - ux * padding;
      y = view_y_start - uy * padding;
      
      // Plot the labels now.
      view.drawText ( ticks[i].content(), x, y, m_font_size, 0.0, xp, yp);
    }
  
  if ( axisModelX.needPMag () )
    {
      double pmag = axisModelX.getPMag ();
      const HippoRectangle view_rect = view.getDrawRect ();
      
      float last_x = view.userToDrawX ( xv[ size -1 ] );
      float x = margin.getX () + last_x;

      const AxisTick & last_tick = ticks.back ();
      const string & last_label = last_tick.content ();
      float label_size = last_label.size ();
      x += 0.5 * label_size * m_font_size;

      float margin_right = margin.getX () + margin.getWidth ();
      x = min ( x, margin_right ); // + XPADDING ( view ) );

      if ( yp == 't' ) {
        y += m_font_size * 2.0;
      } else {
        y -= m_font_size * 2.0; // not tested
      }

      x += view_rect.getX();
      y += view_rect.getY();

       // Logarithmic graphs do not need the magnitude written.
      if ( axisModelX.isLog () == false ) {
        x -= m_font_size;
        view.drawMag ( x, y, static_cast< int >( pmag ), m_font_size * 0.75 );
      }
    }
  
}

void
AxisRepBase::
drawYTickLabels ( const AxisModelBase & axisModelX,
                  const AxisModelBase & axisModelY,
                  const TransformBase & transform,
                  ViewBase & view )
{
  // Calculate the X position in the view coordinate system.
  // const HippoRectangle & margin = view.getMarginRect ();
  // float x = margin.getX () - XPADDING ( view );
  float x, y;
  char xalign = 'r';
  double xpadding = XPADDING ( view );
  double ypadding = YPADDING ( view );
  double padding  = sqrt( xpadding * xpadding + ypadding * ypadding );
  
  const vector< AxisTick > & ticks = axisModelY.getTicks ();
  unsigned int size = ticks.size ();
  if ( size == 0 ) return;

  const BinaryTransform & t 
    = dynamic_cast< const BinaryTransform & > ( transform );

  Range xrange = axisModelX.getRange( false );

  for ( unsigned int i = 0; i < ticks.size(); i++ )
    {
      // In first stage we calculate the tick. This shall help us get
      // the direction of the tick and using it we shall locate where
      // to draw the tick labels.
      double user_x_start = xrange.low();
      double user_y_start = ticks[i].value();
            
      t.transform( user_x_start, user_y_start );
      
      double view_x_start = view.userToDrawX( user_x_start );
      double view_y_start = view.userToDrawY( user_y_start );
      
      double user_x_end 
        = xrange.low() + .05 * ( xrange.high() - xrange.low() );
      double user_y_end = ticks[i].value ();
      
      t.transform( user_x_end, user_y_end );
      
      double view_x_end = view.userToDrawX( user_x_end );
      double view_y_end = view.userToDrawY( user_y_end );

      // Calculating the unit vector (ux,uy) in the direction of the tick
      double dx = view_x_end - view_x_start;
      double dy = view_y_end - view_y_start;
      
      double ux = dx / sqrt( dx * dx + dy * dy );
      double uy = dy / sqrt ( dx * dx + dy * dy );

      // Now calculate the x coord of the end point of the tick by 
      // moving a distance "tick_length" starting from view_x_start 
      // in the direction of ux. Similarly for y coordinate.
      x = view_x_start - ux * padding;
      y = view_y_start - uy * padding;

      // Plot the labels now.
      view.drawText ( ticks[i].content(), x, y, 
                      m_font_size, 0.0, xalign, 'c' );
    }
  
  if ( axisModelY.needPMag() ) {
    // Logarithmic graphs do not need the magnitude written.
    if ( !(axisModelY.isLog() ) ) {
       drawYMag ( axisModelY, view );
    }
  }
}

void
AxisRepBase::
drawCrossHairs ( double x, double y,
                 TransformBase & tb,
                 ViewBase & view )
{

  vector < double > xv ( 4 );
  vector < double > yv ( 4 );
  

   const BinaryTransform & tf
    = dynamic_cast< const BinaryTransform & > ( tb );

  if ( tf.isPeriodic() )
    {
      const PeriodicBinaryTransform & tp 
        = dynamic_cast < const PeriodicBinaryTransform & > ( tb );
      
      double xoffset = tp.xOffset();
      double yoffset = tp.yOffset();
      
      x   = tp.moduloSubX( x, xoffset );
      y   = tp.moduloSubY( y, yoffset );
    }
  
  tf.transform ( x,y );
  
  xv[0] = m_axis_x_origin;
  yv[0] = y;
  
  xv[1] = m_axis_width + m_axis_x_origin;
  yv[1] = y;

  xv[2] = x;
  yv[2] = m_axis_height + m_axis_y_origin;

  xv[3] = x;
  yv[3] = m_axis_y_origin;

  // Note: m_axis_* is already in the transformed system.
  Color grey ( 180, 180, 180 );
  view.drawLines ( xv, yv, Line::Solid, grey, 0 );

}

void
AxisRepBase::
drawAllXTicks ( const AxisModelBase & axisModelX,
                const AxisModelBase & axisModelY,
                const TransformBase & transform,
                ViewBase & view )
{
  drawXTickLines ( axisModelX, axisModelY, transform, view );
  drawXTickLabels ( axisModelX, axisModelY, transform, view );
}

void
AxisRepBase::
drawAllYTicks ( const AxisModelBase & axisModelX,
                const AxisModelBase & axisModelY,
                const TransformBase & transform,
                                   ViewBase & view )
{
  drawYTickLines ( axisModelX, axisModelY, transform, view );
  drawYTickLabels ( axisModelX, axisModelY, transform, view );
}


void AxisRepBase::setXLabelFont( FontBase* font )
{
  assert( font != 0 );
  if( m_xLabelFont == NULL )
    m_xLabelFont = font;
  else
    {
      delete m_xLabelFont;
      m_xLabelFont = font;
    }
}

FontBase* AxisRepBase::xLabelFont( )
{
  return m_xLabelFont;
}


void AxisRepBase::setYLabelFont( FontBase* font )
{
  assert( font != 0 );
  if( m_yLabelFont == NULL )
    m_yLabelFont = font;
  else
    {
      delete m_yLabelFont;
      m_yLabelFont = font;
    }
}

FontBase* AxisRepBase::yLabelFont( )
{
  return m_yLabelFont;
}


void AxisRepBase::setZLabelFont( FontBase* font )
{
  assert( font != 0 );
  if( m_zLabelFont == NULL )
    m_zLabelFont = font;
  else
    {
      delete m_zLabelFont;
      m_zLabelFont = font;
    }
}

FontBase* AxisRepBase::zLabelFont( )
{
  return m_zLabelFont;
}

void AxisRepBase::setTitleFont( FontBase* font )
{
  assert( font != 0 );
  if( m_titleFont == NULL )
    m_titleFont = font;
  else
    {
      delete m_titleFont;
      m_titleFont = font;
    }
}

FontBase* AxisRepBase::titleFont( )
{
  return m_titleFont;
}

void
AxisRepBase::drawColorScale ( const BinToColor &, ViewBase & )
{
  assert ( false );
}

---