CanvasView.cxx

Go to the documentation of this file.

// for MEMFUN1 and others
#ifdef HAVE_CONFIG_H
// for wcslib also
#include "config.h"
#endif

#if QT_VERSION < 0x040000
#else
//Added by the Qt porting tool:
#include <QMouseEvent>
#endif

#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "CanvasView.h"

#include "CanvasSelectionEvent.h"
#include "CanvasSettings.h"
#include "CanvasWindow.h"
#include "Inspector.h"
#include "PlotterEvent.h"
#include "QtViewFactory.h"
#include "PickTable.h"
#include "WindowController.h"
#include "CreateNTuple.h"
#include "QtGroupView.h"

#include "controllers/DisplayController.h"
#include "controllers/FunctionController.h"
#include "datareps/ScatterPlot.h"
#include "datasrcs/DataSourceController.h"
#include "datasrcs/NTupleController.h"
#include "graphics/EpsView.h"
#include "plotters/PlotterBase.h"
#include "plotters/Cut1DPlotter.h"
#include "plotters/Cut2DPlotter.h"
#include "qtxml/QtXMLController.h"
#include "transforms/BinaryTransform.h"

#ifdef HAVE_CFITSIO
#include "fits/FitsController.h"
#endif

#ifdef HAVE_ROOT
#include "root/RootController.h"
#endif

#include <qapplication.h>
#include <qaction.h>

#if QT_VERSION < 0x040000
#include <qfiledialog.h>
#include <qimage.h>
#else
#include <q3action.h>
#include <q3filedialog.h>
#include <QtGui/QImageWriter>
#endif

#include <qcursor.h>
#include <qiconset.h>
#include <qmessagebox.h>
#include <qpainter.h>
#include <qsettings.h>
#include <qstatusbar.h>
#include <qwaitcondition.h>
#include <qfont.h>

#include <algorithm>
#include <exception>

#include <cctype>
#include <cmath>

#include <cassert>

using std::bind2nd;
using std::for_each;
using std::map;
using std::mem_fun;
using std::list;
using std::string;
using std::tolower;
using std::vector;

namespace {
   QWaitCondition mouseEvent;
}

using namespace hippodraw;

/* Use `=' syntax so that Doxygen picks it up. */
const string CanvasView::s_app_name = "HippoDraw";
string CanvasView::s_image_filters;

XmlController * CanvasView::s_xml_controller = 0;

#if QT_VERSION < 0x040000
CanvasView::CanvasView ( QCanvas * c, QWidget * parent,
                         const char * name, Qt::WFlags f )
#else
CanvasView::CanvasView ( Q3Canvas * c, QWidget * parent,
                         const char * name, Qt::WFlags f )
#endif
  :  FigureEditor ( c, parent, name, f ),
     m_inspector ( 0 ),
     m_image_dialog ( 0 ),
     m_num_width ( 2 ),
     m_num_height ( 3 ),
     m_cut_mode ( 1 ),
     m_edge ( 0 ),
     m_clicked( false )

{
  s_xml_controller = QtXMLController::instance ();
  m_table_map.clear();
  m_drag_rect = 0;

  initSettings ();
}

void
CanvasView::
initSettings ()
{
  QSettings settings;
  settings.insertSearchPath ( QSettings::Windows, s_registry );

  m_num_width
    = settings.readNumEntry ( s_app_key + "Canvas/Number/Width", 2 );
  m_num_height
    = settings.readNumEntry ( s_app_key + "Canvas/Number/Height", 3 );
  m_add_selected
    = settings.readBoolEntry ( s_app_key + "Canvas/AddSelected" );
  m_ignore_margin
    = settings.readBoolEntry ( s_app_key + "Canvas/IgnoreMargin" );
}

void
CanvasView::
#if QT_VERSION < 0x040000
initDockWindows ( QMainWindow * mw )
#else
initDockWindows ( Q3MainWindow * mw )
#endif
{
  QSettings settings;
  settings.insertSearchPath ( QSettings::Windows, s_registry );
  bool ok = false;
  QString dockSetting = settings.readEntry ( s_app_key + "DockWindow/Position",
                                             QString::null, &ok );

  if ( ok == false ) return;
  QTextStream stream( &dockSetting, IO_ReadOnly );
  stream >> *mw;
}

void
CanvasView::
initRecentFiles ( QActionGroup * ag )
{
#if QT_VERSION < 0x040000
#else
  QObject * parent = ag -> parent ();
#endif  
  QSettings settings;
  settings.insertSearchPath ( QSettings::Windows, s_registry );
  bool ok = false;

  // Read every entries from the settings.
  for (unsigned int i = 0; i<5; i++){
    QString number=QString::number(i);
    QString entry = settings.readEntry ( s_app_key + "Files/File"+number,
                                         QString::null, &ok );
    
    // No entry or empty entry.
    if ((ok==false) || ( entry == "" )) return;
    
    
#if QT_VERSION < 0x040000
    QAction * action = new QAction ( "", // text
                                     QIconSet(),
                                     entry, // menu test
                                     0, // accel
                                     ag ); // parent
#else
    QAction * action = new QAction ( entry, parent );
    ag -> addAction ( action );
#endif
    m_recent_list.push_back( action );
    action -> setToggleAction ( true );
  }
}


void
CanvasView::
initFitterDefault ()
{
  QSettings settings;
  settings.insertSearchPath ( QSettings::Windows, s_registry );
  bool ok = false;
  QString entry = settings.readEntry ( s_app_key + "Fitter/Name",
                                       QString::null, &ok );
  if ( ok == true ) {
    const string name ( entry.latin1() );
    try { // might not be available
      setFitterDefault ( name );
      if ( m_inspector != 0 ) {
        m_inspector -> setSelectedFitter ( name );
      }
    }
    catch ( ... ) { // not available in this build
      // could raise error dialog, but not nice on initialization
    }
  }
}

void
CanvasView::
setFitterDefault ( const QString & name )
{
  QSettings settings;
  settings.insertSearchPath ( QSettings::Windows, s_registry );
  settings.writeEntry ( s_app_key + "Fitter/Name", name );

  const string fitter ( name.latin1() );
  setFitterDefault ( fitter );
}
void
CanvasView::
setFitterDefault ( const std::string & name )
{
  FunctionController * controller = FunctionController::instance ();
  controller -> setDefaultFitter ( name );
}

void
CanvasView::
initFitterSettings ( QActionGroup * ag )
{
  initFitterDefault ();
  initFitterMenu ( ag );
}

void
CanvasView::
initFitterMenu ( QActionGroup * ag )
{
  FunctionController * controller = FunctionController::instance();
  const vector < string > & fitters = controller -> getFitterNames ();
  const string & def_fitter = controller -> getDefaultFitter ();
#if QT_VERSION < 0x040000
#else
  QObject * parent = ag -> parent ();
#endif
  for ( unsigned int i = 0; i < fitters.size(); i++ ) {
#if QT_VERSION < 0x040000
    const QString name ( fitters[i].c_str() );
    QAction * action = new QAction ( "", // text
                                     QIconSet(),
                                     name, // menu test
                                     0, // accel
                                     ag ); // parent
#else
    const QString name ( fitters[i].c_str() );
    QAction * action = new QAction ( name, parent );
    ag -> addAction ( action );
#endif
    action -> setToggleAction ( true );
    if ( def_fitter == fitters[i] ) {
      action -> setOn ( true );
    }
  }
}


void
CanvasView::
saveSettings () const
{
  QSettings settings;
  settings.insertSearchPath ( QSettings::Windows, s_registry );

  int orientation;
  if( s_printer -> orientation() == QPrinter::Portrait )
    orientation = 0;
  else
    orientation = 1;

  settings.writeEntry ( s_app_key + "Printer/Orientation", orientation );
  settings.writeEntry ( s_app_key + "Canvas/Number/Width",  m_num_width );
  settings.writeEntry ( s_app_key + "Canvas/Number/Height", m_num_height );
  settings.writeEntry ( s_app_key + "Canvas/AddSelected", m_add_selected );
  settings.writeEntry ( s_app_key + "Canvas/IgnoreMargin", m_ignore_margin );

  if( m_printer_bounds == false )
    settings.writeEntry ( s_app_key + "Canvas/Margin", 0 );
  else
    settings.writeEntry ( s_app_key + "Canvas/Margin", 1 );
}

void
CanvasView::
setAddedSelected ( bool yes )
{
  m_add_selected = yes;
}

void CanvasView::initFrom ( const std::list < ViewBase * > & views )
{
  std::list < ViewBase * > ::const_iterator first = views.begin();
  for ( ; first != views.end(); ++first ) {
    QtView * view = dynamic_cast < QtView * > ( *first );
    if ( view -> height () < 0 ||
         view -> width () < 0 ) {
      sizeAndPlace ( view );
    }
    add ( view ); // ignore the rest
  }

#if QT_VERSION < 0x040000
  QCanvasView::ensureVisible ( 0, 0 );
#else
  Q3CanvasView::ensureVisible ( 0, 0 );
#endif
}

void
CanvasView::
initFromFile ( const std::string & filename )
{
  XmlController::Status status = s_xml_controller->openFile ( filename );

  // If file not found, change the directory and try again.
  if ( status == XmlController::NTupleError ) {

    std::list < std::string > & missing_tuples = 
      s_xml_controller -> getMissingTuples ();
    std::list< std::string>::iterator it;

    for ( it=missing_tuples.begin(); it!=missing_tuples.end(); ++it )
      {
        string shortFileName;
        string::size_type pos1 = (*it).find_last_of ("/");
        string::size_type pos2 = (*it).find_last_of (":");
        shortFileName = (*it).substr(pos1+1); // get the short filename
        
        QString cap ( "Select the DataSource:  " );
        cap += shortFileName.c_str(); // Caption of the open file dialog
        QString filter ( "All files(*.*);;Text NTuple(*.tnt);;FITS file(*.fits);;Compressed FITS file(*.fits.gz);;ROOT file(*.root)");
        
        QString filename =
#if QT_VERSION < 0x040000
          QFileDialog::getOpenFileName ( QString::null, // starting directory
                                         filter, // filter
                                         this,
                                         "Open file dialog",
                                         cap ); // caption
#else
        Q3FileDialog::getOpenFileName ( QString::null, // starting directory
                                        filter, // filter
                                        this,
                                        "Open file dialog",
                                        cap ); // caption
#endif

        string newFileName = filename.latin1();


        if ( ( pos2!= string::npos)  && (pos2 != 1) ) {
          ( *it ).replace (0, pos2, newFileName); // keep the name
                                                  // after ":"
                                                  // unchanged
        }
        else {
          ( *it )=newFileName; // with no name
        }

      }

    status = s_xml_controller->openUpdatedNTuples (  );    
  }


  // Second try failed, show failed message.
  if ( status != XmlController::Success ) {
    const string & app_name = applicationName ();

    QString fn = filename.c_str ();
    QString message;
    message = QString("Unable to open document file:\n%1\n").arg ( fn );
    if ( status == XmlController::OpenError ) {
      message += "\nFile could not be read\n";
    } else
      if ( status == XmlController::ParseError ) {
        message += "\nThere was a XML parsing error\n";
      } else {
        message += "\nThere were one or more referenced\n";
        message += "NTuple files that could not be found.";
      }
    QMessageBox::critical ( this, // parent
                            app_name.c_str(), // caption
                            message,
                            QMessageBox::Ok,
                            Qt::NoButton,
                            Qt::NoButton );
    show ();
    return;
  }

  ViewFactory * factory = QtViewFactory::instance ();
  const list < ViewBase * > & view_list
    = s_xml_controller->getViews ( factory );

  initFrom ( view_list );

  notifyObservers ();
}

void
CanvasView::
invalidImageFormatError ( const std::string & filename )
{
  if ( s_image_filters.empty () ) createImageFilters ();

  string types;
  string::size_type size = s_image_filters.size ();
  for ( string::size_type i = 0; i < size; i++ ) {
    string::value_type c = s_image_filters[i];
    if ( c != '(' &&
         c != ')' &&
         c != ';' ) types += c;
  }

  string message ( "Attempt to save image to file:\n" );
  message += filename;
  message += "\nwhose suffix indicates unsupported image format.\n\n";
  message += "Supported image formats are:\n";
  message += types;

  QMessageBox::critical ( this, // parent
                          "Image format error", // caption
                          message.c_str() );

}

bool
CanvasView::
existingFileWarning ( const std::string & filename )
{
  string message ( "The file:\n" );
  message += filename;
  message += "\nalready exists.\n\n";
  message += "Over-write existing file?";

  int yes = QMessageBox::warning ( this, //parent
                                   "Existing file warning", // caption
                                   message.c_str(),
                                   QMessageBox::Yes,
                                   QMessageBox::No,
                                   Qt::NoButton );

  return yes == QMessageBox::Yes;
}

void
CanvasView::
copySelectedToPasteboard ()
{
  const vector < const ViewBase * > & selViews = selectedViews();
  if ( selViews.empty () ) return;

  vector < const ViewBase * > view_list;
  fillSelectedWithObservers ( view_list );
  s_xml_controller->saveToPasteboard ( view_list );

  copySelectedToClipboard ();
}

void
CanvasView::
copyFromPasteboard ()
{
  const vector < const ViewBase * > & targets = views ();
  ViewFactory * factory = QtViewFactory::instance ();

  const list < ViewBase * > & pb_views
    = s_xml_controller->getFromPasteboard ( factory, targets );
  pasteViews ( pb_views );
}

void
CanvasView::
addFromPasteboard ()
{
  const vector < const ViewBase * > & targets = views ();
  ViewFactory * factory = QtViewFactory::instance ();

  const list < ViewBase * > & pb_views
    = s_xml_controller->getFromPasteboard ( factory, targets );
  list < ViewBase * >::const_iterator first = pb_views.begin ();
  while ( first != pb_views.end () ) {
    ViewBase * view = *first++;
    QtView * qtview = dynamic_cast < QtView * > ( view );
    placeGraph ( qtview );
    addView ( qtview, true );
  }
}

void
CanvasView::
deleteSelected ( bool pasteboard )
{
  const vector < const ViewBase * > & selViews = selectedViews();
  if ( selViews.empty () ) return;

  vector < const ViewBase * > view_list;
  fillSelectedWithObservers ( view_list );
  if ( pasteboard ) {
    s_xml_controller->saveToPasteboard ( view_list );
  }

  DisplayController * controller = DisplayController::instance ();
  controller->removeTextObservers ( view_list );

  // Remove views from the canvas.

#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
  vector < const ViewBase * > ::const_iterator iter = view_list.begin();

  // Remove views or group views.
  while ( iter != view_list.end() ) {
    const ViewBase * curview = ( * iter++ );
    const QtView * view = dynamic_cast < const QtView * > ( curview );
    QtView * v = 0;
    if (view) v = const_cast < QtView * > ( view );
    const QtGroupView * groupview = 
      dynamic_cast < const QtGroupView * > ( curview );
    QtGroupView * gv =  0;
    if (groupview) gv = const_cast < QtGroupView * > (groupview);
    if (v) remove ( v );
    if (gv) remove (gv);
  }

  notifyObservers ();
}

void
CanvasView::
clear ()
{
  FigureEditor::clear ();

  notifyObservers ();
}

void CanvasView::removeSelected ( )
{
  const vector < const ViewBase * > & views = selectedViews ();
#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
  vector < const ViewBase * > ::const_iterator first = views.begin();
  while ( first != views.end() ) {
    const QtView * view = dynamic_cast < const QtView * > ( *first++ );
    QtView * v = const_cast < QtView * > ( view );
    remove ( v );
  }
}

void CanvasView::pasteViews ( const std::list < ViewBase * > & views )
{
  clearSelectedList ();
  std::list < ViewBase * > ::const_iterator first = views.begin();
  for ( ; first != views.end(); ++first ) {
    QtView * view = dynamic_cast < QtView * > ( *first );
    paste ( view );
    addSelectedItem ( view );
  }

  setChanged ( true );
}

void CanvasView::setInspector ( Inspector * inspector )
{
  m_inspector = inspector;
  m_inspector->enableNewPlotBox ( );
}

Inspector * CanvasView::getInspector ()
{
  return m_inspector;
}

void CanvasView::setChanged ( bool flag )
{
  QWidget * parent = parentWidget ();
  if ( parent != 0 ) {
    PlotterEvent * event = new PlotterEvent ( 0 );
    QApplication::postEvent ( parent, event );
  }
}

void CanvasView::notifyObservers ()
{
  setChanged ( true );
  if ( m_inspector != 0 ) {
    vector < PlotterBase * > plotters = getSelectedPlotters ();

    CanvasSelectionEvent * event = new CanvasSelectionEvent ( plotters );
    QApplication::postEvent ( m_inspector, event );
  }

  WindowController * controller = WindowController::instance ();
  controller -> updateActions ();
}

vector < PlotterBase * >
CanvasView::
getSelectedPlotters () const
{
  vector < PlotterBase * > plotters;

  const vector < const ViewBase * > & viewList = selectedViews ();
  unsigned int size = viewList.size ();
  for ( unsigned int i = 0; i < size; i++ ) {
    const ViewBase * view = viewList [ i ];

    const QtGroupView * groupView = dynamic_cast <const QtGroupView *> (view);

    if (groupView) {
      const vector <PlotterBase *> groupPlotters = groupView -> getPlotters ();
      plotters.insert ( plotters.end(), 
                        groupPlotters.begin(), groupPlotters.end() );
      break;
    } 

    //else
    PlotterBase * plotter = view -> getPlotter ();
    if ( plotter != 0 ) {
      plotters.push_back ( plotter );
    }
  }

  return plotters;
}

PlotterBase * CanvasView::selectedPlotter () const
{
  const vector < const ViewBase * > & viewList = selectedViews ();

  if ( viewList.size() != 1 )
    {
      return 0;
    }

  PlotterBase * plotter = viewList[0]->getPlotter ();
  //assert ( plotter );      // Can return 0, handle by caller.

  return plotter;
}

void
CanvasView::
addView ( QtView * view, bool select )
{
  add ( view ); // in FigureEditor
  if ( select ) {
    ensureVisible ( view );
    setSelectedItem ( view );
    vector < const ViewBase * > view_list;
    fillSelectedWithObservers ( view_list );
    s_xml_controller -> saveToSelectionCopy ( view_list );
  }
  notifyObservers ();
}

void
CanvasView::
setPlotMatrix ( unsigned int columns, unsigned int rows )
{
  m_num_width = columns;
  m_num_height = rows;
}

void
CanvasView::
swapOrientation ()
{
#if QT_VERSION < 0x040000
  QCanvas * can = canvas();
#else
  Q3Canvas * can = canvas();
#endif
  int numpages = static_cast<int> ( can -> height()
                                   / (double) m_apage_h );
  std::swap( m_upage_w, m_upage_h );
  std::swap( m_apage_w, m_apage_h );

  can -> resize ( static_cast<int> ( 1.2 * m_upage_w ),
                  numpages * m_apage_h );

  showPrinterMargins ( false ); // Delete old ones ( if any    )
  showPrinterMargins ( true );  // Redraw new ones ( if needed )
}

void
CanvasView::
setup ()
{
  CanvasSettings * cs = new CanvasSettings ( this );
  cs -> setOrientation ( s_printer -> orientation() );
  cs -> setWidthNumber ( m_num_width );
  cs -> setHeightNumber ( m_num_height );
  cs -> setAddSelected ( m_add_selected );
  cs -> setPrinterBounds ( m_printer_bounds );
  cs -> setIgnorePrinterMargin ( m_ignore_margin );

  int retval = cs -> exec ();

  if (  retval == CanvasSettings::AcceptedAndRetile ||
        retval == CanvasSettings::Retile )
    {
      m_add_selected = cs -> getAddSelected ();


      if ( cs -> orientation() != s_printer -> orientation() ) {
        s_printer -> setOrientation( cs -> orientation() );
        swapOrientation ();
      }

      if( cs -> printerBounds() == false )
        showPrinterMargins ( false ); // Delete old ones ( if any    )
      else
        {
          showPrinterMargins ( false ); // Delete old ones ( if any    )
          showPrinterMargins ( true );  // Redraw new ones ( if needed )
        }

      m_ignore_margin = cs -> ignorePrinterMargin ();
    }

  if ( retval == CanvasSettings::AcceptedAndRetile ||
       retval == CanvasSettings::Retile ) {
    unsigned int columns = cs -> getWidthNumber ();
    unsigned int rows    = cs -> getHeightNumber ();
    setPlotMatrix ( columns, rows );
    reTile ();
  }

  if ( retval == CanvasSettings::AcceptedAndRetile ) {
    saveSettings ();
  }

  delete cs;
}


void
CanvasView::
setFonts( const QFont & font )
{
  const vector < const ViewBase * > & allviews = views();

  for( unsigned int i = 0; i < allviews.size(); i++ )
    {
      const ViewBase * curview = allviews[ i ];
      const QtView * view = dynamic_cast < const QtView * > ( curview );
      QtView * v = const_cast < QtView * > ( view );
      v -> setDefaultFont( font );
      v -> getPlotter() -> update();
    }
}

void
CanvasView::
calcDefaultSize ( QtView * view, double transform_aspect_ratio )
{
  double width = ( 0.95 * m_upage_w ) / m_num_width;
  double height = ( 0.95 * m_upage_h ) / m_num_height;

  if ( transform_aspect_ratio > 0.0 )
    {
      width = height * transform_aspect_ratio;
    }

  view -> setDrawRect ( 0.0, 0.0, width, height );
}


void
CanvasView::
addPlotDisplay ( PlotterBase * plotter )
{
  addPlotDisplay ( plotter, m_add_selected );
}

QtView *
CanvasView::
wrapPlotter ( PlotterBase * plotter )
{
  ViewFactory * factory = QtViewFactory::instance ();
  ViewBase * view = factory -> createView ( plotter );
  QtView * qtview = dynamic_cast< QtView * > ( view );
  qtview -> setSize ( -1, -1 );

  return qtview;
}

void CanvasView::addPlotDisplay ( PlotterBase * plotter, bool select )
{
  QtView * qtview = wrapPlotter ( plotter );
  qtview -> setPageWidth( m_upage_w );
  qtview -> setInspector( m_inspector );
  sizeAndPlace ( qtview  );

  addView ( qtview, select );
}

void
CanvasView::
sizeAndPlace ( QtView * view )
{
  PlotterBase * plotter = view -> getPlotter ();
  double transform_aspect_ratio = plotter -> getAspectRatio();
  calcDefaultSize ( view, transform_aspect_ratio );
  placeGraph ( view );
}

static bool
#if QT_VERSION < 0x040000
sortViews ( QCanvasItem * first, QCanvasItem * second )
#else
sortViews ( Q3CanvasItem * first, Q3CanvasItem * second )
#endif
{
  bool yes = false;

  QRect frect = first -> boundingRect ();
  QRect srect = second -> boundingRect ();

  if ( frect.left () < srect.left () ) {
    if ( frect.top() < srect.bottom () ) {
      yes = true;
    }
  }
  if ( frect.right () > srect.right () ) {
    if ( frect.bottom () <  srect.top () ) {
      yes = true;
    }
  }
  else {
    yes = frect.top () < srect.top ();
  }

  return yes;
}

void
CanvasView::
reTile ()
{
#if QT_VERSION < 0x040000
  QCanvas temp_canvas;
#else
  Q3Canvas temp_canvas;
#endif
#ifdef MEMFUN1_DEFECT
  for_each ( m_items.begin(), m_items.end(),
#if QT_VERSION < 0x040000
             bind2nd ( mem_fun1 ( & QCanvasItem::setCanvas ), &temp_canvas ) );
#else
             bind2nd ( mem_fun1 ( & Q3CanvasItem::setCanvas ),
                       &temp_canvas ) );
#endif
#else
  for_each ( m_items.begin(), m_items.end(),
#if QT_VERSION < 0x040000
             bind2nd ( mem_fun ( & QCanvasItem::setCanvas ), &temp_canvas ) );
#else
             bind2nd ( mem_fun ( & Q3CanvasItem::setCanvas ), &temp_canvas ) );
#endif
#endif

#if QT_VERSION < 0x040000
  vector < QCanvasItem * > items ( m_items );
#else
  vector < Q3CanvasItem * > items ( m_items );
#endif
  m_items.clear();

  sort ( items.begin(), items.end(), sortViews );

  placeItems ( items );
}

void
CanvasView::
#if QT_VERSION < 0x040000
placeItems ( const std::vector < QCanvasItem * > & items )
{
  vector < QCanvasItem * >:: const_iterator first = items.begin();
#else
placeItems ( const std::vector < Q3CanvasItem * > & items )
{
  vector < Q3CanvasItem * >:: const_iterator first = items.begin();
#endif

  // Place xy plotters before text plotters.
  vector <QtView *> textViews;
  
  while ( first != items.end() )
    {
      QtView * view = dynamic_cast < QtView * > ( *first++ );

      PlotterBase * plotter = view->getPlotter();
      if (plotter->isTextPlotter()) {
        // Move back to (0,0) and add to textView list.
        double x = view -> x ();
        double y = view -> y ();
        view->moveBy(-x, -y);
        textViews.push_back(view);
        continue;
      }
      calcDefaultSize ( view, view -> getAspectRatio() );
      placeGraph ( view );
      add ( view );
    }

  // Add text plotters to their parent plotters
  vector <QtView *>::const_iterator it = textViews.begin();
  while ( it != textViews.end() )
    {
      QtView * view = *it++;
      moveToPlotter(view->getPlotter()->getParentPlotter(), view );
      add ( view );
    }
}

void
CanvasView::
reTilePage ()
{
  int y = contentsY ();
  int page = y / m_apage_h;
  QRect rect ( 0, page * m_apage_h, m_apage_w, m_apage_h );
#if QT_VERSION < 0x040000
  QCanvasItemList c_items = m_canvas -> collisions ( rect );

  // copy to STL vector and remove from item list.
  vector < QCanvasItem * > v_items;
  QCanvasItemList:: const_iterator first = c_items.begin();
  while ( first != c_items.end() ) {
    QCanvasItem * item = *first++;
#else
  Q3CanvasItemList c_items = m_canvas -> collisions ( rect );

  // copy to STL vector and remove from item list.
  vector < Q3CanvasItem * > v_items;
  Q3CanvasItemList:: const_iterator first = c_items.begin();
  while ( first != c_items.end() ) {
    Q3CanvasItem * item = *first++;
#endif
    QtView * view = dynamic_cast < QtView * > ( item );

    if ( view != 0 ) { // avoid page margin rect
      v_items.push_back ( item );
      removeFromItemList ( item );
    }
  }

  placeItems ( v_items );
}

void CanvasView::moveToPlotter ( const PlotterBase * plotter, QtView * view )
{
  QtView * target = getViewFor ( plotter );
  QRect rect = target -> boundingRect ();
  double x = target -> x ();
  double y = target -> y ();
  x += 0.25 * rect.width();
  y += 0.25 * rect.height();

  view->moveBy ( x, y );
}

std::pair<double, double>
CanvasView::
moveToPlotterAt ( const PlotterBase * plotter,
                  QtView * view,
                  double xrel, double yrel )
{
   QtView * sel_item = getViewFor ( plotter );
   QRect rect = sel_item->boundingRect ();
   double x = sel_item->x();
   double y = sel_item->y();
   x += xrel * rect.width();
   y += yrel * rect.height();

   view->moveBy ( x, y );

// Find the lower left corner of the view.
   QRect viewRect = view->boundingRect();
   double xLowerLeft = view->x();
   double yLowerLeft = view->y() + viewRect.height();

// Normalize to selectedItem coordinate system.
   xLowerLeft = ( xLowerLeft - sel_item->x() ) / rect.width();
   yLowerLeft = ( yLowerLeft - sel_item->y() ) / rect.height();

   return std::make_pair(xLowerLeft, yLowerLeft);
}

void
CanvasView::
addTextDisplay ( PlotterBase * plotter,
                 const std::string & s,
                 const std::string & text )
{
  DisplayController * display_controller = DisplayController::instance ();
  ViewFactory * factory = QtViewFactory::instance ();

  ViewBase * view
    = display_controller->createTextView ( factory, plotter, s, text );
  assert ( view != 0 );

  QtView * qtview = dynamic_cast < QtView * > ( view );
  assert ( qtview != 0 );

  moveToPlotter ( plotter, qtview );

  addView ( qtview, false );

  // Make sure new view on top of others
  double z = maximumZ ();
  
  // Make sure the new text plotter on top all other text plotters
  qtview->setZ(z+101.0);
}

std::pair<double, double>
CanvasView::
addTextDisplayAt ( PlotterBase * plotter,
                   const std::string & type,
                   const std::string & text,
                   double x, double y )
{
  DisplayController * display_controller = DisplayController::instance ();
  ViewFactory * factory = QtViewFactory::instance ();

  ViewBase * view
    = display_controller->createTextView ( factory, plotter, type, text );

  QtView * qtview = dynamic_cast < QtView * > ( view );

  std::pair<double, double> lowerLeftCorner
     = moveToPlotterAt ( plotter, qtview, x, y );

  addView ( qtview, false );

  return lowerLeftCorner;
}

void
CanvasView::
addFuncDisplay ( PlotterBase * plotter, const std::string & s)
{
  FunctionController * controller = FunctionController::instance ();
  const ViewFactory * factory = QtViewFactory::instance ();

  ViewBase * view
    = controller->createFuncView ( factory, plotter, s );

  QtView * qtview = dynamic_cast < QtView * > ( view );
  moveToPlotter ( plotter, qtview );

  addView (qtview, false );
}

void
CanvasView::
removeDisplay ( PlotterBase * plotter )
{
 QtView * view = getViewFor ( plotter );

 if ( view != 0 ) remove ( view );
}

void
CanvasView::
setVisibleNonViews ( bool yes )
{
#if QT_VERSION < 0x040000
  QCanvasItemList items = m_canvas->allItems ();
  QCanvasItemList::Iterator first = items.begin();
  while ( first != items.end() ) {
    QCanvasItem * item = *first++;
#else
  Q3CanvasItemList items = m_canvas->allItems ();
  Q3CanvasItemList::Iterator first = items.begin();
  while ( first != items.end() ) {
    Q3CanvasItem * item = *first++;
#endif
    QtView * view = dynamic_cast < QtView * > ( item );
      if ( view == 0 ) {
        item -> setVisible ( yes );
      }
  }
}

void
CanvasView::
print ()
{
  setVisibleNonViews ( false );
  FigureEditor::print ();
  setVisibleNonViews ( true );
}

void
CanvasView::
print ( const std::string & filename )
{
  setVisibleNonViews ( false );
  FigureEditor::print ( filename );
  setVisibleNonViews ( true );
}


const vector < const ViewBase * > &
CanvasView::
selectedViews () const
{
  m_sel_views.clear ();

#if QT_VERSION < 0x040000
  vector < QCanvasItem * > :: const_iterator first = m_selected_list.begin();
  while ( first != m_selected_list.end() ) {
    QCanvasItem * item = *first++;
#else
  vector < Q3CanvasItem * > :: const_iterator first = m_selected_list.begin();
  while ( first != m_selected_list.end() ) {
    Q3CanvasItem * item = *first++;
#endif
    QtView * view = dynamic_cast < QtView * > ( item );
    if ( view != 0 ) { // may be printer page border
      m_sel_views.push_back ( view );
    }
    QtGroupView * groupview = dynamic_cast < QtGroupView * > ( item );
    if ( groupview != 0 ){
      m_sel_views.push_back ( groupview );
    }
  }

  return m_sel_views;
}

const vector < const ViewBase * > & CanvasView::views () const
{
  m_views.clear();

#if QT_VERSION < 0x040000
  QCanvasItemList item_list = m_canvas->allItems();
  QCanvasItemList::Iterator it = item_list.begin();
#else
  Q3CanvasItemList item_list = m_canvas->allItems();
  Q3CanvasItemList::Iterator it = item_list.begin();
#endif
  for ( ; it != item_list.end(); ++ it ) {
    const QtView * view = dynamic_cast < const QtView * > ( *it );
    if ( view != 0 ) {
      m_views.push_back ( view );
    }
  }

  return m_views;
}

void
CanvasView::
fillPlotterList ( std::vector < PlotterBase * > & plotterlist )
{
  plotterlist.clear();

  const vector < const ViewBase * > & view_list = views ();
#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
  vector < const ViewBase * >::const_iterator first = view_list.begin ();
  for ( ; first != view_list.end(); ++first ) {
    const QtView * qtview = dynamic_cast < const QtView * > ( *first );
    plotterlist.push_back ( qtview->getPlotter () );
  }
}


QtView *
CanvasView::
getViewFor ( const PlotterBase * target ) const
{
  QtView * view = 0;
  const vector < const ViewBase * > & all_views = views ();
  vector < const ViewBase * > :: const_iterator  first = all_views.begin();

  while ( first != all_views.end() ) {
    const ViewBase * vb = *first++;
    const PlotterBase * plotter = vb->getPlotter();
    if ( plotter == target ) {
      const QtView * v = dynamic_cast < const QtView * > ( vb );
      view = const_cast < QtView * > ( v );
      break;
    }
  }

  return view;
}

void
CanvasView::
createImageFilters ()
{
#ifdef STRING_CLEAR_DEFECT
  s_image_filters.erase();
#else
  s_image_filters.clear();
#endif

  const string eps ( "eps" );
  bool eps_inserted = false;

#if QT_VERSION < 0x040000
  QStringList slist = QImage::outputFormatList ();
  QStringList::Iterator it = slist.begin();
#else
  QList < QByteArray >  slist = QImageWriter::supportedImageFormats ();
  QList < QByteArray > ::const_iterator it = slist.begin();
#endif

  while ( it != slist.end() ) {
    QString upper = *it++;
    QString lower = upper.lower();
#if QT_VERSION < 0x030100
    string low ( lower );
#else
    string low = lower.latin1();
#endif
#ifdef Q_OS_MACX
#else // not mac os x
  if ( low == "jpeg" ) low = "jpg";
#endif
    if ( eps >= low ) {

#if QT_VERSION < 0x040000
      s_image_filters += low +"(*." + low + ");;";
#else
      s_image_filters += " (*." + low + ");;";
#endif
    }
    else {
      if ( eps_inserted == false ) {
#if QT_VERSION < 0x040000
        s_image_filters += eps + "(*." + eps + ");;";
#else
        s_image_filters += "(*." + eps + ");;";
#endif
        eps_inserted = true;
      }
#if QT_VERSION < 0x040000
      s_image_filters += low + "(*." + low + ");;";
#else
      s_image_filters += "(*." + low + ");;";
#endif
    }
  }
  // Add FITS file.
#if QT_VERSION < 0x040000
  s_image_filters += "FITS(*.fits);;";
#else
  s_image_filters += "(*.fits);;";
#endif

#if QT_VERSION < 0x040000
  s_image_filters += "Compressed FITS(*.fits.gz)";
#else
  s_image_filters += "(*.fits.gz)";
#endif
}

#if QT_VERSION < 0x040000
QFileDialog *
#else
Q3FileDialog *
#endif
CanvasView::
createImageDialog ()
{
  if ( s_image_filters.empty () ) createImageFilters ();

  QString filters = s_image_filters.c_str();

#if QT_VERSION < 0x040000
  QFileDialog * dialog = new QFileDialog ( this );
  dialog->setFilters ( filters );
  dialog->setMode ( QFileDialog::AnyFile );
#else
  Q3FileDialog * dialog = new Q3FileDialog ( this );
  dialog->setFilters ( filters );
  dialog->setMode ( Q3FileDialog::AnyFile );
#endif

  return dialog;
}

/* The menu item calling this method is disabled when no plot is
   selected so there's no need to see if any plots are selected
   here.
*/
void
CanvasView::
saveSelectedImages ()
{
  setVisibleNonViews ( false );

#if QT_VERSION < 0x040000
  const vector < QCanvasItem * > views = getSelectedItems (); // make copy
#else
  const vector < Q3CanvasItem * > views = getSelectedItems (); // make copy
#endif
  assert ( views.empty () == false );

  for ( unsigned int i = 0; i < views.size (); i++ ) {
    setCollidingSelected ( views[i] );
  }

  if ( s_image_filters.empty () ) createImageFilters ();
  QString sel_filt;
#if QT_VERSION < 0x040000
  QString filename 
    = QFileDialog::getSaveFileName ( QString::null, // working dir
                                     s_image_filters.c_str(),
                                     this, // parent
                                     0, // name
                                     "Save image as", // caption
                                     & sel_filt ); // selected filter
#else
  QString filename 
    = Q3FileDialog::getSaveFileName ( QString::null, // working dir
                                      s_image_filters.c_str(),
                                      this, // parent
                                      0, // name
                                      "Save image as", // caption
                                      & sel_filt ); // selected filter
#endif

  if ( filename.isEmpty () ) return;

  filename.stripWhiteSpace ();

#if QT_VERSION < 0x030100
  string fn ( filename );
#else
  string fn = filename.latin1();
#endif

  int pos = filename.findRev ( '.' );
  if ( pos < 0 ) {
    string sf = sel_filt.latin1();
    string::size_type pos1 = sf.find ( '(' );
    string::size_type pos2 = sf.find_last_of ( ')' );
    string::size_type len = ( pos2 ) - ( pos1 + 2 );
    string suffix = sf.substr ( pos1 + 2, len );
    fn += suffix;
  }

  saveSelectedImages ( fn, true );

  // Restore original selection flags.
  m_selected_list.clear();
  for ( unsigned int i = 0; i < views.size(); i++ ) {
    m_selected_list.push_back ( views[i] );
  }
  setSelectedFlags ();
  setVisibleNonViews ( true );
}

void
CanvasView::
saveSelectedImages (const std::string & filename)
{
  setVisibleNonViews ( false );

#if QT_VERSION < 0x040000
  const vector < QCanvasItem * > views = getSelectedItems (); // make copy
#else
  const vector < Q3CanvasItem * > views = getSelectedItems (); // make copy
#endif
  if (views.empty()) {
     return;
  }

  for ( unsigned int i = 0; i < views.size (); i++ ) {
    setCollidingSelected ( views[i] );
  }

  saveSelectedImages ( filename, false );

  // Restore original selection flags.
  m_selected_list.clear();
  for ( unsigned int i = 0; i < views.size(); i++ ) {
    m_selected_list.push_back ( views[i] );
  }
  setSelectedFlags ();
  setVisibleNonViews ( true );
}

void CanvasView::setIntervalEnabled ( bool yes )
{
  DisplayController * controller = DisplayController::instance ();
  const vector < const ViewBase * > & view_list = views ();
  vector < const ViewBase * > ::const_iterator first = view_list.begin ();

  while ( first != view_list.end() ) {
    const ViewBase * view = *first++;
    PlotterBase * plotter = view->getPlotter();
    controller -> setAllIntervalEnabled ( plotter, yes );
  }
}

void
CanvasView::
restoreFromSelectCopy ()
{

  ViewFactory * factory = QtViewFactory::instance ();
  const vector < const ViewBase * > & targets = views ();

  const list < ViewBase * > & views
    = s_xml_controller->getFromSelectionCopy ( factory, targets );

  if ( views.empty() == false ) {
    removeSelected ();
    pasteViews ( views );

    notifyObservers ();
  }
}

void CanvasView::controlMousePressEvent ( )
{
#if QT_VERSION < 0x040000
  QCanvasItem * selItem = m_selected_list.front ();
#else
  Q3CanvasItem * selItem = m_selected_list.front ();
#endif
  QtView * qtview = dynamic_cast < QtView * > ( selItem );
  assert ( qtview );

  PlotterBase * plotter = qtview->getPlotter ();
  assert ( plotter );

  plotter -> toggleActivePlot ();
}

void
CanvasView::
fillSelectedWithObservers ( std::vector < const ViewBase * > & view_list )
{
  const vector < const ViewBase * > & sel_views = selectedViews ();

  view_list.resize ( sel_views.size() );
  copy ( sel_views.begin(), sel_views.end(), view_list.begin() );

  DisplayController * controller = DisplayController::instance ();
  const vector < const ViewBase * > & all_views = views ();

  controller->addTextViewToList ( view_list, all_views );
}

void CanvasView::contentsMousePressEvent ( QMouseEvent* e )
{
  FigureEditor::contentsMousePressEvent ( e );
  if ( (e->button() == Qt::RightButton) ||( e->state() == Qt::RightButton)) {
    contentsMouseMoveEvent ( e );
  }

  const vector < const ViewBase * > & sel_views = selectedViews ();

  if ( ! sel_views.empty () ) {
    vector < const ViewBase * > view_list;
    fillSelectedWithObservers ( view_list );
    s_xml_controller->saveToSelectionCopy ( view_list );
  }

  notifyObservers();
}


void CanvasView::contentsMouseMoveEvent ( QMouseEvent * e )
{
//If right button pressed, get the position and show on the status bar.
  if ( (e->button() == Qt::RightButton) ||( e->state() & Qt::RightButton)) {
#if QT_VERSION < 0x040000
    QCanvasItem * right_item=FigureEditor::getRightItem ();
#else
    Q3CanvasItem * right_item=FigureEditor::getRightItem ();
#endif
    if ( right_item == 0 ) return;

#if QT_VERSION < 0x040000
    QCanvasRectangle * rect
    = dynamic_cast <QCanvasRectangle *> ( right_item );
#else
    Q3CanvasRectangle * rect
    = dynamic_cast <Q3CanvasRectangle *> ( right_item );
#endif


    QPoint p = inverseWorldMatrix().map(e->pos());

    if ( ( p.x() >= rect->x() ) &&
       ( p.x() <= rect->x() + rect->width() ) &&
       ( p.y() >= rect->y() ) &&
       ( p.y() <= rect->y() + rect->height() ) ) {

      QtView * qtview = dynamic_cast < QtView * > ( right_item );
      if ( qtview == 0 ) //return;
        {
          QtGroupView * gv = dynamic_cast <QtGroupView *> (right_item);
          const vector <ViewBase * > & views = gv->getViews();
          vector < ViewBase * >::const_iterator first = views.begin();
          for ( ; first != views.end(); ++first ) {
            QtView * v = dynamic_cast < QtView * > ( *first );
            if ( ( p.x() >= v->x() ) &&
                 ( p.x() <= v->x() + v->width() ) &&
                 ( p.y() >= v->y() ) &&
                 ( p.y() <= v->y() + v->height() ) ) {
              qtview = v;
              break;
            }
          }
          if ( qtview == 0 ) return;     // click between views
        }


      vector < double > picked;
      qtview -> fillPickedPoint ( p.x(), p.y(), picked );
      if ( picked.empty () ) return;

      unsigned int size = picked.size();
      double datax = picked[1];
      double datay = picked[2]; // scaled if needed
      double dataz = 0.0;
      if ( size >= 4 ) {
        dataz = picked[3];
      }

      double unscaledDataX = picked[1];
      double unscaledDataY = picked[2];
      if ( std::abs ( picked[0] - 1.0 ) < 0.5 )  unscaledDataY = picked[3];

      // Set cross cursor for fits image with transfom.
      BinaryTransform * tf_fits
        = dynamic_cast < BinaryTransform * >  
        ( qtview->getPlotter()->getFitsTransform() );

      // tf_fits = 0 if the plot is not fits image with transform.
      if ( tf_fits ){
        tf_fits -> transform ( unscaledDataX, unscaledDataY );
      }

      qtview->setCrossX ( unscaledDataX );
      qtview->setCrossY ( unscaledDataY );
      qtview->setShowCrossHairs ( true );
      const QCursor cursor ( Qt::CrossCursor );
      QApplication::setOverrideCursor ( cursor, true );
      qtview->update(0);

      QString qstr = QString
        ( "Coordinates are : ( %1, %2, %3 )" )
        .arg ( datax )
        .arg ( datay )
        .arg ( dataz );

      CanvasWindow * cw = dynamic_cast < CanvasWindow * > ( parentWidget() );
      QStatusBar * sb = cw->statusBar();
      sb->message ( qstr );


      // Skip cut setting if in pick mode.
      // Add pick table if needed.
      if (m_cut_mode == 0 ){
        PickTable * table = 0;
        map < const QtView*, PickTable * > ::iterator first
          = m_table_map.find ( qtview );
        if ( first != m_table_map.end () ) {
          table = m_table_map [ qtview ];
        }
        else {
          PlotterBase * plotter = qtview->getPlotter ();
          
          table = new PickTable ( plotter );
          m_table_map [ qtview ] = table;
        }
        return;
      }

      // Set the cut range if the current plotter is a cut.
      PlotterBase * plotter = qtview->getPlotter();
      if ( plotter == 0 ) return;
      Cut1DPlotter * cut1d = dynamic_cast < Cut1DPlotter * > (plotter);
      Cut2DPlotter * cut2d = dynamic_cast < Cut2DPlotter * > ( plotter );

      
      // Set the cut range to be within the plotter range.
      // Cut1D plotter
      if ( cut1d ) {
        double cut_low = cut1d->getCutRange().low();
        double cut_high = cut1d->getCutRange().high();
        double plotter_low = cut1d->getRange( Axes::X, true ).low();
        double plotter_high = cut1d->getRange( Axes::X, true ).high();

        if (m_cut_mode == 1){

          if ( cut_low < plotter_low )
            {
              Range currentRange = Range ( plotter_low, cut_high );
              cut1d -> setCutRangeAt ( currentRange , 0 );
            }
          if ( cut_high > plotter_high )
            {
              Range currentRange = Range ( cut_low , plotter_high );
              cut1d -> setCutRangeAt ( currentRange , 0 );
            }
        }

      }

      // Cut2D plotter
      else if ( cut2d ) {
        double cut_low_x = cut2d->getCutRange().low();
        double cut_high_x = cut2d->getCutRange().high();
        double plotter_low_x = cut2d->getRange( Axes::X, true ).low();
        double plotter_high_x = cut2d->getRange( Axes::X, true ).high();
        double cut_low_y = cut2d->getCutRangeY().low();
        double cut_high_y = cut2d->getCutRangeY().high();
        double plotter_low_y = cut2d->getRange( Axes::Y, true ).low();
        double plotter_high_y = cut2d->getRange( Axes::Y, true ).high();

        if ( m_cut_mode == 1 ) {

          if ( cut_low_x < plotter_low_x )
            {
              Range currentRange = Range ( plotter_low_x, cut_high_x );
              cut2d -> setCutRangeAt ( currentRange , 0 );
            }
          if ( cut_high_x > plotter_high_x )
            {
              Range currentRange = Range ( cut_low_x , plotter_high_x );
              cut2d -> setCutRangeAt ( currentRange , 0 );
            }
          
          if ( cut_low_y < plotter_low_y )
            {
              Range currentRange = Range ( plotter_low_y, cut_high_y );
              cut2d -> setCutRangeAt ( currentRange , 1 );
            }
          if ( cut_high_y > plotter_high_y )
            {
              Range currentRange = Range ( cut_low_y , plotter_high_y );
              cut2d -> setCutRangeAt ( currentRange , 1 );
            }
        }
      }
        


      // Set cut according to the cut mode.
      switch ( m_cut_mode ){
      case 1:
        if ( cut1d ) {
          Range oldRange = cut1d -> getCutRange ();
          double old_low = oldRange.low();
          double old_high = oldRange.high();

          if ( datax < ( old_low + old_high ) / 2 ) {
            Range currentRange = Range ( datax , old_high );
            cut1d -> setCutRangeAt ( currentRange , 0 );
          }
          
          else
            {
              Range currentRange = Range ( old_low , datax );
              cut1d -> setCutRangeAt ( currentRange , 0 );
            }
          notifyObservers();
        }

        // Cut2D plotter
        else if ( cut2d ) {
          Range oldRangeX = cut2d -> getCutRange ();
          Range oldRangeY = cut2d -> getCutRangeY ();
          double old_low_x = oldRangeX.low();
          double old_high_x = oldRangeX.high();
          double old_low_y = oldRangeY.low();
          double old_high_y = oldRangeY.high();
        
          // Distances to each edge.
          double dis_low_x = std::abs ( datax - old_low_x );
          double dis_high_x = std::abs ( datax - old_high_x );
          double dis_low_y = std::abs ( datay - old_low_y );
          double dis_high_y = std::abs ( datay - old_high_y );

          // Left-bottom
          if ( ( dis_low_x <= 0.1 * (old_high_x - old_low_x)) &&
               ( dis_low_y <= 0.1 * (old_high_y - old_low_y)) &&
               ( m_edge == 0 ) || ( m_edge == 1 ) ) {
            Range currentRange = Range ( datax, old_high_x );
            cut2d -> setCutRangeAt ( currentRange, 0 );

            // Handle shift drag.
            if ( e->state() & Qt::ShiftButton) {
              int view_top = qtview->toViewY(old_high_y);
              int view_left = qtview->toViewX(datax);
              int view_right = qtview->toViewX(old_high_x);
              int view_bottom = view_top + view_right - view_left;

              // Not effecient to call fillPickedPoint(), but marginToUser() 
              // is protected.
              vector <double> adjusted;
              qtview->fillPickedPoint(view_left, view_bottom, adjusted);
              currentRange = Range ( adjusted[2], old_high_y );
            }
            else
              currentRange = Range ( datay, old_high_y );
            cut2d -> setCutRangeAt ( currentRange, 1 );
            m_edge = 1;
          }

          // Left-top
          else if ( ( dis_low_x <= 0.1 * (old_high_x - old_low_x)) &&
                    ( dis_high_y <= 0.1 * (old_high_y - old_low_y)) &&
                    ( m_edge == 0 ) || ( m_edge == 2 ) ) {
            Range currentRange = Range ( datax, old_high_x );
            cut2d -> setCutRangeAt ( currentRange, 0 );

            // Handle shift drag
            if ( e->state() & Qt::ShiftButton) {
              int view_bottom = qtview->toViewY(old_low_y);
              int view_left = qtview->toViewX(datax);
              int view_right = qtview->toViewX(old_high_x);
              int view_top = view_bottom - view_right + view_left;

              // Not effecient to call fillPickedPoint(), but marginToUser() 
              // is protected.
              vector <double> adjusted;
              qtview->fillPickedPoint(view_left, view_top, adjusted);
              currentRange = Range ( old_low_y, adjusted[2]);
            }
            else
              currentRange = Range ( old_low_y, datay );
            cut2d -> setCutRangeAt ( currentRange, 1 );
            m_edge = 2;
          }
          
          // Right-bottom
          else if ( ( dis_high_x <= 0.1 * (old_high_x - old_low_x)) &&
                    ( dis_low_y <= 0.1 * (old_high_y - old_low_y)) &&
                    ( m_edge == 0 ) || ( m_edge == 3 ) ) {
            Range currentRange = Range ( old_low_x, datax );
            cut2d -> setCutRangeAt ( currentRange, 0 );

            // Handle shift drag.
            if ( e->state() & Qt::ShiftButton) {
              int view_top = qtview->toViewY(old_high_y);
              int view_left = qtview->toViewX(old_low_x);
              int view_right = qtview->toViewX(datax);
              int view_bottom = view_top + view_right - view_left;

              // Not effecient to call fillPickedPoint(), but marginToUser() 
              // is protected.
              vector <double> adjusted;
              qtview->fillPickedPoint(view_right, view_bottom, adjusted);
              currentRange = Range ( adjusted[2], old_high_y );
            }
            else
              currentRange = Range ( datay, old_high_y );
            cut2d -> setCutRangeAt ( currentRange, 1 );
            m_edge = 3;
          }
          
          // Right-top
          else if ( ( dis_high_x <= 0.1 * (old_high_x - old_low_x)) &&
                    ( dis_high_y <= 0.1 * (old_high_y - old_low_y)) &&
                    ( m_edge == 0) || ( m_edge == 4 ) ) {
            Range currentRange = Range ( old_low_x, datax );
            cut2d -> setCutRangeAt ( currentRange, 0 );

            // Handle shift drag.
            if ( e->state() & Qt::ShiftButton) {
              int view_bottom = qtview->toViewY(old_low_y);
              int view_left = qtview->toViewX(old_low_x);
              int view_right = qtview->toViewX(datax);
              int view_top = view_bottom - view_right + view_left;

              // Not effecient to call fillPickedPoint(), but marginToUser() 
              // is protected.
              vector <double> adjusted;
              qtview->fillPickedPoint(view_right, view_top, adjusted);
              currentRange = Range ( old_low_y, adjusted[2] );
            }
            else
              currentRange = Range ( old_low_y, datay );
            cut2d -> setCutRangeAt ( currentRange, 1 );
            m_edge = 4;
          }

          // Left
          else if ( ( dis_low_x <= dis_high_x ) &&
                    ( dis_low_x <= dis_low_y ) &&
                    ( dis_low_x <= dis_high_y ) && 
                    ( m_edge == 0 ) || ( m_edge == 5 ) ) {
            Range currentRange = Range ( datax, old_high_x );
            cut2d -> setCutRangeAt ( currentRange, 0 );
            m_edge = 5;
          }
          
          // Right
          else if ( ( dis_high_x <= dis_low_x ) &&
                    ( dis_high_x <= dis_low_y ) &&
                    ( dis_high_x <= dis_high_y ) &&
                    ( m_edge == 0 ) || ( m_edge == 6 ) ) {
            Range currentRange = Range ( old_low_x, datax );
            cut2d -> setCutRangeAt ( currentRange, 0 );
            m_edge = 6;
          } 

          // Bottom
          else if ( ( dis_low_y <= dis_high_x ) &&
                    ( dis_low_y <= dis_low_x ) &&
                    ( dis_low_y <= dis_high_y ) &&
                    ( m_edge == 0 ) || ( m_edge == 7 ) ) {
            Range currentRange = Range ( datay, old_high_y );
            cut2d -> setCutRangeAt ( currentRange, 1 );
            m_edge = 7;
          }

          // Top
          else 
            {
              Range currentRange = Range ( old_low_y, datay );
              cut2d -> setCutRangeAt ( currentRange, 1 );
              m_edge = 8;
            }
          notifyObservers();
        }
                                         
        break;


      case 2:
        if ( cut1d ) {
          
          if ( !m_clicked ){
            old_pos = datax;
          }

          else {
            double low, high;

            if ( datax > old_pos ) {
              low = old_pos;
              high = datax;
            }

            else  {
              low = datax;
              high= old_pos;
            }

            Range currentRange = Range ( low, high );
            cut1d -> setCutRangeAt ( currentRange , 0 );
          }
          notifyObservers();
        }

        // Cut2D plotter.
        else if ( cut2d ) {
          if ( !m_clicked ){
            old_pos_x = datax;
            old_pos_y = datay;
          }

          else {
            double low, high;
            if ( datax > old_pos_x ) {
              low = old_pos_x;
              high = datax;
            }
            else {
              low = datax;
              high = old_pos_x;
            }
            Range currentRange = Range ( low, high );
            cut2d -> setCutRangeAt ( currentRange, 0 );

            if ( datay > old_pos_y ) {
              low = old_pos_y;
              high = datay;
            }
            else {
              low = datay;
              high = old_pos_y;
            }
            currentRange = Range ( low, high );
            cut2d -> setCutRangeAt ( currentRange, 1 );
          }
          notifyObservers();
        }

        break;


      case 3:
        if ( cut1d ) {

          DisplayController * controller = DisplayController::instance ();
          Range oldRange = cut1d -> getCutRange ();
          double width, low, high;
          
          // Log X axis.
          if ( (controller -> getLog ( plotter, Axes::X )) == true )
            {
              width = log10(oldRange.high())-log10(oldRange.low());
              low = pow ( 10., log10(datax) - ( width/2 ) );
              high = pow ( 10., log10(datax) + ( width/2 ) );         
            }

          // Linear X axis.
          else 
            {
              width = oldRange.high() - oldRange.low();
              low = datax - width/2;
              high = datax + width/2;
            }
          Range currentRange = Range ( low, high );
          cut1d -> setCutRangeAt (currentRange, 0 );
          notifyObservers();
        }
        
        // Cut2D plotter.
        if ( cut2d ) {
          DisplayController * controller = DisplayController::instance ();
          Range oldRangeX = cut2d -> getCutRange ();
          Range oldRangeY = cut2d -> getCutRangeY ();
          double width_x, width_y, low_x, high_x, low_y, high_y;
          
          // Log X axis.
          if ( (controller -> getLog ( plotter, Axes::X )) == true )
            {
              width_x = log10(oldRangeX.high())-log10(oldRangeX.low());
              low_x = pow ( 10., log10(datax) - ( width_x/2 ) );
              high_x = pow ( 10., log10(datax) + ( width_x/2 ) );             
            }

          // Linear X axis.
          else 
            {
              width_x = oldRangeX.high() - oldRangeX.low();
              low_x = datax - width_x/2;
              high_x = datax + width_x/2;
            }

          // Log Y axis.
          if ( (controller -> getLog ( plotter, Axes::Y )) == true )
            {
              width_y = log10(oldRangeY.high())-log10(oldRangeY.low());
              low_y = pow ( 10., log10(datay) - ( width_y/2 ) );
              high_y = pow ( 10., log10(datay) + ( width_y/2 ) );             
            }

          // Linear Y axis.
          else 
            {
              width_y = oldRangeY.high() - oldRangeY.low();
              low_y = datay - width_y/2;
              high_y = datay + width_y/2;
            }

          Range currentRange = Range ( low_x, high_x );
          cut2d -> setCutRangeAt (currentRange, 0 );
          currentRange = Range ( low_y, high_y );
          cut2d -> setCutRangeAt (currentRange, 1 );
          notifyObservers();
        }
          
        break;

      default:
        break;
      }




    }
  }


  // Left button pressed, do zoom in if in zoom mode.
  else{

    if ( isSingleItemSelected () == false )
      {
        FigureEditor::mouseMoveMultiItem(e);
        return;
      }

#if QT_VERSION < 0x040000
    QCanvasItem * item = selectedItem ();
#else
    Q3CanvasItem * item = selectedItem ();
#endif

    if ( item->isActive () ) return;

    QtView * qtview = dynamic_cast < QtView * > ( selectedItem() );

    if (qtview) {
      double aspect = qtview->getAspectRatio();
      FigureEditor::contentsMouseMoveEvent ( e, aspect );
    }
    else {
      QtGroupView * qtgroupview = 
        dynamic_cast < QtGroupView * > ( selectedItem());
      if (qtgroupview) {
        FigureEditor::contentsMouseMoveEvent (e, 0);
      }
    }

#if QT_VERSION < 0x040000
    QCanvasRectangle * rect
       = dynamic_cast <QCanvasRectangle *> ( item );
#else
    Q3CanvasRectangle * rect
      = dynamic_cast <Q3CanvasRectangle *> ( item );
#endif

    if ( getZoomMode() ){
      if ( (e->button() == Qt::LeftButton) ||
           ( e->state() & Qt::LeftButton) ) {

        QPoint p = inverseWorldMatrix().map ( e -> pos() );
        if ( ( p.x() >= rect->x() ) &&
           ( p.x() <= rect->x() + rect->width() ) &&
           ( p.y() >= rect->y() ) &&
           ( p.y() <= rect->y() + rect->height() ) ) {


           if (m_drag_rect != 0 ) {
              delete m_drag_rect;
           }

          QPoint top_left ( std::min ( p.x(), m_zoom_start.x() ),
                            std::max ( p.y(), m_zoom_start.y() ) );
          QPoint bo_right ( std::max ( p.x(), m_zoom_start.x() ),
                            std::min ( p.y(), m_zoom_start.y() ) );

          // Use square to zoom in
          if (e->state() & Qt::ShiftButton) {
            if (top_left.y() == m_zoom_start.y()) { 
              bo_right.setY( top_left.y() - bo_right.x() + top_left.x() );
            }
            
            else { // if (bo_right.y() == m_zoom_start.y()){ 
              top_left.setY( bo_right.y() + bo_right.x() - top_left.x() ); 
            }
          }

#if QT_VERSION < 0x040000
          m_drag_rect = new QCanvasRectangle ( QRect( top_left,bo_right ),
                                           canvas ());
#else
          m_drag_rect = new Q3CanvasRectangle ( QRect( top_left,bo_right ),
                                           canvas ());
#endif
          QColor color ( "black" );
          QPen pen ( color, 1, Qt::DotLine );
          m_drag_rect->setPen(pen);
          
          if ( selectedPlotter() == 0 ) {
            QString message ( "Can not do range zoom in a group view.\n" );
            message += "Please select a single plotter view.";
            QMessageBox::information ( this,
                                       s_app_name.c_str(),
                                       message );
            return;
          }
            

          if ( selectedPlotter()->hasAxis(Axes::Z) ){
            double z = selectedPlotter()->getRange(Axes::Z,true).high() ;
            m_drag_rect -> setZ( z );  // Why setZ? Any thing to do with text plotter?
          }
          m_drag_rect -> setVisible ( true );
          //canvas () -> update ();
        }
      }
    }
  }
}

void
CanvasView::
savePlotAsImage ( const PlotterBase * plotter,
                  const std::string & filename )
{
  if ( plotter == 0 ) return;

  string::size_type i = filename.find_last_of ( '.');
  if ( i != string::npos ) {
    string suffix ( filename.substr ( i + 1 ) );
    if ( suffix == "eps" ||
         suffix == "EPS" ) {
      savePlotAsEps ( plotter, filename );
    }
    else {
      QtView * view = getViewFor ( plotter );
      assert ( view != 0 );

      QRect rect = view -> rect ();
      saveAreaAsPixmap ( rect, filename );
    }
  }
}

void
CanvasView::
toLower ( std::string & upper )
{
  string::size_type size = upper.size();
  for ( string::size_type i = 0; i < size; i++ ) {
    upper[i] = std::tolower ( upper[i] );
  }
}

bool
CanvasView::
isValidImageFormat ( const std::string & suffix )
{
  // Handle gzipped suffix
  if (suffix=="gz" || suffix=="GZ") return true;

  if ( s_image_filters.empty () ) createImageFilters ();

  string star ( "*." + suffix );
  toLower ( star );

  // following could be 64 bit unsigned int
  string::size_type i = s_image_filters.find ( star );

  return i != string::npos;
}

void
CanvasView::
showFitsError () const
{
  QString message ( "Sorry, this installation of " );
  message += s_app_name.c_str();
  message += " was not\n"
    "built with the optional FITS support.";
  QMessageBox::information ( const_cast < CanvasView * > ( this ),
                             s_app_name.c_str(),
                             message );
}

void
CanvasView::
saveSelectedImages ( const std::string & fn, bool check_existing )
{
  string filename = fn;
  string::size_type i = filename.find_last_of ( '.' );

  if ( i == string::npos ) { // no suffix given
    if ( m_image_dialog != 0 ) {
      QString s = m_image_dialog->selectedFilter ();
      string filt = s.latin1();
      string::size_type ipos = filt.find ( "*." ) + 1;
      string::size_type epos = filt.find ( ")" );
      string suffix ( filt.substr ( ipos, epos - ipos ) );
      filename += suffix;
    }
    else {
      filename += ".jpg";
    }
    i = filename.find_last_of ( '.' );
  }

  string suffix ( filename.substr ( i + 1 ) );
  if ( isValidImageFormat ( suffix ) ) {
    string base ( filename.substr ( 0, i - 1 ) ); //basename
    if ( base.empty () ) filename = "image." + suffix;

    if ( check_existing ) {
      QString fn ( filename.c_str() );
      bool yes = QFile::exists ( fn );

      if ( yes ) {
        yes = existingFileWarning ( filename );
        if ( yes == false ) return;
      }
    }

    setVisibleNonViews ( false );
    if ( suffix == "eps" ||
         suffix == "EPS" ) 
      {
        saveSelectedAsEps ( filename );
      } 
    else if (suffix == "fits" ||
             suffix == "FITS" ||
             suffix == "gz"   ||
             suffix == "GZ")
      {
#ifdef HAVE_CFITSIO
        saveSelectedAsFits ( filename );
#else
        showFitsError ();
#endif  
      }
    else
      {
        setUnselectedVisible ( false );
        saveSelectedAsPixmap ( filename );
        setUnselectedVisible ( true );
      }
    setVisibleNonViews ( true );
  }
  else {
    invalidImageFormatError ( filename );
  }
}

void
CanvasView::
savePlotAsFits ( const PlotterBase * plotter,
                 const std::string & filename ) const
{
#ifdef HAVE_CFITSIO
  if ( plotter -> isImageConvertable () == false ) {
    QString message ( "The contents of this plotter is not\n"
                      "onvertable to a FITS image." );
    QMessageBox::information ( const_cast < CanvasView * > ( this ),
                               s_app_name.c_str(),
                               message );
    return;
  }

  PlotterBase * p = const_cast < PlotterBase * > ( plotter );

  const std::vector <unsigned int> & fitsshape = p->getShape();
  const std::vector <double> & fitsdata = p->getZValues();
  
  FitsController::instance ()
    ->writeImageToFile ( fitsshape[0], fitsshape[1], fitsdata, filename );

#else
  showFitsError ();
#endif
}

#ifdef HAVE_CFITSIO
void
CanvasView::
saveSelectedAsFits ( const std::string & filename )
{
  PlotterBase * plotter = selectedPlotter ();

  if ( !plotter ) {
    QString message ( "No plot or more than one plot selected." );
    QMessageBox::information ( this,
                               s_app_name.c_str(),
                               message );
    return;
  }

  else {
    savePlotAsFits ( plotter, filename );
  }
}
#endif
  

void
CanvasView::
savePlotAsEps ( const PlotterBase * plotter,
                const std::string & filename ) const
{
  if ( plotter != 0 ) {
    QtView * view = getViewFor ( plotter );
    assert ( view != 0 );

    QRect rect = view -> rect ();
    EpsView * eps = new EpsView ( filename,
                                  rect.x(), rect.y (),
                                  rect.width(), rect.height() );
    const Rect & marg_rect = view -> getMarginRect ();
    eps -> setMarginRect ( marg_rect );

    PlotterBase * p = const_cast < PlotterBase * > ( plotter );
    eps -> setPlotter ( p );
    eps -> setDrawRect ( rect.x(), rect.y(),
                         rect.width(), rect.height() );
    eps -> drawSelf ();
    eps -> closeFile ();
    delete eps;
  }
}

void
CanvasView::
saveSelectedAsEps ( const std::string & filename )
{
  QRect rect = getSelectedBounds ();

  EpsView * eps_view
    = new EpsView ( filename,
                    rect.x(), rect.y(), rect.width(), rect.height() );

  const vector < const ViewBase * > & viewList = selectedViews ();
#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
  vector < const ViewBase * > :: const_iterator first = viewList.begin();
  while ( first != viewList.end() ) {
    const ViewBase * vb = *first++;
    const QtView * view = dynamic_cast < const QtView * > ( vb );
    PlotterBase * plotter = view->getPlotter ();
    QRect rect = view->rect();

    eps_view -> setPlotter ( plotter );
    eps_view -> setDrawRect ( rect.x(), rect.y(),
                              rect.width(), rect.height() );
    const Rect & marg_rect = view -> getMarginRect ();
    eps_view -> setMarginRect ( marg_rect );

    eps_view -> drawSelf ();
  }

  eps_view -> closeFile ();

  delete eps_view;
}

void
CanvasView::
saveAs ( const std::string & filename ) const
{
  const vector < const ViewBase * > & view_list = views ();
  saveAs ( view_list, filename );
}

void
CanvasView::
saveAs ( const std::vector < PlotterBase * > & plotters,
         const std::string & filename )
{
  vector < const ViewBase * > views;

  unsigned int size = plotters.size ();
  for ( unsigned int i = 0; i < size; i++ ) {
    PlotterBase * plotter = plotters [i];
    QtView * view = wrapPlotter ( plotter );
    views.push_back ( view );
  }
  saveAs ( views, filename );
}

void
CanvasView::
saveAs ( const std::vector < const ViewBase * > & views,
         const std::string & filename )
{
  if ( s_xml_controller == 0 ) {
    s_xml_controller = QtXMLController::instance ();
  }

  XmlController::Status status
    =  s_xml_controller->saveToFile ( views, filename );
  if ( status != XmlController::Success ) {
    return;
  }
}

void
CanvasView::
exportTextTuple ( const std::string & data_suffix )
{
 DataSourceController * controller = DataSourceController::instance ();

  const vector < string > & tuples = controller->getNTupleNames();

  if ( tuples.empty () ) {
    QString message ( "There are no NTuples to be exported" );
    QMessageBox::information ( this,
                               s_app_name.c_str(),
                               message );
    return;
  }

  QString filename =
#if QT_VERSION < 0x040000
    QFileDialog::getSaveFileName ( QString::null, // starting directory
                                   QString::null, // filter
                                   this,
                                   "save file dialog",
                                   "Save data source as ..." ); // caption
#else
    Q3FileDialog::getSaveFileName ( QString::null, // starting directory
                                    QString::null, // filter
                                    this,
                                    "save file dialog",
                                    "Save data source as ..." ); // caption
#endif

  if ( filename == QString::null ) return;

  QString suffix ( data_suffix.c_str() );
#if QT_VERSION < 0x030300
  QString suffix2 ( suffix );
  suffix2.upper ();
  if ( filename.endsWith ( suffix )  == false &&
       filename.endsWith ( suffix2 ) == false ) {
    filename += data_suffix;
  }
#else
  if ( filename.endsWith ( suffix, false ) == false ) {
    filename += data_suffix.c_str();
  }
#endif

  const string tuple_name = m_inspector -> getSelectedDataSourceName ();

#if defined(QT_NO_STL) || QT_VERSION < 0x030100
  string tuple_file( filename );
#else
  string tuple_file ( filename.latin1() );
#endif

  try {
    NTupleController::instance ()
      ->writeNTupleToFile ( tuple_name, tuple_file );
    controller -> changeName ( tuple_name, tuple_file );
  }
  catch ( const std::exception & e ) {
    QString message ( "An error occurred in writing file.\n\n" );
    message += e.what();
    QMessageBox::critical ( this, // parent
                            QString ( "Write error" ), // caption
                            message,
                            QMessageBox::Ok,
                            QMessageBox::NoButton,
                            QMessageBox::NoButton );
  }

  notifyObservers ();
}
 
void
CanvasView::
contentsMouseReleaseEvent(QMouseEvent * e) {
  
  FigureEditor::contentsMouseReleaseEvent(e);
  
  std::vector<double> picked;
  fillPickedPoint(e, picked);

  QPoint p = inverseWorldMatrix().map(e->pos());
  
  QtView * qtview(0);
  
  // For right button, just fill m_mouseData and return...
  // Behave differently in different cut modes. 
  if (e->button() == Qt::RightButton || e->state() == Qt::RightButton) {

#if QT_VERSION < 0x040000
    QCanvasItem * right_item=FigureEditor::getRightItem ();
#else
    Q3CanvasItem * right_item=FigureEditor::getRightItem ();
#endif

    if ( right_item == 0 ) {
      return;
    }

    qtview = dynamic_cast < QtView * > ( right_item );

    // Select a view if a group view is selected.
    if ( qtview == 0 )
      {
        QtGroupView * gv = dynamic_cast <QtGroupView *> (right_item);
        const vector <ViewBase * > & views = gv->getViews();
        vector < ViewBase * >::const_iterator first = views.begin();
        for ( ; first != views.end(); ++first ) {
          QtView * v = dynamic_cast < QtView * > ( *first );
          if ( ( p.x() >= v->x() ) &&
               ( p.x() <= v->x() + v->width() ) &&
               ( p.y() >= v->y() ) &&
               ( p.y() <= v->y() + v->height() ) ) {
              qtview = v;
              break;
          }
        }
        if ( qtview == 0 ) return;     // click between views
      }



    fillMouseData(picked);
    
    // In pick mode, update the pick table.
    if ( qtview && ( m_cut_mode == 0 ) ) {
        
#if QT_VERSION < 0x040000
      QCanvasRectangle * rect
        = dynamic_cast <QCanvasRectangle *> ( qtview );
#else
      Q3CanvasRectangle * rect
        = dynamic_cast <Q3CanvasRectangle *> ( qtview );
#endif
      
      
      if ( ( p.x() >= rect->x() ) &&
           ( p.x() <= rect->x() + rect->width() ) &&
           ( p.y() >= rect->y() ) &&
           ( p.y() <= rect->y() + rect->height() ) ) {
        
        vector < double > picked2;
        qtview -> fillPickedPoint ( p.x(), p.y(), picked2 );
        updatePickTable ( qtview, picked2 );
      }
    }
        
    // In cut mode 2, up date m_clicked to identify first and second click.
    if ( qtview && ( m_cut_mode == 2 ) ) m_clicked=!m_clicked;
    if ( qtview && ( m_cut_mode == 1 ) ) m_edge = 0;
  
  } 
  
  else {  // zoom in
    qtview = dynamic_cast < QtView * > ( selectedItem() );
    if (qtview && !picked.empty() && m_whereClicked != invalid &&
        m_drag_rect != 0 ) { // We have a rectangle selected.

      std::vector <double> zoom_top_left;
      std::vector <double> zoom_bo_right;

      // Zoom in use the rect instead of the release point.
      qtview->fillPickedPoint(m_drag_rect->x(), 
                              m_drag_rect->y(), 
                              zoom_top_left);
      qtview->fillPickedPoint(m_drag_rect->x()+m_drag_rect->width(), 
                              m_drag_rect->y()+m_drag_rect->height(), 
                              zoom_bo_right);
      setPlotZoom(zoom_top_left, zoom_bo_right);

      delete m_drag_rect;   // Erase the rectangle.
      m_drag_rect = 0;
      canvas()->update();
    } else {
      m_mouseData.clear();
    }
  }
  
  QApplication::restoreOverrideCursor ();
  
  CanvasWindow * cw = dynamic_cast < CanvasWindow * > ( parentWidget() );
  QStatusBar * sb = cw->statusBar();
  sb->clear();
  
  if (qtview) {
    qtview->setShowCrossHairs ( false );
    qtview->update(0);
  }
  
  ::mouseEvent.wakeAll();
  notifyObservers ();
}

bool
CanvasView::
fillPickedPoint(QMouseEvent * e, std::vector<double> & picked) {
   QPoint p = inverseWorldMatrix().map(e->pos());

#if QT_VERSION < 0x040000
   QCanvasItem * selItem = FigureEditor::selectedItem();
   QCanvasRectangle * rect = dynamic_cast<QCanvasRectangle *>(selItem);
#else
   Q3CanvasItem * selItem = FigureEditor::selectedItem();
   Q3CanvasRectangle * rect = dynamic_cast<Q3CanvasRectangle *>(selItem);
#endif
   if (selItem) {
      QtView * qtview = dynamic_cast<QtView *>(selItem);
      if (!qtview) return false;
      picked.clear();
      if ( ( p.x() >= rect->x() ) &&
           ( p.x() <= rect->x() + rect->width() ) &&
           ( p.y() >= rect->y() ) &&
           ( p.y() <= rect->y() + rect->height() ) ) {
         qtview -> fillPickedPoint ( p.x(), p.y(), picked );
         if (!picked.empty()) {
            return true;
         }
      }
   }
   return false;
}

void
CanvasView::
fillMouseData(const std::vector<double> & picked) {
   if (!picked.empty()) {
      m_mouseData.clear();
      m_mouseData.reserve(3);
      m_mouseData.push_back(picked[1]);
      m_mouseData.push_back(picked[2]);
      if (picked.size() == 4) {
         m_mouseData.push_back(picked[3]);
      } else {
         m_mouseData.push_back(0);
      }
   }
}

void
CanvasView::
updatePickTable(QtView * qtview, std::vector<double> & picked) {
  if (!picked.empty()){
    PickTable * table = 0;
    map < const QtView *, PickTable * > ::iterator first
      = m_table_map.find ( qtview );
    if ( first != m_table_map.end () ) {
      table = m_table_map [ qtview ];
    }
    if ( m_cut_mode == 0 ) {
      table -> addItem ( picked );
    }
  }
}

/* Note: indexing into the picked vector offset by one because the
   first entry is the type.   See XyPlotter::fillPickedPointFrom().
 */
void
CanvasView::
setPlotZoom(const std::vector<double> & start_picked,
            const std::vector<double> & picked) {
   if (getZoomMode()) {
      if ( !(selectedPlotter()->getCurrentRangeSaved()) ) {
         setCurrentRange();
      }
      PlotterBase * plotter = selectedPlotter();
      plotter->setRange( "x",
                         std::min(picked[1], start_picked[1]),
                         std::max(picked[1], start_picked[1]) );
      if (plotter->hasAxis(Axes::Z) || plotter->hasZoomY()) {
         plotter->setRange( "y",
                            std::min(picked[2], start_picked[2]),
                            std::max(picked[2], start_picked[2]) );
      }
      plotter -> setCurrentRangeSaved ( false );
   }
}

void
CanvasView::
setCurrentRange()
{
  if ( ! m_current_range.empty () ){
    m_current_range.clear ();
  }
  PlotterBase * plotter = selectedPlotter ();

    m_current_range.push_back( plotter -> getRange(Axes::X,true).low());
    m_current_range.push_back( plotter -> getRange(Axes::X,true).high());
    m_current_range.push_back( plotter -> getRange(Axes::Y,true).low());
    m_current_range.push_back( plotter -> getRange(Axes::Y,true).high());

    int i = plotter  -> currentView();
    plotter -> saveViewAtIndex( m_current_range , i + 1 );
    plotter -> setCurrentRangeSaved( true );
}

std::vector<double>&
CanvasView::
getCurrentRange()
{
  return m_current_range;
}

void
CanvasView::
showInspector ()
{
  m_inspector -> show ();
}

void
CanvasView::
viewShowPickTable()
{
//   if ( !isSingleItemSelected() ) return;
  if ( isSingleItemSelected () == false ) {
    QString message ( "One must select a single plot before showing\n"
                      "the pick table." );
    QMessageBox::information ( this,
                               s_app_name.c_str(),
                               message );
    return;
  }

#if QT_VERSION < 0x040000
  QCanvasItem * selItem = selectedItem();
#else
  Q3CanvasItem * selItem = selectedItem();
#endif
  QtView * qtview = dynamic_cast < QtView * > ( selItem );
  if ( qtview == 0 ) {
    QString message ( "Can not show pick table of a group view.\n" );
    message += "Please select a single plotter view.";
    QMessageBox::information ( this,
                               s_app_name.c_str(),
                               message );
    return;
  }
  map < const QtView *, PickTable * > ::iterator first
    = m_table_map.find ( qtview );

  if ( first == m_table_map.end() ) {
    PlotterBase * plotter = qtview->getPlotter ();

    PickTable * table = new PickTable ( plotter );
    m_table_map [ qtview ] = table;
    table->show();
  }
  else {
    // Show existing pick table.
    m_table_map[qtview]->show();
  }
}



const std::vector<double> &
CanvasView::
mouseEventData()
{
#if QT_VERSION < 0x040000
  ::mouseEvent.wait();
#else
  // need to learn about equivalent
  //  ::mouseEvent.wait( mutex, time );
#endif
   return m_mouseData;
}

void
CanvasView::helpAbout()
{
  const std::string & version = WindowController::version ();
  std::string about = "<h2>HippoDraw version: ";
  about += version;
  about += "<h3> Built on ";
  about += "<ul>";
  about += "<li> Qt ";
  about += QT_VERSION_STR;
#ifdef HAVE_CFITSIO
  about += "<li> CFITSIO ";
  const string & fits_version = FitsController::instance () -> version ();
  about += fits_version.c_str();
#endif

#ifdef HAVE_MINUIT
  about += "<li> C++ Minuit";
#endif

#ifdef HAVE_MINUIT2
  about += "<li> Minuit2";
#endif

#ifdef HAVE_ROOT
  about += "<li> ROOT ";
  const string & root_version = RootController::instance() -> version ();
  about += root_version.c_str();
#endif

#ifdef HAVE_WCSLIB
  about += "<li> WCSlib ";
  about += "4.x";
#endif
  about += "</ul>";

  about += "<h3>Contributors...";
  about += "<ul>";
  about += "<li> Stephane Bonneaud";
  about += "<li> James Chiang";
  about += "<li> Johann Cohen-Tanugi";
  about += "<li> Xie Fang";
  about += "<li> Kaustuv";
  about += "<li> Paul F. Kunz";
  about += "<li> Sanket B. Malde";
  about += "<li> Matthew D. Langston";
  about += "<li> Joy Rajiv";
  about += "<li> Matan Shacham";
  about += "<li> Oded Wurman";
  about += "</ul>";

  static QMessageBox* mbox
    = new QMessageBox ( "HippoDraw",
                        about.c_str(),
                        QMessageBox::Information, 1, 0, 0, this, 0, false );
  mbox->setButtonText ( 1, "OK" );

  mbox -> exec (); // run modal
}

const std::string &
CanvasView::
applicationName () const
{
  return s_app_name;
}


PlotterBase *
CanvasView::
getRightClickedPlotter()
{

#if QT_VERSION < 0x040000
  QCanvasItem * right_item=FigureEditor::getRightItem ();
#else
  Q3CanvasItem * right_item=FigureEditor::getRightItem ();
#endif

  QtView * view = dynamic_cast <QtView *> (right_item);
  
  if ( view == 0 ) return 0;
  PlotterBase * plotter = view -> getPlotter ();
  return plotter;
}

void
CanvasView::
setCutMode ( int mode )
{
  m_cut_mode=mode;
}

void
CanvasView::
createNTuple ()
{
  DataSourceController * controller = DataSourceController::instance ();

  const vector < string > & tuples = controller->getNTupleNames();

  if ( tuples.empty () ) {
    QString message ( "There are no NTuples to be used as source" );
    QMessageBox::information ( this,
                               s_app_name.c_str(),
                               message );
    return;
  }

  CreateNTuple * cnt = new CreateNTuple ();
  cnt-> show ();
}

NTuple *
CanvasView::
getPickTable ()
{

  const ViewBase * selview;
  if (m_sel_views.size()==1) selview = m_sel_views[0];
  else return NULL;

  const QtView * view = dynamic_cast < const QtView * > ( selview );

  PickTable * table=0;
  map < const QtView *, PickTable * > ::iterator first
    = m_table_map.find ( view );
  if ( first != m_table_map.end () ) {
    table = m_table_map [ view ];
  }
  if ( table ) {
    return table->getPickTable();
  }
  
  return NULL;

}

NTuple *
CanvasView::
getPickTable ( const PlotterBase * plotter )
{

  const QtView * view = getViewFor ( plotter );
  
  PickTable * table = 0;
  map < const QtView *, PickTable * > :: iterator first
    = m_table_map.find (view);
  if ( first !=m_table_map.end() ) {
    table = m_table_map [view];
  }
  if ( table ) {
    return table->getPickTable();
  }
  
  return NULL;
}

void
CanvasView::
groupView ()
{
  const vector < const ViewBase * > & selViews = selectedViews();
  if ( selViews.empty () ) return;

  QRect groupRect = QRect(0,0,0,0);

  QtGroupView * groupView = new QtGroupView ();

  vector < const ViewBase * >::const_iterator it = selViews.begin();
  for ( ; it != selViews.end(); ++it ) {
    ViewBase * view = const_cast < ViewBase * > ( *it );

    QtView * qtview = dynamic_cast < QtView * > ( view );
    if (!qtview) continue;  // don't include groupview in groupview

    groupView->addView (view);
    removeFromItemList (qtview);
    QRect temp = qtview->boundingRect();
    groupRect|=temp;   // get a rect to contain all QtViews
  }
  
  groupView->setDrawRect(groupRect);
  groupView->setPositions();  // set relative position
  add(groupView);
  clearSelectedList();
  addSelectedItem ( groupView );
}

void
CanvasView::
ungroupView ()
{
  const vector < const ViewBase * > & selViews = selectedViews();
  if ( selViews.size() != 1 ) return;

  const QtGroupView * groupView = 
    dynamic_cast < const QtGroupView * > ( selViews[0] );
  if (!groupView) return;

  QtGroupView * gv = const_cast < QtGroupView * > ( groupView );
  clearSelectedList ();
  const vector < ViewBase * > & views = gv->getViews();

  vector < ViewBase * >::const_iterator first = views.begin();
  for ( ; first != views.end(); ++first ) {
    QtView * qtview = dynamic_cast < QtView * > ( *first );
    add (qtview);
    gv->removeView(*first);
    --first;     // a view is removed, decrease the iterator
    addSelectedItem (qtview );
  }
  remove ( gv );
}

void CanvasView::hideSelected ( )
{
  const vector < const ViewBase * > & views = selectedViews ();
#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
  vector < const ViewBase * > ::const_iterator first = views.begin();
  while ( first != views.end() ) {
    const QtView * view = dynamic_cast < const QtView * > ( *first++ );
    QtView * v = const_cast < QtView * > ( view );
    hide(v);
  }
}

void
CanvasView::
addRecentFile (const QString & filename, QActionGroup * ag )
{
  #if QT_VERSION < 0x040000
#else
  QObject * parent = ag -> parent ();
#endif  
    
  // Avoid duplicate recently opened files. 
  // Remove old item with same name if needed.
  std::list<QAction *>::iterator it=m_recent_list.begin();

  for (; it!=m_recent_list.end(); ++it){
    if (((*it)->menuText())==filename){
      delete *it;    // need removeFrom(ag) ?
      it=m_recent_list.erase(it);
      break;
    }
  }

  // Add new item.
#if QT_VERSION < 0x040000
  QAction * action = new QAction ( "", // text
                                   QIconSet(),
                                   filename, // menu test
                                   0, // accel
                                   ag ); // parent
#else
  QAction * action = new QAction ( filename, parent );
  ag -> addAction ( action );
#endif
  action -> setToggleAction ( true );
  m_recent_list.push_back(action);

  // Remove the first element if size is more than 5.
  if (m_recent_list.size() > 5) {
    it=m_recent_list.begin();
    delete *it;    //need removeFrom(ag) ?
    m_recent_list.pop_front();
  }
}

void
CanvasView::
#if QT_VERSION < 0x040000
autosaveSettings (QMainWindow * mw)
#else
autosaveSettings (Q3MainWindow * mw)
#endif
{
  QSettings settings;
  settings.insertSearchPath ( QSettings::Windows, s_registry );
  QString fn;
  list<QAction *>::iterator it;
  unsigned int i=0;


  // Save recently opened files
  for ( it=m_recent_list.begin(); 
        it!=m_recent_list.end(); i++, it++ )
    {
      fn = (*it)->menuText();
      QString number=QString::number(i);
      settings.writeEntry ( s_app_key + "Files/File"+number, fn );
    }

  // Save dock window positions.
  QString dockSetting;
  QTextStream stream( &dockSetting, IO_WriteOnly );
  stream << *mw;
  settings.writeEntry(s_app_key+"DockWindow/Position", dockSetting);
}

void
CanvasWindow::
defaultToolbar()
{
  moveDockWindow(toolBar);
  moveDockWindow(Toolbar_2);
  moveDockWindow(Toolbar);
  moveDockWindow(Toolbar_4);

  lineUpDockWindows();
}