CanvasWindow.cxx

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "CanvasWindow.h"

#include "CanvasView.h"
#include "QtFileDialog.h"
#include "PlotTable.h"
#include "PlotTableEvent.h"
#include "QtView.h"
#include "SaveAsImageEvent.h"
#include "WindowController.h"

#include "plotters/PlotterBase.h"
#include "datasrcs/NTupleController.h"
#include "qtxml/QtXMLController.h"

#include <qapplication.h>
#if QT_VERSION < 0x040000
#include <qaction.h>
#else
//Added by the Qt porting tool:
#include <QCloseEvent>
#include <QCustomEvent>
#include <QHideEvent>
#include <QResizeEvent>
#include <QShowEvent>
#include <q3action.h>
#endif

#include <qmessagebox.h>
#include <qfontdialog.h>

#include <algorithm>

#include <cassert>

using std::exception;
using std::list;
using std::string;
using std::vector;

PlotTable * CanvasWindow::s_plot_table = 0;

#if QT_VERSION < 0x040000
CanvasWindow::CanvasWindow ( QWidget * parent,
                             const char * name,
                             Qt::WFlags fl )
  : CanvasWindowBase ( parent, name, fl ),
#else
CanvasWindow::CanvasWindow ( QWidget * parent )
  : Q3MainWindow ( parent ),
#endif
    m_file_dialog ( 0 ),
    m_prefix ( "HippoDraw - Canvas " ),
    m_filename ( "UNTITLED" ),
    m_changed (" - Not Saved " ),
    m_hasChanged ( false ),
    m_inhibit_close ( false ),
    m_allow_close ( false ),
    m_filenameExists ( false )
{
#if QT_VERSION < 0x040000
  QCanvas * canvas = new QCanvas ();
#else
  setupUi ( this );
  Q3Canvas * canvas = new Q3Canvas ();
#endif

  m_xml_controller = QtXMLController::instance ();
  m_canvas_view = new CanvasView ( canvas, this );
  setCentralWidget ( m_canvas_view );

  resize ( sizeHint () ) ;

  WindowController * controller = WindowController::instance ();
  controller->newWindow ( this );

  setCaption ();
  m_file_dialog = new QtFileDialog ( QString::null, // starting dir
                                     this, // parent
                                     "Save file as", // internal name
                                     true ); // modal
}

void
CanvasWindow::
resetFontSize ()
{
  QFont font = QApplication::font ();
  int size = font.pointSize ();
  if ( size > 10 ) {
    font.setPointSize ( 10 );
    QApplication::setFont ( font, true );
  }
}

CanvasWindow::CanvasWindow ( const CanvasWindow & )
{
  assert ( false );
}

CanvasWindow::~CanvasWindow()
{
#if QT_VERSION < 0x040000
  QCanvas * canvas = m_canvas_view->canvas();
#else
  Q3Canvas * canvas = m_canvas_view->canvas();
#endif

  delete m_canvas_view;
  delete canvas;
}

void
CanvasWindow::
customEvent ( QCustomEvent * event )
{
  SaveAsImageEvent * image_event
    = dynamic_cast < SaveAsImageEvent * > ( event );

  if ( image_event != 0 ) {
    const PlotterBase * plotter = image_event -> plotter ();
    const string & filename = image_event -> filename ();
    m_canvas_view -> savePlotAsImage ( plotter, filename );
    return;
  }

  PlotTableEvent * ptevent = dynamic_cast < PlotTableEvent * > ( event );
  if ( ptevent != 0 ) {
    int type = ptevent -> type();

    if ( type == PlotTableEvent::Copy ) {
      m_canvas_view -> addFromPasteboard ();
      return;
    }

    if ( type == PlotTableEvent::Close ) {
      if ( m_browsed_canvas != 0 ) {
        delete m_browsed_canvas;
      }
      s_plot_table -> setBrowserMode ( false );
      return;
    }
  }
}

void CanvasWindow::windowActivationChange ( bool oldActive )
{
  QWidget::windowActivationChange ( oldActive );

  if ( isActiveWindow () == true ) {
    WindowController * wc = WindowController::instance ();
    if ( wc -> currentCanvas ( ) != this ) {
      wc -> setCurrentCanvas ( this );
      updateActions ();
      m_canvas_view -> notifyObservers ();
    }
  }
}

void
CanvasWindow::
setAllowClose ( bool yes )
{
  m_allow_close = yes;
}

bool CanvasWindow::allowClose ( )
{
  if ( m_allow_close ||
       m_hasChanged == false ) return true;

  bool _allowClose = true;
  const string & app_name = m_canvas_view -> applicationName ();

  QString message;
  QString fn = m_filename.c_str();
  message = QString("The document,\n%1\n").arg ( fn );
  message.append("contains unsaved changes.\n\n");
  message.append("Do you want to save the document before closing it?");

  int retval
    = QMessageBox::information ( this,
                                 app_name.c_str(),
                                 message,
                                 "&Save", "&Discard", "Cancel");

  switch (retval)
    {
    case 0: // save
      fileSave ();
      _allowClose = true;
      break;

    case 1:
      _allowClose = true;
      break;

    case 2:
      _allowClose = false;
      break;

    default:
      _allowClose = false;
      break;
    }

  return _allowClose;
}

bool
CanvasWindow::closeNoPrompt ( )
{
  m_allow_close = true;

  return QWidget::close ( true );
}

void CanvasWindow::closeEvent ( QCloseEvent * e )
{
  if ( m_allow_close ) {
    e -> accept ();
    WindowController::instance() -> aboutToClose ( this );
    return;
  }

  if ( allowClose () == false ) {
    e->ignore ();
    return;
  }

  if ( m_inhibit_close == true ) {
    const string & app_name = m_canvas_view -> applicationName ();

    QString message ( "Closing the only document window will also " );
    message.append ( "terminate the application.\n\n"
                     "Do you want to quit?" );
    int retval = QMessageBox::information ( this,
                                            app_name.c_str(),
                                            message,
                                            QMessageBox::Yes,
                                            QMessageBox::No |
                                            QMessageBox::Default |
                                            QMessageBox::Escape,
                                            Qt::NoButton );

    switch (retval)
      {
      case QMessageBox::Yes: // save
        break;

      case QMessageBox::No:
        e->ignore();
        return;
        break;

      default:
        e->ignore();
        return;
        break;
      }
  }

  e->accept ();
  WindowController::instance() -> aboutToClose ( this );
}

void CanvasWindow::hideEvent ( QHideEvent * )
{
  WindowController::instance () -> hasBeenHidden ( this );
}

void CanvasWindow::showEvent ( QShowEvent * )
{
  WindowController::instance () -> unHide ( this );
}

void CanvasWindow::inhibitClose ( bool flag )
{
  m_inhibit_close = flag;
}

void CanvasWindow::setChanged ( bool flag )
{
  WindowController * controller = WindowController::instance ();
  controller -> updateActions ();

 if ( m_hasChanged == flag ) return;

  if ( flag == true ) {
    m_changed = "   not saved";
  }
  else {
    m_changed = "   saved";
  }
  m_hasChanged = flag;
  setCaption ();

}

void CanvasWindow::updateActions ()
{
  XmlController * controller = QtXMLController::instance ();
  bool no = controller -> isPasteboardEmpty ();
  m_editPasteAction -> setEnabled ( ! no );

  const std::vector < const ViewBase * > & views
    = m_canvas_view->selectedViews ();
  bool yes = ! views.empty ();

  m_fileSaveSelected->setEnabled ( yes );
  m_editClearAction->setEnabled ( yes );
  m_editCutAction->setEnabled ( yes );
  m_editCopyAction->setEnabled ( yes );
  m_editDeleteAction -> setEnabled ( yes );
  m_editUndoAction->setEnabled ( yes );
  m_viewLockAction->setEnabled ( yes );
  m_viewUnlockAction->setEnabled ( yes );
  if ( yes == false ) return;

  bool one_locked = false;
  bool one_unlocked = false;
  std::vector < const ViewBase * >:: const_iterator first = views.begin ();
  while ( first != views.end () ) {
    const QtView * view = dynamic_cast < const QtView * > ( *first++ );
    //
    bool locked = view->isActive ();
    one_locked |= locked;
    one_unlocked |= ! locked;
  }
  m_viewLockAction->setEnabled ( one_unlocked );
  m_viewUnlockAction->setEnabled ( one_locked );
}

void
CanvasWindow::
filePrint()
{
  m_canvas_view->print ();
}

void CanvasWindow::editCopy ()
{
  m_canvas_view->copySelectedToPasteboard ();

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

void
CanvasWindow::
editClear ()
{
  QString message ( "The clear operation can not be undone.\n\n" );
  message.append ( "Are you sure you want to remove all canvas items?" );
  int retval
    = QMessageBox::warning ( this,
                             "Warning",
                             message,
                             QMessageBox::Yes,
                             QMessageBox::No );
  if ( retval != QMessageBox::Yes ) return;

  clear ();

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

void CanvasWindow::editCut ()
{
  m_canvas_view->deleteSelected ( true );  // copy to pasteboard and delete

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

void CanvasWindow::editDelete ()
{
  m_canvas_view->deleteSelected ( false );  // just delete

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

void
CanvasWindow::
editReTile ()
{
  m_canvas_view->reTile ();
}

void
CanvasWindow::
editReTilePage ()
{
  m_canvas_view->reTilePage ();
}

void
CanvasWindow::
editUndo ()
{
  m_canvas_view->restoreFromSelectCopy ();

  m_canvas_view->notifyObservers();
}

/* virtual */
void CanvasWindow::editPaste ()
{
  m_canvas_view->copyFromPasteboard ();
}

void
CanvasWindow::
editSelectAll ()
{
  m_canvas_view->setAllSelected ( true );

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

void CanvasWindow::fileNew ()
{
  CanvasWindow * window = new CanvasWindow ();
  WindowController::instance () -> newWindow ( window );
  window->setCaption ();
  window->show ();
}

void
CanvasWindow::
on_fileBrowse_actived()
{
  m_file_dialog -> createBrowseFilter ();

  int retval = m_file_dialog -> exec ();

  if ( retval == QDialog::Accepted ) {
    QString filename = m_file_dialog -> selectedFile ();
    QString s = filename.stripWhiteSpace ();
    const string fn = s.latin1();

    string::size_type pos = fn.find_last_of ( '.' );
    const string suffix = fn.substr ( pos );

    if ( m_file_dialog -> isDocSuffix ( suffix ) ) {
      QCanvas * canvas = new QCanvas ();
      CanvasView * m_browsed_canvas = new CanvasView ( canvas, this );
      m_browsed_canvas -> initFromFile ( fn );
      if ( s_plot_table == 0 ) {
        s_plot_table = new PlotTable ();
      }
      s_plot_table -> setBrowserMode ( true, this );
      s_plot_table -> setCanvas ( m_browsed_canvas );
      s_plot_table -> show ();
    }
  }
}

void
CanvasWindow::
on_fileOpen_activated ()
{
  m_file_dialog -> createOpenFilter ();

  int retval = m_file_dialog -> exec ();

  if ( retval == QDialog::Accepted ) {
    QString filename = m_file_dialog -> selectedFile ();
    QString s = filename.stripWhiteSpace ();
    const string fn = s.latin1();

    string::size_type pos = fn.find_last_of ( '.' );
    const string suffix = fn.substr ( pos );

    if ( m_file_dialog -> isDocSuffix ( suffix ) ) {
      CanvasWindow * window = new CanvasWindow ();
      try {
        window -> initFromFile ( fn );
      }
      catch ( exception & e ) {
        m_file_dialog -> openFileError ( filename.latin1() , e );
        window -> setChanged ( false );
        window -> close ();
      }
      return;
    }

    else if ( m_file_dialog -> isTextSuffix ( suffix ) ) {
      m_file_dialog -> openTextTuple ( fn );
    }
#ifdef HAVE_ROOT
    else if ( m_file_dialog -> isRootSuffix ( suffix ) ) {
      m_file_dialog -> openRootTuple ( fn );
      m_canvas_view -> notifyObservers ();
      return;
    }
#endif

#ifdef HAVE_CFITSIO
    else if ( m_file_dialog -> isFitsSuffix ( suffix ) ) {
      m_file_dialog -> openFitsTuple ( fn );
      m_canvas_view -> notifyObservers ();
      return;
    }
    else {
      bool yes = m_file_dialog -> isFitsFile ( fn );
      if ( yes ) {
        m_file_dialog -> openFitsTuple ( fn );
        m_canvas_view -> notifyObservers ();
        return;
      }
    }
#endif
    // if all else fails, try text file
    m_file_dialog -> openTextTuple ( fn );

    m_canvas_view -> notifyObservers ();
  }
}

void
CanvasWindow::
initFromFile ( const std::string & filename )
{
  m_canvas_view -> initFromFile ( filename );
  setTitleFileName ( filename );
  setChanged ( false );

  show();
}

void
CanvasWindow::
clear()
{
  m_canvas_view->clear();
}

void CanvasWindow::resizeEvent ( QResizeEvent * e )
{
  m_canvas_view->resizeEvent ( e );

  QWidget::resizeEvent ( e );
}

void CanvasWindow::viewAddPage()
{
  m_canvas_view->addPage ();
}

bool CanvasWindow::areDataSourcesSaved ()
{
  const vector < const ViewBase * > & views = m_canvas_view->views ();
  bool yes = m_xml_controller->areDataSourcesSaved ( views );

  if ( yes == false ) {
    const string & app_name = m_canvas_view -> applicationName ();

    QString menutext = m_exportTextTuple->menuText();
    QString message;
    message += "Document can not be saved.\n\n"
      "It uses data sources that were neither\n"
      "read from nor saved to a file.\n\n";
    message += "Use File menu: \"";
    message += menutext;
    message += "\"\n";
    message += "to save the data sources first, or\n";
    message += "use the File menu: \"";
    menutext = m_fileSaveAllAction->menuText();
    message += menutext;
    message += "\".";

    QMessageBox::critical ( this, // parent
                            app_name.c_str(), // caption
                            message,
                            QMessageBox::Ok,
                            Qt::NoButton );
  }

  return yes;
}

void CanvasWindow::fileSave()
{
  bool yes = areDataSourcesSaved ();
  if ( ! yes ) return;

  if ( m_filenameExists )
    {
      if ( m_hasChanged )
        {
          QString message ( "Document file exists\n\n" );
          message.append ( "Over-write existing file?" );
          int retval
            = QMessageBox::warning ( this,
                                     "Warning",
                                     message,
                                     QMessageBox::Yes,
                                     QMessageBox::No );
          if ( retval != QMessageBox::Yes ) return;
          saveAs ( m_filename );
        }
    }
  else
    {
      fileSaveAs ();
    }
}

bool
CanvasWindow::
setFilenameFromDialog ()
{
  m_filename = m_file_dialog -> getSaveDocFilename ();

  m_filenameExists = m_filename.empty () ? false : true;

  return m_filenameExists;
}

void CanvasWindow::fileSaveAs()
{
  bool yes = areDataSourcesSaved ();
  if ( ! yes ) return;

bool ok = setFilenameFromDialog ();
  if ( ! ok ) return;

  saveAs ( m_filename );
}


void
CanvasWindow::
fileSaveAll()
{
  if ( m_filenameExists == false ) {
    fileSaveAllAs ();
    return;
  }
  saveAllAs ( m_filename );
}

void
CanvasWindow::
fileSaveAllAs()
{
  bool ok = setFilenameFromDialog ();
  if ( ! ok ) return;
  saveAllAs ( m_filename );
}

void
CanvasWindow::
saveAllAs ( const std::string & filename )
{
  const string & suffix = m_file_dialog -> getDocSuffix ();
  string::size_type pos = filename.find ( suffix );
  string prefix = filename.substr ( 0, pos );
  NTupleController * controller = NTupleController::instance ();

  const string & data_suffix = QtFileDialog::getTextSuffix ();
  controller -> saveNTuples ( prefix, data_suffix );
  saveAs ( filename );
}

void CanvasWindow::fileSaveSelectedImages ()
{
  m_canvas_view->saveSelectedImages ();
}

void CanvasWindow::fileSaveSelectedImages ( const std::string & filename )
{
   m_canvas_view->saveSelectedImages(filename);
}

void
CanvasWindow::
saveAs ( const std::string & filename )
{
  m_canvas_view -> saveAs ( filename );

  setTitleFileName ( filename );
  setChanged ( false );
  setCaption ();
}

CanvasView *
CanvasWindow::
getCanvasView ()
{
  return m_canvas_view;
}

void
CanvasWindow::
fileExportTextTuple ()
{
  const string & data_suffix = QtFileDialog::getTextSuffix ();
  m_canvas_view -> exportTextTuple ( data_suffix );
}

void
CanvasWindow::
on_fileExit_activated()
{
  bool ok = WindowController::instance () -> okToQuit();

  if ( ok ) qApp->quit ();
}

void CanvasWindow::viewZoomIn()
{
  m_canvas_view->viewZoomIn ();
}

void CanvasWindow::viewZoomOut()
{
  m_canvas_view->viewZoomOut ();
}

void
CanvasWindow::
viewZoomReset()
{
  m_canvas_view -> viewZoomReset ();
}

void
CanvasWindow::
viewLock ()
{
  m_canvas_view->setLocked ( true );
  updateActions ();
}

void
CanvasWindow::
viewUnlock ()
{
  m_canvas_view->setLocked ( false );
  updateActions ();
}

void CanvasWindow::helpAbout()
{
  m_canvas_view -> helpAbout ();
}

void
CanvasWindow::
on_aboutQt_activated()
{
  QMessageBox::aboutQt ( this );
}

void CanvasWindow::setCaption ()
{
  QString fn = m_filename.c_str();
  QWidget::setCaption ( m_prefix + fn + m_changed );

}

void
CanvasWindow::
setTitleFileName ( const std::string & name )
{
  m_filename = name;
  m_filenameExists = true;
}

void
CanvasWindow::
addTextDisplay ( PlotterBase * plotter,
                 const std::string & s )
{
  m_canvas_view->addTextDisplay ( plotter, s );
}

void
CanvasWindow::
addTextDisplay ( PlotterBase * plotter,
                 const std::string & type,
                 const std::string & text)
{
  m_canvas_view->addTextDisplay ( plotter, type, text );
}

std::pair<double, double>
CanvasWindow::
addTextDisplayAt ( PlotterBase * plotter,
                   const std::string & type,
                   const std::string & text,
                   double xrel, double yrel )
{
   return m_canvas_view->addTextDisplayAt( plotter, type, text, xrel, yrel );
}

void
CanvasWindow::
addFuncDisplay ( PlotterBase * plotter, const std::string & s )
{
  m_canvas_view->addFuncDisplay ( plotter, s );
}

void
CanvasWindow::
addPlotDisplay ( PlotterBase * plotter )
{
  m_canvas_view->addPlotDisplay ( plotter );
}

void CanvasWindow::addPlotDisplay ( PlotterBase * plotter, bool sel )
{
  m_canvas_view->addPlotDisplay ( plotter, sel );
}

void CanvasWindow::addDisplay ( PlotterBase * plotter )
{
  m_canvas_view->addPlotDisplay ( plotter );
}

void
CanvasWindow::
removeDisplay ( PlotterBase * plotter )
{
  m_canvas_view->removeDisplay ( plotter );
}

PlotterBase * CanvasWindow::selectedPlotter ()
{
  return m_canvas_view->selectedPlotter ();
}

const vector < const ViewBase * > & CanvasWindow::views ()
{
  return m_canvas_view->views ();
}

void
CanvasWindow::
fillPlotterList ( std::vector < PlotterBase * > & plotters )
{
  m_canvas_view -> fillPlotterList ( plotters );
}

QtView *
CanvasWindow::
getViewFor ( const PlotterBase * plotter ) const
{
  return m_canvas_view->getViewFor ( plotter );
}

void CanvasWindow::setIntervalEnabled ( bool yes )
{
  m_canvas_view->setIntervalEnabled ( yes );
}

void
CanvasWindow::
viewShowInspector ()
{
  m_canvas_view -> showInspector ();
}

void
CanvasWindow::
viewShowPlotTable ()
{
  if ( s_plot_table == 0 ) {
    s_plot_table = new PlotTable ();
  }
  s_plot_table->setCanvas ( m_canvas_view );
  s_plot_table->show();
}

void
CanvasWindow::
viewShowPickTable ()
{
  m_canvas_view->viewShowPickTable();
}

void
CanvasWindow::
savePlotAsImage ( const PlotterBase * plotter,
                  const std::string & filename )
{
  SaveAsImageEvent * event = new SaveAsImageEvent ( plotter, filename );
  QApplication::postEvent ( this, event );
}

void
CanvasWindow::
saveAsImage ( const PlotterBase * plotter,
              const std::string & filename )
{
  qApp -> lock ();
  m_canvas_view -> savePlotAsImage ( plotter, filename );
  qApp -> unlock ();
}

void
CanvasWindow::
savePlotAsImageImmediate ( const PlotterBase * plotter,
                           const std::string & filename )
{
  m_canvas_view -> savePlotAsImage ( plotter, filename );
}

void
CanvasWindow::
setAllSelected ( bool flag )
{
   m_canvas_view->setAllSelected( flag );
}

void
CanvasWindow::
setSelected ( QtView * view )
{
   m_canvas_view->setSelectedItem( view );
}

void 
CanvasWindow::
previousView ( )
{
  if ( ! ( selectedPlotter() ->getCurrentRangeSaved () ) )
    m_canvas_view -> setCurrentRange () ;

  m_canvas_view ->selectedPlotter () -> nextView (false );
  m_canvas_view -> canvas () -> update();
}

void 
CanvasWindow::
nextView ( )
{
  if ( ! ( selectedPlotter() ->getCurrentRangeSaved () ) )
    m_canvas_view -> setCurrentRange () ;

  m_canvas_view ->selectedPlotter () -> nextView ( true );
  m_canvas_view -> canvas () -> update();
}


void
CanvasWindow::
setZoomMode ( )
{
  if (  dynamic_cast<FigureEditor *> (m_canvas_view ) -> getZoomMode () )
     dynamic_cast<FigureEditor * >  (m_canvas_view ) -> setZoomMode ( false );
  else  dynamic_cast<FigureEditor * > (m_canvas_view ) -> setZoomMode ( true );
}

const std::vector<double> &
CanvasWindow::
mouseEventData()
{
   return m_canvas_view->mouseEventData();
}

void
CanvasWindow::
settingPrinter()
{
  m_canvas_view -> setPrinterSettings ();
}

void
CanvasWindow::
settingCanvas()
{
  m_canvas_view -> setup ();
}

void
CanvasWindow::
settingFonts()
{
  bool ok;

  // From the Qt documentation - "The usual way to use QFontDialog class is
  // to call one of the static convenience functions"
  QFont font
    = QFontDialog::getFont ( &ok, QFont( "Helvetica [Cronyx]", 10), this);

  m_canvas_view -> setFonts( font );
}

void
CanvasWindow::
print ( const std::string & filename )
{
  m_canvas_view -> print ( filename );
}

void
CanvasWindow::
setPlotMatrix ( unsigned int columns, unsigned int rows )
{
  m_canvas_view -> setPlotMatrix ( columns, rows );
  m_canvas_view -> reTile ();
}

void
CanvasWindow::
setAddedSelected ( bool yes )
{
  m_canvas_view -> setAddedSelected ( yes );
}

---