qsedataexport.cpp

Go to the documentation of this file.

#include "qsedataexport.h"
#include "qsedataexportpreview.h"
#include "qsedataexportpreviewui.h"
#include <QDirModel>
#include <QString>
#include "qsesettings.h"
#include <QMessageBox>
#include <QFileDialog>

#include <stdio.h>

QseDataExport::QseDataExport(const QString &id, QseDataSet *data, QList<int> selections, QWidget *parent)
  : QDialog(parent),
    m_Identifier(id),
    m_Selections(selections),
    m_DataSet(data),
    m_Preview(NULL),
    m_PreviewUI(NULL)
{
  ui.setupUi(this);

  m_Preview = new QseDataExportPreview(this, this);

  readSettings();

  int i;
  int nscans = data->scanCount();

  for (i = 0; i<nscans; i++) {
    QString scanname = data->scan(i)->name();

    ui.m_ScanList->addItem(scanname);
  }

  scanRevert();

  ui.m_DirectoryView->setModel(&m_DirModel);
  ui.m_DirectoryView->hideColumn(1);
  ui.m_DirectoryView->hideColumn(2);
  ui.m_DirectoryView->hideColumn(3);

  updateNewDirectory();

  ui.m_OutputPatternEdit -> setText(m_OutputPattern);

  ui.m_SaveHeaderOption -> setChecked(m_Options & SaveHeader);
  ui.m_BriefHeaderOption -> setChecked(m_Options & BriefHeader);
  ui.m_SingleFileOption -> setChecked(m_Options & SingleFile);
  ui.m_FileHeaderInEachOption -> setChecked(m_Options & FileHeaderInEach);
  ui.m_ColumnHeaderLineOption -> setChecked(m_Options & ColumnHeaderLine);
  ui.m_AutoRenameOption -> setChecked(m_Options & AutoRename);

  setWindowTitle(QString("Export Data from %1").arg(data->fileName()));

  setupConnections();
}

void QseDataExport::setupConnections()
{
  connect(ui.m_DirectoryCombo, SIGNAL(currentIndexChanged(const QString&)),
          this, SLOT(directoryChanged(const QString&)));

  connect(ui.m_DirectoryNewButton, SIGNAL(clicked()), this, SLOT(newDirectory()));
  connect(ui.m_DirectoryUpButton, SIGNAL(clicked()), this, SLOT(upDirectory()));
  connect(ui.m_DirectoryHomeButton, SIGNAL(clicked()), this, SLOT(homeDirectory()));
  connect(ui.m_DirectoryView, SIGNAL(doubleClicked(const QModelIndex&)), 
          this, SLOT(directoryChanged(const QModelIndex&)));

  connect(ui.m_ScanSelectAllButton, SIGNAL(clicked()), this, SLOT(scanSelectAll()));
  connect(ui.m_ScanSelectNoneButton, SIGNAL(clicked()), this, SLOT(scanSelectNone()));
  connect(ui.m_ScanRevertButton, SIGNAL(clicked()), this, SLOT(scanRevert()));

  connect(ui.m_OutputPatternEdit, SIGNAL(textChanged(const QString&)), this, SLOT(newOutputPattern(const QString&)));
  connect(ui.m_SaveHeaderOption, SIGNAL(clicked(bool)), this, SLOT(saveHeaderOptionChanged(bool)));
  connect(ui.m_BriefHeaderOption, SIGNAL(clicked(bool)), this, SLOT(briefHeaderOptionChanged(bool)));
  connect(ui.m_SingleFileOption, SIGNAL(clicked(bool)), this, SLOT(singleFileOptionChanged(bool)));
  connect(ui.m_FileHeaderInEachOption, SIGNAL(clicked(bool)), this, SLOT(fileHeaderInEachOptionChanged(bool)));
  connect(ui.m_ColumnHeaderLineOption, SIGNAL(clicked(bool)), this, SLOT(columnHeaderLineOptionChanged(bool)));
  connect(ui.m_AutoRenameOption, SIGNAL(clicked(bool)), this, SLOT(autoRenameOptionChanged(bool)));

  connect(ui.m_CancelButton, SIGNAL(clicked()), this, SLOT(cancelPressed()));
  connect(ui.m_ExportButton, SIGNAL(clicked()), this, SLOT(exportPressed()));
  connect(ui.m_PreviewButton, SIGNAL(clicked()), this, SLOT(previewPressed()));

  connect(this, SIGNAL(dataChanged()), m_Preview, SLOT(onDataChanged()));
}

void QseDataExport::newOutputPattern(const QString &patt)
{
  m_OutputPattern = patt;
}

void QseDataExport::saveHeaderOptionChanged(bool opt)
{
  if (opt) {
    m_Options |= SaveHeader;
  } else {
    m_Options &= ~SaveHeader;
  } 
}

void QseDataExport::briefHeaderOptionChanged(bool opt)
{
  if (opt) {
    m_Options |= BriefHeader;
  } else {
    m_Options &= ~BriefHeader;
  } 
}

void QseDataExport::singleFileOptionChanged(bool opt)
{
  if (opt) {
    m_Options |= SingleFile;
  } else {
    m_Options &= ~SingleFile;
  } 
}

void QseDataExport::fileHeaderInEachOptionChanged(bool opt)
{
  if (opt) {
    m_Options |= FileHeaderInEach;
  } else {
    m_Options &= ~FileHeaderInEach;
  } 
}

void QseDataExport::columnHeaderLineOptionChanged(bool opt)
{
  if (opt) {
    m_Options |= ColumnHeaderLine;
  } else {
    m_Options &= ~ColumnHeaderLine;
  } 
}

void QseDataExport::autoRenameOptionChanged(bool opt)
{
  if (opt) {
    m_Options |= AutoRename;
  } else {
    m_Options &= ~AutoRename;
  } 
}

void QseDataExport::exportSelectedData(const QString &id, QseDataSet *data, QList<int> selections)
{
  QseDataExport dialog(id, data, selections);

  dialog.exec();
}

void QseDataExport::updateNewDirectory()
{
  ui.m_DirectoryView->setRootIndex(m_DirModel.index(m_OutputDir.path()));

  ui.m_DirectoryCombo->blockSignals(true);

  ui.m_DirectoryCombo->clear();

  QDir qd = m_OutputDir;

  do {
    if (qd.exists()) ui.m_DirectoryCombo->addItem(qd.absolutePath());
  } while(qd.cdUp());

  ui.m_DirectoryCombo->blockSignals(false);
}

void QseDataExport::newDirectory()
{
  QString newdir = QFileDialog::getExistingDirectory(this);

  if (newdir.length()) {
    m_OutputDir.cd(newdir);
  }

  updateNewDirectory();
}

void QseDataExport::upDirectory()
{
  m_OutputDir.cdUp();

  updateNewDirectory();
}

void QseDataExport::homeDirectory()
{
  m_OutputDir.cd(QDir::currentPath());

  updateNewDirectory();
}

void QseDataExport::directoryChanged(const QModelIndex& index)
{
  QString fp = m_DirModel.filePath(index);

  directoryChanged(fp);
}

void QseDataExport::directoryChanged(const QString& newdir)
{
  QDir qd(newdir);

  if (qd.exists()) {
    m_OutputDir.cd(newdir);

    updateNewDirectory();
  }
}

void QseDataExport::scanSelectAll()
{
  ui.m_ScanList->selectAll();
}

void QseDataExport::scanSelectNone()
{
  ui.m_ScanList->clearSelection();
}

void QseDataExport::scanRevert()
{
  int i;
  ui.m_ScanList->clearSelection();

  foreach(i, m_Selections) {
    QModelIndex sel = ui.m_ScanList->model()->index(i,0);

    ui.m_ScanList->selectionModel()->select(sel, QItemSelectionModel::Select);
  }
}

QList<int> QseDataExport::selectedScans() const
{
  QList<int> res;
  QList<QListWidgetItem*> selected = ui.m_ScanList->selectedItems();
  QListWidgetItem* w;

  foreach(w, selected) {
    res.append(ui.m_ScanList->row(w));
  }

  return res;
}

void  QseDataExport::autoRenameFiles()
{
  QList<QString> dups;
  QList<QString> files;

  int nscans = m_Preview -> countFiles();

  for(int i=0; i<nscans; i++) {
    QString fnam = m_Preview -> getFile(i);

    if (QFile::exists(m_OutputDir.filePath(fnam)) ||
        files.contains(fnam)) {

      for (int n=1; ; n++) {
        QString fnam2 = fnam+QString("_%1").arg(n,5,10,QLatin1Char('0'));

        if ((!QFile::exists(m_OutputDir.filePath(fnam2))) &&
            (!files.contains(fnam2))) {
          files.append(fnam2);
          m_Preview -> setFile(i, fnam2);
          break;
        }
      }
    }
  }
}

bool  QseDataExport::checkForOverwriting()
{
  QList<QString> dups;
  QList<QString> files;
  int i, nd=0, nid=0;
  int nscans = m_Preview -> countFiles();

  for(int i=0; i<nscans; i++) {
    QString fnam = m_Preview -> getFile(i);

    if (QFile::exists(m_OutputDir.filePath(fnam))) {
      dups.append(fnam);
    }

    if (files.contains(fnam)) {
      nid++;
    } else {
      files.append(fnam);
    }
  }

  nd = dups.count();
  QString msg;

  if (nd) {
    msg.append(QString("%1 files will be overwritten by this operation").arg(nd));
    for (i = 0; i < qMin(5, nd); i++) {
      msg.append("\n");
      msg.append(dups[i]);
    }

    if (nd > 5) {
      msg.append("\n...");
    }
  }

  if (nid) {
    msg.append(QString("%1 of the output file names are duplicated").arg(nd));
  }

  if (nd || nid) {
    msg.append("\nHow do you want to proceed?");
    QMessageBox msgBox;
    QPushButton *goAheadButton = msgBox.addButton("Overwrite", QMessageBox::ActionRole);
    QPushButton *renameButton  = msgBox.addButton("Rename", QMessageBox::ActionRole);
    QPushButton *cancelButton  = msgBox.addButton("Cancel", QMessageBox::ActionRole);

    msgBox.setWindowTitle("Overwrite...");
    msgBox.setText("Some of the filenames to be used for output are either duplicated or already exist.  What do you want to do?");
    msgBox.setDetailedText(msg);
    msgBox.setIcon(QMessageBox::Question);
    
    msgBox.exec();

    if (msgBox.clickedButton() == goAheadButton) {
      return true;
    } else if (msgBox.clickedButton() == renameButton) {
      autoRenameFiles();
      return true;
    } else {
      return false;
    }
  }

  return true;
}

void QseDataExport::previewPressed()
{
  updatePreview();

  if (m_PreviewUI == NULL) {
    m_PreviewUI = new QseDataExportPreviewUI(m_Preview, this);
  }

  m_PreviewUI -> show();

  emit dataChanged();
}

void QseDataExport::exportPressed()
{
  updatePreview();

  if (checkForOverwriting()) {
    writePreview();
    done(0);
  }
}

void QseDataExport::cancelPressed()
{
  done(0);
}

void QseDataExport::writePreview()
{
  int nfiles = m_Preview -> countFiles();

  for (int i=0; i<nfiles; i++) {
    QString fnam = m_Preview -> getFile(i);
    QString path = m_OutputDir.absoluteFilePath(fnam);

    FILE* f = fopen(qPrintable(path), "w");

    fputs(qPrintable(m_Preview -> getLines(i)), f);

    fclose(f);
  }
}

void QseDataExport::updatePreview()
{
  printf("Export Options = %d\n", m_Options);

  QString patt = ui.m_OutputPatternEdit -> text();
  int i;
  QList<int> selected = selectedScans();
  QString fnam = "";
  int f;

  m_Preview -> clear();

  foreach(i, selected) {
    QseScan *scan = m_DataSet -> scan(i);
    int nrows = scan -> maxRowCount();
    int ncols = scan -> columnCount();

    if (fnam == "") {
      if (m_Options & SingleFile) {
        fnam = substituteFilenamePatterns(patt, 0, m_DataSet);
      } else {
        fnam = substituteFilenamePatterns(patt, i, m_DataSet);
      }
        
//       if (QFile::exists(m_OutputDir.filePath(fnam))) {
//      if (m_Options & AutoRename) {
//        int n=1;
            
//        while (QFile::exists(m_OutputDir.filePath(fnam+QString("_%1").arg(n,5,10,QLatin1Char('0'))))) {
//          n += 1;
//        }

//        fnam = fnam+QString("_%1").arg(n,5,10,QLatin1Char('0'));
//      } else {
//        printf("Duplicate file name %s\n", qPrintable(fnam));
//      }
//       }
      
//       printf("Scan %d : %s\n", i, qPrintable(fnam));
      
      f = m_Preview -> appendNewFile(fnam);
    }

    if (f >= 0) {
      if (m_Options & FileHeaderInEach) {
        QString s;
        QStringList hdr = m_DataSet->header();

        foreach(s,hdr) {
          m_Preview -> appendLine(f, s);
        }
      }

      if (m_Options & SaveHeader) {
        QString s;
        m_Preview -> appendLine(f, scan->scanCommand());
        m_Preview -> appendLine(f, scan->scanDateLine());

        QStringList hdr = scan->header();
        
        foreach(s,hdr) {
          m_Preview -> appendLine(f, s);
        }

        m_Preview -> appendLine(f, scan->scanColumnCountLine());
        m_Preview -> appendLine(f, scan->scanColumnNamesLine());
      } else if (m_Options & BriefHeader) {
        m_Preview -> appendLine(f, scan->scanCommand());
        m_Preview -> appendLine(f, scan->scanDateLine());
        m_Preview -> appendLine(f, scan->scanColumnCountLine());
        m_Preview -> appendLine(f, scan->scanColumnNamesLine());
      }

      if (m_Options & ColumnHeaderLine) {
        QString colnames;
        for (int i=0; i<ncols; i++) {
          QseColumn *col = scan->column(i);
          if (i == 0) {
            colnames = col->name();
          } else{
            colnames += "\t";
            colnames += col->name();
          }
        }
        
        m_Preview -> appendLine(f, colnames);
      }
      
      for (int r=0; r<nrows; r++) {
        QString dataline;
        for (int c=0; c<ncols; c++) {
          if (c == 0) {
            dataline = tr("%1").arg(scan->column(c)->data(r));
          } else {
            dataline += "\t";
            dataline += tr("%1").arg(scan->column(c)->data(r));
          }
        }
        m_Preview -> appendLine(f, dataline);
      }
      
      if (!(m_Options & SingleFile)) {
        fnam = "";
      }
    }
  }
  
  if (m_Options & AutoRename) {
    autoRenameFiles();
  }

  writeSettings();
}

QString QseDataExport::substituteFilenamePatterns(const QString &patt, int index, const QseDataSet *ds)
{
  QseScan *scan = ds->scan(index);
  QString fnam = ds->fileName();
  int scannum = scan -> scanNumber();
  QDateTime dt = scan -> scanDateTime();

  QString res = patt;

  res.replace("%i", QString("%1").arg(index+1));
  res.replace("%n", QString("%1").arg(scannum));
  res.replace("%f", QFileInfo(fnam).completeBaseName());
  res.replace("%x", QFileInfo(fnam).suffix());
  res.replace("%d", dt.toString("yyyyMMdd_hhmmss"));
  res.replace("%t", dt.toString("yyyyMMdd"));

  return res;
}

void QseDataExport::readSettings()
{
  QseSettings settings;

  m_Options = settings.value(QString("%1/options").arg(m_Identifier),0).toInt();
  m_OutputDir.cd(settings.value(QString("%1/outputdir").arg(m_Identifier),QDir::currentPath()).toString());
  m_OutputPattern = settings.value(QString("%1/outputpattern").arg(m_Identifier),"%f_%d_%n").toString();
}

void QseDataExport::writeSettings()
{
  QseSettings settings;

  settings.setValue(QString("%1/options").arg(m_Identifier), int(m_Options));
  settings.setValue(QString("%1/outputdir").arg(m_Identifier), m_OutputDir.absolutePath());
  settings.setValue(QString("%1/outputpattern").arg(m_Identifier), m_OutputPattern);
}