def __init__(self, parent=None):
""" Init
"""
# call base
QDialog.__init__(self)
# parent
self._myParent = parent
# set up UI
ui_path = os.path.join(os.path.dirname(__file__), "gui/LogSnapView.ui")
self.ui = load_ui(ui_path, baseinstance=self)
self._promote_widgets()
# Event handling
self.ui.pushButton_apply.clicked.connect(self.do_apply_change)
self.ui.pushButton_saveQuit.clicked.connect(self.do_save_quit)
self.ui.pushButton_cancel.clicked.connect(self.do_quit_no_save)
# Class state variables
self._slicerIsSaved = False
self._currSessionDiscardable = True
self._logName = None
self._myRunNumber = None
# Controller variables
self._myWorkflowController = None
self._horizontalIndicatorList = None
self._verticalIndicatorList = [None, None]
return
def __init__(self, parent=None):
""" Init
"""
# base class initialization
super(AtomicReduced1DViewer, self).__init__(parent)
self._parent = parent
# set up UI
ui_path = os.path.join(os.path.dirname(__file__),
"gui/SimpleReducedDataView.ui")
self.ui = load_ui(ui_path, baseinstance=self)
self._promote_widgets()
# set X: no line edits for X range
self._x_min = None
self._x_max = None
# set X
self.ui.pushButton_setXRange.clicked.connect(self.do_set_x_range)
self.ui.pushButton_setYRange.clicked.connect(self.do_set_y_range)
self.ui.pushButton_removeLine.clicked.connect(self.do_remove_line)
self.ui.pushButton_addLine.clicked.connect(self.do_add_line)
self.ui.pushButton_saveData.clicked.connect(self.do_save_data)
self.ui.actionQuit.triggered.connect(self.do_quit)
# list of plot IDs for add/remove
self._plot_id_dict = dict() # [run, (chop-sq)] = plot ID
self._plot_id_list = list() # for any non-registered plot
self._norm_proton_charge = False # normalized by proton charge
self._van_number = None # normalized by vanadium or not
self._run_ipts_map = dict() # [run number] = IPTS number
return
def __init__(self, parent=None):
""" Init
"""
# call base
QWidget.__init__(self)
# Parent & others
self._myMainWindow = None
self._myParent = parent
# set up UI
ui_path = os.path.join(os.path.dirname(__file__), "WorkspacesView.ui")
self.ui = load_ui(ui_path, baseinstance=self)
self._promote_widgets()
self.ui.tableWidget_dataStructure.setup()
self.ui.widget_ipython.set_main_application(self)
# define event handling methods
# TODO - FUTURE - self.ui.pushButton_plot.clicked.connect(self.do_plot_workspace)
self.ui.pushButton_toIPython.clicked.connect(
self.do_write_workspace_name)
self.ui.pushButton_toIPythonMtd.clicked.connect(
self.do_write_workspace_instance)
self.ui.pushButton_toIPythonAssign.clicked.connect(
self.do_assign_workspace)
self.ui.pushButton_clear.clicked.connect(self.do_clear_canvas)
self.ui.pushButton_fitCanvas.clicked.connect(self.do_fit_canvas)
return
def __init__(self, parent):
"""
Initialization
:param parent:
"""
QMainWindow.__init__(self)
ui_path = os.path.join(os.path.dirname(__file__), "gui/import.ui")
self.ui = load_ui(ui_path, baseinstance=self)
# Define event handling
self.connect(self.ui.pushButton_applyIPTS, QtCore.SIGNAL('clicked()'),
self.do_apply_ipts_config)
self.connect(self.ui.pushButton_cancelQuit, QtCore.SIGNAL('clicked()'),
self.do_quit)
# class variables
self._myController = None
# configuration information (global)
self._rootDataDir = None
self._workingDir = None
self._dataAccessPatten = None
self._relativeGSASDir = None
# configuration for IPTS
self._currentIPTS = None
self._iptsDataDir = None
self._iptsGSSDir = None
return
def __init__(self, parent):
"""
Initialization
:param parent:
"""
# check
assert parent is not None, 'Parent (window) cannot be None!'
# call base class init
super(GroupPeakDialog, self).__init__(parent)
# set up parent window
self._parentWindow = parent
# set up UI
ui_path = os.path.join(os.path.dirname(__file__),
"gui/GroupPeakDialog.ui")
self.ui = load_ui(ui_path, baseinstance=self)
# init set up of widgets
self.ui.radioButton_highIntensity.setChecked(True)
self.ui.lineEdit_numberFWHM.setText('6')
# line event handlers
self.ui.pushButton_groupPeaks.clicked.connect(self.do_group_peaks)
self.ui.pushButton_addPeakReturn.clicked.connect(
self.do_add_peak_return)
self.ui.pushButton_cancel.clicked.connect(self.do_cancel_return)
# hide widgets that is unused but may be needed in future
self.ui.pushButton_clearGroup.hide()
return
def __init__(self, parent):
"""
Init ...
:return:
"""
# Initialize
QDialog.__init__(self, parent)
ui_path = os.path.join(os.path.dirname(__file__),
'gui/PeakWidthSetup.ui')
self.ui = load_ui(ui_path, baseinstance=self)
# Define event handlers
self.ui.pushButton_cancel.clicked.connect(self.do_quit)
self.ui.pushButton_set.clicked.connect(self.do_set_width)
# self.connect(self.ui.pushButton_cancel, QtCore.SIGNAL('clicked()'),
# self.do_quit)
# self.connect(self.ui.pushButton_set, QtCore.SIGNAL('clicked()'),
# self.do_set_width)
# Class variables
self._peakWidth = None
return
def __init__(self, parent=None):
""" Initialization
:param parent:
"""
super(SampleLogPlotSetupDialog, self).__init__(parent)
ui_path = os.path.join(os.path.dirname(__file__),
"gui/LiveDataGPPlotSetup.ui")
self.ui = load_ui(ui_path, baseinstance=self)
self._promote_widgets()
# init widget
self._init_widgets()
# link
self.ui.pushButton_quit.clicked.connect(self.do_quit)
self.ui.pushButton_apply.clicked.connect(self.do_apply)
# push buttons to set up
self.ui.pushButton_addPeakParam.clicked.connect(self.do_add_peak_param)
self.ui.pushButton_addSampleLog.clicked.connect(self.do_add_sample_log)
# other parameters
self.ui.pushButton_remove.clicked.connect(self.do_remove_item)
self.ui.pushButton_clear.clicked.connect(self.do_clear_selected_items)
self.ui.pushButton_filterLog.clicked.connect(
self.do_filter_sample_logs)
# self.connect(self.ui.pushButton_quit, QtCore.SIGNAL('clicked()'),
# self.do_quit)
# self.connect(self.ui.pushButton_apply, QtCore.SIGNAL('clicked()'),
# self.do_apply)
#
# # push buttons to set up
# self.connect(self.ui.pushButton_addPeakParam, QtCore.SIGNAL('clicked()'),
# self.do_add_peak_param)
# self.connect(self.ui.pushButton_addSampleLog, QtCore.SIGNAL('clicked()'),
# self.do_add_sample_log)
#
# # other parameters
# self.connect(self.ui.pushButton_remove, QtCore.SIGNAL('clicked()'),
# self.do_remove_item)
# self.connect(self.ui.pushButton_clear, QtCore.SIGNAL('clicked()'),
# self.do_clear_selected_items)
# self.connect(self.ui.pushButton_filterLog, QtCore.SIGNAL('clicked()'),
# self.do_filter_sample_logs)
# other class variable
self._myControlWindow = parent # real parent window launch this dialog
if parent is not None:
self.PlotSignal.connect(self._myControlWindow.plot_log_live)
# a record for being selected
self._selectedParameters = list()
# keep a copy of sample logs added
self._sampleLogsList = list()
return
def __init__(self, parent=None):
"""
Init
:param parent:
"""
super(AtomicReduction3DViewer, self).__init__(parent)
# set up UI
ui_path = os.path.join(os.path.dirname(__file__),
'gui/Simple2DReductionView.ui')
self.ui = load_ui(ui_path, baseinstance=self)
self._promote_widgets()
return
def __init__(self, parent, run_number, raw_file_name):
"""
Initialization
:param parent:
"""
# base class init
super(QuickChopDialog, self).__init__(parent)
# init UI
ui_path = os.path.join(os.path.dirname(__file__), "gui/ChopDialog.ui")
self.ui = load_ui(ui_path, baseinstance=self)
# set up the default value of the widgets
self.ui.lineEdit_runNumber.setText(str(run_number))
self.ui.lineEdit_sourceFile.setText(str(raw_file_name))
self.ui.radioButton_saveToArbitrary.setChecked(False)
self.ui.radioButton_saveToArchive.setChecked(True)
self.ui.lineEdit_outputDir.setEnabled(False)
self.ui.pushButton_browse.setEnabled(False)
self.ui.radioButton_chopOnly.setChecked(True)
self.ui.radioButton_chopReduce.setChecked(True)
# default output directory
self.ui.lineEdit_outputDir.setText(os.getcwd())
# set up event handlers
self.ui.pushButton_browse.clicked.connect(self.do_browse_output)
self.ui.radioButton_saveToArbitrary.toggled.connect(
self.event_save_to_changed)
self.ui.radioButton_saveToArchive.toggled.connect(
self.event_save_to_changed)
self.ui.buttonBox.accepted.connect(self.do_chop)
self.ui.buttonBox.rejected.connect(self.do_quit)
# self.connect(self.ui.buttonBox, QtCore.SIGNAL('accepted()'),
# self.do_chop)
# self.connect(self.ui.pushButton_browse, QtCore.SIGNAL('clicked()'),
# self.do_browse_output)
# self.connect(self.ui.buttonBox, QtCore.SIGNAL('rejected()'),
# self.do_quit)
#
# self.connect(self.ui.radioButton_saveToArbitrary, QtCore.SIGNAL('toggled(bool)'),
# self.event_save_to_changed)
# self.connect(self.ui.radioButton_saveToArchive, QtCore.SIGNAL('toggled(bool)'),
# self.event_save_to_changed)
return
def __init__(self, parent):
"""
init
:param parent:
"""
super(VulcanExperimentRecordView, self).__init__(parent)
ui_path = os.path.join(os.path.dirname(__file__), "gui/ExperimentRecord.ui")
self.ui = load_ui(ui_path, baseinstance=self)
self._promote_widgets()
self.ui.tableWidget_recordsInfoTable.setup()
return
def __init__(self, parent):
"""
initialization
:param parent: parent window
"""
super(ManualSlicerSetupTableDialog, self).__init__(parent)
self._myParent = parent
ui_path = os.path.join(os.path.dirname(__file__),
"gui/ManualSlicerTable.ui")
self.ui = load_ui(ui_path, baseinstance=self)
self._promote_widgets()
self._init_widgets()
# define widgets' event handling
self.ui.pushButton_selectAll.clicked.connect(self.do_select_all_rows)
self.ui.pushButton_expand2ndLevelChop.clicked.connect(
self.do_expand_slicers)
self.ui.pushButton_applyTimeSegs.clicked.connect(self.do_apply_slicers)
self.ui.pushButton_saveTimeSegs.clicked.connect(
self.do_save_slicers_to_file)
self.ui.pushButton_loadSlicerFromFile.clicked.connect(
self.do_load_slicers_from_file)
self.ui.pushButton_hide.clicked.connect(self.do_hide_window)
self.ui.pushButton_deselectAll.clicked.connect(self.do_set_target)
# tab-plot cyclic slicers
self.ui.pushButton_set1.clicked.connect(self.do_set_show_target_1)
self.ui.pushButton_showSlicers.clicked.connect(
self.do_show_cyclic_slicers)
self.ui.pushButton_hideSlicers.clicked.connect(
self.do_hide_cyclic_slicers)
# FIXME / FUTURE : it is not well defined to remove a slicer from table and reflected to pickers on plotting
# self.connect(self.ui.pushButton_deleteSlicer, QtCore.SIGNAL('clicked()'),
# self.do_delete_slicer)
self.ui.pushButton_deleteSlicer.setEnabled(False)
# define handler to signals
# TODO/ISSUE/NEXT - Implement this
return
def __init__(self, parent=None):
"""
Init
:param parent:
"""
super(AtomicReduction2DViewer, self).__init__(parent)
# set up UI
ui_path = os.path.join(os.path.dirname(__file__),
'gui/Simple2DReductionView.ui')
self.ui = load_ui(ui_path, baseinstance=self)
self._promote_widgets()
self.ui.pushButton_setXrange.clicked.connect(self.do_set_x_range)
return
def __init__(self):
"""
"""
super(LauncherManager, self).__init__(None)
# set up UI: it is tricky
script_dir = os.path.dirname(__file__)
dir_names = os.listdir('{}/..'.format(script_dir))
print(f'dir names: {dir_names}')
lib_dir = None
for dir_name in dir_names:
if dir_name.startswith('lib'):
lib_dir = dir_name
if lib_dir is None:
ui_dir = os.path.join(script_dir, '../pyvdrive/interface/gui')
else:
ui_dir = os.path.join(
script_dir, '../{}/pyvdrive/interface/gui'.format(lib_dir))
ui_path = os.path.join(ui_dir, 'LaunchManager.ui')
self.ui = load_ui(ui_path, baseinstance=self)
# init widgets
self.ui.checkBox_keepOpen.setChecked(True)
# define event handlers
self.ui.pushButton_quit.clicked.connect(self.do_exit)
self.ui.pushButton_vdrivePlot.clicked.connect(self.do_launch_vdrive)
self.ui.pushButton_choppingHelper.clicked.connect(
self.do_launch_chopper)
self.ui.pushButton_peakProcessing.clicked.connect(
self.do_launch_peak_picker)
self.ui.pushButton_reducedDataViewer.clicked.connect(
self.do_launch_viewer)
self.ui.pushButton_terminal.clicked.connect(self.do_launch_terminal)
# initialize main window (may not be shown though)
self._mainReducerWindow = VdriveMainWindow(
) # the main ui class in this file is called MainWindow
self._myPeakPickerWindow = None
self._myLogPickerWindow = None
return
def __init__(self, parent):
""" Set up main window
"""
# Init & set up GUI
QMainWindow.__init__(self, parent)
ui_path = os.path.join(os.path.dirname(__file__), "gui/import.ui")
self.ui = load_ui(ui_path, baseinstance=self)
# Set up class variable
self._myParent = parent
self._myProjectName = ""
self._myIPTS = None
self._currRowIndex = -1
self._numRows = 0
# Widget handlers
self.ui.pushButton_selectAll.clicked.connect(self.doSelectAll)
self.ui.pushButton_clear.clicked.connect(self.doClearAllSelection)
self.ui.pushButton_exitToReduce.clicked.connect(
self.doQuitContinueReduce)
# self.connect(self.ui.pushButton_selectAll, QtCore.SIGNAL('clicked()'),
# self.doSelectAll)
#
# self.connect(self.ui.pushButton_clear, QtCore.SIGNAL('clicked()'),
# self.doClearAllSelection)
#
# self.connect(self.ui.pushButton_exitToReduce, QtCore.SIGNAL('clicked()'),
# self.doQuitContinueReduce)
# Signal handlers
if self._myParent is not None:
self.mySelectSignal.connect(self._myParent.evtReduceData)
return
def __init__(self, parent):
"""
initialization
:param parent:
"""
# call base
super(LiveViewSetupDialog, self).__init__(parent)
# my parent
self._myParent = parent
# set up UI
ui_path = os.path.join(os.path.dirname(__file__),
"gui/LiveDataViewSetup.ui")
self.ui = load_ui(ui_path, baseinstance=self)
self._promote_widgets()
# initialize some widget
self.ui.radioButton_plotAcc.setChecked(True)
self.ui.radioButton_plotRun.setChecked(False)
# define the event handlers
self.ui.pushButton_setRefreshRate.clicked.connect(
self.do_set_refresh_rate)
self.ui.pushButton_setLiveUpdate.clicked.connect(self.do_set_acc_plot)
self.ui.pushButton_setupMix2D.clicked.connect(self.do_set_run_view)
self.ui.pushButton_quit.clicked.connect(self.do_quit)
self.ui.pushButton_browseGSS.clicked.connect(self.do_browse_van_gss)
self.ui.pushButton_loadGSS.clicked.connect(self.do_load_van_gss)
self.ui.radioButton_plotRun.toggled.connect(self.toggle_options)
# self.ui.radioButton_plotAcc.toggled.connect(self.toggle_options)
# set up every in last step
self.toggle_options()
return
def __init__(self, parent):
"""
Initialization
:param parent: main GUI window for controller
"""
QDialog.__init__(self)
# Parent
assert getattr(parent, 'get_controller', None) is not None, 'Parent method' \
'has not method get_controller()'
self._myParent = parent
# other parameters
self.quit = False
# Set up widgets
ui_path = os.path.join(os.path.dirname(__file__), "gui/import.ui")
self.ui = load_ui(ui_path, baseinstance=self)
# Initialize widgets
self._init_widgets()
# Set event handler
# group to add archive IPTS
self.ui.radioButton_useNumber.toggled.connect(self.evt_change_data_access_mode)
self.ui.radioButton_useDir.toggled.connect(self.evt_change_data_access_mode)
self.ui.pushButton_browse.clicked.connect(self.do_browse_data_directory)
self.ui.pushButton_addArchiveIPTS.clicked.connect(self.do_add_archive_ipts)
# self.connect(self.ui.radioButton_useNumber, QtCore.SIGNAL('toggled(bool)'),
# self.evt_change_data_access_mode)
# self.connect(self.ui.radioButton_useDir, QtCore.SIGNAL('toggled(bool)'),
# self.evt_change_data_access_mode)
# QtCore.QObject.connect(self.ui.pushButton_browse, QtCore.SIGNAL('clicked()'),
# self.do_browse_data_directory)
# QtCore.QObject.connect(self.ui.pushButton_addArchiveIPTS, QtCore.SIGNAL('clicked()'),
# self.do_add_archive_ipts)
# group to add local HDD data
self.ui.pushButton_addLocalHDDDir.clicked.connect(self.do_add_hdd_data)
self.ui.pushButton_browseLogFile.clicked.connect(self.do_browse_record_file)
# group to add runs
self.ui.pushButton_AddRuns.clicked.connect(self.do_add_runs)
self.ui.radioButton_filterByRun.toggled.connect(self.evt_change_filter_mode)
self.ui.radioButton_filterByDate.toggled.connect(self.evt_change_filter_mode)
# controllers
self.ui.pushButton_return.clicked.connect(self.do_quit_app)
# self.connect(self.ui.pushButton_addLocalHDDDir, QtCore.SIGNAL('clicked()'),
# self.do_add_hdd_data)
# self.connect(self.ui.pushButton_browseLogFile, QtCore.SIGNAL('clicked()'),
# self.do_browse_record_file)
#
# # group to add runs
# QtCore.QObject.connect(self.ui.pushButton_AddRuns, QtCore.SIGNAL('clicked()'),
# self.do_add_runs)
# self.connect(self.ui.radioButton_filterByRun, QtCore.SIGNAL('toggled(bool)'),
# self.evt_change_filter_mode)
# self.connect(self.ui.radioButton_filterByDate, QtCore.SIGNAL('toggled(bool'),
# self.evt_change_filter_mode)
#
# # controllers
# QtCore.QObject.connect(self.ui.pushButton_return, QtCore.SIGNAL('clicked()'),
# self.do_quit_app)
# Init setup for starting date and run
self._beginDate = '01/01/2000'
today = datetime.date.today()
self._endDate = '%02d/%02d/%02d' % (today.month, today.day, today.year)
self._beginRunNumber = 0
self._endRunNumber = 999999999999
# Data set
self._iptsNumber = 0
self._iptsDir = None
self._iptsDirFromNumber = ''
self._iptsDirFromDir = ''
self._dataDir = None
self._homeDir = os.path.expanduser('~')
self._isArchiveAccessible = False
# key to access IPTS from archive
self._archiveKey = None
self._skipScanData = False
return
def __init__(self, parent):
""" Set up main window
"""
# Init & set up GUI
super(VanadiumProcessControlDialog, self).__init__(parent)
self._myParent = parent
# stored default parameters
self._defaultDict = dict()
# other class variables
self._inInteractiveMode = False # flag for being in interactive vanadium smoothing mode
# mutex
self._slidersMutex = False # mutex for sliders
# class variables
self._min_smooth_n = 2 # 1 is the lower boundary for minimum smooth N
self._max_smooth_n = None
self._min_smooth_order = 1 # 1 is the lower boundary for minimum smooth order
self._max_smooth_order = None
# setup UI
ui_path = os.path.join(os.path.dirname(__file__),
"gui/ProcessVanadiumDialog.ui")
self.ui = load_ui(ui_path, baseinstance=self)
# initialize the widgets' initial value
self._init_widgets()
# define event handling
# tab for peak striping
self.ui.pushButton_stripVanadiumPeaks.clicked.connect(
self.do_strip_vanadium_peaks)
self.ui.pushButton_undoPeakStrip.clicked.connect(self.do_undo_strip)
self.ui.pushButton_setPeakStripParamToDefaults.clicked.connect(
self.do_restore_peak_strip_parameters)
self.ui.pushButton_savePeakStripParamAsDefaults.clicked.connect(
self.do_save_peak_strip_parameters)
# self.ui.pushButton_showVPeaks.clicked.connect(self.do_show_vanadium_peaks)
self.ui.pushButton_nDecrease.clicked.connect(self.do_decrease_smooth_n)
self.ui.pushButton_nIncrease.clicked.connect(self.do_increase_smooth_n)
self.ui.pushButton_orderDecrease.clicked.connect(
self.do_decrease_smooth_order)
self.ui.pushButton_orderIncrease.clicked.connect(
self.do_increase_smooth_order)
# TODO - 20181103 - Implement: self.ui.comboBox_banks currentIndexChange: re-plot
# tab for smoothing vanadium
self.ui.pushButton_smoothVanadium.clicked.connect(
self.do_smooth_vanadium)
self.ui.pushButton_undoSmooth.clicked.connect(
self.do_undo_smooth_vanadium)
self.ui.pushButton_setPeakStripParamToDefaults.clicked.connect(
self.do_restore_smooth_vanadium_parameters)
self.ui.pushButton_saveSmoothParamAsDefaults.clicked.connect(
self.do_save_vanadium_smooth_parameters)
self.ui.pushButton_setSmoothNRange.clicked.connect(
self.do_set_smooth_n_range)
self.ui.pushButton_setSmoothOrderRange.clicked.connect(
self.do_set_smooth_order_range)
self.ui.lineEdit_smoothParameterN.textChanged.connect(
self.evt_smooth_vanadium)
self.ui.lineEdit_smoothParameterOrder.textChanged.connect(
self.evt_smooth_vanadium)
self.ui.horizontalSlider_smoothN.valueChanged.connect(
self.evt_smooth_param_changed)
self.ui.horizontalSlider_smoothOrder.valueChanged.connect(
self.evt_smooth_param_changed)
# final
self.ui.pushButton_applyVanProcessResult.clicked.connect(
self.do_save_result)
self.ui.pushButton_quit.clicked.connect(self.do_quit)
# define signal
self.myStripPeakSignal.connect(
self._myParent.signal_strip_vanadium_peaks)
self.myUndoStripPeakSignal.connect(
self._myParent.signal_undo_strip_van_peaks)
self.mySmoothVanadiumSignal.connect(
self._myParent.signal_smooth_vanadium)
self.myUndoSmoothVanadium.connect(
self._myParent.signal_smooth_vanadium)
self.myApplyResultSignal.connect(
self._myParent.signal_save_processed_vanadium)
self.myShowVPeaksSignal.connect(
self._myParent._subControllerVanadium.show_hide_v_peaks)
# TODO - TONIGHT 1 - self.ui.pushButton_bfSearchSmooth.connect(self.do_smooth_bf)
return
def __init__(self, parent, ipts_number=None):
"""
:param parent:
:return:
"""
# GUI window
QMainWindow.__init__(self)
# check input
assert ipts_number is None or (isinstance(ipts_number, int) and ipts_number > 0)
# signal
self.mtsLogReturnSignal.connect(parent.signal_scanned_mts_log)
# set up parent
self._myParent = parent
# set up widgets from ui file
ui_path = os.path.join(os.path.dirname(__file__), "gui/loadVulcanMTSLogFile.ui")
self.ui = load_ui(ui_path, baseinstance=self)
self._promote_widgets()
# initialize values of widgets
self._init_widgets()
# set up event handling for widgets
self.ui.pushButton_browseLoadFile.clicked.connect(self.do_peek_log_file)
self.ui.pushButton_formatSet.clicked.connect(self.do_set_init_format)
self.ui.pushButton_setBlocks.clicked.connect(self.do_correct_blocks)
self.ui.pushButton_setExpTime.clicked.connect(self.do_set_exp_time)
self.ui.pushButton_checkTime.clicked.connect(self.do_check_time)
self.ui.pushButton_loadReturn.clicked.connect(self.do_accept_return)
self.ui.pushButton_cancel.clicked.connect(self.do_quit)
self.ui.actionQuit.triggered.connect(self.do_quit)
self.ui.actionReset.triggered.connect(self.do_reset_gui)
# self.connect(self.ui.pushButton_browseLoadFile, QtCore.SIGNAL('clicked()'),
# self.do_peek_log_file)
# self.connect(self.ui.pushButton_formatSet, QtCore.SIGNAL('clicked()'),
# self.do_set_init_format)
# self.connect(self.ui.pushButton_setBlocks, QtCore.SIGNAL('clicked()'),
# self.do_correct_blocks)
# self.connect(self.ui.pushButton_setExpTime, QtCore.SIGNAL('clicked()'),
# self.do_set_exp_time)
#
# self.connect(self.ui.pushButton_checkTime, QtCore.SIGNAL('clicked()'),
# self.do_check_time)
#
# self.connect(self.ui.pushButton_loadReturn, QtCore.SIGNAL('clicked()'),
# self.do_accept_return)
# self.connect(self.ui.pushButton_cancel, QtCore.SIGNAL('clicked()'),
# self.do_quit)
#
# self.connect(self.ui.actionQuit, QtCore.SIGNAL('triggered()'),
# self.do_quit)
# self.connect(self.ui.actionReset, QtCore.SIGNAL('triggered()'),
# self.do_reset_gui)
# class variables
self._logFileName = None
self._iptsNumber = ipts_number
self._dataDir = None
self._logFileSize = 0
# format
self._logFormatDict = dict() # keys: block (dictionary of block index and start/stop line number)
self._blockStartFlag = None
self._unitList = None
self._headerList = None
self._comments = ''
# summary
self._summaryDict = None
return
