qsegraphcontroller.cpp

Go to the documentation of this file.

#include "qsegraphcontroller.h"

#include <QListWidget>
#include <QTableWidget>
#include <QPrinter>
#include <QPrintDialog>
#include <QMenu>
#include <QMap>
#include <QThread>

#include <qwt_plot.h>
#include <qwt_plot_zoomer.h>
#include <qwt_plot_panner.h>
#include <qwt_plot_magnifier.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_layout.h>
#include <qwt_legend.h>
#include <qwt_picker_machine.h>
#include <qwt_plot_renderer.h>

#include "qsedataset.h"
#include "qsedataexport.h"
#include "qsedatareference.h"
#include "qsegraphscansmodel.h"
#include "qsegraphcolumnsmodel.h"

#include <stdio.h>

QseGraphController::QseGraphController(QseDataSet *f, QWidget *parent)
  : QWidget(parent),
    m_DataSet(f),
    m_ScansModel(NULL),
    m_ScansSelection(NULL),
    m_ColumnsModel(NULL),
    m_ColumnsSelection(NULL),
    m_Zoomer(NULL),
    m_Zoomer2(NULL),
    m_Panner(NULL),
    m_Magnifier(NULL),
    m_Legend(NULL),
    m_LegendShown(true),
    m_ScanPenStep(1),
    m_ScanSymbolStep(0),
    m_CurvePenStep(0),
    m_CurveSymbolStep(1)
{
  m_Pens[0].setColor(Qt::black);
  m_Pens[1].setColor(Qt::red);
  m_Pens[2].setColor(Qt::green);
  m_Pens[3].setColor(Qt::blue);
  m_Pens[4].setColor(Qt::cyan);
  m_Pens[5].setColor(Qt::magenta);
  m_Pens[6].setColor(Qt::darkYellow);
  m_Pens[7].setColor(Qt::darkRed);
  m_Pens[8].setColor(Qt::darkGreen);
  m_Pens[9].setColor(Qt::darkBlue);
  m_Pens[10].setColor(Qt::darkCyan);
  m_Pens[11].setColor(Qt::darkMagenta);

  setupUi(this);

  m_Graph->setCanvasBackground(QColor(Qt::white));

  m_Zoomer = new QwtPlotZoomer(QwtPlot::xBottom, QwtPlot::yLeft, m_Graph->canvas());
  m_Zoomer -> setStateMachine(new QwtPickerDragRectMachine());
  m_Zoomer2 = new QwtPlotZoomer(QwtPlot::xTop, QwtPlot::yRight, m_Graph->canvas());
  m_Zoomer2 -> setStateMachine(new QwtPickerDragRectMachine());

  m_Magnifier = new QwtPlotMagnifier(m_Graph->canvas());
  m_Magnifier -> setMouseFactor(1.0);

  enableAxes(true, false);

  // RightButton: zoom out by 1
  // Ctrl+RightButton: zoom out to full size

  m_Zoomer -> setMousePattern(QwtEventPattern::MouseSelect2,
                              Qt::LeftButton, Qt::ControlModifier | Qt::ShiftModifier);
  m_Zoomer2 -> setMousePattern(QwtEventPattern::MouseSelect2,
                              Qt::LeftButton, Qt::ControlModifier | Qt::ShiftModifier);
  
  m_Zoomer -> setMousePattern(QwtEventPattern::MouseSelect3,
                              Qt::LeftButton, Qt::ControlModifier);
  m_Zoomer2 -> setMousePattern(QwtEventPattern::MouseSelect3,
                              Qt::LeftButton, Qt::ControlModifier);

  m_Panner = new QwtPlotPanner(m_Graph->canvas());
  m_Panner -> setMouseButton(Qt::MidButton);
  m_Panner -> setEnabled(true);

  m_Legend = new QwtLegend;
  m_Legend -> setFrameStyle(QFrame::Box|QFrame::Sunken);
  m_Legend -> setDefaultItemMode(QwtLegendData::Checkable);

  m_Graph -> insertLegend(m_Legend, QwtPlot::BottomLegend);

  connect(m_Legend, SIGNAL(checked(const QVariant&, bool, int)), this, SLOT(legendChecked(const QVariant&, bool, int)));

  m_Graph -> canvas() -> setContextMenuPolicy(Qt::CustomContextMenu);
  connect(m_Graph -> canvas(), SIGNAL(customContextMenuRequested(const QPoint &)),
          this, SLOT(graphContextMenu(const QPoint&)));

  m_ScansView -> setContextMenuPolicy(Qt::CustomContextMenu);
  connect(m_ScansView, SIGNAL(customContextMenuRequested(const QPoint &)),
            this, SLOT(scansListContextMenu(const QPoint &)));

  m_ColumnsView -> setContextMenuPolicy(Qt::CustomContextMenu);
  connect(m_ColumnsView, SIGNAL(customContextMenuRequested(const QPoint &)),
            this, SLOT(columnsTableContextMenu(const QPoint &)));

  m_ScansModel = new QseGraphScansModel(m_DataSet, m_ScansView, this);
  m_ColumnsModel = new QseGraphColumnsModel(this, m_ColumnsView, this);

  m_ScansView -> setModel(m_ScansModel);
  m_ColumnsView -> setModel(m_ColumnsModel);

  m_ScansSelection = m_ScansView->selectionModel();
  m_ColumnsSelection = m_ColumnsView->selectionModel();

  connect(m_DataSet, SIGNAL(dataCleared()),   this, SLOT(dataCleared()));
  connect(m_DataSet, SIGNAL(dataChanged()),   this, SLOT(dataChanged()));
  connect(m_DataSet, SIGNAL(operationCompleted()), this, SLOT(operationCompleted()));
//   connect(m_DataSet, SIGNAL(scanAdded(int)),  this, SLOT(scanAdded(int)));

  connect(m_ColumnsView, SIGNAL(clicked(const QModelIndex&)),
          this, SLOT(columnsCellClicked(const QModelIndex&)));

  connect(m_ScansSelection, 
          SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)),
          this,
          SLOT(scansSelectionChanged(const QItemSelection&, const QItemSelection&)));

  connect(m_PrintButton, SIGNAL(clicked()), this, SLOT(printGraph()));
  connect(m_ZoomAllButton, SIGNAL(clicked()), this, SLOT(zoomGraphAll()));
  connect(m_ZoomInButton, SIGNAL(clicked()), this, SLOT(zoomGraphIn()));
  connect(m_ZoomOutButton, SIGNAL(clicked()), this, SLOT(zoomGraphOut()));
  connect(m_ExportButton, SIGNAL(clicked()), this, SLOT(saveSelectedScans()));

  m_ScansView->resizeColumnsToContents();
  m_ScansView->resizeRowsToContents();

  m_ColumnsView->resizeColumnsToContents();
  m_ColumnsView->resizeRowsToContents();
}

QseGraphController::~QseGraphController()
{
}

QseDataSet* QseGraphController::dataSet() const
{
  return m_DataSet;
}

int QseGraphController::selectedColumnCount() const
{
  return m_SelectedScanColumns.count();
}

QString QseGraphController::selectedColumn(int i) const
{
  return m_SelectedScanColumns[i];
}

void QseGraphController::setTitle(const QString &title)
{
  m_Graph -> setTitle(title);
}

void QseGraphController::addContextMenuAction(QAction *action)
{
  m_Actions.append(action);
}

void QseGraphController::scanAdded(int s)
{
}

void QseGraphController::operationCompleted()
{
//   printf("QseGraphController::operationCompleted\n");

//   m_ScansView->resizeRowsToContents();
//   m_ScansView->resizeColumnsToContents();

  updateGraph();
}

void QseGraphController::dataCleared()
{
  m_SelectedScanColumns.clear();
  m_SelectedScanColumnCounts.clear();

  m_ColumnsModel -> columnsChanged();
}

void QseGraphController::dataChanged()
{
}

bool QseGraphController::scanSelected(int i)
{
  return m_ScansSelection -> isRowSelected(i, QModelIndex());
}

bool QseGraphController::selectedPlotX(int i) const
{
  QString colname = selectedColumn(i);

  return m_PlotXColumns.contains(colname);
}

bool QseGraphController::selectedPlotY(int i) const
{
  QString colname = selectedColumn(i);

  return m_PlotYColumns.contains(colname);
}

bool QseGraphController::selectedPlotY2(int i) const
{
  QString colname = selectedColumn(i);

  return m_PlotY2Columns.contains(colname);
}

bool QseGraphController::selectedPlotNorm(int i) const
{
  QString colname = selectedColumn(i);

  return m_PlotNormColumns.contains(colname);
}

void QseGraphController::scansSelectionChanged
(const QItemSelection & selected, const QItemSelection & deselected)
{
//   printf("QseGraphController::scansSelectionChanged()\n");

  m_SelectedScanColumns.clear();
  m_SelectedScanColumnCounts.clear();

  int n = scanCount();

  for (int i = 0; i<n; i++) {
    if (scanSelected(i)) {
      QseScan* s = m_DataSet -> scan(i);

      if (s) {
        int nc = s->columnCount();

        for (int i=0; i<nc; i++) {
          QseColumn* col = s->column(i);
          if (col) {
            QString colname = col->name();
            if (!m_SelectedScanColumnCounts.contains(colname)) {
              m_SelectedScanColumns.append(colname);
            }
            m_SelectedScanColumnCounts[colname] += 1;
          }
        }
      }
    }
  }

  m_ColumnsModel -> columnsChanged();
//   m_ColumnsView->resizeRowsToContents();
//   m_ColumnsView->resizeColumnsToContents();

  updateGraph();
}

void QseGraphController::toggleGraphSelection
(int n, QSet<QString>& set)
{
  QString colname = selectedColumn(n);

  if (set.contains(colname)) {
    set.remove(colname);
  } else {
    set.insert(colname);
  }
}

void QseGraphController::columnsSelectionChanged
(const QItemSelection & selected, const QItemSelection & deselected)
{
//   printf("QseGraphController::columnsSelectionChanged()\n");

  QItemSelectionRange r;
  
  foreach(r, selected) {
    int tp=r.top(), bt=r.bottom();
    int lf=r.left(), rt=r.right();
    for (int i=tp; i<=bt; i++) {
      for (int j=lf; j<=rt; j++) {
        printf("QseGraphController::columnsSelectionChanged::selected(%d,%d)\n",i,j);
//      switch(j) {
//      case 1:
//        m_PlotXColumns.clear();
//        toggleGraphSelection(i, m_PlotXColumns);
//        break;
//      case 2:
//        toggleGraphSelection(i, m_PlotYColumns);
//        break;
//      case 3:
//        toggleGraphSelection(i, m_PlotY2Columns);
//        break;
//      case 4:
//        toggleGraphSelection(i, m_PlotNormColumns);
//        break;
//      }
      }
    }

    m_ColumnsModel -> emitDataChanged(r.topLeft(), r.bottomRight());
  }

  foreach(r, deselected) {
    int tp=r.top(), bt=r.bottom();
    int lf=r.left(), rt=r.right();
    for (int i=tp; i<=bt; i++) {
      for (int j=lf; j<=rt; j++) {
        printf("QseGraphController::columnsSelectionChanged::deselected(%d,%d)\n",i,j);
      }
    }

    m_ColumnsModel -> emitDataChanged(r.topLeft(), r.bottomRight());
  }
//   m_ColumnsModel -> columnsChanged();

  updateGraph();
}

void QseGraphController::columnsCellClicked(const QModelIndex& index)
{
//   printf("QseGraphController::columnsCellClicked(%d,%d)\n", index.column(), index.row());

  int i = index.row(), j = index.column();

  switch (j) {
  case 1:
    m_PlotXColumns.clear();
    toggleGraphSelection(i, m_PlotXColumns);
    m_ColumnsModel -> emitDataChanged(m_ColumnsModel->index(0,1), 
                                      m_ColumnsModel->index(m_ColumnsModel->rowCount(),1));
    break;
  case 2:
    toggleGraphSelection(i, m_PlotYColumns);
    break;
  case 3:
    toggleGraphSelection(i, m_PlotY2Columns);
    break;
  case 4:
    toggleGraphSelection(i, m_PlotNormColumns);
    break;
  }

  m_ColumnsModel -> emitDataChanged(index, index);

  updateGraph();
}

void QseGraphController::updateGraph()
{
//   printf("QseGraphController::updateGraph()\n");

  m_Graph -> detachItems(QwtPlotItem::Rtti_PlotCurve);
  m_Graph -> detachItems(QwtPlotItem::Rtti_PlotMarker);

  int s;
  int nscans = 0;
  int nscanstotal = m_DataSet -> scanCount();

  for (s=0; s<nscanstotal; s++) {
    if (scanSelected(s)) {
      nscans++;
    }
  }

  int pnnum = 0;
  int smnum = -1;

  int ncurves = 0;
  int npscans = 0;
  int ncrvscn = 0;

  QSet<QString> xnames, ynames, y2names;

  if (nscans > 1) {
    m_Graph -> setTitle(QString("%1 Scans").arg(nscans));
  }

  int hasy1 = false;
  int hasy2 = false;

  for (s=0; s<nscanstotal; s++) {
    if (scanSelected(s)) {
//     printf("Scan %d\n", s);

      ncrvscn = 0;

      if (m_ScanPenStep) {
        pnnum = (pnnum + m_ScanPenStep + NPENS) % NPENS;
      } else {
        pnnum = 0;
      }

      if (m_ScanSymbolStep) {
        smnum = (smnum + m_ScanSymbolStep + NSYMBOLS) % NSYMBOLS;
      } else {
        smnum = 0;
      }

      QseScan *scan = m_DataSet -> scan(s);

      if (scan) {
        if (nscans == 1) {
          m_Graph->setTitle(scan->scanCommand());
        }
        int nc = scan->columnCount();
        QseColumn *xc = NULL;
        int nxc = -1;
        
        for (int c = 0; c<nc; c++) {
          QseColumn *col = scan->column(c);
          if (col) {
            QString colname = col->name();
            
            if (m_PlotXColumns.contains(colname)) {
              xc = col;
              nxc = c;
              break;
            }
          }
        }
 
        if (nc && (xc == NULL)) {
          xc = scan->column(0);
          nxc = 0;
        }
        
        if (xc) {
          //    int nr = xc->rowCount();
          int nnc = 0;
          
          for (int c = 0; c<nc; c++) {
            QseColumn *yc = scan->column(c);
            if (yc) {
              QString colname = yc->name();
              
              if (m_PlotYColumns.contains(colname)) {
                QString name;
                nnc += 1;
                ncurves += 1;
                
                if (nnc == 1) {
                  xnames.insert(xc->name());
                }
                ynames.insert(colname);
                
                if (ncurves <= MAX_CURVES) {
                  if (ncrvscn == 0) {
                    npscans += 1;
                  }
                  ncrvscn += 1;
                  
                  if (nscans == 1) {
                    name = colname;
                  } else {
                    name = QString("S%1:%2").arg(scan->scanNumber()).arg(colname);
                  }
              
                  QwtPlotCurve *pc = new QwtPlotCurve(name);
                  //            pc->setData(xc->data(), yc->data(), nr);
                  pc->setData(new QseDataReference(m_DataSet, s, nxc, c));
                  pc->setPen(m_Pens[pnnum]);
                  QwtSymbol *ps = newSymbol(smnum);
                  ps->setPen(m_Pens[pnnum]);
                  ps->setBrush(QBrush(m_Pens[pnnum].color()));
                  pc->setSymbol(ps);
                  pnnum = (pnnum + m_CurvePenStep + NPENS) % NPENS;
                  smnum = (smnum + m_CurveSymbolStep + NSYMBOLS) % NSYMBOLS;
                  pc->setItemAttribute(QwtPlotItem::Legend, m_LegendShown);
                  pc->attach(m_Graph);
                  hasy1 = true;
                }
              }
            }
          }
            
          for (int c = 0; c<nc; c++) {
            QseColumn *yc = scan->column(c);
            if (yc) {
              QString colname = yc->name();
              
              if (m_PlotY2Columns.contains(colname)) {
                QString name;
                nnc += 1;
                ncurves += 1;
                
                if (nnc == 1) {
                  xnames.insert(xc->name());
                }
                y2names.insert(colname);
                
                if (ncurves <= MAX_CURVES) {
                  if (ncrvscn == 0) {
                    npscans += 1;
                  }
                  ncrvscn += 1;
                  
                  if (nscans == 1) {
                    name = colname;
                  } else {
                    name = QString("S%1:%2").arg(scan->scanNumber()).arg(colname);
                  }
                  
                  QwtPlotCurve *pc = new QwtPlotCurve(name);
                  //            pc->setData(xc->data(), yc->data(), nr);
                  pc->setData(new QseDataReference(m_DataSet, s, nxc, c));
                  pc->setYAxis(QwtPlot::yRight);
                  pc->setPen(m_Pens[pnnum]);
                  QwtSymbol *ps = newSymbol(smnum);
                  ps->setPen(m_Pens[pnnum]);
                  ps->setBrush(QBrush(m_Pens[pnnum].color()));
                  pc->setSymbol(ps);
                  pnnum = (pnnum + m_CurvePenStep + NPENS) % NPENS;
                  smnum = (smnum + m_CurveSymbolStep + NSYMBOLS) % NSYMBOLS;
                  pc->setItemAttribute(QwtPlotItem::Legend, m_LegendShown);
                  pc->attach(m_Graph);
                  hasy2 = true;
                }
              }
            }
          }
        }
      }
    }
  }

  if (ncurves > MAX_CURVES) {
    m_Graph -> setTitle(QString("%1 of %2 curves from %3 scans").
                        arg(MAX_CURVES).arg(ncurves).arg(npscans));
  } else if (npscans > 1) {
    m_Graph -> setTitle(QString("%1 curves from %2 scans").arg(ncurves).arg(npscans));
  }

  setAxisTitle(QwtPlot::xBottom, xnames);
  setAxisTitle(QwtPlot::yLeft,   ynames);
  setAxisTitle(QwtPlot::yRight,  y2names);

  enableAxes(hasy1, hasy2);

  m_Graph -> replot();

  if (m_Zoomer -> zoomRectIndex() == 0) {
    m_Zoomer -> setZoomBase();
  }

  if (m_Zoomer2 -> zoomRectIndex() == 0) {
    m_Zoomer2 -> setZoomBase();
  }

//   printf("finished\n");
}

void QseGraphController::setAxisTitle(int axisId, const QSet<QString>& names)
{
  QString title, name;
  int n = names.count();
  int nt;

  if (n == 0) {
    m_Graph -> setAxisTitle(axisId, "");
  } else {
    if (n > 4) {
      nt = 4;
    } else {
      nt = n;
    }

    QSet<QString>::const_iterator it = names.constBegin();
    title = *it;

    for (int i = 1; i<nt; i++) {
      it++;
      title += ", " + *it;
    }

    if (n > nt) {
      title += "...";
    }

    m_Graph -> setAxisTitle(axisId, title);
  }
}

void QseGraphController::enableAxes(bool y1, bool y2)
{
  m_Graph -> enableAxis(QwtPlot::yLeft, y1 | !y2);
  m_Graph -> enableAxis(QwtPlot::yRight, y2);

  if (y1 | !y2) {
    m_Zoomer -> setTrackerMode(QwtPicker::AlwaysOn);
    m_Zoomer -> setRubberBand(QwtPicker::RectRubberBand);
    m_Zoomer2 -> setTrackerMode(QwtPicker::AlwaysOff);
    m_Zoomer2 -> setRubberBand(QwtPicker::NoRubberBand);
  } else {
    m_Zoomer2 -> setTrackerMode(QwtPicker::AlwaysOn);
    m_Zoomer2 -> setRubberBand(QwtPicker::RectRubberBand);
    m_Zoomer -> setTrackerMode(QwtPicker::AlwaysOff);
    m_Zoomer -> setRubberBand(QwtPicker::NoRubberBand);
  }
}

void QseGraphController::setAutoScale()
{
  m_Graph -> setAxisAutoScale(QwtPlot::xBottom);
  m_Graph -> setAxisAutoScale(QwtPlot::yLeft);
  m_Graph -> setAxisAutoScale(QwtPlot::yRight);
  m_Graph -> replot();
  
  m_Zoomer -> setZoomBase();
  m_Zoomer2 -> setZoomBase();
}

void QseGraphController::showLegend()
{
  m_LegendShown = true;

  QwtPlotItem *item;
  const QwtPlotItemList &items = m_Graph->itemList();

  foreach (item, items) {
    item->setItemAttribute(QwtPlotItem::Legend, true);
  }

  m_Graph -> updateLayout();
}

void QseGraphController::hideLegend()
{
  m_LegendShown = false;

  QwtPlotItem *item;
  const QwtPlotItemList &items = m_Graph->itemList();

  foreach (item, items) {
    item->setItemAttribute(QwtPlotItem::Legend, false);
  }

  m_Graph -> updateLayout();
}

void QseGraphController::printGraph()
{
  QPrinter printer (QPrinter::HighResolution);

  printer.setCreator("Spec EXAFS Processor");
  //   printer.setOrientation(QPrinter::Landscape);

  QPrintDialog dialog(&printer);

  if (dialog.exec()) {
    QwtPlotRenderer filter;

//     if ( printer.colorMode() == QPrinter::GrayScale ) {
//       filter.setOptions(QwtPlotPrintFilter::PrintAll & ~QwtPlotPrintFilter::PrintCanvasBackground);
//     }
    
    filter.renderTo(m_Graph, printer);
  }
}

void QseGraphController::legendChecked(const QVariant &v, bool checked, int n)
{
//  printf("QseGraphController::legendChecked(%s,%d,%d)\n", qPrintable(v.toString()), checked, n);

  QwtPlotItem *item = m_Graph->infoToItem(v);

  if (item) {
    QwtPlotCurve *pc = dynamic_cast<QwtPlotCurve*>(item);

    if (pc) {
      QPen p = pc->pen();
      if (checked) {
        p.setWidth(3);
      } else {
        p.setWidth(0);
      }

      if (m_Graph) {
        pc->setPen(p);
        m_Graph->replot();
      }
    }
  }
}

void QseGraphController::columnsTableContextMenu(const QPoint & pos)
{
  QMenu menu(NULL, NULL);

  QAction* selectCells = menu.addAction(QString("Select..."));
  QAction* deselectCells = menu.addAction(QString("Deselect..."));

  menu.setMouseTracking(true);

  QAction* id = menu.exec(QCursor::pos() + QPoint( -40, -10), selectCells);

}

void QseGraphController::scansListContextMenu(const QPoint & pos)
{
  QMenu menu(NULL, NULL);

  QAction* selectCells = menu.addAction(QString("Select..."));
  QAction* deselectCells = menu.addAction(QString("Deselect..."));

  menu.setMouseTracking(true);

  QAction* id = menu.exec(QCursor::pos() + QPoint( -40, -10), selectCells);
}

void QseGraphController::graphContextMenu(const QPoint &pos)
{
  QMenu menu(NULL, NULL);
  QAction *action;

  foreach (action, m_Actions) {
    menu.addAction(action);
  }

  QAction* autoscaleItem = menu.addAction(QString("Autoscale Graph"));
  QAction* printItem   = menu.addAction(QString("Print Graph..."));
  
  QAction* showLegendItem = NULL;
  QAction* hideLegendItem = NULL;

  if (m_LegendShown) {
    hideLegendItem = menu.addAction(QString("Hide Legend"));
  } else {
    showLegendItem = menu.addAction(QString("Display Legend"));
  }

  QAction* saveItem = NULL;
  QAction* removeItem = NULL;

  if (m_ScansView) {
    saveItem    = menu.addAction(QString("Save selected scans"));
    removeItem  = menu.addAction(QString("Remove selected scans"));
  }

  menu.setMouseTracking(true);

  QAction* id = menu.exec(QCursor::pos() + QPoint( -40, -10), saveItem);

  if (id == autoscaleItem) {
    setAutoScale();
  } else if (id == printItem) {
    printGraph();
  } else if (id == showLegendItem) {
    showLegend();
  } else if (id == hideLegendItem) {
    hideLegend();
  } else if (m_ScansView && (id == saveItem)) {
    saveSelectedScans();
  } else if (m_ScansView && (id == removeItem)) {
    removeSelectedScans();
  }
}

int QseGraphController::scanCount()
{
  return m_DataSet -> scanCount();
}

QList<int> QseGraphController::selectedScans()
{
  QList<int> res;
  int nscans = scanCount();

  for (int i=0; i<nscans; i++) {
    if (scanSelected(i)) {
      res.append(i);
    }
  }

  return res;
}

void QseGraphController::saveSelectedScans()
{
  QseDataExport::exportSelectedData(QString("export/%1").arg(m_DataSet->objectName()), m_DataSet, selectedScans());
}

void QseGraphController::removeSelectedScans()
{
}

void QseGraphController::zoomGraphAll()
{
  setAutoScale();
}

void QseGraphController::zoomGraphOut()
{
  m_Zoomer -> zoom(-1);
  m_Zoomer2 -> zoom(-1);
}

void QseGraphController::zoomGraphIn()
{
  m_Zoomer -> zoom(1);
  m_Zoomer2 -> zoom(1);
}

QwtSymbol *QseGraphController::newSymbol(int n)
{
//  printf("QseGraphController::newSymbol(%d)\n", n);

  QwtSymbol *res = NULL;

  switch (n) {
  default:
  case 0:
    res = new QwtSymbol(QwtSymbol::Ellipse, QBrush(), m_Pens[0], QSize(3,3));
    break;

  case 1:
    res = new QwtSymbol(QwtSymbol::Ellipse, QBrush(), m_Pens[1], QSize(5,5));
    break;

  case 2:
    res = new QwtSymbol(QwtSymbol::Rect, QBrush(), m_Pens[2], QSize(5,5));
    break;

  case 3:
    res = new QwtSymbol(QwtSymbol::Diamond, QBrush(), m_Pens[3], QSize(5,5));
    break;

  case 4:
    res = new QwtSymbol(QwtSymbol::Triangle, QBrush(), m_Pens[4], QSize(5,5));
    break;

  case 5:
    res = new QwtSymbol(QwtSymbol::DTriangle, QBrush(), m_Pens[5], QSize(5,5));
    break;

  case 6:
    res = new QwtSymbol(QwtSymbol::UTriangle, QBrush(), m_Pens[6], QSize(5,5));
    break;

  case 7:
    res = new QwtSymbol(QwtSymbol::LTriangle, QBrush(), m_Pens[7], QSize(5,5));
    break;

  case 8:
    res = new QwtSymbol(QwtSymbol::RTriangle, QBrush(), m_Pens[8], QSize(5,5));
    break;

  case 9:
    res = new QwtSymbol(QwtSymbol::Cross, QBrush(), m_Pens[9], QSize(5,5));
    break;

  case 10:
    res = new QwtSymbol(QwtSymbol::XCross, QBrush(), m_Pens[10], QSize(5,5));
    break;

  case 11:
    res = new QwtSymbol(QwtSymbol::Star1, QBrush(), m_Pens[11], QSize(5,5));
    break;
  }

  return res;
}