PickTable.cxx

Go to the documentation of this file.

#include "PickTable.h"

#include "controllers/DisplayController.h"
#include "datareps/DataRep.h"
#include "datasrcs/DataSourceController.h"
#include "datasrcs/NTuple.h"
#include "datasrcs/NTupleSorter.h"
#include "graphics/SymbolType.h"
#include "plotters/PlotterBase.h"

#if QT_VERSION < 0x040000
#include <qheader.h>
#include <qlistview.h>
#else
#include <q3header.h>
#include <q3listview.h>
#endif

#include <qlineedit.h>
#include <qpushbutton.h>
#include <qlabel.h>
#include <qcheckbox.h>

using std::string;
using std::vector;

using namespace hippodraw;

PickTable::
PickTable ( PlotterBase * plotter )
{
  m_target = plotter;

  NTuple * ntuple = plotter -> createPickTuple ();
  m_sorter = new NTupleSorter ( ntuple );

  const string & name = ntuple -> getName ();
  m_title->setText ( name.c_str() );

  const DataRep * rep = plotter->getDataRep ( 0 );
  const string & type = rep -> name ();

  string text = "Plot type : ";
  text += type.c_str();
  m_type->setText ( text.c_str() );

  const vector < string > & labels = ntuple -> getLabels ();
  m_pick_table->setColumnText ( 1, labels[1].c_str() );
  m_pick_table->setColumnText ( 2, labels[2].c_str() );
  unsigned int size = ntuple -> columns ();
  m_column = size;
  if ( size == 3 ) {
    m_pick_table -> removeColumn ( 3 );
    zLineEdit -> setEnabled ( false );
    wLineEdit -> setEnabled ( false );
  }
  else {
    m_pick_table -> setColumnText ( 3, labels[3].c_str() );
    if ( size == 5 ) {
      const QString & str ( labels[4].c_str() );
      m_pick_table -> addColumn ( str );
    }
    else wLineEdit -> setEnabled ( false );
  }

  DataSourceController::instance()->registerNTuple ( ntuple );

#if QT_VERSION < 0x040000
  QHeader * header = m_pick_table->header();
#else
  Q3Header * header = m_pick_table->header();
#endif
  connect ( header, SIGNAL ( clicked (int) ), 
            this, SLOT( listSorted ( int ) ) );
  m_pick_table->setSorting ( -1 );
  m_pick_table->setShowSortIndicator ( true );
  m_delete -> setEnabled ( false );

  // Picked points are show by default.
  addDataRep();
}

void
PickTable::
listSorted ( int i )
{
  m_sorter -> setSorting ( i );
  m_sorter -> sort ( );

#if QT_VERSION < 0x040000
  QListViewItem * item = m_pick_table ->selectedItem ();
#else
  Q3ListViewItem * item = m_pick_table ->selectedItem ();
#endif
  QString text = item -> text ( 0 );
  unsigned int selected = text.toUInt ();

  refreshItems ( selected );
}

void PickTable::clear()
{
  m_pick_table->clear();
  m_sorter->clear();
}

void
PickTable::
addItem ( std::vector < double > & v )
{
  unsigned int row = m_sorter -> rows ();
  v[0] = row;
  m_sorter -> addRow ( v );

  refreshItems ( row );
}

void
PickTable::
refreshItems ( unsigned int select )
{
  m_pick_table -> clear();

  unsigned int row = m_sorter->rows ();
  bool yes = row > 0;
  m_delete -> setEnabled ( yes );

  while ( row-- != 0 ) {
    const vector < double > & vec = m_sorter->getRow ( row );
    unsigned int current = static_cast < unsigned int > ( vec[0] );
#if QT_VERSION < 0x040000
    QListViewItem * item = new QListViewItem ( m_pick_table );
#else
    Q3ListViewItem * item = new Q3ListViewItem ( m_pick_table );
#endif
    unsigned int size = vec.size();

    for ( unsigned int i = 0; i < size; i++ ) {
      item -> setText ( i, QString ( "%1" ).arg ( vec[i] ) );
    }

    m_pick_table -> insertItem ( item );

    if ( select == current ) {
      m_pick_table -> setSelected ( item, true );
      m_pick_table -> ensureItemVisible ( item );
    }
  }
}

unsigned int
PickTable::
#if QT_VERSION < 0x040000
indexOf ( QListViewItem * target )
#else
indexOf ( Q3ListViewItem * target )
#endif
{
  unsigned int index = 0;
#if QT_VERSION < 0x040000
  QListViewItem * item = m_pick_table -> firstChild ();
#else
  Q3ListViewItem * item = m_pick_table -> firstChild ();
#endif
  while ( item != target ) {
    index++;
    item = item->nextSibling();
    if ( item == 0 ) break;
  }

  return index;
}

void PickTable::deleteSelectedItem ()
{
#if QT_VERSION < 0x040000
  QListViewItem * item = m_pick_table->selectedItem ();
#else
  Q3ListViewItem * item = m_pick_table->selectedItem ();
#endif
  if ( item != 0 ) {
    unsigned int index = indexOf ( item );

    m_sorter->eraseRow ( index );

    unsigned int row = index == 0 ? 0 : index - 1;
    refreshItems ( row );
  }
}

void
PickTable::
addDataRep()
{
  const string plotTypeStr ( "Scatter Plot" );  
  NTuple * ntuple = m_sorter -> getNTuple ();
  const vector < string > & labels = ntuple -> getLabels ();
  vector < string > bindings;
  bindings.push_back ( labels[1] );
  bindings.push_back ( labels[2] );
  if ( labels.size() == 4 ) {
    if ( labels[3] == "Density" ) {
      bindings[1] = "Density";
    }
  }

  DisplayController * controller = DisplayController::instance();
  DataRep * rep 
    = controller -> addDataRep ( m_target, plotTypeStr, 
                                 ntuple, bindings );
  m_datarep = rep;

  const Color red ( Color::red );
  rep -> setRepColor ( red );
  rep -> setRepStyle ( Symbol::CIRCLE );
  rep -> setRepSize ( 6.0 );
}

void
PickTable::
m_pick_table_selectionChanged ()
{
#if QT_VERSION < 0x040000
  QListViewItem * item = m_pick_table -> selectedItem ();
#else
  Q3ListViewItem * item = m_pick_table -> selectedItem ();
#endif
  bool yes = item != 0;

  m_delete -> setEnabled ( yes );
}

NTuple *
PickTable::
getPickTable () const
{
  NTuple * ntuple = m_sorter -> getNTuple ();
  return ntuple;
}

void
PickTable::
addEntry()
{
  vector <double> new_entry;
  double x=xLineEdit->text().toDouble();
  double y=yLineEdit->text().toDouble();
  new_entry.push_back(3.0);
  new_entry.push_back(x);
  new_entry.push_back(y);
  
  if ( m_column > 3 ){
    double z=zLineEdit->text().toDouble();
    new_entry.push_back(z);
  }
  if ( m_column == 5 ){
    double w=wLineEdit->text().toDouble();
    new_entry.push_back(w);
  }

  addItem(new_entry);
}

void
PickTable::
pickedCheckBoxClicked()
{
  bool show = m_pickedCheckBox->isChecked();
  if (show) addDataRep();
  else m_target -> removeDataRep ( m_datarep );
}