#include <QFileDialog>
#include <QString>
#include <QDir>
#include <QTableWidget>
#include <QMessageBox>
#include <QTextEdit>
#include <QComboBox>

#include <TSystem.h>

#include <string>
#include <map>
#include <iostream>
#include <fstream>
#include <sstream>
#include <cmath>
#include <iomanip>
#include <stdlib.h>
#include <stdio.h>

#include <DataView.h>
#include "WaferButton.h"
#include "WaferComboBox.h"
#include "WaferAnalysisPanel.h"

#define _MULTITHREAD false

WaferAnalysisPanel::WaferAnalysisPanel(QWidget * parent, Qt::WindowFlags flags) : 
QMainWindow (parent, flags), _waferAnalysis()
{
	setupUi(this);
	QObject::connect(actionAdd_Data, SIGNAL(activated()), this, SLOT(addWafer()));
	QObject::connect(actionCreateXML, SIGNAL(activated()), this, SLOT(exportResultsToXML()));
	QObject::connect(actionClear_Data, SIGNAL(activated()), this, SLOT(clearData()));
	QObject::connect(actionExit, SIGNAL(activated()), this, SLOT(exitAll()));
	QObject::connect(actionOpen_Cuts, SIGNAL(activated()), this, SLOT(browseCuts()));
	QObject::connect(actionOpen_Settings, SIGNAL(activated()), this, SLOT(browseSettings()));
	QObject::connect(actionReload_Cuts, SIGNAL(activated()), this, SLOT(refreshResultCuts()));
	QObject::connect(actionReload_Settings, SIGNAL(activated()), this, SLOT(reloadSettings()));
	QObject::connect(pushButton_Analyze, SIGNAL(clicked()), this, SLOT(analyzeData()));
	QObject::connect(actionCreate_Wafer_Plots, SIGNAL(activated()), this, SLOT(createWaferResult()));
	QObject::connect(actionDebug, SIGNAL(activated()), this, SLOT(setDebugOutput()));
	QObject::connect(actionInfo, SIGNAL(activated()), this, SLOT(setInfoOutput()));
	QObject::connect(actionWarning, SIGNAL(activated()), this, SLOT(setWarningOutput()));
	QObject::connect(actionError, SIGNAL(activated()), this, SLOT(setErrorOutput()));
	QObject::connect(actionCreate_Chip_Plots, SIGNAL(activated()), this, SLOT(setChipPlotOutput()));
	QObject::connect(spinBox_waferNr, SIGNAL(valueChanged(int)), this, SLOT(setWaferSerialNumber(int)));

	QApplication* app=0;
	m_dataView = new DataView(false,0, "PixelDataViewer", 0, app, true );

	label_green->setStyleSheet("QLabel { background-color : lightgreen; color : black; }");
	label_yellow->setStyleSheet("QLabel { background-color : yellow; color : black; }");
	label_red->setStyleSheet("QLabel { background-color : tomato; color : black; }");
	label_blue->setStyleSheet("QLabel { background-color : lightblue; color : black; }");
	label_nocut->setStyleSheet("QLabel { background-color : lightgrey; color : black; }");

	progressBarSetting = 0;

	tryAutoOpenCutFile();
	tryAutoOpenSettingsFile();
}
WaferAnalysisPanel::~WaferAnalysisPanel()
{
  delete m_dataView;
}

void WaferAnalysisPanel::addWafer()
{

//  resultsTable->clear();
  QString fname="", wname="(none)";
  QStringList filter;
  filter += "DB ROOT file (*.root)";
  filter += "Any file (*.*)";
  QFileDialog fdia(this,"Select any wafer data file");
  fdia.setNameFilters(filter);
  fdia.setFileMode(QFileDialog::ExistingFile);
  if(fdia.exec() == QDialog::Accepted){
    fname = fdia.selectedFile();
      QApplication::setOverrideCursor(Qt::waitCursor);
      if (_waferAnalysis._waferData.getNwafers() > 0){
    	  _waferAnalysis._waferData.addFileGroup(std::string(fname.latin1()));
      }
      else{
    	  FILE *cuts = fopen(cutsFileName->text().latin1(),"r");
    	  if(cuts!=0)
    	  	fclose(cuts);
    	  else
    	   QMessageBox::warning(this,"Cut file not found","Can't find cut file "+cutsFileName->text()+".\nWon't run analysis.");
    	  _waferAnalysis._waferData.openFileGroup(std::string(fname.latin1()));
      }
      wname = _waferAnalysis._waferData.getWaferName().c_str();
      plotTable();
      waferName->setText(wname);
      QApplication::restoreOverrideCursor();
  }
  label_chipNr->setText(QString::number(_waferAnalysis._waferData.getNchips()));
}

void WaferAnalysisPanel::exportResultsToXML(){
	_waferAnalysis.exportResultsToXML();
}

void WaferAnalysisPanel::clearData()
{
	_waferAnalysis._waferData.clearAllData();
	resultsTable->clear();
	resultsTable->setColumnCount(0);
	resultsTable->setRowCount(0);
	resultsTable->setHorizontalHeaderLabels(QStringList(""));
	waferName->setText("(none)");
	label_chipNr->setText("-");
}

void WaferAnalysisPanel::clearAnalyzedData()
{
	_waferAnalysis._waferData.clearAllData();
	resultsTable->clear();
	resultsTable->setColumnCount(0);
	resultsTable->setRowCount(0);
	resultsTable->setHorizontalHeaderLabels(QStringList(""));
	waferName->setText("(none)");
	label_chipNr->setText("-");
}

void  WaferAnalysisPanel::startViewer(QString path){
  m_dataView->clearMA(false);
  m_dataView->browseFile(path);
  m_dataView->setWindowModality(Qt::WindowModal);
  m_dataView->show();
}
void  WaferAnalysisPanel::exitAll(){
  m_dataView->close();
  close();
}
void  WaferAnalysisPanel::browseCuts(){
  QStringList filter;
  filter += "Text file (*.txt)";
  filter += "Any file (*.*)";
  QFileDialog fdia(this,"Specify the name of the cuts file");
  fdia.setNameFilters(filter);
  fdia.setFileMode(QFileDialog::ExistingFile);
  if(fdia.exec() == QDialog::Accepted){
	_waferAnalysis._waferCuts.setCutFile(QString(fdia.selectedFile()).toStdString());
	_waferAnalysis._waferCuts.ReadCutFile();
	label_cutversion->setText(QString::number(_waferAnalysis._waferCuts.getCutFileVersion()));
	std::string tCutFileName = _waferAnalysis._waferCuts.getCutFile();
	tCutFileName = tCutFileName.substr(tCutFileName.find_last_of("/")+1,tCutFileName.size()-tCutFileName.find_last_of("/"));
	cutsFileName->setText(QString(tCutFileName.c_str()));
	actionAdd_Data->setEnabled(true);
  }
}

void  WaferAnalysisPanel::browseSettings(){
  QStringList filter;
  filter += "Text file (*.txt)";
  filter += "Any file (*.*)";
  QFileDialog fdia(this,"Specify the name of the settings file");
  fdia.setNameFilters(filter);
  fdia.setFileMode(QFileDialog::ExistingFile);
  if(fdia.exec() == QDialog::Accepted){
	_waferAnalysis._waferSettings.setSettingsFileName(QString(fdia.selectedFile()).toStdString());
	_waferAnalysis._waferSettings.ReadSettingsFile();
	std::string tSettingsFileName = _waferAnalysis._waferSettings.getSettingsFileName();
	tSettingsFileName = tSettingsFileName.substr(tSettingsFileName.find_last_of("/")+1,tSettingsFileName.size()-tSettingsFileName.find_last_of("/"));
	settingsFileName->setText(QString(tSettingsFileName.c_str()));
  }
}

void  WaferAnalysisPanel::plotTable()
{
	resultsTable->hide();	//some QT people say this enhances the speed when you redraw the table
	resultsTable->clear();
	if (_waferAnalysis._waferData.getNchips() > 0)
		plotTableFrame();
	for (unsigned int i=0; i <_waferAnalysis._waferData.getNchips(); ++i){
		plotTableIndex(i);
		if (i * _waferAnalysis._waferData.getNresults() < __MAXTABLEENTRIES) plotTableRow(i);	//do not plot all data (QT speed reason)
	}
	if (_waferAnalysis._waferData.getNchips() > 0)
		plotTableSummary();
	resultsTable->show();	//some QT people say this enhances the speed when you redraw the table
}
void  WaferAnalysisPanel::analyzeData()
{
	analyzesStarted();
	progressBar->setValue(0);
	progressBarSetting = 0;
	_waferAnalysis._waferCuts.ReadCutFile(cutsFileName->text().latin1());
	label_cutversion->setText(QString::number(_waferAnalysis._waferCuts.getCutFileVersion()));
	_waferAnalysis._waferSettings.ReadSettingsFile();

	if(_MULTITHREAD){
		QThread* tWorkerThread = new QThread;	//thread to to the analysis
		WaferWorker* tWaferWorker = new WaferWorker(_waferAnalysis);	//worker that does the analysis
		tWaferWorker->moveToThread(tWorkerThread);
		QObject::connect(tWorkerThread, SIGNAL(started()), tWaferWorker, SLOT(start()));
		QObject::connect(tWaferWorker, SIGNAL(progress()), this, SLOT(increaseProgressBar()));
		QObject::connect(tWaferWorker, SIGNAL(finished()), tWorkerThread, SLOT(quit()));
		QObject::connect(tWaferWorker, SIGNAL(finished()), tWaferWorker, SLOT(deleteLater()));
		QObject::connect(tWaferWorker, SIGNAL(finished()), tWorkerThread, SLOT(deleteLater()));
		QObject::connect(tWaferWorker, SIGNAL(finished()), this, SLOT(refreshTableSummary()));
		QObject::connect(tWaferWorker, SIGNAL(finished()), this, SLOT(analyzesFinished()));
		tWorkerThread->start();
	}
	else{
		for (unsigned int i = 0; i < _waferAnalysis._waferData.getNchips(); ++i){
			_waferAnalysis.openAndAnalyzeChipFile(i);
			progressBar->setValue((int) ((double)(i+1)/(double)_waferAnalysis._waferData.getNchips()*100.));
		}
		_waferAnalysis._waferData.calculateChipStatuses();
		_waferAnalysis._waferData.AverageResults();
		plotTable();
		analyzesFinished();
	}
}

void  WaferAnalysisPanel::refreshResultCuts()
{
	QApplication::setOverrideCursor(Qt::waitCursor);
	progressBar->setValue(0);
	_waferAnalysis._waferCuts.ReadCutFile(cutsFileName->text().latin1());
	label_cutversion->setText(QString::number(_waferAnalysis._waferCuts.getCutFileVersion()));
	for (unsigned int i = 0; i < _waferAnalysis._waferData.getNchips(); ++i){
		_waferAnalysis.refreshResultCuts(i);
		progressBar->setValue((int) ((double)(i+1)/(double)_waferAnalysis._waferData.getNchips()*100.));
	}
	_waferAnalysis._waferData.calculateChipStatuses();
	_waferAnalysis._waferData.AverageResults();
	plotTable();
	QApplication::restoreOverrideCursor();
}

void  WaferAnalysisPanel::addTableText(unsigned int pX, unsigned int pY, QString pQstring, QBrush pQbrush)
{
	QTableWidgetItem* tItem = new QTableWidgetItem(pQstring);
	tItem->setTextAlignment(4);
	resultsTable->setItem(pX,pY, tItem);
	resultsTable->item(pX,pY)->setBackground(pQbrush);
}

void WaferAnalysisPanel::addTableItem(unsigned int pX, unsigned int pY, QWidget* pWidget)
{
	resultsTable->setCellWidget(pX,pY,pWidget);
}

void WaferAnalysisPanel::createWaferResult()
{
	QApplication::setOverrideCursor(Qt::waitCursor);
	_waferAnalysis.createWaferResults();
	QApplication::restoreOverrideCursor();
}

void WaferAnalysisPanel::setDebugOutput()
{
  _waferAnalysis.setDebugOutput(actionDebug->isChecked());
}
void WaferAnalysisPanel::setInfoOutput()
{
  _waferAnalysis.setInfoOutput(actionInfo->isChecked());
}

void WaferAnalysisPanel::setWarningOutput()
{
  _waferAnalysis.setWarningOutput(actionWarning->isChecked());
}

void WaferAnalysisPanel::setErrorOutput()
{
  _waferAnalysis.setErrorOutput(actionError->isChecked());
}

void WaferAnalysisPanel::setWaferSerialNumber(int pSerialNumber)
{
	_waferAnalysis._waferData.setWaferSerialNumber((unsigned int) pSerialNumber);
}

void WaferAnalysisPanel::setResultStatus(unsigned int pChipIndex, std::string pResultName, int pResultStatus, QString)
{
	switch (pResultStatus){
		case 1:
			_waferAnalysis._waferData.setResultStatus(pChipIndex,pResultName,SETRED);
			break;
		case 2:
			_waferAnalysis._waferData.setResultStatus(pChipIndex,pResultName,SETYELLOW);
			break;
		case 3:
			_waferAnalysis._waferData.setResultStatus(pChipIndex,pResultName,SETGREEN);
			break;
		default:
			_waferAnalysis._waferData.setResultStatus(pChipIndex,pResultName,BLUE);
	}
	_waferAnalysis._waferData.calculateChipStatus(pChipIndex);
	plotTableRow(pChipIndex);
	plotTableSummary();
}
void WaferAnalysisPanel::setChipStatus(unsigned int pChipIndex, std::string pResultName, int pChipStatus, QString)
{
	switch (pChipStatus){
		case 1:
			_waferAnalysis._waferData.setChipStatus(pChipIndex,SETRED);
			break;
		case 2:
			_waferAnalysis._waferData.setChipStatus(pChipIndex,SETYELLOW);
			break;
		case 3:
			_waferAnalysis._waferData.setChipStatus(pChipIndex,SETGREEN);
			break;
		default:
			_waferAnalysis._waferData.setChipStatus(pChipIndex,BLUE);
	}
//	plotTableIndex(pChipIndex);
	plotTableRow(pChipIndex);
	plotTableSummary();
}

void WaferAnalysisPanel::plotTableFrame()
{
	QStringList list;
	list<<"#chip";
	list<<"WaferSN";
	std::list<std::string> tResultNames;
	_waferAnalysis._waferData.getResultNames(tResultNames);

	for (std::list<std::string>::iterator it=tResultNames.begin(); it!=tResultNames.end(); ++it)
		list<<it->c_str();

	list<<"Action";
	resultsTable->setEditTriggers(QAbstractItemView::NoEditTriggers); //results cannot be changed by user
	resultsTable->setColumnCount(list.size());
	resultsTable->setColumnWidth(0,40);
	resultsTable->setColumnWidth(1,75);
	resultsTable->setColumnWidth(2,75);
	resultsTable->setColumnWidth(3,75);
	resultsTable->setColumnWidth(4,80);
	resultsTable->setColumnWidth(5,80);
	resultsTable->setColumnWidth(6,80);
	resultsTable->setColumnWidth(11,40);
	resultsTable->setColumnWidth(12,40);
	resultsTable->setHorizontalHeaderLabels(list);
	resultsTable->verticalHeader()->hide();	//header cannot have different colors
	resultsTable->setRowCount(_waferAnalysis._waferData.getNchips()+7);	//+7 for average, deviation and results statistics output
}
void WaferAnalysisPanel::plotTableRow(unsigned int pIndex)
{
	std::list<std::string> tResultNames;
	_waferAnalysis._waferData.getResultNames(tResultNames);

	QBrush tCellCol;

	int j = 1;

	for (std::list<std::string>::iterator it=tResultNames.begin(); it!=tResultNames.end(); ++it){
		double tValue = 0;
		j++;
		status tResultStatus = GREY;
		if (_waferAnalysis._waferData.getResult(pIndex, *it, tValue)){
			_waferAnalysis._waferData.getResultStatus(pIndex, *it, tResultStatus);
			if (tResultStatus != BLUE && tResultStatus != SETRED && tResultStatus != SETYELLOW && tResultStatus != SETGREEN){
				addTableText(pIndex,j,QString::number(tValue, 'd',0),QBrush("white"));
				switch(tResultStatus){
					case GREY:
						tCellCol = QBrush("lightgrey");
						break;
					case GREEN:
						tCellCol = QBrush("lightgreen");
						break;
					case YELLOW:
						tCellCol = QBrush("yellow");
						break;
					case RED:
						tCellCol = QBrush("tomato");
						break;
					case BLUE:
						tCellCol = QBrush("lightblue");
						break;
					default:
						tCellCol = QBrush("white");
					}
				resultsTable->item(pIndex,j)->setBackground(tCellCol);
			}
			else{
				if (it->compare("status") == 0){
					WaferComboBox* tComboBox = new WaferComboBox(pIndex, *it, QString::number(tValue, 'd',0), tResultStatus, resultsTable);
					QObject::connect(tComboBox, SIGNAL(getState(unsigned int, std::string, int, QString)), this, SLOT(setChipStatus(unsigned int, std::string, int, QString)));
					addTableItem(pIndex,j,tComboBox);
				}
				else{
					WaferComboBox* tComboBox = new WaferComboBox(pIndex, *it, QString::number(tValue, 'd',0), tResultStatus, resultsTable);
					QObject::connect(tComboBox, SIGNAL(getState(unsigned int, std::string, int, QString)), this, SLOT(setResultStatus(unsigned int, std::string, int, QString)));
					addTableItem(pIndex,j,tComboBox);
				}
			}
		}
		else{
//			WaferComboBox* tComboBox = new WaferComboBox(pIndex, *it, QString("-"), tResultStatus);
//			QObject::connect(tComboBox, SIGNAL(getState(unsigned int, std::string, int)), this, SLOT(setResultStatus(unsigned int, std::string, int)));
//			addTableItem(pIndex,j,tComboBox);
			addTableText(pIndex,j,QString("-"),QBrush("lightgrey"));
		}
		addTableText(_waferAnalysis._waferData.getNchips()+2, j, QString::number((double) _waferAnalysis._waferData.getResultStatistic(*it, GREEN)/(double) _waferAnalysis._waferData.getNchips()*100., 'd',0)+QString("%"), QBrush("lightgreen"));
		addTableText(_waferAnalysis._waferData.getNchips()+3, j, QString::number((double) _waferAnalysis._waferData.getResultStatistic(*it, YELLOW)/(double) _waferAnalysis._waferData.getNchips()*100., 'd',0)+QString("%"), QBrush("yellow"));
		addTableText(_waferAnalysis._waferData.getNchips()+4, j, QString::number((double) _waferAnalysis._waferData.getResultStatistic(*it, RED)/(double) _waferAnalysis._waferData.getNchips()*100., 'd',0)+QString("%"), QBrush("tomato"));
		addTableText(_waferAnalysis._waferData.getNchips()+5, j, QString::number((double) _waferAnalysis._waferData.getResultStatistic(*it, BLUE)/(double) _waferAnalysis._waferData.getNchips()*100., 'd',0)+QString("%"), QBrush("lightblue"));
		addTableText(_waferAnalysis._waferData.getNchips()+6, j, QString::number((double) _waferAnalysis._waferData.getResultStatistic(*it, GREY)/(double) _waferAnalysis._waferData.getNchips()*100., 'd',0)+QString("%"), QBrush("lightgrey"));
	}
	WaferButton* button = new WaferButton(QString(_waferAnalysis._waferData.getFileName(pIndex).c_str()), resultsTable);
	QObject::connect(button, SIGNAL(showViewer(QString)), this, SLOT(startViewer(QString)));
	addTableItem(pIndex,_waferAnalysis._waferData.getNresults()+2, button);
}
void WaferAnalysisPanel::plotTableSummary()
{
	//average and deviation output
	resultsTable->setItem(_waferAnalysis._waferData.getNchips(),0, new QTableWidgetItem(QString("Avr.")));
	resultsTable->setItem(_waferAnalysis._waferData.getNchips()+1,0, new QTableWidgetItem(QString("Std.")));

	//number of chips in the different states output
	addTableText(_waferAnalysis._waferData.getNchips()+2, 0, QString::number(_waferAnalysis._waferData.getNgreenChips()), QBrush("lightgreen"));
	addTableText(_waferAnalysis._waferData.getNchips()+3, 0, QString::number(_waferAnalysis._waferData.getNyellowChips()), QBrush("yellow"));
	addTableText(_waferAnalysis._waferData.getNchips()+4, 0, QString::number(_waferAnalysis._waferData.getNredChips()), QBrush("tomato"));
	addTableText(_waferAnalysis._waferData.getNchips()+5, 0, QString::number(_waferAnalysis._waferData.getNblueChips()), QBrush("lightblue"));
	addTableText(_waferAnalysis._waferData.getNchips()+6, 0, QString::number(_waferAnalysis._waferData.getNgreyChips()), QBrush("lightgrey"));

	int i = 2;
	std::map<std::string, std::pair<double, double> > tAverageValues;
	_waferAnalysis._waferData.getAverageValues(tAverageValues);
	for (std::map<std::string, std::pair<double, double> >::iterator it = tAverageValues.begin(); it != tAverageValues.end(); ++it){
		QTableWidgetItem* tItem = new QTableWidgetItem(QString::number(it->second.first, 'd',0));
		tItem->setTextAlignment(4);
		resultsTable->setItem(_waferAnalysis._waferData.getNchips(),i, tItem);
		tItem = new QTableWidgetItem(QString::number(it->second.second, 'd',0));
		tItem->setTextAlignment(4);
		resultsTable->setItem(_waferAnalysis._waferData.getNchips()+1,i, tItem);
		i++;
	}
	QPushButton* tButton = new QPushButton();
	tButton->setText("Refresh");
	QObject::connect(tButton, SIGNAL(clicked()), this, SLOT(refreshTableSummary()));
	addTableItem(_waferAnalysis._waferData.getNchips(), i,tButton);

}
void WaferAnalysisPanel::plotTableIndex(unsigned int pIndex)
{
	QTableWidgetItem* tItem = new QTableWidgetItem(QString::number(_waferAnalysis._waferData.getChipNumber(pIndex)));	//chip number, NOT index
	QTableWidgetItem* tItem2 = new QTableWidgetItem(QString::number(_waferAnalysis._waferData.getWaferSerialNumber(pIndex)));	//wafer serial number of the chip
	tItem->setTextAlignment(4);
	tItem2->setTextAlignment(4);
	resultsTable->setItem(pIndex,0, tItem);
	resultsTable->setItem(pIndex,1, tItem2);

	QBrush tCellCol;
	status tChipStatus = GREY;
	_waferAnalysis._waferData.getChipStatus(pIndex, tChipStatus);

	switch(tChipStatus){
		case GREY:
			tCellCol = QBrush("lightgrey");
			break;
		case GREEN:
			tCellCol = QBrush("lightgreen");
			break;
		case YELLOW:
			tCellCol = QBrush("yellow");
			break;
		case RED:
			tCellCol = QBrush("tomato");
			break;
		case SETGREEN:
			tCellCol = QBrush("lightgreen");
			break;
		case SETYELLOW:
			tCellCol = QBrush("yellow");
			break;
		case SETRED:
			tCellCol = QBrush("tomato");
			break;
		case BLUE:
			tCellCol = QBrush("lightblue");
			break;
		default:
			tCellCol = QBrush("white");
	}
	resultsTable->item(pIndex,0)->setBackground(tCellCol);
	resultsTable->item(pIndex,1)->setBackground(QBrush("lightgrey"));
}
void WaferAnalysisPanel::refreshTableSummary()
{
	QApplication::setOverrideCursor(Qt::waitCursor);
	_waferAnalysis._waferData.AverageResults();
	plotTable();
	QApplication::restoreOverrideCursor();
}

void WaferAnalysisPanel::tryAutoOpenCutFile()
{
	QDir curr = QDir::current();
	curr.cdUp();
	FILE *cuts = fopen((curr.path()+"/Applications/Pixel/WaferAnalysis/CutConf.txt").latin1(),"r");
	if(cuts!=0){
		fclose(cuts);
		_waferAnalysis._waferCuts.setCutFile(QString(curr.path()+"/Applications/Pixel/WaferAnalysis/CutConf.txt").toStdString());
		_waferAnalysis._waferCuts.ReadCutFile();
		std::string tCutFileName = _waferAnalysis._waferCuts.getCutFile();
		tCutFileName = tCutFileName.substr(tCutFileName.find_last_of("/")+1,tCutFileName.size()-tCutFileName.find_last_of("/"));
		cutsFileName->setText(QString(tCutFileName.c_str()));
		label_cutversion->setText(QString::number(_waferAnalysis._waferCuts.getCutFileVersion()));
		actionAdd_Data->setEnabled(true);
	}
	else{ // failed, so let's check if the DAQ_BASE envir. variable is set
		QString basePath = gSystem->Getenv("DAQ_BASE");
		basePath.replace(QString("\\"),QString("/"));
		cuts = fopen((basePath+"/Applications/Pixel/WaferAnalysis/CutConf.txt").latin1(),"r");
		if(cuts!=0){
			fclose(cuts);
			_waferAnalysis._waferCuts.setCutFile(QString(basePath+"/Applications/Pixel/WaferAnalysis/CutConf.txt").toStdString());
			_waferAnalysis._waferCuts.ReadCutFile();
			label_cutversion->setText(QString::number(_waferAnalysis._waferCuts.getCutFileVersion()));
			std::string tCutFileName = _waferAnalysis._waferCuts.getCutFile();
			tCutFileName = tCutFileName.substr(tCutFileName.find_last_of("/")+1,tCutFileName.size()-tCutFileName.find_last_of("/"));
			cutsFileName->setText(QString(tCutFileName.c_str()));
			actionAdd_Data->setEnabled(true);
		}
		else{
			actionAdd_Data->setEnabled(false);
			cutsFileName->setText("(open cuts file)");
		}
	}
}

void WaferAnalysisPanel::tryAutoOpenSettingsFile()
{
	QDir curr = QDir::current();
	curr.cdUp();
	FILE *cuts = fopen((curr.path()+"/Applications/Pixel/WaferAnalysis/Settings.txt").latin1(),"r");
	if(cuts!=0){
		fclose(cuts);
		_waferAnalysis._waferSettings.setSettingsFileName(QString(curr.path()+"/Applications/Pixel/WaferAnalysis/Settings.txt").toStdString());
		_waferAnalysis._waferSettings.ReadSettingsFile();
		std::string tSettingsFileName = _waferAnalysis._waferSettings.getSettingsFileName();
		tSettingsFileName = tSettingsFileName.substr(tSettingsFileName.find_last_of("/")+1,tSettingsFileName.size()-tSettingsFileName.find_last_of("/"));
		settingsFileName->setText(QString(tSettingsFileName.c_str()));
	}
	else{ // failed, so let's check if the DAQ_BASE envir. variable is set
		QString basePath = gSystem->Getenv("DAQ_BASE");
		basePath.replace(QString("\\"),QString("/"));
		cuts = fopen((basePath+"/Applications/Pixel/WaferAnalysis/Settings.txt").latin1(),"r");
		if(cuts!=0){
			fclose(cuts);
			_waferAnalysis._waferSettings.setSettingsFileName(QString(basePath+"/Applications/Pixel/WaferAnalysis/Settings.txt").toStdString());
			_waferAnalysis._waferSettings.ReadSettingsFile();
			std::string tSettingsFileName = _waferAnalysis._waferSettings.getSettingsFileName();
			tSettingsFileName = tSettingsFileName.substr(tSettingsFileName.find_last_of("/")+1,tSettingsFileName.size()-tSettingsFileName.find_last_of("/"));
			settingsFileName->setText(QString(tSettingsFileName.c_str()));
		}
		else{
			settingsFileName->setText("(open settings file)");
		}
	}
}

void WaferAnalysisPanel::reloadSettings()
{
	_waferAnalysis._waferSettings.ReadSettingsFile();
}

void WaferAnalysisPanel::analyzesStarted()
{
	QApplication::setOverrideCursor(Qt::waitCursor);
	actionOpen_Settings->setEnabled(false);
	actionOpen_Cuts->setEnabled(false);
	actionAdd_Data->setEnabled(false);
	actionClear_Data->setEnabled(false);
	actionReload_Settings->setEnabled(false);
	actionReload_Cuts->setEnabled(false);
	actionCreate_Wafer_Plots->setEnabled(false);
	pushButton_Analyze->setEnabled(false);
	//pushButton_Stop->setEnabled(false);
	analysing = true;
}
void WaferAnalysisPanel::analyzesFinished()
{
	QApplication::restoreOverrideCursor();
	actionOpen_Settings->setEnabled(true);
	actionOpen_Cuts->setEnabled(true);
	actionAdd_Data->setEnabled(true);
	actionClear_Data->setEnabled(true);
	pushButton_Analyze->setEnabled(true);
	actionReload_Settings->setEnabled(true);
	actionReload_Cuts->setEnabled(true);
	actionCreate_Wafer_Plots->setEnabled(true);
	//pushButton_Stop->setEnabled(false);
	analysing = false;
}
void WaferAnalysisPanel::increaseProgressBar()
{
	progressBarSetting++;
	progressBar->setValue((int) ((double)(progressBarSetting)/(double)_waferAnalysis._waferData.getNchips()*100.));
}

void WaferAnalysisPanel::setChipPlotOutput()
{
	_waferAnalysis.setPlotOutput(actionCreate_Chip_Plots->isChecked());
}