CanvasView.cxx

Go to the documentation of this file.

// for MEMFUN1 and others
#ifdef HAVE_CONFIG_H
#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 "QtView.h"
#include "QtViewFactory.h"
#include "PickTable.h"
#include "WindowController.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 "qtxml/QtXMLController.h"

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

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

#include <qapplication.h>


#if QT_VERSION < 0x040000
#include <qfiledialog.h>
#include <qimage.h>
#else
#include <q3filedialog.h>
#include <QImageIO>
#endif

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

#include <algorithm>


#include <cctype>
#include <cassert>

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

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

namespace {
   QWaitCondition mouseEvent;
}

#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_xml_controller = QtXMLController::instance ();
  m_table_map.clear();
  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" );

}

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 );
  
  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 );
    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 = m_xml_controller->openFile ( filename );

  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
    = m_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 );
  m_xml_controller->saveToPasteboard ( view_list );
}

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

  const list < ViewBase * > & pb_views 
    = m_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 
    = m_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 ) {
    m_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();
  
  while ( iter != view_list.end() ) {
    const ViewBase * curview = ( * iter++ );
    const QtView * view = dynamic_cast < const QtView * > ( curview );
    QtView * v = const_cast < QtView * > ( view );
    remove ( v );
  }

  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 ) {
    CanvasWindow * window = dynamic_cast < CanvasWindow * > ( parent );
    window->setChanged ( flag );
  }
}

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

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

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 ];
    PlotterBase * plotter = view -> getPlotter ();
    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 );

  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 );
    m_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::
setup ()
{
  CanvasSettings * cs = new CanvasSettings ( this );
  cs -> setOrientation ( s_printer -> orientation() );
  cs -> setWidthNumber ( m_num_width );
  cs -> setHeightNumber ( m_num_height );
  cs -> setPrinterBounds ( m_printer_bounds );
  
  int retval = cs -> exec ();

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

        
      if( cs -> orientation() != s_printer -> orientation() ) 
        {
#if QT_VERSION < 0x040000
          QCanvas * can = canvas();
#else
          Q3Canvas * can = canvas();
#endif
          int numpages = static_cast<int>( can -> height()
                                           / (double) m_apage_h );
          
          s_printer -> setOrientation( cs -> orientation() );

          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 )
        }
     
      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 )
        }

    }

  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 );
    }
}

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 );
}

void CanvasView::addPlotDisplay ( PlotterBase * plotter, bool select )
{
  ViewFactory * factory = QtViewFactory::instance ();
  ViewBase * view = factory->createView ( plotter );

  QtView * qtview = dynamic_cast< QtView * > ( view );
  qtview -> setPageWidth( m_upage_w );
  qtview -> setInspector( m_inspector );
  
  double transform_aspect_ratio = plotter -> getAspectRatio();
  calcDefaultSize ( qtview, transform_aspect_ratio );
    
  placeGraph ( qtview );
  
  addView ( qtview, select );
}

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

  while ( first != items.end() )
    {
      QtView * view = dynamic_cast < QtView * > ( *first++ );
      calcDefaultSize ( view, view -> getAspectRatio() );
      placeGraph ( 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<double, double>(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 );
}

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 );
    }
  }

  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 ()
{
  const string eps ( "eps" );
  bool eps_inserted = false;

  s_image_filters = "files (";

#if QT_VERSION < 0x040000
  QStringList slist = QImage::outputFormatList ();
  QStringList::Iterator it = slist.begin();
#else
  QList < QByteArray >  slist = QImageIO::outputFormats ();
  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
    if ( low == "jpeg" ) low = "jpg";
    if ( eps >= low ) {
      s_image_filters += " *." + low;
    }
    else {
      if ( eps_inserted == false ) {
        s_image_filters += " *." + eps + ");; (";
        eps_inserted = true;
      }
      s_image_filters += " *." + low;
    }
    s_image_filters += ");; (";
  }

  string::size_type pos = s_image_filters.find_last_of ( ";;" );
  s_image_filters.erase ( pos - 1 );
}

#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 ( m_image_dialog == 0 ) m_image_dialog = createImageDialog ();

  m_image_dialog->show ();

 if ( m_image_dialog->exec() != QDialog::Accepted ) return;

  QString filename = m_image_dialog->selectedFile ();

  if ( filename.isEmpty () ) return;


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

  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 
    = m_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 );

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

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

  notifyObservers();
}

void CanvasView::contentsMouseMoveEvent ( QMouseEvent * e )
{

  if ( isSingleItemSelected () == false ) 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 );
  }

#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 (drag_rect != 0 )
          delete drag_rect;
 
        QPoint top_left ( std::min ( p.x(), zoom_start.x() ),
                          std::max ( p.y(), zoom_start.y() ) );
        QPoint bo_right ( std::max ( p.x(), zoom_start.x() ),
                          std::min ( p.y(), zoom_start.y() ) );
        drag_rect = new QCanvasRectangle ( QRect( top_left,bo_right ), 
                                           canvas ());
        
        drag_rect -> setVisible ( true );
        canvas () -> update ();
      }
    }
  }
}


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

  QtView * view = getViewFor ( plotter );
  assert ( view != 0 );

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

void
CanvasView::
toLower ( 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 )
{
  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::
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 {
      setUnselectedVisible ( false );
      saveSelectedAsPixmap ( filename );
      setUnselectedVisible ( true );
    }
    setVisibleNonViews ( true );
  }
  else {
    invalidImageFormatError ( filename );
  }
}

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() );
    eps_view -> drawSelf ();
  }

  eps_view -> endPlot ();

  delete eps_view;
}

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

  XmlController::Status status 
    =  m_xml_controller->saveToFile ( view_list, 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

  NTupleController::instance () 
    ->writeNTupleToFile ( tuple_name, tuple_file );
  controller -> changeName ( tuple_name, tuple_file );

  notifyObservers ();
}

void CanvasView::contentsMouseReleaseEvent ( QMouseEvent* e )
{
  if ( m_whereClicked == invalid ) {
     m_mouseData.clear();
     ::mouseEvent.wakeAll();
     return;
  }
  if ( !isSingleItemSelected() ) {
     m_mouseData.clear();
     ::mouseEvent.wakeAll();
     return;
  }

#if QT_VERSION < 0x040000
  QCanvasItem * selItem = selectedItem();
#else
  Q3CanvasItem * selItem = selectedItem();
#endif
  QtView * qtview = dynamic_cast < QtView * > ( selItem );
  if ( !qtview ) {
     m_mouseData.clear();
     ::mouseEvent.wakeAll();
     return;
  }
  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 ];
  }

  // Compute the (x, y, z) data for this event.
  QPoint p = inverseWorldMatrix().map(e->pos());
    
#if QT_VERSION < 0x040000
  QCanvasRectangle * rect 
     = dynamic_cast <QCanvasRectangle *> ( selItem );
#else
  Q3CanvasRectangle * rect 
    = dynamic_cast <Q3CanvasRectangle *> ( selItem );
#endif


  if (drag_rect != 0){
    delete drag_rect;
    drag_rect = 0;
    canvas() -> update ();
  }

  if ( e->button() == Qt::LeftButton ) {
    if ( ( p.x() >= rect->x() ) &&
         ( p.x() <= rect->x() + rect->width() ) &&
         ( p.y() >= rect->y() ) &&
         ( p.y() <= rect->y() + rect->height() ) ) {
      
     vector < double > picked , start_picked;
     
     qtview -> fillPickedPoint ( p.x(), p.y(), picked );
     qtview -> fillPickedPoint(zoom_start.x(),zoom_start.y(),start_picked);
     
     if ( picked.empty() == false ) {
       
       // Fill the current 3-vector of mouse event data.
       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. );
       }
       
       // Add the point to the list.
       if ( table && table->isVisible() ) {
         table -> addItem ( picked );
       }
       // Change range on the selected plotter.
     
       if ( getZoomMode () ) {
         if ( ! ( selectedPlotter() ->getCurrentRangeSaved () ) )
           setCurrentRange();
         
         selectedPlotter() -> 
           setRange ( "x", 
                      std::min ( picked[1],start_picked[1] ),
                      std::max ( picked[1],start_picked[1] ) );
         
         if ( ( selectedPlotter() -> hasAxis(Axes::Z) ) && 
              ( (selectedPlotter() -> hasZoomY ( ) ) ) )
           {
             selectedPlotter() -> 
               setRange ( "y",
                          std::min ( picked[2],start_picked[2] ),
                          std::max ( picked[2],start_picked[2] ) );
           }
         selectedPlotter()->setCurrentRangeSaved ( false );

       }
     }
    }
  }



  //  QApplication::restoreOverrideCursor ();

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

  qtview->setShowCrossHairs ( false );
  qtview->update(0);

  ::mouseEvent.wakeAll();
}

void 
CanvasView::
setCurrentRange()
{
  if ( ! m_current_range.empty () ){
    m_current_range.clear ();
  }
    m_current_range.push_back(selectedPlotter()->getRange(Axes::X,true).low());
    m_current_range.push_back(selectedPlotter()->getRange(Axes::X,true).high());
    m_current_range.push_back(selectedPlotter()->getRange(Axes::Y,true).low());
    m_current_range.push_back(selectedPlotter()->getRange(Axes::Y,true).high());
    
    int i = selectedPlotter () -> currentView();
    selectedPlotter () -> saveViewAtIndex( m_current_range , i + 1 );
    selectedPlotter () -> setCurrentRangeSaved( true );
}


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

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

void
CanvasView::
viewShowPickTable()
{
  if ( !isSingleItemSelected() ) return;
  
#if QT_VERSION < 0x040000
  QCanvasItem * selItem = selectedItem();
#else
  Q3CanvasItem * selItem = selectedItem();
#endif
  QtView * qtview = dynamic_cast < QtView * > ( selItem );
  if ( qtview == 0 ) 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 += "<h4> Qt ";
  about += QT_VERSION_STR;
#ifdef HAVE_CFITSIO
  about += "<h4> cfitsio ";
  const string & fits_version = FitsController::instance () -> version ();
  about += fits_version.c_str();
#endif
#ifdef HAVE_MINUIT
  about += "<h4> C++ Minuit";
#endif
#ifdef HAVE_ROOT
  about += "<h4> ROOT ";
  const string & root_version = RootController::instance() -> version ();
  about += root_version.c_str();
#endif

  about += "<h3>Contributers...";
  about += "<ul>";
  about += "<li> Kaustuv";
  about += "<li> Paul F. Kunz";
  about += "<li> Sanket B. Malde";
  about += "<li> Joy Rajiv";
  about += "</ul>";

  about += "<h3>Based on HippoDraw C++ library";
  about += "<h3>Contributors...";
  about += "<ul>";
  about += "<li> Stephane Bonneaud";
  about += "<li> James Chiang";
  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> Johann Cohen-Tanugi";
  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->show();
}

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

---