detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-23 15:00:02 +02:00
Code Issues Actions Packages Releases Activity
slsDetectorPackage/slsDetectorGui/src/qDetectorMain.cpp
l_maliakal_d 04e04db2ad problem with segmentation fault when trying to capture config loading logs at start:fixed 
git-svn-id: file:///afs/psi.ch/project/sls_det_software/svn/slsDetectorGui@98 af1100a4-978c-4157-bff7-07162d2ba061
2012-10-19 10:21:56 +00:00

674 lines
26 KiB
C++
Raw Blame History

/**********************************************************************
* TO DO
* 1. settcpsocket is done with slsdetector.maybe do for all detectors connected: mythen
* ********************************************************************/
// Qt Project Class Headers
#include "qDetectorMain.h"
#include "qDefs.h"
#include "qDrawPlot.h"
#include "qTabMeasurement.h"
#include "qTabDataOutput.h"
#include "qTabPlot.h"
#include "qTabActions.h"
#include "qTabAdvanced.h"
#include "qTabSettings.h"
#include "qTabDebugging.h"
#include "qTabDeveloper.h"
#include "qTabMessages.h"
// Project Class Headers
#include "slsDetector.h"
#include "multiSlsDetector.h"
#include "sls_detector_defs.h"
// Qt Include Headers
#include <QSizePolicy>
#include <QFileDialog>
// C++ Include Headers
#include<iostream>
#include <string>
using namespace std;
//-------------------------------------------------------------------------------------------------------------------------------------------------
int main (int argc, char **argv) {
QApplication *theApp = new QApplication(argc, argv);
theApp->setWindowIcon(QIcon( ":/icons/images/mountain.png" ));
qDetectorMain *det=new qDetectorMain(argc, argv, theApp,0);
det->show();
//theApp->connect( theApp, SIGNAL(lastWindowClosed()), theApp, SLOT(quit()));
return theApp->exec();
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
qDetectorMain::qDetectorMain(int argc, char **argv, QApplication *app, QWidget *parent) :
QMainWindow(parent), theApp(app),myDet(0),detID(0),myPlot(NULL),tabs(NULL),isDeveloper(0){
string configFName = "";
// Getting all the command line arguments
for(int iarg=1; iarg<argc; iarg++){
if(!strcasecmp(argv[iarg],"-developer")) {isDeveloper=1;}
if(!strcasecmp(argv[iarg],"-id")) {detID=atoi(argv[iarg+1]);}
if(!strcasecmp(argv[iarg],"-config")) {configFName=string(argv[iarg+1]);}
if(!strcasecmp(argv[iarg],"-help")){
cout << "Possible Arguments are:" << endl;
cout << "-help \t\t : \t This help" << endl;
cout << "-developer \t : \t Enables the developer tab" << endl;
cout << "-id i \t\t : \t Sets the multi detector id to i (the default is 0). "
"Required only when more than one multi detector object is needed." << endl;
}
}
setupUi(this);
SetUpDetector(configFName);
SetUpWidgetWindow();
Initialization();
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
qDetectorMain::~qDetectorMain(){
delete myDet;
if (menubar) delete menubar;
if (centralwidget) delete centralwidget;
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qDetectorMain::SetUpWidgetWindow(){
// Layout
layoutTabs= new QGridLayout;
centralwidget->setLayout(layoutTabs);
//plot setup
myPlot = new qDrawPlot(dockWidgetPlot,myDet); cout<<"DockPlot ready"<<endl;
dockWidgetPlot->setWidget(myPlot);
//tabs setup
tabs = new MyTabWidget(this);
layoutTabs->addWidget(tabs); cout<<"DockPlot ready"<<endl;
// creating all the other tab widgets
tab_measurement = new qTabMeasurement (this, myDet,myPlot); cout<<"Measurement ready"<<endl;
tab_dataoutput = new qTabDataOutput (this, myDet); cout<<"DataOutput ready"<<endl;
tab_plot = new qTabPlot (this, myDet,myPlot); cout<<"Plot ready"<<endl;
tab_actions = new qTabActions (this, myDet); cout<<"Actions ready"<<endl;
tab_settings = new qTabSettings (this, myDet); cout<<"Settings ready"<<endl;
tab_advanced = new qTabAdvanced (this, myDet,myPlot); cout<<"Advanced ready"<<endl;
tab_debugging = new qTabDebugging (this, myDet); cout<<"Debugging ready"<<endl;
tab_developer = new qTabDeveloper (this, myDet); cout<<"Developer ready"<<endl;
// creating the scroll area widgets for the tabs
for(int i=0;i<NumberOfTabs;i++){
scroll[i] = new QScrollArea;
scroll[i]->setFrameShape(QFrame::NoFrame);
}
// setting the tab widgets to the scrollareas
scroll[Measurement] ->setWidget(tab_measurement);
scroll[DataOutput] ->setWidget(tab_dataoutput);
scroll[Plot] ->setWidget(tab_plot);
scroll[Actions] ->setWidget(tab_actions);
scroll[Settings] ->setWidget(tab_settings);
scroll[Advanced] ->setWidget(tab_advanced);
scroll[Debugging] ->setWidget(tab_debugging);
scroll[Developer] ->setWidget(tab_developer);
// inserting all the tabs
tabs->insertTab(Measurement, scroll[Measurement], "Measurement");
tabs->insertTab(DataOutput, scroll[DataOutput], "Data Output");
tabs->insertTab(Plot, scroll[Plot], "Plot");
tabs->insertTab(Actions, scroll[Actions], "Actions");
tabs->insertTab(Settings, scroll[Settings], "Settings");
tabs->insertTab(Advanced, scroll[Advanced], "Advanced");
tabs->insertTab(Debugging, scroll[Debugging], "Debugging");
tabs->insertTab(Developer, scroll[Developer], "Developer");
//no scroll buttons this way
tabs->insertTab(Messages, tab_messages, "Messages");
//swap tabs so that messages is last tab
tabs->tabBar()->moveTab(tabs->indexOf(tab_measurement), Measurement);
tabs->tabBar()->moveTab(tabs->indexOf(tab_settings), Settings);
tabs->tabBar()->moveTab(tabs->indexOf(tab_dataoutput), DataOutput);
tabs->tabBar()->moveTab(tabs->indexOf(tab_plot), Plot);
tabs->tabBar()->moveTab(tabs->indexOf(tab_actions), Actions);
tabs->tabBar()->moveTab(tabs->indexOf(tab_advanced), Advanced);
tabs->tabBar()->moveTab(tabs->indexOf(tab_debugging), Debugging);
tabs->tabBar()->moveTab(tabs->indexOf(tab_developer), Developer);
tabs->tabBar()->moveTab(tabs->indexOf(tab_messages), Messages);
tabs->setCurrentIndex(Measurement);
//other tab properties
// Default tab color
defaultTabColor = tabs->tabBar()->tabTextColor(DataOutput);
//Set the current tab(measurement) to blue as it is the current one
tabs->tabBar()->setTabTextColor(0,QColor(0,0,200,255));
// increase the width so it uses all the empty space for the tab titles
tabs->tabBar()->setFixedWidth(width()+61);
// mode setup - to set up the tabs initially as disabled, not in form so done here
#ifdef VERBOSE
cout << "Setting Debug Mode to 0\nSetting Expert Mode to 0\nSetting Developer Mode to " << isDeveloper << "\nSetting Dockable Mode to false\n" << endl;
#endif
tabs->setTabEnabled(Debugging,false);
tabs->setTabEnabled(Advanced,false);
tabs->setTabEnabled(Developer,isDeveloper);
actionLoadTrimbits->setVisible(false);
actionSaveTrimbits->setVisible(false);
actionLoadCalibration->setVisible(false);
actionSaveCalibration->setVisible(false);
dockWidgetPlot->setFloating(false);
dockWidgetPlot->setFeatures(QDockWidget::NoDockWidgetFeatures);
// Other setup
//Height of plot and central widget
heightPlotWindow = dockWidgetPlot->size().height();
heightCentralWidget = centralwidget->size().height();
// Default zoom Tool Tip
zoomToolTip = dockWidgetPlot->toolTip();
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qDetectorMain::SetUpDetector(const string fName){
//instantiate detector and set window title
myDet = new multiSlsDetector(detID);
//create messages tab to capture config file loading logs
tab_messages = new qTabMessages (this,myDet); cout<<"Messages ready"<<endl;
//loads the config file at startup
if(!fName.empty()) LoadConfigFile(fName);
//gets the hostname if it worked
string host = myDet->getHostname();
//if hostname doesnt exist even in shared memory
if(!host.length()){
#ifdef VERBOSE
cout << endl << "No Detector Connected." << endl;
#endif
qDefs::Message(qDefs::CRITICAL,"No Detectors Connected. ","Main");
exit(-1);
}
//check if the detector is not even connected
string offline = myDet->checkOnline();
if(!offline.empty()){
qDefs::Message(qDefs::CRITICAL,string("<nobr>The detector(s) <b>")+offline+string(" </b> is/are not connected. Exiting GUI.</nobr>"),"Main");
cout << "The detector(s) " << host << " is/are not connected. Exiting GUI." << endl;
exit(-1);
}
// Check if type valid. If not, exit
slsDetectorDefs::detectorType detType = myDet->getDetectorsType();
switch(detType){
case slsDetectorDefs::MYTHEN: break;
case slsDetectorDefs::EIGER: break;
case slsDetectorDefs::GOTTHARD: actionLoadTrimbits->setText("Load Settings"); actionSaveTrimbits->setText("Save Settings"); break;
case slsDetectorDefs::AGIPD: actionLoadTrimbits->setText("Load Settings"); actionSaveTrimbits->setText("Save Settings"); break;
default:
string detName = myDet->slsDetectorBase::getDetectorType(detType);
string errorMess = host+string(" has unknown detector type \"")+
detName+string("\". Exiting GUI.");
qDefs::Message(qDefs::CRITICAL,errorMess,"Main");
exit(-1);
}
setWindowTitle("SLS Detector GUI : "+
QString(slsDetectorBase::getDetectorType(detType).c_str())+ " - "+QString(host.c_str()));
#ifdef VERBOSE
cout << endl << "Type : " << slsDetectorBase::getDetectorType(detType) << "\nDetector : " << host << endl;
#endif
myDet->setOnline(slsDetectorDefs::ONLINE_FLAG);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qDetectorMain::Initialization(){
// Dockable Plot
connect(dockWidgetPlot, SIGNAL(topLevelChanged(bool)), this,SLOT(ResizeMainWindow(bool)));
// tabs
connect(tabs, SIGNAL(currentChanged(int)), this, SLOT(Refresh(int)));//( QWidget*)));
// Measurement tab
connect(tab_measurement, SIGNAL(StartSignal()), this,SLOT(EnableTabs()));
connect(tab_measurement, SIGNAL(StopSignal()), myPlot,SLOT(StopAcquisition()));
connect(tab_measurement, SIGNAL(CheckPlotIntervalSignal()), tab_plot,SLOT(SetFrequency()));
// Data Output Tab
connect(tab_dataoutput, SIGNAL(AngularConversionSignal(bool)), tab_actions,SLOT(EnablePositions(bool)));
//enable scanbox( for angles)
connect(tab_dataoutput, SIGNAL(AngularConversionSignal(bool)), tab_plot,SLOT(EnableScanBox()));
// Plot tab
connect(tab_plot, SIGNAL(DisableZoomSignal(bool)), this,SLOT(SetZoomToolTip(bool)));
// Actions tab (only for scan)
connect(tab_actions, SIGNAL(EnableScanBox()), tab_plot,SLOT(EnableScanBox()));
//settings to advanced tab(int=id is always 0 to only refresh)
connect(tab_settings, SIGNAL(UpdateTrimbitSignal(int)), tab_advanced,SLOT(UpdateTrimbitPlot(int)));
// Plotting
// When the acquisition is finished, must update the meas tab
connect(myPlot, SIGNAL(UpdatingPlotFinished()), this, SLOT(EnableTabs()));
connect(myPlot, SIGNAL(UpdatingPlotFinished()), tab_measurement, SLOT(UpdateFinished()));
//This should not be called as it will change file name to measurement when run finished
//connect(myPlot, SIGNAL(UpdatingPlotFinished()), tab_plot, SLOT(Refresh()));
connect(myPlot, SIGNAL(SetCurrentMeasurementSignal(int)), tab_measurement, SLOT(SetCurrentMeasurement(int)));
// menubar
// Modes Menu
connect(menuModes, SIGNAL(triggered(QAction*)), this,SLOT(EnableModes(QAction*)));
// Utilities Menu
connect(menuUtilities, SIGNAL(triggered(QAction*)), this,SLOT(ExecuteUtilities(QAction*)));
// Help Menu
connect(menuHelp, SIGNAL(triggered(QAction*)), this,SLOT(ExecuteHelp(QAction*)));
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qDetectorMain::LoadConfigFile(const string fName){
#ifdef VERBOSE
cout << "Loading config file at start up:" << fName << endl;
#endif
QString file = QString(fName.c_str());//.section('/',-1);
if((file.contains('.'))&&(QFile::exists(file))){
if(myDet->readConfigurationFile(fName)!=slsDetectorDefs::FAIL)
qDefs::Message(qDefs::INFORMATION,"<nobr>The Configuration Parameters have been loaded successfully at start up.</nobr>","Main");
else qDefs::Message(qDefs::WARNING,string("<nobr>Could not load the Configuration Parameters at start up from file:</nobr><br><nobr>")+fName,"Main");
}else qDefs::Message(qDefs::WARNING,string("<nobr>Start up configuration failed to load. The following file does not exist:</nobr><br><nobr>")+fName,"Main");
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qDetectorMain::EnableModes(QAction *action){
bool enable;
//Set DebugMode
if(action==actionDebug){
enable = actionDebug->isChecked();
tabs->setTabEnabled(Debugging,enable);
#ifdef VERBOSE
cout << "Setting Debug Mode to " << enable << endl;
#endif
}
//Set ExpertMode(comes here only if its a digital detector)
else if(action==actionExpert){
enable = actionExpert->isChecked();
tabs->setTabEnabled(Advanced,enable);
actionLoadTrimbits->setVisible(enable);
actionSaveTrimbits->setVisible(enable);
actionLoadCalibration->setVisible(enable);
actionSaveCalibration->setVisible(enable);
tab_measurement->SetExpertMode(enable);
tab_settings->SetExpertMode(enable);
#ifdef VERBOSE
cout << "Setting Expert Mode to " << enable << endl;
#endif
}
//Set DockableMode
else{
enable = actionDockable->isChecked();
if(enable)
dockWidgetPlot->setFeatures(QDockWidget::DockWidgetFloatable);
else{
dockWidgetPlot->setFloating(false);
dockWidgetPlot->setFeatures(QDockWidget::NoDockWidgetFeatures);
}
#ifdef VERBOSE
cout << "Setting Dockable Mode to " << enable << endl;
#endif
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qDetectorMain::ExecuteUtilities(QAction *action){
if(action==actionOpenSetup){
#ifdef VERBOSE
cout << "Loading Setup" << endl;
#endif
QString fName = QString(myDet->getFilePath().c_str());
fName = QFileDialog::getOpenFileName(this,
tr("Load Detector Setup"),fName,
tr("Detector Setup files (*.det)"));
// Gets called when cancelled as well
if (!fName.isEmpty()){
if(myDet->retrieveDetectorSetup(string(fName.toAscii().constData()))!=slsDetectorDefs::FAIL)
qDefs::Message(qDefs::INFORMATION,"The Setup Parameters have been loaded successfully.","Main");
else qDefs::Message(qDefs::WARNING,string("Could not load the Setup Parameters from file:\n")+fName.toAscii().constData(),"Main");
}
}
else if(action==actionSaveSetup){
#ifdef VERBOSE
cout << "Saving Setup" << endl;
#endif
QString fName = QString(myDet->getFilePath().c_str());
fName = QFileDialog::getSaveFileName(this,
tr("Save Current Detector Setup"),fName,
tr("Detector Setup files (*.det) "));
// Gets called when cancelled as well
if (!fName.isEmpty()){
if(myDet->dumpDetectorSetup(string(fName.toAscii().constData()))!=slsDetectorDefs::FAIL)
qDefs::Message(qDefs::INFORMATION,"The Setup Parameters have been saved successfully.","Main");
else qDefs::Message(qDefs::WARNING,string("Could not save the Setup Parameters from file:\n")+fName.toAscii().constData(),"Main");
}
}
else if(action==actionOpenConfiguration){
#ifdef VERBOSE
cout << "Loading Configuration" << endl;
#endif
QString fName = QString(myDet->getFilePath().c_str());
fName = QFileDialog::getOpenFileName(this,
tr("Load Detector Configuration"),fName,
tr("Configuration files (*.config)"));
// Gets called when cancelled as well
if (!fName.isEmpty()){
if(myDet->readConfigurationFile(string(fName.toAscii().constData()))!=slsDetectorDefs::FAIL)
qDefs::Message(qDefs::INFORMATION,"The Configuration Parameters have been configured successfully.","Main");
else qDefs::Message(qDefs::WARNING,string("Could not load the Configuration Parameters from file:\n")+fName.toAscii().constData(),"Main");
}
}
else if(action==actionSaveConfiguration){
#ifdef VERBOSE
cout << "Saving Configuration" << endl;
#endif
QString fName = QString(myDet->getFilePath().c_str());
fName = QFileDialog::getSaveFileName(this,
tr("Save Current Detector Configuration"),fName,
tr("Configuration files (*.config) "));
// Gets called when cancelled as well
if (!fName.isEmpty()){
if(myDet->writeConfigurationFile(string(fName.toAscii().constData()))!=slsDetectorDefs::FAIL)
qDefs::Message(qDefs::INFORMATION,"The Configuration Parameters have been saved successfully.","Main");
else qDefs::Message(qDefs::WARNING,string("Could not save the Configuration Parameters from file:\n")+fName.toAscii().constData(),"Main");
}
}
else if(action==actionLoadTrimbits){
QString fName = QString(myDet->getSettingsDir());
//gotthard
if(actionLoadTrimbits->text().contains("Settings")){
#ifdef VERBOSE
cout << "Loading Settings" << endl;
#endif
fName = QFileDialog::getOpenFileName(this,
tr("Load Detector Settings"),fName,
tr("Settings files (*.settings settings.sn*)"));
// Gets called when cancelled as well
if (!fName.isEmpty()){
if(myDet->loadSettingsFile(string(fName.toAscii().constData()),-1)!=slsDetectorDefs::FAIL)
qDefs::Message(qDefs::INFORMATION,"The Settings have been loaded successfully.","Main");
else qDefs::Message(qDefs::WARNING,string("Could not load the Settings from file:\n")+fName.toAscii().constData(),"Main");
}
}//mythen and eiger
else{
#ifdef VERBOSE
cout << "Loading Trimbits" << endl;
#endif
fName = QFileDialog::getOpenFileName(this,
tr("Load Detector Trimbits"),fName,
tr("Trimbit files (*.trim noise.sn*)"));
// Gets called when cancelled as well
if (!fName.isEmpty()){
if(myDet->loadSettingsFile(string(fName.toAscii().constData()),-1)!=slsDetectorDefs::FAIL)
qDefs::Message(qDefs::INFORMATION,"The Trimbits have been loaded successfully.","Main");
else qDefs::Message(qDefs::WARNING,string("Could not load the Trimbits from file:\n")+fName.toAscii().constData(),"Main");
}
}
}
else if(action==actionSaveTrimbits){
//gotthard
if(actionLoadTrimbits->text().contains("Settings")){
#ifdef VERBOSE
cout << "Saving Settings" << endl;
#endif
//different output directory so as not to overwrite
QString fName = QString(myDet->getSettingsDir());
fName = QFileDialog::getSaveFileName(this,
tr("Save Current Detector Settings"),fName,
tr("Settings files (*.settings settings.sn*) "));
// Gets called when cancelled as well
if (!fName.isEmpty()){
if(myDet->saveSettingsFile(string(fName.toAscii().constData()),-1)!=slsDetectorDefs::FAIL)
qDefs::Message(qDefs::INFORMATION,"The Settings have been saved successfully.","Main");
else qDefs::Message(qDefs::WARNING,string("Could not save the Settings to file:\n")+fName.toAscii().constData(),"Main");
}
}//mythen and eiger
else{
#ifdef VERBOSE
cout << "Saving Trimbits" << endl;
#endif//different output directory so as not to overwrite
QString fName = QString(myDet->getSettingsDir());
fName = QFileDialog::getSaveFileName(this,
tr("Save Current Detector Trimbits"),fName,
tr("Trimbit files (*.trim noise.sn*) "));
// Gets called when cancelled as well
if (!fName.isEmpty()){
if(myDet->saveSettingsFile(string(fName.toAscii().constData()),-1)!=slsDetectorDefs::FAIL)
qDefs::Message(qDefs::INFORMATION,"The Trimbits have been saved successfully.","Main");
else qDefs::Message(qDefs::WARNING,string("Could not save the Trimbits to file:\n")+fName.toAscii().constData(),"Main");
}
}
}
else if(action==actionLoadCalibration){
#ifdef VERBOSE
cout << "Loading Calibration Data" << endl;
#endif
QString fName = QString(myDet->getCalDir());
fName = QFileDialog::getOpenFileName(this,
tr("Load Detector Calibration Data"),fName,
tr("Calibration files (*.cal calibration.sn*)"));
// Gets called when cancelled as well
if (!fName.isEmpty()){
if(myDet->loadCalibrationFile(string(fName.toAscii().constData()),-1)!=slsDetectorDefs::FAIL)
qDefs::Message(qDefs::INFORMATION,"The Calibration Data have been loaded successfully.","Main");
else qDefs::Message(qDefs::WARNING,string("Could not load the Calibration data from file:\n")+ fName.toAscii().constData(),"Main");
}
}
else if(action==actionSaveCalibration){
#ifdef VERBOSE
cout << "Saving Calibration Data" << endl;
#endif//different output directory so as not to overwrite
QString fName = QString(myDet->getCalDir());
fName = QFileDialog::getSaveFileName(this,
tr("Save Current Detector Calibration Data"),fName,
tr("Calibration files (*.cal calibration.sn*) "));
// Gets called when cancelled as well
if (!fName.isEmpty()){
if(myDet->saveCalibrationFile(string(fName.toAscii().constData()),-1)!=slsDetectorDefs::FAIL)
qDefs::Message(qDefs::INFORMATION,"The Calibration Data have been saved successfully.","Main");
else qDefs::Message(qDefs::WARNING,string("Could not save the Calibration data to file:\n")+fName.toAscii().constData(),"Main");
}
}
Refresh(tabs->currentIndex());
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qDetectorMain::ExecuteHelp(QAction *action){
if(action==actionAbout){
#ifdef VERBOSE
cout << "About: Common GUI for Mythen, Eiger, Gotthard and Agipd detectors" << endl;
#endif
char version[200];
sprintf(version,"%llx",myDet->getId(slsDetectorDefs::THIS_SOFTWARE_VERSION));
string thisClientVersion = string(version);
//<h1 style="font-family:verdana;">A heading</h1>
qDefs::Message(qDefs::INFORMATION,"<p style=\"font-family:verdana;\">"
"SLS Detector GUI version: " + string(QString("%1").arg(GUI_VERSION).toAscii().constData())+"<br>"
"SLS Detector Client version: "+thisClientVersion+"<br><br>"
"Common GUI to control the SLS Detectors: "
"Mythen, Eiger, Gotthard and Agipd.<br><br>"
"It can be operated in parallel with the command line interface:<br>"
"sls_detector_put,<br>sls_detector_get,<br>sls_detector_acquire and<br>sls_detector_help.<br><br>"
"The GUI Software is still in progress. "
"Please report bugs to dhanya.maliakal@psi.ch or anna.bergamaschi@psi.ch.<\\p>","About SLS Detector GUI");
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qDetectorMain::Refresh(int index){
if(!tabs->isTabEnabled(index))
tabs->setCurrentIndex((index++)<(tabs->count()-1)?index:Measurement);
else{
switch(tabs->currentIndex()){
case Measurement: tab_measurement->Refresh(); break;
case Settings: tab_settings->Refresh(); break;
case DataOutput: tab_dataoutput->Refresh(); break;
case Plot: tab_plot->Refresh(); break;
case Actions: tab_actions->Refresh(); break;
case Advanced: tab_advanced->Refresh(); break;
case Debugging: tab_debugging->Refresh(); break;
case Developer: tab_developer->Refresh(); break;
case Messages: break;
}
}
for(int i=0;i<NumberOfTabs;i++)
tabs->tabBar()->setTabTextColor(i,defaultTabColor);
tabs->tabBar()->setTabTextColor(index,QColor(0,0,200,255));
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qDetectorMain::ResizeMainWindow(bool b){
#ifdef VERBOSE
cout << "Resizing Main Window: height:" << height() << endl;
#endif
// undocked from the main window
if(b){
// sets the main window height to a smaller maximum to get rid of space
setMaximumHeight(height()-heightPlotWindow-9);
dockWidgetPlot->setMinimumHeight(0);
cout << "undocking it from main window" << endl;
}
else{
setMaximumHeight(QWIDGETSIZE_MAX);
// the minimum for plot will be set when the widget gets resized automatically
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qDetectorMain::resizeEvent(QResizeEvent* event){
if(!dockWidgetPlot->isFloating()){
if(tabs->currentIndex()== Actions){
dockWidgetPlot->setMinimumHeight(heightPlotWindow-100);
centralwidget->setMaximumHeight(QWIDGETSIZE_MAX);
}
else{
dockWidgetPlot->setMinimumHeight(height()-centralwidget->height()-50);
centralwidget->setMaximumHeight(heightCentralWidget);
}
}
//adjusting tab width
if(width()>=800){ tabs->tabBar()->setFixedWidth(width()+61);}
else { tabs->tabBar()->setMinimumWidth(0);
tabs->tabBar()->setExpanding(true);
tabs->tabBar()->setUsesScrollButtons(true);
}
event->accept();
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qDetectorMain::EnableTabs(){
#ifdef VERBOSE
cout << "Entering EnableTabs function" << endl;
#endif
bool enable;
enable=!(tabs->isTabEnabled(DataOutput));
// or use the Enable/Disable button
// normal tabs
tabs->setTabEnabled(DataOutput,enable);
tabs->setTabEnabled(Actions,enable);
tabs->setTabEnabled(Settings,enable);
tabs->setTabEnabled(Messages,enable);
//actions check
actionOpenSetup->setEnabled(enable);
actionSaveSetup->setEnabled(enable);
actionOpenConfiguration->setEnabled(enable);
actionSaveConfiguration->setEnabled(enable);
actionMeasurementWizard->setEnabled(enable);
actionDebug->setEnabled(enable);
actionExpert->setEnabled(enable);
// special tabs
tabs->setTabEnabled(Debugging,enable && (actionDebug->isChecked()));
tabs->setTabEnabled(Developer,enable && isDeveloper);
//expert
bool expertTab = enable && (actionExpert->isChecked());
tabs->setTabEnabled(Advanced,expertTab);
actionLoadTrimbits->setVisible(expertTab);
actionSaveTrimbits->setVisible(expertTab);
actionLoadCalibration->setVisible(expertTab);
actionSaveCalibration->setVisible(expertTab);
//moved to here, so that its all in order, instead of signals and different threads
if(!enable) {
//set the plot type first(acccss shared memory)
tab_plot->SetScanArgument();
//sets running to true
myPlot->StartStopDaqToggle();
}
else//to enable scan box
tab_plot->Refresh();
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
void qDetectorMain::SetZoomToolTip(bool disable){
if(disable)
dockWidgetPlot->setToolTip("<span style=\" color:#00007f;\">To Enable mouse-controlled zooming capabilities,\ndisable min and max for all axes.<span> ");
else
dockWidgetPlot->setToolTip(zoomToolTip);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
View Git Blame Copy Permalink