pyckster 26.1.5__py3-none-any.whl → 26.2.1__py3-none-any.whl

pyckster/core.py

@@ -80,6 +80,7 @@ from .obspy_utils import (
     remove_trace,
     move_trace,
     mute_trace,
+    zero_pad_trace,
     swap_header_format,
     merge_streams,
     get_max_decimals,
@@ -874,7 +875,7 @@ class TraceSelector(QDialog):
             self.layout.addWidget(self.createFormItem("Trace Position (m):", self.tracePositionLineEdit))
             
             # If trace_positions provided, initialize with the first trace position
-            if trace_positions and len(trace_positions) > 0:
+            if trace_positions is not None and len(trace_positions) > 0:
                 self.tracePositionLineEdit.setText(str(trace_positions[0]))
 
         # Add a checkbox to apply the changes to all shots
@@ -1249,6 +1250,154 @@ def find_icon_path():
 # Auto Pick Dialog
 #######################################
 
+class AcquisitionParametersDialog(QDialog):
+    """Dialog to display acquisition parameters summary"""
+    def __init__(self, params, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Acquisition Parameters")
+        self.setMinimumWidth(500)
+        self.setMinimumHeight(400)
+        self.resize(600, 500)  # Set initial size
+        
+        # Enable resizing and maximize button
+        self.setWindowFlags(Qt.Window | Qt.WindowMaximizeButtonHint | Qt.WindowCloseButtonHint)
+        
+        layout = QVBoxLayout(self)
+        
+        # Create a QTextEdit to display the parameters
+        self.textEdit = QTextEdit()
+        self.textEdit.setReadOnly(True)
+        self.textEdit.setFont(QFont("Courier", 10))
+        
+        # Format the parameters text
+        text = self.formatParameters(params)
+        self.textEdit.setPlainText(text)
+        
+        layout.addWidget(self.textEdit)
+        
+        # Add OK button
+        buttonBox = QDialogButtonBox(QDialogButtonBox.Ok)
+        buttonBox.accepted.connect(self.accept)
+        layout.addWidget(buttonBox)
+    
+    def formatParameters(self, params):
+        """Format the parameters into a readable text"""
+        lines = []
+        lines.append("=" * 60)
+        lines.append("ACQUISITION PARAMETERS SUMMARY")
+        lines.append("=" * 60)
+        lines.append("")
+        
+        if 'error' in params:
+            lines.append(f"Error: {params['error']}")
+            return "\n".join(lines)
+        
+        # Roll-along detection FIRST
+        lines.append("ACQUISITION TYPE:")
+        lines.append("-" * 60)
+        if params.get('roll_along_detected'):
+            lines.append(f"  Roll-along acquisition:  YES")
+            if params.get('roll_along_segments') is not None:
+                lines.append(f"  Number of segments:      {params['roll_along_segments']}")
+        else:
+            lines.append(f"  Roll-along acquisition:  NO (standard acquisition)")
+        
+        # Shot positioning
+        if params.get('shot_positioning'):
+            lines.append(f"  Shot positioning:        {params['shot_positioning']}")
+        lines.append("")
+        
+        # Geophones/Traces section
+        lines.append("GEOPHONES/TRACES:")
+        lines.append("-" * 60)
+        if params.get('total_unique_traces') is not None:
+            lines.append(f"  Total number of traces:  {params['total_unique_traces']}")
+        else:
+            lines.append(f"  Number of traces/shot:   {params.get('n_traces', 'N/A')}")
+        if params.get('trace_spacing') is not None:
+            lines.append(f"  Trace spacing:           {params['trace_spacing']:.2f} m")
+        else:
+            lines.append(f"  Trace spacing:           N/A")
+        if params.get('total_trace_extent') is not None:
+            lines.append(f"  Total trace extent:      {params['total_trace_extent']:.2f} m")
+        else:
+            lines.append(f"  Trace extent:            N/A")
+        if params.get('first_trace_pos') is not None:
+            lines.append(f"  First trace position:    {params['first_trace_pos']:.2f} m")
+        else:
+            lines.append(f"  First trace position:    N/A")
+        if params.get('last_trace_pos') is not None:
+            lines.append(f"  Last trace position:     {params['last_trace_pos']:.2f} m")
+        else:
+            lines.append(f"  Last trace position:     N/A")
+        
+        # Add roll-along segment details if available
+        if params.get('roll_along_detected') and params.get('roll_along_segment_details'):
+            lines.append("")
+            lines.append("  Roll-along segment details:")
+            for i, seg_detail in enumerate(params['roll_along_segment_details'], 1):
+                lines.append(f"    Segment {i}: {seg_detail}")
+        lines.append("")
+        
+        # Sources/Shots section
+        lines.append("SOURCES/SHOTS:")
+        lines.append("-" * 60)
+        lines.append(f"  Total number of shots:   {params.get('n_shots', 'N/A')}")
+        if params.get('source_spacing') is not None:
+            spacing_label = "  Source spacing (median): " if params.get('roll_along_detected') else "  Source spacing:          "
+            lines.append(f"{spacing_label}{params['source_spacing']:.2f} m")
+        else:
+            lines.append(f"  Source spacing:          N/A")
+        if params.get('total_source_extent') is not None:
+            lines.append(f"  Total source extent:     {params['total_source_extent']:.2f} m")
+        else:
+            lines.append(f"  Source extent:           N/A")
+        if params.get('first_shot_pos') is not None:
+            lines.append(f"  First shot position:     {params['first_shot_pos']:.2f} m")
+        else:
+            lines.append(f"  First shot position:     N/A")
+        if params.get('last_shot_pos') is not None:
+            lines.append(f"  Last shot position:      {params['last_shot_pos']:.2f} m")
+        else:
+            lines.append(f"  Last shot position:      N/A")
+        if params.get('min_offset') is not None:
+            lines.append(f"  Minimum offset:          {abs(params['min_offset']):.2f} m")
+        else:
+            lines.append(f"  Minimum offset:          N/A")
+        if params.get('max_offset') is not None:
+            lines.append(f"  Maximum offset:          {abs(params['max_offset']):.2f} m")
+        else:
+            lines.append(f"  Maximum offset:          N/A")
+        
+        # Add roll-along shot segment details if available
+        if params.get('roll_along_detected') and params.get('roll_along_shot_segment_details'):
+            lines.append("")
+            lines.append("  Roll-along segment details:")
+            for i, seg_detail in enumerate(params['roll_along_shot_segment_details'], 1):
+                lines.append(f"    Segment {i}: {seg_detail}")
+        lines.append("")
+        
+        # Timing section
+        lines.append("TIMING:")
+        lines.append("-" * 60)
+        if params.get('sample_interval') is not None:
+            lines.append(f"  Sampling interval:       {params['sample_interval']*1000:.3f} ms")
+        else:
+            lines.append(f"  Sampling interval:       N/A")
+        if params.get('record_length') is not None:
+            lines.append(f"  Recording time:          {params['record_length']*1000:.2f} ms")
+        else:
+            lines.append(f"  Recording time:          N/A")
+        if params.get('delay') is not None:
+            lines.append(f"  Delay time:              {params['delay']*1000:.3f} ms")
+        else:
+            lines.append(f"  Delay time:              N/A")
+        lines.append("")
+        lines.append("=" * 60)
+        
+        return "\n".join(lines)
+
+
 class AutoPickDialog(QDialog):
     """Dialog for entering frequency range for auto pick operation"""
     def __init__(self, parent=None, fmin_default=0.0, fmax_default=200.0):
@@ -1493,6 +1642,12 @@ class MainWindow(QMainWindow):
         self.fileListWidget.setMinimumWidth(50)  # Set minimum width
         leftLayout.addWidget(self.fileListWidget)
 
+        # Add Acquisition parameters button
+        self.acqParamsButton = QPushButton("Acquisition parameters")
+        self.acqParamsButton.clicked.connect(self.showAcquisitionParameters)
+        self.acqParamsButton.setToolTip("Show acquisition parameters summary")
+        leftLayout.addWidget(self.acqParamsButton)
+
         # Add separator line
         separator = QFrame()
         separator.setFrameShape(QFrame.HLine)
@@ -1506,7 +1661,7 @@ class MainWindow(QMainWindow):
         leftLayout.addWidget(QLabel("Plot traces by:"))
         self.tracesCombo = QComboBox()
         self.tracesCombo.addItems(["Original trace no", "Trace in shot", "Trace in survey", "Position"])
-        self.tracesCombo.setCurrentText("Original trace no")
+        self.tracesCombo.setCurrentText("Trace in shot")
         self.tracesCombo.currentTextChanged.connect(self._onTracesComboChanged)
         leftLayout.addWidget(self.tracesCombo)
         
@@ -2144,6 +2299,16 @@ class MainWindow(QMainWindow):
         self.editTraceSubMenu.addAction(self.reverseTracesAction)
         self.reverseTracesAction.triggered.connect(self.reverseTraces)
 
+        # Create a QAction for inserting zero traces
+        self.insertMutedTracesAction = QAction('Insert zero traces', self)
+        self.editTraceSubMenu.addAction(self.insertMutedTracesAction)
+        self.insertMutedTracesAction.triggered.connect(self.insertMutedTraces)
+
+        # Create a QAction for zero padding traces
+        self.zeroPadTraceAction = QAction('Zero pad traces', self)
+        self.editTraceSubMenu.addAction(self.zeroPadTraceAction)
+        self.zeroPadTraceAction.triggered.connect(self.zeroPadTrace)
+
         # Create a submenu for batch editing traces
         self.batchEditTraceSubMenu = self.headerMenu.addMenu('Batch edit traces')
 
@@ -2172,6 +2337,16 @@ class MainWindow(QMainWindow):
         self.batchEditTraceSubMenu.addAction(self.batchReverseTracesAction)
         self.batchReverseTracesAction.triggered.connect(self.batchReverseTraces)
 
+        # Create a QAction for batch inserting zero traces
+        self.batchInsertMutedTracesAction = QAction('Batch insert zero traces', self)
+        self.batchEditTraceSubMenu.addAction(self.batchInsertMutedTracesAction)
+        self.batchInsertMutedTracesAction.triggered.connect(self.batchInsertMutedTraces)
+
+        # Create a QAction for batch zero padding traces
+        self.batchZeroPadTracesAction = QAction('Batch zero pad traces', self)
+        self.batchEditTraceSubMenu.addAction(self.batchZeroPadTracesAction)
+        self.batchZeroPadTracesAction.triggered.connect(self.batchZeroPadTraces)
+
         # Add separator
         self.headerMenu.addSeparator()
 
@@ -2945,107 +3120,111 @@ class MainWindow(QMainWindow):
     
     def _process_bottom_view_change(self, view_type):
         """Process bottom view change - handles plotting logic"""
-        # Prevent redundant control visibility updates if we're in a swap
-        should_update_visibility = not getattr(self, '_in_view_swap', False)
-        
-        # Map view names to internal types
-        view_mapping = {
-            "Seismogram": "seismogram",
-            "Layout": "layout",
-            "Traveltimes": "traveltime",
-            "Topography": "topo",
-            "Spectrogram": "spectrogram",
-            "Dispersion": "dispersion",
-            "Pseudo-section": "pseudosection"
-        }
-        new_plot_type = view_mapping.get(view_type, "layout")
-        
-        # Only rebuild dynamic controls if the view type has actually changed
-        # This prevents unnecessary widget destruction/creation and flickering
-        if getattr(self, '_last_bottom_plot_type', None) != new_plot_type:
-            self.buildBottomControlsForView(view_type)
-            self._last_bottom_plot_type = new_plot_type
-        
-        # Scroll bottom controls scroll area to the beginning (left)
-        if hasattr(self, 'bottomControlsScrollArea'):
-            self.bottomControlsScrollArea.horizontalScrollBar().setValue(0)
-        
-        # Track bottom plot type for control visibility
-        self.bottomPlotType = new_plot_type
-        
-        # Update trace window checkbox state based on view combination
-        self._updateTraceWindowCheckboxState()
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            # Prevent redundant control visibility updates if we're in a swap
+            should_update_visibility = not getattr(self, '_in_view_swap', False)
+            
+            # Map view names to internal types
+            view_mapping = {
+                "Seismogram": "seismogram",
+                "Layout": "layout",
+                "Traveltimes": "traveltime",
+                "Topography": "topo",
+                "Spectrogram": "spectrogram",
+                "Dispersion": "dispersion",
+                "Pseudo-section": "pseudosection"
+            }
+            new_plot_type = view_mapping.get(view_type, "layout")
+            
+            # Only rebuild dynamic controls if the view type has actually changed
+            # This prevents unnecessary widget destruction/creation and flickering
+            if getattr(self, '_last_bottom_plot_type', None) != new_plot_type:
+                self.buildBottomControlsForView(view_type)
+                self._last_bottom_plot_type = new_plot_type
+            
+            # Scroll bottom controls scroll area to the beginning (left)
+            if hasattr(self, 'bottomControlsScrollArea'):
+                self.bottomControlsScrollArea.horizontalScrollBar().setValue(0)
+            
+            # Track bottom plot type for control visibility
+            self.bottomPlotType = new_plot_type
+            
+            # Update trace window checkbox state based on view combination
+            self._updateTraceWindowCheckboxState()
 
-        # Populate trace range dropdowns if this is Dispersion view
-        if view_type == "Dispersion":
-            # Only enable if we have a stream loaded
-            if self.streams and self.currentIndex is not None:
-                self.populateTraceRangeComboboxes()
+            # Populate trace range dropdowns if this is Dispersion view
+            if view_type == "Dispersion":
+                # Only enable if we have a stream loaded
+                if self.streams and self.currentIndex is not None:
+                    self.populateTraceRangeComboboxes()
+                else:
+                    if hasattr(self, 'traceRangeSlider') and self.traceRangeSlider is not None:
+                        try:
+                            self.traceRangeSlider.disableControls()
+                        except RuntimeError:
+                            pass  # Widget may have been deleted during UI rebuild
             else:
+                # Disable trace range slider for other view types
                 if hasattr(self, 'traceRangeSlider') and self.traceRangeSlider is not None:
                     try:
                         self.traceRangeSlider.disableControls()
                     except RuntimeError:
                         pass  # Widget may have been deleted during UI rebuild
-        else:
-            # Disable trace range slider for other view types
-            if hasattr(self, 'traceRangeSlider') and self.traceRangeSlider is not None:
-                try:
-                    self.traceRangeSlider.disableControls()
-                except RuntimeError:
-                    pass  # Widget may have been deleted during UI rebuild
-        
-        if view_type == "Seismogram":
-            # Plot seismogram to bottom widget
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.updatePlots()
-        elif view_type == "Layout":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotLayout()
-            self._restoreSceneClickSignals(self.bottomPlotWidget, "bottom")
-        elif view_type == "Traveltimes":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotTravelTime()
-            self._restoreSceneClickSignals(self.bottomPlotWidget, "bottom")
-        elif view_type == "Topography":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotTopo()
-            self._restoreSceneClickSignals(self.bottomPlotWidget, "bottom")
-        elif view_type == "Spectrogram":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotSpectrogram()
-            self._restoreSceneClickSignals(self.bottomPlotWidget, "bottom")
-        elif view_type == "Dispersion":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotDispersion()
-        elif view_type == "Pseudo-section":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotPseudoSection()
-            self._restoreSceneClickSignals(self.bottomPlotWidget, "bottom")
-        
-        # Reset target widget after plotting
-        self._plot_target_widget = None
-        self._plot_target_viewbox = None
-        
-        # Draw/update trace extent indicator after view change
-        self.drawTraceExtentIndicator()
-        
-        # Reset view to proper default range after switching
-        self.resetBottomView()
-        
-        # Update title to show on correct plot widget based on current view types
-        self.updateTitle()
-        
-        # Update control visibility based on current view types (only if not in a swap)
-        if should_update_visibility:
-            self._updateControlVisibility()
+            
+            if view_type == "Seismogram":
+                # Plot seismogram to bottom widget
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.updatePlots()
+            elif view_type == "Layout":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotLayout()
+                self._restoreSceneClickSignals(self.bottomPlotWidget, "bottom")
+            elif view_type == "Traveltimes":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotTravelTime()
+                self._restoreSceneClickSignals(self.bottomPlotWidget, "bottom")
+            elif view_type == "Topography":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotTopo()
+                self._restoreSceneClickSignals(self.bottomPlotWidget, "bottom")
+            elif view_type == "Spectrogram":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotSpectrogram()
+                self._restoreSceneClickSignals(self.bottomPlotWidget, "bottom")
+            elif view_type == "Dispersion":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotDispersion()
+            elif view_type == "Pseudo-section":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotPseudoSection()
+                self._restoreSceneClickSignals(self.bottomPlotWidget, "bottom")
+            
+            # Reset target widget after plotting
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+            
+            # Draw/update trace extent indicator after view change
+            self.drawTraceExtentIndicator()
+            
+            # Reset view to proper default range after switching
+            self.resetBottomView()
+            
+            # Update title to show on correct plot widget based on current view types
+            self.updateTitle()
+            
+            # Update control visibility based on current view types (only if not in a swap)
+            if should_update_visibility:
+                self._updateControlVisibility()
+        finally:
+            QApplication.restoreOverrideCursor()
     
     def _updateSeismoMenuActionsForMode(self):
         """Update menu action availability based on seismogram display mode.
@@ -3854,76 +4033,92 @@ class MainWindow(QMainWindow):
         self.spectrogram_norm_per_trace = bool(state)
         if not (hasattr(self, 'currentIndex') and self.currentIndex is not None and self.streams):
             return
-        # Replot both top and bottom if they use spectrogram
-        if hasattr(self, 'topPlotType') and self.topPlotType == "spectrogram":
-            self._plot_target_widget = self.plotWidget
-            self._plot_target_viewbox = self.viewBox
-            self.plotSpectrogram()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
-        if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "spectrogram":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotSpectrogram()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            # Replot both top and bottom if they use spectrogram
+            if hasattr(self, 'topPlotType') and self.topPlotType == "spectrogram":
+                self._plot_target_widget = self.plotWidget
+                self._plot_target_viewbox = self.viewBox
+                self.plotSpectrogram()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+            if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "spectrogram":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotSpectrogram()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+        finally:
+            QApplication.restoreOverrideCursor()
 
     def onNormPerTraceChanged_Dispersion(self, state):
         """Handle per-trace normalization toggle for Dispersion view"""
         self.dispersion_norm_per_trace = bool(state)
         if not (hasattr(self, 'currentIndex') and self.currentIndex is not None and self.streams):
             return
-        # Replot both top and bottom if they use dispersion
-        if hasattr(self, 'topPlotType') and self.topPlotType == "dispersion":
-            self._plot_target_widget = self.plotWidget
-            self._plot_target_viewbox = self.viewBox
-            self.plotDispersion()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
-        if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "dispersion":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotDispersion()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            # Replot both top and bottom if they use dispersion
+            if hasattr(self, 'topPlotType') and self.topPlotType == "dispersion":
+                self._plot_target_widget = self.plotWidget
+                self._plot_target_viewbox = self.viewBox
+                self.plotDispersion()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+            if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "dispersion":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotDispersion()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+        finally:
+            QApplication.restoreOverrideCursor()
 
     def onNormPerFreqChanged_Spectrogram(self, state):
         """Handle per-freq normalization toggle for Spectrogram view"""
         self.spectrogram_norm_per_freq = bool(state)
         if not (hasattr(self, 'currentIndex') and self.currentIndex is not None and self.streams):
             return
-        # Replot both top and bottom if they use spectrogram
-        if hasattr(self, 'topPlotType') and self.topPlotType == "spectrogram":
-            self._plot_target_widget = self.plotWidget
-            self._plot_target_viewbox = self.viewBox
-            self.plotSpectrogram()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
-        if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "spectrogram":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotSpectrogram()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            # Replot both top and bottom if they use spectrogram
+            if hasattr(self, 'topPlotType') and self.topPlotType == "spectrogram":
+                self._plot_target_widget = self.plotWidget
+                self._plot_target_viewbox = self.viewBox
+                self.plotSpectrogram()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+            if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "spectrogram":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotSpectrogram()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+        finally:
+            QApplication.restoreOverrideCursor()
 
     def onNormPerFreqChanged_Dispersion(self, state):
         """Handle per-freq normalization toggle for Dispersion view"""
         self.dispersion_norm_per_freq = bool(state)
         if not (hasattr(self, 'currentIndex') and self.currentIndex is not None and self.streams):
             return
-        # Replot both top and bottom if they use dispersion
-        if hasattr(self, 'topPlotType') and self.topPlotType == "dispersion":
-            self._plot_target_widget = self.plotWidget
-            self._plot_target_viewbox = self.viewBox
-            self.plotDispersion()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
-        if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "dispersion":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotDispersion()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            # Replot both top and bottom if they use dispersion
+            if hasattr(self, 'topPlotType') and self.topPlotType == "dispersion":
+                self._plot_target_widget = self.plotWidget
+                self._plot_target_viewbox = self.viewBox
+                self.plotDispersion()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+            if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "dispersion":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotDispersion()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+        finally:
+            QApplication.restoreOverrideCursor()
 
     def onDispersionSaturationChanged(self, value):
         """Handle saturation slider change for dispersion images"""
@@ -5138,7 +5333,11 @@ class MainWindow(QMainWindow):
         # Replot if either top or bottom shows seismogram (updatePlots() handles both)
         if (hasattr(self, 'topPlotType') and self.topPlotType == "seismogram") or \
            (hasattr(self, 'bottomPlotType') and self.bottomPlotType == "seismogram"):
-            self.updatePlots()
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            try:
+                self.updatePlots()
+            finally:
+                QApplication.restoreOverrideCursor()
     
     def onSeismoGainChanged(self, value):
         """Handle seismogram gain change - unified"""
@@ -5148,7 +5347,11 @@ class MainWindow(QMainWindow):
         # Replot if either top or bottom shows seismogram (updatePlots() handles both)
         if (hasattr(self, 'topPlotType') and self.topPlotType == "seismogram") or \
            (hasattr(self, 'bottomPlotType') and self.bottomPlotType == "seismogram"):
-            self.updatePlots()
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            try:
+                self.updatePlots()
+            finally:
+                QApplication.restoreOverrideCursor()
     
     def onSeismoFillModeChanged(self, mode_text):
         """Handle seismogram fill mode change (Pos/Neg/None) - unified"""
@@ -5174,7 +5377,11 @@ class MainWindow(QMainWindow):
         # Replot if either top or bottom shows seismogram (updatePlots() handles both)
         if (hasattr(self, 'topPlotType') and self.topPlotType == "seismogram") or \
            (hasattr(self, 'bottomPlotType') and self.bottomPlotType == "seismogram"):
-            self.updatePlots()
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            try:
+                self.updatePlots()
+            finally:
+                QApplication.restoreOverrideCursor()
     
     def _calculateAmplitudeRatio(self):
         """Calculate the amplitude ratio (max/min) across all loaded traces"""
@@ -5252,8 +5459,12 @@ class MainWindow(QMainWindow):
         # Replot if either top or bottom shows seismogram (updatePlots() handles both)
         if (hasattr(self, 'topPlotType') and self.topPlotType == "seismogram") or \
            (hasattr(self, 'bottomPlotType') and self.bottomPlotType == "seismogram"):
-            self.updatePlots()
-    
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            try:
+                self.updatePlots()
+            finally:
+                QApplication.restoreOverrideCursor()
+    
     def onSeismoClipChanged(self, state):
         """Handle seismogram clip toggle - unified"""
         self.seismo_clip = bool(state)
@@ -5263,7 +5474,11 @@ class MainWindow(QMainWindow):
         # Replot if either top or bottom shows seismogram (updatePlots() handles both)
         if (hasattr(self, 'topPlotType') and self.topPlotType == "seismogram") or \
            (hasattr(self, 'bottomPlotType') and self.bottomPlotType == "seismogram"):
-            self.updatePlots()
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            try:
+                self.updatePlots()
+            finally:
+                QApplication.restoreOverrideCursor()
     
     def onSeismoOverlapChanged(self, display_value):
         """Handle seismogram overlap multiplicator change
@@ -5287,7 +5502,11 @@ class MainWindow(QMainWindow):
         # Replot if either top or bottom shows seismogram
         if (hasattr(self, 'topPlotType') and self.topPlotType == "seismogram") or \
            (hasattr(self, 'bottomPlotType') and self.bottomPlotType == "seismogram"):
-            self.updatePlots()
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            try:
+                self.updatePlots()
+            finally:
+                QApplication.restoreOverrideCursor()
     
     def onSeismoReversePolarityChanged(self, state):
         """Handle seismogram reverse polarity toggle - unified"""
@@ -5326,7 +5545,11 @@ class MainWindow(QMainWindow):
         # Replot if either top or bottom shows seismogram (updatePlots() handles both)
         if (hasattr(self, 'topPlotType') and self.topPlotType == "seismogram") or \
            (hasattr(self, 'bottomPlotType') and self.bottomPlotType == "seismogram"):
-            self.updatePlots()
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            try:
+                self.updatePlots()
+            finally:
+                QApplication.restoreOverrideCursor()
     
     def onSeismoMaxTimeChanged(self, value):
         """Handle seismogram max time change - unified"""
@@ -5336,7 +5559,11 @@ class MainWindow(QMainWindow):
         # Replot if either top or bottom shows seismogram (updatePlots() handles both)
         if (hasattr(self, 'topPlotType') and self.topPlotType == "seismogram") or \
            (hasattr(self, 'bottomPlotType') and self.bottomPlotType == "seismogram"):
-            self.updatePlots()
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            try:
+                self.updatePlots()
+            finally:
+                QApplication.restoreOverrideCursor()
     
     def onPickingShowCrosshairChanged(self, state):
         """Handle picking crosshair toggle - unified for seismogram and dispersion views"""
@@ -6489,7 +6716,7 @@ class MainWindow(QMainWindow):
         self.col = 'k'
         self.fill_brush = (0, 0, 0, 150)
         self._batch_loading = False  # Flag to prevent plotting during batch loading
-        self.plotTypeX = 'shot_trace_number'  # Plot type for X axis
+        self.plotTypeX = 'file_trace_number'  # Plot type for X axis
         self.plotTypeY = 'ffid'  # Plot type for Y axis
         self.t_label = 'Time (s)'
         self.relativeError = 0.05
@@ -7055,6 +7282,250 @@ class MainWindow(QMainWindow):
 
         self.updatePlotTypeDict()
 
+    def showAcquisitionParameters(self):
+        """Display a dialog with acquisition parameters summary"""
+        if not self.streams or len(self.streams) == 0:
+            QMessageBox.information(self, "No Data", "No seismic files loaded.")
+            return
+        
+        # Calculate parameters from all loaded streams
+        params = self.calculateAcquisitionParameters()
+        
+        # Show the dialog
+        dialog = AcquisitionParametersDialog(params, self)
+        dialog.exec_()
+    
+    def calculateAcquisitionParameters(self):
+        """Calculate acquisition parameters from loaded data"""
+        params = {}
+        
+        try:
+            # Number of shots
+            params['n_shots'] = len(self.streams)
+            
+            # Get parameters from current or first file
+            idx = self.currentIndex if self.currentIndex is not None else 0
+            
+            if idx >= len(self.streams):
+                params['error'] = "Invalid file index"
+                return params
+            
+            # Number of traces (from current/first shot)
+            params['n_traces'] = len(self.streams[idx])
+            
+            # Collect all unique trace positions across all shots for total extent
+            all_trace_positions = set()
+            if hasattr(self, 'trace_position') and len(self.trace_position) > 0:
+                for trace_pos_list in self.trace_position:
+                    if trace_pos_list is not None:
+                        all_trace_positions.update(trace_pos_list)
+            
+            # Total unique traces and overall extent
+            if len(all_trace_positions) > 0:
+                params['total_unique_traces'] = len(all_trace_positions)
+                params['total_trace_extent'] = max(all_trace_positions) - min(all_trace_positions)
+                params['first_trace_pos'] = min(all_trace_positions)
+                params['last_trace_pos'] = max(all_trace_positions)
+            else:
+                params['total_unique_traces'] = None
+                params['total_trace_extent'] = None
+                params['first_trace_pos'] = None
+                params['last_trace_pos'] = None
+            
+            # Trace spacing (from current/first shot)
+            if hasattr(self, 'trace_position') and idx < len(self.trace_position):
+                trace_pos = self.trace_position[idx]
+                if trace_pos is not None and len(trace_pos) > 1:
+                    # Calculate spacing using median for robustness
+                    spacings = [trace_pos[i+1] - trace_pos[i] for i in range(len(trace_pos)-1)]
+                    params['trace_spacing'] = np.median(spacings)
+                elif trace_pos is not None and len(trace_pos) == 1:
+                    params['trace_spacing'] = None
+                else:
+                    params['trace_spacing'] = None
+            else:
+                params['trace_spacing'] = None
+            
+            # Source spacing and extent
+            if hasattr(self, 'source_position') and len(self.source_position) > 1:
+                source_positions = self.source_position
+                if len(source_positions) > 1:
+                    # Calculate spacing using MEDIAN to handle roll-along gaps
+                    spacings = [source_positions[i+1] - source_positions[i] for i in range(len(source_positions)-1)]
+                    params['source_spacing'] = np.median(np.abs(spacings))
+                    # Total extent from all shots
+                    params['total_source_extent'] = max(source_positions) - min(source_positions)
+                    params['first_shot_pos'] = min(source_positions)
+                    params['last_shot_pos'] = max(source_positions)
+                else:
+                    params['source_spacing'] = None
+                    params['total_source_extent'] = None
+                    params['first_shot_pos'] = source_positions[0] if len(source_positions) > 0 else None
+                    params['last_shot_pos'] = source_positions[0] if len(source_positions) > 0 else None
+            else:
+                params['source_spacing'] = None
+                params['total_source_extent'] = None
+                params['first_shot_pos'] = None
+                params['last_shot_pos'] = None
+            
+            # Detect shot positioning relative to traces
+            params['shot_positioning'] = None
+            if (hasattr(self, 'source_position') and hasattr(self, 'trace_position') and 
+                len(self.source_position) > 0 and len(self.trace_position) > 0):
+                try:
+                    # Collect all unique trace positions across all shots
+                    all_trace_positions = set()
+                    for trace_pos_list in self.trace_position:
+                        if trace_pos_list is not None:
+                            all_trace_positions.update(trace_pos_list)
+                    
+                    # Check each source position against trace positions
+                    tolerance = 0.1  # 10 cm tolerance for considering positions equal
+                    at_trace_count = 0
+                    between_trace_count = 0
+                    
+                    for src_pos in self.source_position:
+                        is_at_trace = any(abs(src_pos - trace_pos) < tolerance for trace_pos in all_trace_positions)
+                        if is_at_trace:
+                            at_trace_count += 1
+                        else:
+                            between_trace_count += 1
+                    
+                    # Determine positioning type
+                    if at_trace_count > 0 and between_trace_count == 0:
+                        params['shot_positioning'] = "At trace positions (coincident)"
+                    elif between_trace_count > 0 and at_trace_count == 0:
+                        params['shot_positioning'] = "Between traces (offset)"
+                    elif at_trace_count > 0 and between_trace_count > 0:
+                        params['shot_positioning'] = f"Mixed ({at_trace_count} at traces, {between_trace_count} between)"
+                    else:
+                        params['shot_positioning'] = "Unknown"
+                except Exception:
+                    params['shot_positioning'] = "Unknown"
+            
+            # Min/Max offset
+            if hasattr(self, 'offset') and len(self.offset) > 0:
+                all_offsets = []
+                for offset_list in self.offset:
+                    if offset_list is not None and len(offset_list) > 0:
+                        all_offsets.extend(offset_list)
+                if len(all_offsets) > 0:
+                    # Use absolute values for offset ranges
+                    abs_offsets = [abs(offset) for offset in all_offsets]
+                    params['min_offset'] = min(abs_offsets)
+                    params['max_offset'] = max(abs_offsets)
+                else:
+                    params['min_offset'] = None
+                    params['max_offset'] = None
+            else:
+                params['min_offset'] = None
+                params['max_offset'] = None
+            
+            # Roll-along detection
+            params['roll_along_detected'] = False
+            params['roll_along_segments'] = None
+            params['roll_along_segment_details'] = None
+            params['roll_along_shot_segment_details'] = None
+            
+            if (hasattr(self, 'source_position') and hasattr(self, 'trace_position') and 
+                len(self.source_position) > 1 and len(self.trace_position) > 1):
+                try:
+                    # Detect roll-along by checking if trace positions change while
+                    # some shots might be at similar positions
+                    # Group shots by similar trace array positions
+                    segments = []
+                    current_segment = [0]
+                    
+                    for i in range(1, len(self.trace_position)):
+                        if self.trace_position[i] is not None and self.trace_position[i-1] is not None:
+                            # Check if trace positions have changed significantly
+                            prev_min = min(self.trace_position[i-1])
+                            prev_max = max(self.trace_position[i-1])
+                            curr_min = min(self.trace_position[i])
+                            curr_max = max(self.trace_position[i])
+                            
+                            # If the trace array has shifted (different min/max positions)
+                            # This indicates a new segment in roll-along
+                            if abs(curr_min - prev_min) > 0.1 or abs(curr_max - prev_max) > 0.1:
+                                segments.append(current_segment)
+                                current_segment = [i]
+                            else:
+                                current_segment.append(i)
+                        else:
+                            current_segment.append(i)
+                    
+                    # Add last segment
+                    if current_segment:
+                        segments.append(current_segment)
+                    
+                    # Roll-along is detected if we have multiple segments
+                    if len(segments) > 1:
+                        params['roll_along_detected'] = True
+                        params['roll_along_segments'] = len(segments)
+                        
+                        # Get detailed info for each segment (traces)
+                        segment_details = []
+                        for seg_idx, segment in enumerate(segments):
+                            # Get trace positions for this segment
+                            seg_trace_pos = self.trace_position[segment[0]]
+                            if seg_trace_pos is not None:
+                                seg_unique_traces = set()
+                                for shot_idx in segment:
+                                    if self.trace_position[shot_idx] is not None:
+                                        seg_unique_traces.update(self.trace_position[shot_idx])
+                                
+                                seg_min = min(seg_unique_traces)
+                                seg_max = max(seg_unique_traces)
+                                seg_extent = seg_max - seg_min
+                                seg_n_traces = len(seg_unique_traces)
+                                
+                                detail = f"{seg_n_traces} traces, {seg_min:.0f} to {seg_max:.0f} m (extent: {seg_extent:.0f} m)"
+                                segment_details.append(detail)
+                        
+                        params['roll_along_segment_details'] = segment_details
+                        
+                        # Get detailed info for each segment (shots)
+                        shot_segment_details = []
+                        for seg_idx, segment in enumerate(segments):
+                            # Get shot positions for this segment
+                            seg_shot_positions = [self.source_position[i] for i in segment if i < len(self.source_position)]
+                            if seg_shot_positions:
+                                seg_min_shot = min(seg_shot_positions)
+                                seg_max_shot = max(seg_shot_positions)
+                                seg_extent_shot = seg_max_shot - seg_min_shot
+                                seg_n_shots = len(seg_shot_positions)
+                                
+                                detail = f"{seg_n_shots} shots, {seg_min_shot:.0f} to {seg_max_shot:.0f} m (extent: {seg_extent_shot:.0f} m)"
+                                shot_segment_details.append(detail)
+                        
+                        params['roll_along_shot_segment_details'] = shot_segment_details
+                except Exception:
+                    # If roll-along detection fails, just mark as not detected
+                    pass
+            
+            # Sampling interval
+            if hasattr(self, 'sample_interval') and idx < len(self.sample_interval):
+                params['sample_interval'] = self.sample_interval[idx]
+            else:
+                params['sample_interval'] = None
+            
+            # Recording time
+            if hasattr(self, 'record_length') and idx < len(self.record_length):
+                params['record_length'] = self.record_length[idx]
+            else:
+                params['record_length'] = None
+            
+            # Delay time
+            if hasattr(self, 'delay') and idx < len(self.delay):
+                params['delay'] = self.delay[idx]
+            else:
+                params['delay'] = None
+                
+        except Exception as e:
+            params['error'] = f"Error calculating parameters: {str(e)}"
+        
+        return params
+
     def clearMemory(self):
         # Clear memory (reset the application)
 
@@ -10746,187 +11217,191 @@ class MainWindow(QMainWindow):
         # Set the file update flag to True
         self.update_file_flag = True
 
-        # Get the current row index directly (this handles duplicates properly)
-        selected_row = self.fileListWidget.currentRow()
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            # Get the current row index directly (this handles duplicates properly)
+            selected_row = self.fileListWidget.currentRow()
 
-        # If a valid row is selected
-        if selected_row >= 0 and selected_row < len(self.fileNames):
-            self.currentFileName = self.fileNames[selected_row] # Set the current file name
-            self.currentIndex = selected_row # Set the current index
-            
-            # Clear dispersion picking state for this new shot (without calling loadStream)
-            # This ensures old picks don't show when switching shots
-            for view in ['top', 'bottom']:
-                state = self.dispersion_picking_state[view]
-                plot_widget = self.plotWidget if view == 'top' else self.bottomPlotWidget
+            # If a valid row is selected
+            if selected_row >= 0 and selected_row < len(self.fileNames):
+                self.currentFileName = self.fileNames[selected_row] # Set the current file name
+                self.currentIndex = selected_row # Set the current index
                 
-                # Remove all mode items from the plot
-                for mode_num, mode_data in state['modes'].items():
-                    # Remove picked point items
-                    for item in mode_data['picked_point_items']:
-                        if item is not None:
+                # Clear dispersion picking state for this new shot (without calling loadStream)
+                # This ensures old picks don't show when switching shots
+                for view in ['top', 'bottom']:
+                    state = self.dispersion_picking_state[view]
+                    plot_widget = self.plotWidget if view == 'top' else self.bottomPlotWidget
+                    
+                    # Remove all mode items from the plot
+                    for mode_num, mode_data in state['modes'].items():
+                        # Remove picked point items
+                        for item in mode_data['picked_point_items']:
+                            if item is not None:
+                                try:
+                                    plot_widget.removeItem(item)
+                                except:
+                                    pass
+                        
+                        # Remove curve line
+                        if mode_data['curve_line'] is not None:
                             try:
-                                plot_widget.removeItem(item)
+                                plot_widget.removeItem(mode_data['curve_line'])
                             except:
                                 pass
                     
-                    # Remove curve line
-                    if mode_data['curve_line'] is not None:
-                        try:
-                            plot_widget.removeItem(mode_data['curve_line'])
-                        except:
-                            pass
-                
-                # Reset modes but keep current mode from spinbox
-                current_mode = self.dispersionModeSpinBox.value()
-                state['modes'] = {}
-                self._ensure_mode_exists(view, current_mode)
-                state['current_mode'] = current_mode
-                state['current_dispersion_data'] = None
-            
-            # Now restore picks from storage if this shot has them
-            if self.currentIndex < len(self.dispersion_curves) and self.dispersion_curves[self.currentIndex] is not None:
-                curve_data = self.dispersion_curves[self.currentIndex]
-                
-                # Get current mode from spinbox
-                current_mode = self.dispersionModeSpinBox.value()
+                    # Reset modes but keep current mode from spinbox
+                    current_mode = self.dispersionModeSpinBox.value()
+                    state['modes'] = {}
+                    self._ensure_mode_exists(view, current_mode)
+                    state['current_mode'] = current_mode
+                    state['current_dispersion_data'] = None
                 
-                # Check if data is in new multi-mode format or old single-mode format
-                if 'modes' in curve_data:
-                    # New multi-mode format
-                    for view in ['top', 'bottom']:
-                        state = self.dispersion_picking_state[view]
-                        state['modes'] = {}
-                        for mode_num, mode_curve_data in curve_data['modes'].items():
-                            # Avoid auto-creating interpolated lines for pvc-file imports
-                            curve_data_to_store = None
-                            if mode_curve_data.get('interpolated', False):
-                                curve_data_to_store = mode_curve_data.copy()
-                            elif mode_curve_data.get('source') not in ('pvc_file',):
-                                curve_data_to_store = mode_curve_data.copy()
-
-                            state['modes'][mode_num] = {
-                                'picked_points': mode_curve_data.get('picked_points', []).copy(),
-                                'picked_point_items': [None] * len(mode_curve_data.get('picked_points', [])),
-                                'error_bar_items': [],
-                                'curve_line': None,
-                                'interp_error_fill': None,
-                                'curve_data': curve_data_to_store
-                            }
-                        # Ensure current mode exists (from spinbox)
-                        if current_mode not in state['modes']:
-                            self._ensure_mode_exists(view, current_mode)
-                        state['current_mode'] = current_mode
-                else:
-                    # Old single-mode format - convert to mode 0
-                    for view in ['top', 'bottom']:
-                        state = self.dispersion_picking_state[view]
-                        state['modes'] = {
-                            0: {
-                                'picked_points': curve_data.get('picked_points', []).copy(),
-                                'picked_point_items': [None] * len(curve_data.get('picked_points', [])),
-                                'error_bar_items': [],
-                                'curve_line': None,
-                                'interp_error_fill': None,
-                                'curve_data': curve_data.copy()
-                            }
-                        }
-                        # Ensure current mode exists
-                        if current_mode not in state['modes']:
-                            self._ensure_mode_exists(view, current_mode)
-                        state['current_mode'] = current_mode
-                
-                # Clear current_dispersion_data to avoid stale references
-                self.dispersion_picking_state['top']['current_dispersion_data'] = None
-                self.dispersion_picking_state['bottom']['current_dispersion_data'] = None
-
-            # Plot the selected file
-            # Ensure plotting parameters are initialized for this file
-            if (self.currentIndex < len(self.shot_trace_number) and 
-                self.shot_trace_number[self.currentIndex] is None):
-                # This file's parameters haven't been initialized yet
-                # This can happen with ASCII imports or corrupted file loading
-                try:
-                    self.getPlotParameters()
-                    self.updatePlotTypeDict()
-                except:
-                    # If getPlotParameters fails (e.g., for ASCII data), set up basic defaults
-                    if self.currentIndex < len(self.streams) and self.streams[self.currentIndex]:
-                        num_traces = len(self.streams[self.currentIndex])
-                        self.shot_trace_number[self.currentIndex] = list(range(1, num_traces + 1))
-                        self.file_trace_number[self.currentIndex] = np.arange(1, num_traces + 1)
-                        self.trace_position[self.currentIndex] = list(range(num_traces))
-                        self.offset[self.currentIndex] = [i * 1.0 for i in range(num_traces)]  # Default 1m spacing
-                        self.updatePlotTypeDict()
-            
-            # Restore trace ranges from memory if available
-            self._restoreTraceRangesFromMemory()
-            
-            # Update title and plots directly without triggering full view change handlers
-            # This prevents unnecessary control rebuilds when just changing shots
-            self.updateTitle()
-            
-            # Plot current shot in the existing views (no view type change)
-            if self.streams and self.currentIndex is not None:
-                # Update top view
-                if hasattr(self, 'topPlotType'):
-                    self._plot_target_widget = self.plotWidget
-                    self._plot_target_viewbox = self.viewBox
+                # Now restore picks from storage if this shot has them
+                if self.currentIndex < len(self.dispersion_curves) and self.dispersion_curves[self.currentIndex] is not None:
+                    curve_data = self.dispersion_curves[self.currentIndex]
                     
-                    if self.topPlotType == "seismogram":
-                        self.updatePlots()
-                    elif self.topPlotType == "layout":
-                        self.plotLayout()
-                    elif self.topPlotType == "traveltime":
-                        self.plotTravelTime()
-                    elif self.topPlotType == "topo":
-                        self.plotTopo()
-                    elif self.topPlotType == "spectrogram":
-                        self.plotSpectrogram()
-                    elif self.topPlotType == "dispersion":
-                        self.plotDispersion()
-                    elif self.topPlotType == "pseudosection":
-                        self.plotPseudoSection()
-                    
-                    # Reset target widget after plotting
-                    self._plot_target_widget = None
-                    self._plot_target_viewbox = None
-                
-                # Update bottom view
-                if hasattr(self, 'bottomPlotType'):
-                    self._plot_target_widget = self.bottomPlotWidget
-                    self._plot_target_viewbox = self.bottomViewBox
+                    # Get current mode from spinbox
+                    current_mode = self.dispersionModeSpinBox.value()
                     
-                    if self.bottomPlotType == "seismogram":
-                        self.updatePlots()
-                    elif self.bottomPlotType == "layout":
-                        self.plotLayout()
-                    elif self.bottomPlotType == "traveltime":
-                        self.plotTravelTime()
-                    elif self.bottomPlotType == "topo":
-                        self.plotTopo()
-                    elif self.bottomPlotType == "spectrogram":
-                        self.plotSpectrogram()
-                    elif self.bottomPlotType == "dispersion":
-                        self.plotDispersion()
-                    elif self.bottomPlotType == "pseudosection":
-                        self.plotPseudoSection()
+                    # Check if data is in new multi-mode format or old single-mode format
+                    if 'modes' in curve_data:
+                        # New multi-mode format
+                        for view in ['top', 'bottom']:
+                            state = self.dispersion_picking_state[view]
+                            state['modes'] = {}
+                            for mode_num, mode_curve_data in curve_data['modes'].items():
+                                # Avoid auto-creating interpolated lines for pvc-file imports
+                                curve_data_to_store = None
+                                if mode_curve_data.get('interpolated', False):
+                                    curve_data_to_store = mode_curve_data.copy()
+                                elif mode_curve_data.get('source') not in ('pvc_file',):
+                                    curve_data_to_store = mode_curve_data.copy()
+
+                                state['modes'][mode_num] = {
+                                    'picked_points': mode_curve_data.get('picked_points', []).copy(),
+                                    'picked_point_items': [None] * len(mode_curve_data.get('picked_points', [])),
+                                    'error_bar_items': [],
+                                    'curve_line': None,
+                                    'interp_error_fill': None,
+                                    'curve_data': curve_data_to_store
+                                }
+                            # Ensure current mode exists (from spinbox)
+                            if current_mode not in state['modes']:
+                                self._ensure_mode_exists(view, current_mode)
+                            state['current_mode'] = current_mode
+                    else:
+                        # Old single-mode format - convert to mode 0
+                        for view in ['top', 'bottom']:
+                            state = self.dispersion_picking_state[view]
+                            state['modes'] = {
+                                0: {
+                                    'picked_points': curve_data.get('picked_points', []).copy(),
+                                    'picked_point_items': [None] * len(curve_data.get('picked_points', [])),
+                                    'error_bar_items': [],
+                                    'curve_line': None,
+                                    'interp_error_fill': None,
+                                    'curve_data': curve_data.copy()
+                                }
+                            }
+                            # Ensure current mode exists
+                            if current_mode not in state['modes']:
+                                self._ensure_mode_exists(view, current_mode)
+                            state['current_mode'] = current_mode
                     
-                    # Reset target widget after plotting
-                    self._plot_target_widget = None
-                    self._plot_target_viewbox = None
-                
-                # Update FFID/source in status bar for all views
-                if hasattr(self, 'ffid') and self.ffid and self.currentIndex < len(self.ffid):
+                    # Clear current_dispersion_data to avoid stale references
+                    self.dispersion_picking_state['top']['current_dispersion_data'] = None
+                    self.dispersion_picking_state['bottom']['current_dispersion_data'] = None
+
+                # Plot the selected file
+                # Ensure plotting parameters are initialized for this file
+                if (self.currentIndex < len(self.shot_trace_number) and 
+                    self.shot_trace_number[self.currentIndex] is None):
+                    # This file's parameters haven't been initialized yet
+                    # This can happen with ASCII imports or corrupted file loading
                     try:
-                        ffid_val = self.ffid[self.currentIndex]
-                        src_val = self.source_position[self.currentIndex] if self.source_position else 'N/A'
-                        self.ffidLabel.setText(f'FFID: {ffid_val} | Source at {src_val} m')
-                    except Exception:
-                        pass
+                        self.getPlotParameters()
+                        self.updatePlotTypeDict()
+                    except:
+                        # If getPlotParameters fails (e.g., for ASCII data), set up basic defaults
+                        if self.currentIndex < len(self.streams) and self.streams[self.currentIndex]:
+                            num_traces = len(self.streams[self.currentIndex])
+                            self.shot_trace_number[self.currentIndex] = list(range(1, num_traces + 1))
+                            self.file_trace_number[self.currentIndex] = np.arange(1, num_traces + 1)
+                            self.trace_position[self.currentIndex] = list(range(num_traces))
+                            self.offset[self.currentIndex] = [i * 1.0 for i in range(num_traces)]  # Default 1m spacing
+                            self.updatePlotTypeDict()
+                
+                # Restore trace ranges from memory if available
+                self._restoreTraceRangesFromMemory()
+                
+                # Update title and plots directly without triggering full view change handlers
+                # This prevents unnecessary control rebuilds when just changing shots
+                self.updateTitle()
                 
-                # Update dispersion window info in status bar
-                self.updateDispersionWindowInfo()
+                # Plot current shot in the existing views (no view type change)
+                if self.streams and self.currentIndex is not None:
+                    # Update top view
+                    if hasattr(self, 'topPlotType'):
+                        self._plot_target_widget = self.plotWidget
+                        self._plot_target_viewbox = self.viewBox
+                        
+                        if self.topPlotType == "seismogram":
+                            self.updatePlots()
+                        elif self.topPlotType == "layout":
+                            self.plotLayout()
+                        elif self.topPlotType == "traveltime":
+                            self.plotTravelTime()
+                        elif self.topPlotType == "topo":
+                            self.plotTopo()
+                        elif self.topPlotType == "spectrogram":
+                            self.plotSpectrogram()
+                        elif self.topPlotType == "dispersion":
+                            self.plotDispersion()
+                        elif self.topPlotType == "pseudosection":
+                            self.plotPseudoSection()
+                        
+                        # Reset target widget after plotting
+                        self._plot_target_widget = None
+                        self._plot_target_viewbox = None
+                    
+                    # Update bottom view
+                    if hasattr(self, 'bottomPlotType'):
+                        self._plot_target_widget = self.bottomPlotWidget
+                        self._plot_target_viewbox = self.bottomViewBox
+                        
+                        if self.bottomPlotType == "seismogram":
+                            self.updatePlots()
+                        elif self.bottomPlotType == "layout":
+                            self.plotLayout()
+                        elif self.bottomPlotType == "traveltime":
+                            self.plotTravelTime()
+                        elif self.bottomPlotType == "topo":
+                            self.plotTopo()
+                        elif self.bottomPlotType == "spectrogram":
+                            self.plotSpectrogram()
+                        elif self.bottomPlotType == "dispersion":
+                            self.plotDispersion()
+                        elif self.bottomPlotType == "pseudosection":
+                            self.plotPseudoSection()
+                        
+                        # Reset target widget after plotting
+                        self._plot_target_widget = None
+                        self._plot_target_viewbox = None
+                    
+                    # Update FFID/source in status bar for all views
+                    if hasattr(self, 'ffid') and self.ffid and self.currentIndex < len(self.ffid):
+                        try:
+                            ffid_val = self.ffid[self.currentIndex]
+                            src_val = self.source_position[self.currentIndex] if self.source_position else 'N/A'
+                            self.ffidLabel.setText(f'FFID: {ffid_val} | Source at {src_val} m')
+                        except Exception:
+                            pass
+                    
+                    # Update dispersion window info in status bar
+                    self.updateDispersionWindowInfo()
+        finally:
+            QApplication.restoreOverrideCursor()
 
     def navigateToPreviousFile(self):
         """Navigate to the previous file in the list"""
@@ -11608,21 +12083,26 @@ class MainWindow(QMainWindow):
             # Clear batch loading flag and trigger initial plot if this was a batch load
             if hasattr(self, '_batch_loading') and self._batch_loading:
                 self._batch_loading = False
-                # Now trigger the plot for the first loaded file, respecting current view selections
-                if counter_stream > 0 and firstNewFile:
-                    self.currentFileName = firstNewFile
-                    self.currentIndex = self.fileNames.index(firstNewFile)
-                    # Ensure plot parameters are initialized for this file
-                    self.getPlotParameters()
-                    # Make sure plotTypeX is correctly set for the first file
-                    # Call autoSelectPlotTypes explicitly to ensure it's based on current file's data
-                    self.autoSelectPlotTypes()
-                    self.fileListWidget.setCurrentRow(self.currentIndex)
-                    # Trigger plots based on currently selected views (not hardcoded seismogram)
-                    if hasattr(self, 'topViewComboBox'):
-                        self.onTopViewChanged(self.topViewComboBox.currentText())
-                    if hasattr(self, 'bottomViewComboBox'):
-                        self.onBottomViewChanged(self.bottomViewComboBox.currentText())
+                # Show wait cursor while rendering the initial wiggle/image display
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    # Now trigger the plot for the first loaded file, respecting current view selections
+                    if counter_stream > 0 and firstNewFile:
+                        self.currentFileName = firstNewFile
+                        self.currentIndex = self.fileNames.index(firstNewFile)
+                        # Ensure plot parameters are initialized for this file
+                        self.getPlotParameters()
+                        # Make sure plotTypeX is correctly set for the first file
+                        # Call autoSelectPlotTypes explicitly to ensure it's based on current file's data
+                        self.autoSelectPlotTypes()
+                        self.fileListWidget.setCurrentRow(self.currentIndex)
+                        # Trigger plots based on currently selected views (not hardcoded seismogram)
+                        if hasattr(self, 'topViewComboBox'):
+                            self.onTopViewChanged(self.topViewComboBox.currentText())
+                        if hasattr(self, 'bottomViewComboBox'):
+                            self.onBottomViewChanged(self.bottomViewComboBox.currentText())
+                finally:
+                    QApplication.restoreOverrideCursor()
             
             # Clean up potential batch loading flag
             if hasattr(self, '_potential_batch_loading'):
@@ -11717,97 +12197,105 @@ class MainWindow(QMainWindow):
         self.stream = read_seismic_file(self.currentFileName, separate_sources=True)
 
     def loadStream(self):
-        # Ensure all lists are properly sized for the current index
-        for attr in self.attributes_to_initialize:
-            attr_list = getattr(self, attr)
-            while len(attr_list) <= self.currentIndex:
-                if attr == 'airWaveItems':
-                    attr_list.append([None, None, None])
-                else:
-                    attr_list.append(None)
+        # Skip wait cursor if batch loading is active (progress dialog already shown)
+        show_cursor = not getattr(self, '_batch_loading', False)
+        if show_cursor:
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            # Ensure all lists are properly sized for the current index
+            for attr in self.attributes_to_initialize:
+                attr_list = getattr(self, attr)
+                while len(attr_list) <= self.currentIndex:
+                    if attr == 'airWaveItems':
+                        attr_list.append([None, None, None])
+                    else:
+                        attr_list.append(None)
         
-        self.streams[self.currentIndex] = self.stream[self.streamIndex]
-        self.input_format[self.currentIndex] = check_format(self.streams[self.currentIndex])
-        self.getPlotParameters()
+            self.streams[self.currentIndex] = self.stream[self.streamIndex]
+            self.input_format[self.currentIndex] = check_format(self.streams[self.currentIndex])
+            self.getPlotParameters()
 
-        # Always update dispersion picking states when loading a shot
-        # First, clear any old items from both plot widgets
-        for view in ['top', 'bottom']:
-            state = self.dispersion_picking_state[view]
-            plot_widget = self.plotWidget if view == 'top' else self.bottomPlotWidget
-            
-            # Remove all mode items from the plot
-            for mode_num, mode_data in state['modes'].items():
-                # Remove picked point items
-                for item in mode_data['picked_point_items']:
-                    if item is not None:
-                        try:
-                            plot_widget.removeItem(item)
-                        except:
-                            pass
-                
-                # Remove curve line
-                if mode_data['curve_line'] is not None:
-                    try:
-                        plot_widget.removeItem(mode_data['curve_line'])
-                    except:
-                        pass
+            # Always update dispersion picking states when loading a shot
+            # First, clear any old items from both plot widgets
+            for view in ['top', 'bottom']:
+                state = self.dispersion_picking_state[view]
+                plot_widget = self.plotWidget if view == 'top' else self.bottomPlotWidget
                 
-                # Remove error bars
-                for item in mode_data.get('error_bar_items', []):
-                    if item is not None:
+                # Remove all mode items from the plot
+                for mode_num, mode_data in state['modes'].items():
+                    # Remove picked point items
+                    for item in mode_data['picked_point_items']:
+                        if item is not None:
+                            try:
+                                plot_widget.removeItem(item)
+                            except:
+                                pass
+                    
+                    # Remove curve line
+                    if mode_data['curve_line'] is not None:
                         try:
-                            plot_widget.removeItem(item)
+                            plot_widget.removeItem(mode_data['curve_line'])
                         except:
                             pass
+                    
+                    # Remove error bars
+                    for item in mode_data.get('error_bar_items', []):
+                        if item is not None:
+                            try:
+                                plot_widget.removeItem(item)
+                            except:
+                                pass
+                    
+                    # Remove interpolated error fill
+                    if mode_data.get('interp_error_fill') is not None:
+                        interp_items = mode_data['interp_error_fill']
+                        if isinstance(interp_items, list):
+                            for item in interp_items:
+                                if item is not None:
+                                    try:
+                                        plot_widget.removeItem(item)
+                                    except:
+                                        pass
                 
-                # Remove interpolated error fill
-                if mode_data.get('interp_error_fill') is not None:
-                    interp_items = mode_data['interp_error_fill']
-                    if isinstance(interp_items, list):
-                        for item in interp_items:
-                            if item is not None:
-                                try:
-                                    plot_widget.removeItem(item)
-                                except:
-                                    pass
-            
-            # CLEAR THE STATE DATA (reset to fundamental mode only)
-            state['modes'] = {
-                0: {
-                    'picked_points': [],
-                    'picked_point_items': [],
-                    'error_bar_items': [],
-                    'curve_line': None,
-                    'interp_error_fill': None,
-                    'curve_data': None
+                # CLEAR THE STATE DATA (reset to fundamental mode only)
+                state['modes'] = {
+                    0: {
+                        'picked_points': [],
+                        'picked_point_items': [],
+                        'error_bar_items': [],
+                        'curve_line': None,
+                        'interp_error_fill': None,
+                        'curve_data': None
+                    }
                 }
-            }
-            state['current_mode'] = 0
-            state['current_dispersion_data'] = None
-        
-        # Now check if this shot has stored dispersion data and restore it
-        self._restoreDispersionPicksFromStorage()
-
-        # If it is the first time the file is loaded, update the sources and traces lists
-        if self.picks[self.currentIndex] is None:
-            # Initialize picks for the current file with a list of nans of the same length as the traces
-            self.picks[self.currentIndex] = [np.nan] * len(self.trace_position[self.currentIndex])
-            # Intialize errors for the current file with a list of nans of the same length as the traces
-            self.error[self.currentIndex] = [np.nan] * len(self.trace_position[self.currentIndex])
-            # Initialize the scatter items for the current file with list of empty lists of the same length as the traces
-            self.pickSeismoItems[self.currentIndex] = [None] * len(self.trace_position[self.currentIndex])
-            # Separate collections for top and bottom seismogram plots
-            if self.currentIndex >= len(self.pickSeismoItems_top):
-                self.pickSeismoItems_top.extend([None] * (self.currentIndex - len(self.pickSeismoItems_top) + 1))
-            if self.currentIndex >= len(self.pickSeismoItems_bottom):
-                self.pickSeismoItems_bottom.extend([None] * (self.currentIndex - len(self.pickSeismoItems_bottom) + 1))
-            self.pickSeismoItems_top[self.currentIndex] = [None] * len(self.trace_position[self.currentIndex])
-            self.pickSeismoItems_bottom[self.currentIndex] = [None] * len(self.trace_position[self.currentIndex])
-            # Initialize the scatter items for the current file with list of empty lists of the same length as the traces
-            self.pickLayoutItems[self.currentIndex] = [None] * len(self.trace_position[self.currentIndex])
-            # Initialize dispersion curves for the current file (one curve per shot)
-            self.dispersion_curves[self.currentIndex] = None
+                state['current_mode'] = 0
+                state['current_dispersion_data'] = None
+            
+            # Now check if this shot has stored dispersion data and restore it
+            self._restoreDispersionPicksFromStorage()
+
+            # If it is the first time the file is loaded, update the sources and traces lists
+            if self.picks[self.currentIndex] is None:
+                # Initialize picks for the current file with a list of nans of the same length as the traces
+                self.picks[self.currentIndex] = [np.nan] * len(self.trace_position[self.currentIndex])
+                # Intialize errors for the current file with a list of nans of the same length as the traces
+                self.error[self.currentIndex] = [np.nan] * len(self.trace_position[self.currentIndex])
+                # Initialize the scatter items for the current file with list of empty lists of the same length as the traces
+                self.pickSeismoItems[self.currentIndex] = [None] * len(self.trace_position[self.currentIndex])
+                # Separate collections for top and bottom seismogram plots
+                if self.currentIndex >= len(self.pickSeismoItems_top):
+                    self.pickSeismoItems_top.extend([None] * (self.currentIndex - len(self.pickSeismoItems_top) + 1))
+                if self.currentIndex >= len(self.pickSeismoItems_bottom):
+                    self.pickSeismoItems_bottom.extend([None] * (self.currentIndex - len(self.pickSeismoItems_bottom) + 1))
+                self.pickSeismoItems_top[self.currentIndex] = [None] * len(self.trace_position[self.currentIndex])
+                self.pickSeismoItems_bottom[self.currentIndex] = [None] * len(self.trace_position[self.currentIndex])
+                # Initialize the scatter items for the current file with list of empty lists of the same length as the traces
+                self.pickLayoutItems[self.currentIndex] = [None] * len(self.trace_position[self.currentIndex])
+                # Initialize dispersion curves for the current file (one curve per shot)
+                self.dispersion_curves[self.currentIndex] = None
+        finally:
+            if show_cursor:
+                QApplication.restoreOverrideCursor()
 
     def removeShot(self):
         if self.currentIndex is not None:
@@ -11860,15 +12348,19 @@ class MainWindow(QMainWindow):
                 format.upper() + " files (*." + format.lower() + ")")
 
             if savePath:
-                stream = self.streams[self.currentIndex]
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    stream = self.streams[self.currentIndex]
 
-                stream = swap_header_format(stream, format)
-                
-                # Save the stream as a SEGY or SU file
-                stream.write(savePath, format=format, 
-                    data_encoding=5, byteorder='>')
-                print(f"Saved single shot ({format.upper()}): {savePath}")
-                QMessageBox.information(self, "File Saved", f"File saved as: {savePath}")
+                    stream = swap_header_format(stream, format)
+                    
+                    # Save the stream as a SEGY or SU file
+                    stream.write(savePath, format=format, 
+                        data_encoding=5, byteorder='>')
+                    print(f"Saved single shot ({format.upper()}): {savePath}")
+                    QMessageBox.information(self, "File Saved", f"File saved as: {savePath}")
+                finally:
+                    QApplication.restoreOverrideCursor()
                 
     def saveAllFiles(self, single=False):
         # Save all shots as SEGY or SU files
@@ -11883,48 +12375,51 @@ class MainWindow(QMainWindow):
                 saveDir = QFileDialog.getExistingDirectory(self, f"Select folder to save individual {self.output_format.upper()} files with modified headers")
 
                 if saveDir:
-
-                    # Start progress dialog if there are multiple files
-                    if len(self.streams) > 1:
-                        progress = QProgressDialog("Saving files...", "Cancel", 0, len(self.streams), self)
-                        progress.setWindowTitle(f"Saving Files") # Explicitly set the window title
-                        progress.setMinimumDuration(0)  # Show immediately
-                        progress.setWindowModality(QtCore.Qt.WindowModal)
-                        progress.setValue(0)
-                        progress.show()
-                        QApplication.processEvents()
-
-                    for i, stream in enumerate(self.streams):
+                    QApplication.setOverrideCursor(Qt.WaitCursor)
+                    try:
+                        # Start progress dialog if there are multiple files
                         if len(self.streams) > 1:
-                            # Update the progress dialog
-                            progress.setValue(i)
+                            progress = QProgressDialog("Saving files...", "Cancel", 0, len(self.streams), self)
+                            progress.setWindowTitle(f"Saving Files") # Explicitly set the window title
+                            progress.setMinimumDuration(0)  # Show immediately
+                            progress.setWindowModality(QtCore.Qt.WindowModal)
+                            progress.setValue(0)
+                            progress.show()
                             QApplication.processEvents()
 
-                        stream = swap_header_format(stream, self.output_format)
-                        self.input_format[i] = check_format(stream)
+                        for i, stream in enumerate(self.streams):
+                            if len(self.streams) > 1:
+                                # Update the progress dialog
+                                progress.setValue(i)
+                                QApplication.processEvents()
 
-                        # Default file name is fileNames[i] without extension _ffid.format
-                        # check if ffid is in the original file name
-                        if str(self.ffid[i]) in os.path.basename(self.fileNames[i]):
-                            defaultSavePath = os.path.splitext(self.fileNames[i])[0] + '.' + self.output_format.lower()
-                        else:
-                            defaultSavePath = os.path.splitext(self.fileNames[i])[0] + '_' + str(self.ffid[i]) + '.' + self.output_format.lower()
+                            stream = swap_header_format(stream, self.output_format)
+                            self.input_format[i] = check_format(stream)
 
-                        savePath = os.path.join(saveDir, os.path.basename(defaultSavePath))
-                        # Make sure we're not overwriting an existing file
-                        # if os.path.exists(savePath):
-                        savePath = savePath.replace('.' + self.output_format.lower(), '_updated.' + self.output_format.lower())
-                        stream.write(savePath, format=self.output_format, 
-                            data_encoding=5, byteorder='>')
-                        print(f"Saved shot {i+1}/{len(self.streams)} ({self.output_format.upper()}): {savePath}")
+                            # Default file name is fileNames[i] without extension _ffid.format
+                            # check if ffid is in the original file name
+                            if str(self.ffid[i]) in os.path.basename(self.fileNames[i]):
+                                defaultSavePath = os.path.splitext(self.fileNames[i])[0] + '.' + self.output_format.lower()
+                            else:
+                                defaultSavePath = os.path.splitext(self.fileNames[i])[0] + '_' + str(self.ffid[i]) + '.' + self.output_format.lower()
 
-                    if len(self.streams) > 1:
-                        # Ensure the progress dialog closes
-                        progress.setValue(len(self.streams))
-                        QMessageBox.information(self, "Files Saved", f"{len(self.streams)} files saved successfully in: {saveDir}")
-                    
-                    # Reset headers modified flag after successful save
-                    self.headers_modified = False
+                            savePath = os.path.join(saveDir, os.path.basename(defaultSavePath))
+                            # Make sure we're not overwriting an existing file
+                            # if os.path.exists(savePath):
+                            savePath = savePath.replace('.' + self.output_format.lower(), '_updated.' + self.output_format.lower())
+                            stream.write(savePath, format=self.output_format, 
+                                data_encoding=5, byteorder='>')
+                            print(f"Saved shot {i+1}/{len(self.streams)} ({self.output_format.upper()}): {savePath}")
+
+                        if len(self.streams) > 1:
+                            # Ensure the progress dialog closes
+                            progress.setValue(len(self.streams))
+                            QMessageBox.information(self, "Files Saved", f"{len(self.streams)} files saved successfully in: {saveDir}")
+                        
+                        # Reset headers modified flag after successful save
+                        self.headers_modified = False
+                    finally:
+                        QApplication.restoreOverrideCursor()
             else:
                 # Ask for single filename
                 savePath, _ = QFileDialog.getSaveFileName(self, "Save as " + self.output_format.upper() + " file", 
@@ -11932,21 +12427,25 @@ class MainWindow(QMainWindow):
                     self.output_format.upper() + " files (*." + self.output_format.lower() + ")")
                 
                 if savePath:
-                    # Merge all streams into a single stream
-                    merged_stream = merge_streams(self.streams)
+                    QApplication.setOverrideCursor(Qt.WaitCursor)
+                    try:
+                        # Merge all streams into a single stream
+                        merged_stream = merge_streams(self.streams)
 
-                    merged_stream = swap_header_format(merged_stream, self.output_format)
-                    for i, stream in enumerate(self.streams):
-                        self.input_format[i] = check_format(stream)
+                        merged_stream = swap_header_format(merged_stream, self.output_format)
+                        for i, stream in enumerate(self.streams):
+                            self.input_format[i] = check_format(stream)
 
-                    # Save the merged stream as a SEGY or SU file
-                    merged_stream.write(savePath, format=self.output_format, 
-                        data_encoding=5, byteorder='>')
-                    print(f"Saved all shots merged into single file ({self.output_format.upper()}): {savePath}")
-                    QMessageBox.information(self, "File Saved", f"File saved as: {savePath}")
-                    
-                    # Reset headers modified flag after successful save
-                    self.headers_modified = False
+                        # Save the merged stream as a SEGY or SU file
+                        merged_stream.write(savePath, format=self.output_format, 
+                            data_encoding=5, byteorder='>')
+                        print(f"Saved all shots merged into single file ({self.output_format.upper()}): {savePath}")
+                        QMessageBox.information(self, "File Saved", f"File saved as: {savePath}")
+                        
+                        # Reset headers modified flag after successful save
+                        self.headers_modified = False
+                    finally:
+                        QApplication.restoreOverrideCursor()
                 
                     
     def saveSingleFileSEGY(self):
@@ -12203,12 +12702,12 @@ class MainWindow(QMainWindow):
                 self.sourcesCombo.setCurrentText("Position")
         else:
             # Use trace number and FFID plotting (default)
-            self.plotTypeX = 'shot_trace_number'
+            self.plotTypeX = 'file_trace_number'
             self.plotTypeY = 'ffid'
             # Update menu actions to reflect the change
-            if hasattr(self, 'shotTraceNumberAction'):
-                self.shotTraceNumberAction.setChecked(True)
-                self.fileTraceNumberAction.setChecked(False)
+            if hasattr(self, 'fileTraceNumberAction'):
+                self.fileTraceNumberAction.setChecked(True)
+                self.shotTraceNumberAction.setChecked(False)
                 self.uniqueTraceNumberAction.setChecked(False)
                 self.tracePositionAction.setChecked(False)
             if hasattr(self, 'ffidAction'):
@@ -12217,7 +12716,7 @@ class MainWindow(QMainWindow):
                 self.offsetAction.setChecked(False)
             # Update comboboxes to reflect the change
             if hasattr(self, 'tracesCombo'):
-                self.tracesCombo.setCurrentText("Original trace no")
+                self.tracesCombo.setCurrentText("Trace in shot")
             if hasattr(self, 'sourcesCombo'):
                 self.sourcesCombo.setCurrentText("FFID")
         
@@ -12444,18 +12943,22 @@ class MainWindow(QMainWindow):
             )
 
             if dialog.exec_():
-                values = dialog.getValues()
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
 
-                ffid = values['FFID']
-                self.ffid[self.currentIndex] = int(ffid)
-                # Sync headers to obspy streams immediately
-                self.syncHeadersToStreams(self.currentIndex)
-                self.headers_modified = True  # Mark headers as modified
-                QMessageBox.information(self, "FFID Updated", f"FFID set to {ffid} for file {os.path.basename(self.currentFileName)}")
+                    ffid = values['FFID']
+                    self.ffid[self.currentIndex] = int(ffid)
+                    # Sync headers to obspy streams immediately
+                    self.syncHeadersToStreams(self.currentIndex)
+                    self.headers_modified = True  # Mark headers as modified
+                    QMessageBox.information(self, "FFID Updated", f"FFID set to {ffid} for file {os.path.basename(self.currentFileName)}")
 
-                self.updateTitle()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                    self.updateTitle()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
 
 
     def editDelay(self):
@@ -12473,38 +12976,42 @@ class MainWindow(QMainWindow):
             )
 
             if dialog.exec_():
-                values = dialog.getValues()
-                apply_to_all = dialog.isChecked()
-                delay = values['Delay (in s)']
-                diff_delay = delay - self.delay[self.currentIndex]
-
-                if apply_to_all: 
-                    self.delay = [delay] * len(self.delay)  # Apply the delay to all files
-                    self.time = [np.arange(n_sample) * sample_interval + delay for n_sample, sample_interval in zip(self.n_sample, self.sample_interval)]
-                    # Update the picks with the new delay for files containing picks
-                    for i, picks in enumerate(self.picks):
-                        if picks is not None:
-                            self.picks[i] = [pick + diff_delay for pick in picks]
-                    # Sync headers to obspy streams immediately for all files
-                    for i in range(len(self.streams)):
-                        self.syncHeadersToStreams(i)
-                    self.headers_modified = True  # Mark headers as modified
-                    QMessageBox.information(self, "Delay Updated", f"Delay set to {delay} s for all files")
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
+                    apply_to_all = dialog.isChecked()
+                    delay = values['Delay (in s)']
+                    diff_delay = delay - self.delay[self.currentIndex]
+
+                    if apply_to_all: 
+                        self.delay = [delay] * len(self.delay)  # Apply the delay to all files
+                        self.time = [np.arange(n_sample) * sample_interval + delay for n_sample, sample_interval in zip(self.n_sample, self.sample_interval)]
+                        # Update the picks with the new delay for files containing picks
+                        for i, picks in enumerate(self.picks):
+                            if picks is not None:
+                                self.picks[i] = [pick + diff_delay for pick in picks]
+                        # Sync headers to obspy streams immediately for all files
+                        for i in range(len(self.streams)):
+                            self.syncHeadersToStreams(i)
+                        self.headers_modified = True  # Mark headers as modified
+                        QMessageBox.information(self, "Delay Updated", f"Delay set to {delay} s for all files")
 
-                else:
-                    self.delay[self.currentIndex] = delay
-                    self.time[self.currentIndex] = np.arange(self.n_sample[self.currentIndex]) * self.sample_interval[self.currentIndex] + self.delay[self.currentIndex]
-                    if self.picks is not None:
-                        self.picks[self.currentIndex] = [pick + diff_delay for pick in self.picks[self.currentIndex]]
-                    # Sync headers to obspy streams immediately
-                    self.syncHeadersToStreams(self.currentIndex)
-                    self.headers_modified = True  # Mark headers as modified
-                    QMessageBox.information(self, "Delay Updated", f"Delay set to {delay} s for file {os.path.basename(self.currentFileName)}")
-                # Mark headers/traces as modified
-                self.headers_modified = True
-                self.updatePlots()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                    else:
+                        self.delay[self.currentIndex] = delay
+                        self.time[self.currentIndex] = np.arange(self.n_sample[self.currentIndex]) * self.sample_interval[self.currentIndex] + self.delay[self.currentIndex]
+                        if self.picks is not None:
+                            self.picks[self.currentIndex] = [pick + diff_delay for pick in self.picks[self.currentIndex]]
+                        # Sync headers to obspy streams immediately
+                        self.syncHeadersToStreams(self.currentIndex)
+                        self.headers_modified = True  # Mark headers as modified
+                        QMessageBox.information(self, "Delay Updated", f"Delay set to {delay} s for file {os.path.basename(self.currentFileName)}")
+                    # Mark headers/traces as modified
+                    self.headers_modified = True
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
 
     def editSampleInterval(self):
         if self.streams:
@@ -12557,21 +13064,24 @@ class MainWindow(QMainWindow):
             )
 
             if dialog.exec_():
-                values = dialog.getValues()
-                source_position = values['Source Position (in m)']
-                self.source_position[self.currentIndex] = source_position
-                self.offset[self.currentIndex] = self.trace_position[self.currentIndex] - source_position
-                # Sync headers to obspy streams immediately
-                self.syncHeadersToStreams(self.currentIndex)
-                self.headers_modified = True  # Mark headers as modified
-                QMessageBox.information(self, "Source Position Updated", f"Source position set to {source_position} m for file {os.path.basename(self.currentFileName)}")
-
-                # Mark headers/traces as modified
-                self.headers_modified = True
-                self.updateMeanSpacing()
-                self.updatePlots()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
+                    source_position = values['Source Position (in m)']
+                    self.source_position[self.currentIndex] = source_position
+                    self.offset[self.currentIndex] = self.trace_position[self.currentIndex] - source_position
+                    # Sync headers to obspy streams immediately
+                    self.syncHeadersToStreams(self.currentIndex)
+                    self.headers_modified = True  # Mark headers as modified
+
+                    # Mark headers/traces as modified
+                    self.headers_modified = True
+                    self.updateMeanSpacing()
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
 
     def editTracePosition(self):
         if self.streams:
@@ -12580,28 +13090,44 @@ class MainWindow(QMainWindow):
 
             dialog = TraceSelector(trace_numbers, trace_positions, parent=self,title="Edit Trace Position",show_position=True)
             if dialog.exec_():
-                selected_index, new_position, apply_to_all = dialog.getValues()
-                if apply_to_all:
-                    # Set trace position for all files
-                    for i in range(len(self.streams)):
-                        self.trace_position[i][selected_index] = new_position
-                        self.offset[i][selected_index] = new_position - self.source_position[i]
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    selected_index, new_position, apply_to_all = dialog.getValues()
+                    if apply_to_all:
+                        # Set trace position for all files
+                        for i in range(len(self.streams)):
+                            self.trace_position[i][selected_index] = new_position
+                            self.offset[i][selected_index] = new_position - self.source_position[i]
+                            
+                            # Reorder traces by position to maintain spatial order
+                            self._reorderTracesByPosition(i)
+                            
+                            # Sync headers to obspy streams immediately
+                            self.syncHeadersToStreams(i)
+                        self.headers_modified = True  # Mark headers as modified
+                        
+                        # Recalculate unique trace numbers for all files at once
+                        self._updateAllUniqueTraceNumbers()
+                    else:
+                        self.trace_position[self.currentIndex][selected_index] = new_position
+                        self.offset[self.currentIndex][selected_index] = new_position - self.source_position[self.currentIndex]
+                        
+                        # Reorder traces by position to maintain spatial order
+                        self._reorderTracesByPosition(self.currentIndex)
+                        
                         # Sync headers to obspy streams immediately
-                        self.syncHeadersToStreams(i)
-                    self.headers_modified = True  # Mark headers as modified
-                    QMessageBox.information(self, "Trace Position Updated", f"Trace position for trace #{trace_numbers[selected_index]} set to {new_position} m for all files")
-                else:
-                    self.trace_position[self.currentIndex][selected_index] = new_position
-                    self.offset[self.currentIndex][selected_index] = new_position - self.source_position[self.currentIndex]
-                    # Sync headers to obspy streams immediately
-                    self.syncHeadersToStreams(self.currentIndex)
-                    self.headers_modified = True  # Mark headers as modified
-                    QMessageBox.information(self, "Trace Position Updated", f"Trace position for trace #{trace_numbers[selected_index]} set to {new_position} m for file {os.path.basename(self.currentFileName)}")
+                        self.syncHeadersToStreams(self.currentIndex)
+                        self.headers_modified = True  # Mark headers as modified
+                        
+                        # Recalculate unique trace numbers for all files at once
+                        self._updateAllUniqueTraceNumbers()
 
-                self.updateMeanSpacing()
-                self.updatePlots()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                        self.updateMeanSpacing()
+                        self.updatePlots()
+                        self.updateFileListDisplay()
+                        self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
 
     def autoPickSTA_LTA(self):
         """Automatic STA/LTA picker. Shows a parameter dialog, then applies the detector to the current shot or all shots."""
@@ -14675,6 +15201,51 @@ class MainWindow(QMainWindow):
             QMessageBox.warning(self, "Optimization Error", f"Optimization failed: {str(e)}")
             return None
 
+    def _reorderTracesByPosition(self, file_idx):
+        """Reorder traces in a file based on their spatial positions (ascending order).
+        This maintains consistency between trace order and spatial layout.
+        
+        Args:
+            file_idx: Index of the file to reorder
+        """
+        if file_idx >= len(self.trace_position):
+            return
+        
+        # Get the current positions and create a sorted index array
+        positions = np.array(self.trace_position[file_idx])
+        sorted_indices = np.argsort(positions)
+        
+        # Check if already sorted (no reordering needed)
+        if np.array_equal(sorted_indices, np.arange(len(sorted_indices))):
+            return  # Already in correct order
+        
+        # Reorder the stream traces
+        input_format = self.input_format[file_idx]
+        original_traces = [self.streams[file_idx][i] for i in sorted_indices]
+        self.streams[file_idx].traces = original_traces
+        
+        # Reorder all associated arrays (ensure they're numpy arrays first)
+        self.trace_position[file_idx] = positions[sorted_indices]
+        self.trace_elevation[file_idx] = np.array(self.trace_elevation[file_idx])[sorted_indices]
+        self.offset[file_idx] = np.array(self.offset[file_idx])[sorted_indices]
+        self.shot_trace_number[file_idx] = np.array(self.shot_trace_number[file_idx])[sorted_indices]
+        self.file_trace_number[file_idx] = np.array(self.file_trace_number[file_idx])[sorted_indices]
+        
+        # Reorder picks and errors
+        if self.picks[file_idx] is not None:
+            self.picks[file_idx] = np.array(self.picks[file_idx])[sorted_indices]
+        if self.error[file_idx] is not None:
+            self.error[file_idx] = np.array(self.error[file_idx])[sorted_indices]
+        
+        # Reorder pick items (handle as numpy array for consistent indexing)
+        if self.pickSeismoItems[file_idx] is not None:
+            self.pickSeismoItems[file_idx] = np.array(self.pickSeismoItems[file_idx], dtype=object)[sorted_indices]
+        if self.pickLayoutItems[file_idx] is not None:
+            self.pickLayoutItems[file_idx] = np.array(self.pickLayoutItems[file_idx], dtype=object)[sorted_indices]
+        
+        # Update file_trace_number to be sequential (1, 2, 3...)
+        self._updateSequentialTraceNumbers(file_idx)
+
     def _updateSequentialTraceNumbers(self, file_index):
         """Update file_trace_number to be sequential (1, 2, 3...) after any trace modification.
         This keeps trace numbering relative regardless of which traces have been removed or reordered.
@@ -14750,17 +15321,53 @@ class MainWindow(QMainWindow):
             )
 
             if dialog.exec_():
-                values = dialog.getValues()
-                first_trace = values['First Trace #']  # 1-based user input
-                second_trace = values['Second Trace #']  # 1-based user input
-                
-                # Convert to 0-based indices
-                first_idx = first_trace - 1
-                second_idx = second_trace - 1
-
-                # Swap the traces
-                if dialog.isChecked():
-                    for i in range(len(self.streams)):
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
+                    first_trace = values['First Trace #']  # 1-based user input
+                    second_trace = values['Second Trace #']  # 1-based user input
+                    
+                    # Convert to 0-based indices
+                    first_idx = first_trace - 1
+                    second_idx = second_trace - 1
+
+                    # Swap the traces
+                    if dialog.isChecked():
+                        for i in range(len(self.streams)):
+                            n_traces = len(self.streams[i])
+                            # Validate indices
+                            if first_idx < n_traces and second_idx < n_traces and first_idx != second_idx:
+                                self.streams[i] = swap_traces(self.streams[i], first_trace, second_trace)
+                                
+                                # Swap picks and errors (they follow their traces)
+                                if self.picks[i] is not None:
+                                    self.picks[i][first_idx], self.picks[i][second_idx] = \
+                                        self.picks[i][second_idx], self.picks[i][first_idx]
+                                if self.error[i] is not None:
+                                    self.error[i][first_idx], self.error[i][second_idx] = \
+                                        self.error[i][second_idx], self.error[i][first_idx]
+                                
+                                # Swap pick items
+                                if self.pickSeismoItems[i] is not None:
+                                    self.pickSeismoItems[i][first_idx], self.pickSeismoItems[i][second_idx] = \
+                                        self.pickSeismoItems[i][second_idx], self.pickSeismoItems[i][first_idx]
+                                if self.pickLayoutItems[i] is not None:
+                                    self.pickLayoutItems[i][first_idx], self.pickLayoutItems[i][second_idx] = \
+                                        self.pickLayoutItems[i][second_idx], self.pickLayoutItems[i][first_idx]
+                                
+                                # Rebuild shot_trace_number from updated obspy headers (follows its associated trace)
+                                shot_trace_number = [trace.stats[self.input_format[i]].trace_header.trace_number_within_the_original_field_record 
+                                                    for trace in self.streams[i]]
+                                self.shot_trace_number[i] = shot_trace_number
+                                
+                                # Update file_trace_number to be sequential and recalculate unique_trace_number
+                                self._updateSequentialTraceNumbers(i)
+                                # Sync headers to obspy streams immediately
+                                self.syncHeadersToStreams(i)
+                        
+                        self.headers_modified = True  # Mark headers as modified
+                    else:
+                        i = self.currentIndex
                         n_traces = len(self.streams[i])
                         # Validate indices
                         if first_idx < n_traces and second_idx < n_traces and first_idx != second_idx:
@@ -14791,64 +15398,57 @@ class MainWindow(QMainWindow):
                             self._updateSequentialTraceNumbers(i)
                             # Sync headers to obspy streams immediately
                             self.syncHeadersToStreams(i)
-                    
-                    QMessageBox.information(self, "Traces Swapped", f"Traces {first_trace} and {second_trace} swapped for all files")
-                    self.headers_modified = True  # Mark headers as modified
-                else:
-                    i = self.currentIndex
-                    n_traces = len(self.streams[i])
-                    # Validate indices
-                    if first_idx < n_traces and second_idx < n_traces and first_idx != second_idx:
-                        self.streams[i] = swap_traces(self.streams[i], first_trace, second_trace)
-                        
-                        # Swap picks and errors (they follow their traces)
-                        if self.picks[i] is not None:
-                            self.picks[i][first_idx], self.picks[i][second_idx] = \
-                                self.picks[i][second_idx], self.picks[i][first_idx]
-                        if self.error[i] is not None:
-                            self.error[i][first_idx], self.error[i][second_idx] = \
-                                self.error[i][second_idx], self.error[i][first_idx]
-                        
-                        # Swap pick items
-                        if self.pickSeismoItems[i] is not None:
-                            self.pickSeismoItems[i][first_idx], self.pickSeismoItems[i][second_idx] = \
-                                self.pickSeismoItems[i][second_idx], self.pickSeismoItems[i][first_idx]
-                        if self.pickLayoutItems[i] is not None:
-                            self.pickLayoutItems[i][first_idx], self.pickLayoutItems[i][second_idx] = \
-                                self.pickLayoutItems[i][second_idx], self.pickLayoutItems[i][first_idx]
-                        
-                        # Rebuild shot_trace_number from updated obspy headers (follows its associated trace)
-                        shot_trace_number = [trace.stats[self.input_format[i]].trace_header.trace_number_within_the_original_field_record 
-                                            for trace in self.streams[i]]
-                        self.shot_trace_number[i] = shot_trace_number
-                        
-                        # Update file_trace_number to be sequential and recalculate unique_trace_number
-                        self._updateSequentialTraceNumbers(i)
-                        # Sync headers to obspy streams immediately
-                        self.syncHeadersToStreams(i)
-                        
-                        QMessageBox.information(self, "Traces Swapped", f"Traces {first_trace} and {second_trace} swapped for file {os.path.basename(self.currentFileName)}")
-                        self.headers_modified = True  # Mark headers as modified
-                    else:
-                        QMessageBox.warning(self, "Invalid Trace Numbers", f"Invalid trace indices: {first_trace}, {second_trace}")
+                            
+                            self.headers_modified = True  # Mark headers as modified
+                        else:
+                            QMessageBox.warning(self, "Invalid Trace Numbers", f"Invalid trace indices: {first_trace}, {second_trace}")
 
-                self.updatePlots()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                        self.updatePlots()
+                        self.updateFileListDisplay()
+                        self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
 
     def removeTrace(self):
         if self.streams:
             trace_numbers = self.shot_trace_number[self.currentIndex]
             dialog = TraceSelector(trace_numbers, trace_positions=None, parent=self, title="Remove Trace", show_position=False)
             if dialog.exec_():
-                selected_index, apply_to_all = dialog.getValues()
-                # selected_index is the array index (0-based) directly from TraceSelector
-                trace_display_number = trace_numbers[selected_index]
-
-                if apply_to_all:
-                    # Remove the trace for all files
-                    for i in range(len(self.streams)):
-                        if selected_index < len(self.streams[i]):
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    selected_index, apply_to_all = dialog.getValues()
+                    # selected_index is the array index (0-based) directly from TraceSelector
+                    trace_display_number = trace_numbers[selected_index]
+
+                    if apply_to_all:
+                        # Remove the trace for all files
+                        for i in range(len(self.streams)):
+                            if selected_index < len(self.streams[i]):
+                                self.streams[i] = remove_trace(self.streams[i], trace_display_number)
+                                # Delete by index (directly remove from position)
+                                self.offset[i] = np.delete(self.offset[i], selected_index)
+                                self.trace_position[i] = np.delete(self.trace_position[i], selected_index)
+                                self.trace_elevation[i] = np.delete(self.trace_elevation[i], selected_index)
+                                self.shot_trace_number[i] = np.delete(self.shot_trace_number[i], selected_index)
+                                self.file_trace_number[i] = np.delete(self.file_trace_number[i], selected_index)
+                                self.picks[i] = np.delete(self.picks[i], selected_index)
+                                self.error[i] = np.delete(self.error[i], selected_index)
+                                self.pickSeismoItems[i] = np.delete(self.pickSeismoItems[i], selected_index)
+                                self.pickLayoutItems[i] = np.delete(self.pickLayoutItems[i], selected_index)
+                                
+                                # Rebuild shot_trace_number from updated obspy headers
+                                self.shot_trace_number[i] = [trace.stats[self.input_format[i]].trace_header.trace_number_within_the_original_field_record 
+                                                            for trace in self.streams[i]]
+                                # Update file_trace_number to be sequential (1, 2, 3...)
+                                self._updateSequentialTraceNumbers(i)
+                                # Sync headers to obspy streams immediately
+                                self.syncHeadersToStreams(i)
+                        
+                        self.headers_modified = True  # Mark headers as modified
+                    else:
+                        # Remove the trace for the current file only
+                        if selected_index < len(self.streams[self.currentIndex]):
+                            i = self.currentIndex
                             self.streams[i] = remove_trace(self.streams[i], trace_display_number)
                             # Delete by index (directly remove from position)
                             self.offset[i] = np.delete(self.offset[i], selected_index)
@@ -14868,39 +15468,169 @@ class MainWindow(QMainWindow):
                             self._updateSequentialTraceNumbers(i)
                             # Sync headers to obspy streams immediately
                             self.syncHeadersToStreams(i)
-                    
-                    QMessageBox.information(self, "Trace Removed", f"Trace #{trace_display_number} removed for all files")
-                    self.headers_modified = True  # Mark headers as modified
-                else:
-                    # Remove the trace for the current file only
-                    if selected_index < len(self.streams[self.currentIndex]):
+
+                        self.updateMeanSpacing()
+                        self.updatePlots()
+                        self.updateFileListDisplay()
+                        self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
+
+    def insertMutedTraces(self):
+        """Insert one or more zero traces after a specified trace number."""
+        if self.streams:
+            n_traces = len(self.streams[self.currentIndex])
+            
+            parameters = [
+                {'label': 'Insert after Trace # (0 for beginning)', 'initial_value': n_traces, 'type': 'int'},
+                {'label': 'Number of traces to insert', 'initial_value': 1, 'type': 'int'}
+            ]
+            
+            dialog = GenericParameterDialog(
+                title="Insert Zero Traces",
+                parameters=parameters,
+                add_checkbox=True,
+                checkbox_text="Apply to all shots",
+                parent=self
+            )
+            
+            if dialog.exec_():
+                values = dialog.getValues()
+                insert_after = values['Insert after Trace # (0 for beginning)']
+                num_to_insert = values['Number of traces to insert']
+                apply_to_all = dialog.isChecked()
+                
+                # Validate inputs
+                if num_to_insert < 1:
+                    QMessageBox.warning(self, "Invalid Input", "Number of traces must be at least 1")
+                    return
+                
+                # Show wait cursor while processing
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    if apply_to_all:
+                        # Insert traces for all files
+                        for i in range(len(self.streams)):
+                            n_traces_i = len(self.streams[i])
+                            if insert_after > n_traces_i:
+                                continue  # Skip if position is beyond trace count
+                            
+                            self._insertMutedTracesInFile(i, insert_after, num_to_insert)
+                            # Sync headers to obspy streams immediately
+                            self.syncHeadersToStreams(i)
+                        
+                        self.headers_modified = True
+                    else:
+                        # Insert traces for current file only
                         i = self.currentIndex
-                        self.streams[i] = remove_trace(self.streams[i], trace_display_number)
-                        # Delete by index (directly remove from position)
-                        self.offset[i] = np.delete(self.offset[i], selected_index)
-                        self.trace_position[i] = np.delete(self.trace_position[i], selected_index)
-                        self.trace_elevation[i] = np.delete(self.trace_elevation[i], selected_index)
-                        self.shot_trace_number[i] = np.delete(self.shot_trace_number[i], selected_index)
-                        self.file_trace_number[i] = np.delete(self.file_trace_number[i], selected_index)
-                        self.picks[i] = np.delete(self.picks[i], selected_index)
-                        self.error[i] = np.delete(self.error[i], selected_index)
-                        self.pickSeismoItems[i] = np.delete(self.pickSeismoItems[i], selected_index)
-                        self.pickLayoutItems[i] = np.delete(self.pickLayoutItems[i], selected_index)
+                        n_traces_i = len(self.streams[i])
+                        if insert_after > n_traces_i:
+                            QMessageBox.warning(self, "Invalid Position", 
+                                f"Insert position ({insert_after}) exceeds trace count ({n_traces_i})")
+                            return
                         
-                        # Rebuild shot_trace_number from updated obspy headers
-                        self.shot_trace_number[i] = [trace.stats[self.input_format[i]].trace_header.trace_number_within_the_original_field_record 
-                                                    for trace in self.streams[i]]
-                        # Update file_trace_number to be sequential (1, 2, 3...)
-                        self._updateSequentialTraceNumbers(i)
+                        self._insertMutedTracesInFile(i, insert_after, num_to_insert)
                         # Sync headers to obspy streams immediately
                         self.syncHeadersToStreams(i)
                         
-                        QMessageBox.information(self, "Trace Removed", f"Trace #{trace_display_number} removed for file {os.path.basename(self.currentFileName)}")
-
-                self.updateMeanSpacing()
-                self.updatePlots()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                        self.headers_modified = True
+                    
+                    # Recalculate unique trace numbers for all files at once
+                    self._updateAllUniqueTraceNumbers()
+                    self.updateMeanSpacing()
+                    self.updatePlotTypeDict()
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    # Always restore cursor even if there's an error
+                    QApplication.restoreOverrideCursor()
+    
+    def _insertMutedTracesInFile(self, file_idx, insert_after, num_to_insert):
+        """Helper function to insert zero traces in a specific file.
+        
+        Args:
+            file_idx: Index of the file
+            insert_after: Insert after this trace number (0 = beginning, 1-based)
+            num_to_insert: Number of zero traces to insert
+        """
+        from obspy import Trace, Stream
+        import copy
+        
+        # Determine insert position (0-based index)
+        insert_pos = insert_after  # If insert_after=0, insert at position 0; if insert_after=1, insert at position 1
+        
+        # Get a reference trace to copy metadata from (use first trace or the one before insert position)
+        if len(self.streams[file_idx]) > 0:
+            if insert_after > 0 and insert_after <= len(self.streams[file_idx]):
+                ref_trace = self.streams[file_idx][insert_after - 1]
+            else:
+                ref_trace = self.streams[file_idx][0]
+        else:
+            QMessageBox.warning(self, "No Traces", "Cannot insert traces into empty stream")
+            return
+        
+        input_format = self.input_format[file_idx]
+        
+        # Find the next available trace number
+        existing_trace_numbers = [trace.stats[input_format].trace_header.trace_number_within_the_original_field_record 
+                                  for trace in self.streams[file_idx]]
+        max_trace_number = max(existing_trace_numbers) if existing_trace_numbers else 0
+        
+        # Create the zero traces
+        new_traces = []
+        for offset in range(num_to_insert):
+            # Create a copy of the reference trace
+            new_trace = ref_trace.copy()
+            
+            # Zero out the data
+            new_trace.data = np.zeros_like(new_trace.data)
+            
+            # Assign a new trace number
+            new_trace_number = max_trace_number + offset + 1
+            new_trace.stats[input_format].trace_header.trace_number_within_the_original_field_record = new_trace_number
+            
+            # Set position and elevation to 0
+            if input_format == 'segy':
+                new_trace.stats.segy.trace_header.group_coordinate_x = 0
+                new_trace.stats.segy.trace_header.group_coordinate_y = 0
+            elif input_format == 'su':
+                new_trace.stats.su.trace_header.group_coordinate_x = 0
+                new_trace.stats.su.trace_header.group_coordinate_y = 0
+            
+            new_traces.append(new_trace)
+        
+        # Rebuild the stream with traces inserted at the correct position
+        new_stream = Stream()
+        old_stream_list = list(self.streams[file_idx])  # Convert to list
+        new_stream_list = old_stream_list[:insert_pos] + new_traces + old_stream_list[insert_pos:]
+        for trace in new_stream_list:
+            new_stream.append(trace)
+        self.streams[file_idx] = new_stream
+        
+        # Insert into associated arrays - insert all at the same position repeatedly
+        # This works because each insert shifts subsequent elements right
+        for offset in range(num_to_insert):
+            new_trace_number = max_trace_number + offset + 1
+            
+            # Always insert at insert_pos - numpy.insert shifts elements right automatically
+            self.trace_position[file_idx] = np.insert(self.trace_position[file_idx], insert_pos, 0.0)
+            self.trace_elevation[file_idx] = np.insert(self.trace_elevation[file_idx], insert_pos, 0.0)
+            self.offset[file_idx] = np.insert(self.offset[file_idx], insert_pos, 
+                                              0.0 - self.source_position[file_idx])
+            self.shot_trace_number[file_idx] = np.insert(self.shot_trace_number[file_idx], insert_pos, new_trace_number)
+            self.file_trace_number[file_idx] = np.insert(self.file_trace_number[file_idx], insert_pos, insert_pos + 1)
+            
+            # Insert NaN for picks and errors
+            self.picks[file_idx] = np.insert(self.picks[file_idx], insert_pos, np.nan)
+            self.error[file_idx] = np.insert(self.error[file_idx], insert_pos, np.nan)
+            
+            # Insert None for pick items
+            self.pickSeismoItems[file_idx] = np.insert(self.pickSeismoItems[file_idx], insert_pos, None)
+            self.pickLayoutItems[file_idx] = np.insert(self.pickLayoutItems[file_idx], insert_pos, None)
+        
+        # Update file_trace_number to be sequential after all insertions
+        self._updateSequentialTraceNumbers(file_idx)
 
     def moveTrace(self):
         if self.streams:
@@ -14908,12 +15638,13 @@ class MainWindow(QMainWindow):
             max_position = n_traces
             
             parameters = [
-            {'label': 'Trace # (relative)', 'initial_value': 1, 'type': 'int'},
+            {'label': 'First Trace # to move', 'initial_value': 1, 'type': 'int'},
+            {'label': 'Last Trace # to move', 'initial_value': 1, 'type': 'int'},
             {'label': 'New Position (1 to ' + str(max_position) + ')', 'initial_value': 1, 'type': 'int'}
             ]
 
             dialog = GenericParameterDialog(
-                title="Move Trace",
+                title="Move Trace(s)",
                 parameters=parameters,
                 add_checkbox=True,
                 checkbox_text="Apply to all shots",
@@ -14922,100 +15653,72 @@ class MainWindow(QMainWindow):
 
             if dialog.exec_():
                 values = dialog.getValues()
-                trace_num_input = values['Trace # (relative)']  # 1-based user input
+                first_trace_input = values['First Trace # to move']  # 1-based user input
+                last_trace_input = values['Last Trace # to move']  # 1-based user input
                 new_position_input = values['New Position (1 to ' + str(max_position) + ')']  # 1-based user input
                 
+                # Validate input range
+                if first_trace_input > last_trace_input:
+                    QMessageBox.warning(self, "Invalid Range", "First trace must be less than or equal to last trace")
+                    return
+                
                 # Convert to 0-based indices
-                trace_idx = trace_num_input - 1
+                first_trace_idx = first_trace_input - 1
+                last_trace_idx = last_trace_input - 1
                 new_idx = new_position_input - 1
+                num_traces_to_move = last_trace_idx - first_trace_idx + 1
 
                 if dialog.isChecked():
                     for i in range(len(self.streams)):
                         n_traces_i = len(self.streams[i])
-                        if trace_idx < n_traces_i and new_idx < n_traces_i and trace_idx != new_idx:
-                            self.streams[i] = move_trace(self.streams[i], trace_num_input, new_idx)
-                            
-                            # Move all associated data arrays EXCEPT trace_position (spatial position stays with array index)
-                            for attr in [self.trace_elevation[i], self.offset[i],
-                                       self.file_trace_number[i]]:
-                                if len(attr) > trace_idx:
-                                    attr_val = attr[trace_idx]
-                                    attr[:] = np.insert(np.delete(attr, trace_idx), new_idx, attr_val)
-                            
-                            # Move shot_trace_number array
-                            if len(self.shot_trace_number[i]) > trace_idx:
-                                shot_val = self.shot_trace_number[i][trace_idx]
-                                self.shot_trace_number[i] = np.insert(np.delete(self.shot_trace_number[i], trace_idx), new_idx, shot_val)
-                            
-                            # Move picks and errors
-                            if self.picks[i] is not None and len(self.picks[i]) > trace_idx:
-                                pick_val = self.picks[i][trace_idx]
-                                self.picks[i] = np.insert(np.delete(self.picks[i], trace_idx), new_idx, pick_val)
-                            if self.error[i] is not None and len(self.error[i]) > trace_idx:
-                                error_val = self.error[i][trace_idx]
-                                self.error[i] = np.insert(np.delete(self.error[i], trace_idx), new_idx, error_val)
-                            if self.pickSeismoItems[i] is not None and len(self.pickSeismoItems[i]) > trace_idx:
-                                pick_seismo_val = self.pickSeismoItems[i][trace_idx]
-                                self.pickSeismoItems[i] = np.insert(np.delete(self.pickSeismoItems[i], trace_idx), new_idx, pick_seismo_val)
-                            if self.pickLayoutItems[i] is not None and len(self.pickLayoutItems[i]) > trace_idx:
-                                pick_layout_val = self.pickLayoutItems[i][trace_idx]
-                                self.pickLayoutItems[i] = np.insert(np.delete(self.pickLayoutItems[i], trace_idx), new_idx, pick_layout_val)
-                            
-                            # Rebuild shot_trace_number from updated obspy headers (follows its associated trace)
-                            shot_trace_number = [trace.stats[self.input_format[i]].trace_header.trace_number_within_the_original_field_record 
-                                                for trace in self.streams[i]]
-                            self.shot_trace_number[i] = shot_trace_number
+                        if first_trace_idx < n_traces_i and last_trace_idx < n_traces_i and new_idx < n_traces_i:
+                            # Move traces one by one - determine order to avoid index shifting issues
+                            # If moving to earlier position, move from first to last
+                            # If moving to later position, move from last to first
+                            if new_idx < first_trace_idx:
+                                # Moving to earlier position - move from first to last
+                                for offset in range(num_traces_to_move):
+                                    current_trace_num = first_trace_input + offset
+                                    current_new_pos = new_idx + offset
+                                    self._moveSingleTrace(i, current_trace_num, current_new_pos)
+                            else:
+                                # Moving to later position - move from last to first
+                                for offset in range(num_traces_to_move - 1, -1, -1):
+                                    current_trace_num = first_trace_input + offset
+                                    current_new_pos = new_idx + offset
+                                    self._moveSingleTrace(i, current_trace_num, current_new_pos)
                             
-                            # Update shot_trace_number to be sequential
+                            # Update file_trace_number to be sequential
                             self._updateSequentialTraceNumbers(i)
                             # Sync headers to obspy streams immediately
                             self.syncHeadersToStreams(i)
                     
-                    QMessageBox.information(self, "Trace Moved", f"Trace #{trace_num_input} moved to position {new_position_input} for all files")
                     self.headers_modified = True  # Mark headers as modified
                 else:
                     i = self.currentIndex
                     n_traces_i = len(self.streams[i])
-                    if trace_idx < n_traces_i and new_idx < n_traces_i and trace_idx != new_idx:
-                        self.streams[i] = move_trace(self.streams[i], trace_num_input, new_idx)
-                        
-                        # Move all associated data arrays EXCEPT trace_position (spatial position stays with array index)
-                        for attr in [self.trace_elevation[i], self.offset[i],
-                                   self.file_trace_number[i]]:
-                            if len(attr) > trace_idx:
-                                attr_val = attr[trace_idx]
-                                attr[:] = np.insert(np.delete(attr, trace_idx), new_idx, attr_val)
-                        
-                        # Move shot_trace_number array
-                        if len(self.shot_trace_number[i]) > trace_idx:
-                            shot_val = self.shot_trace_number[i][trace_idx]
-                            self.shot_trace_number[i] = np.insert(np.delete(self.shot_trace_number[i], trace_idx), new_idx, shot_val)
-                        
-                        # Move picks and errors
-                        if self.picks[i] is not None and len(self.picks[i]) > trace_idx:
-                            pick_val = self.picks[i][trace_idx]
-                            self.picks[i] = np.insert(np.delete(self.picks[i], trace_idx), new_idx, pick_val)
-                        if self.error[i] is not None and len(self.error[i]) > trace_idx:
-                            error_val = self.error[i][trace_idx]
-                            self.error[i] = np.insert(np.delete(self.error[i], trace_idx), new_idx, error_val)
-                        if self.pickSeismoItems[i] is not None and len(self.pickSeismoItems[i]) > trace_idx:
-                            pick_seismo_val = self.pickSeismoItems[i][trace_idx]
-                            self.pickSeismoItems[i] = np.insert(np.delete(self.pickSeismoItems[i], trace_idx), new_idx, pick_seismo_val)
-                        if self.pickLayoutItems[i] is not None and len(self.pickLayoutItems[i]) > trace_idx:
-                            pick_layout_val = self.pickLayoutItems[i][trace_idx]
-                            self.pickLayoutItems[i] = np.insert(np.delete(self.pickLayoutItems[i], trace_idx), new_idx, pick_layout_val)
-                        
-                        # Rebuild shot_trace_number from updated obspy headers (follows its associated trace)
-                        shot_trace_number = [trace.stats[self.input_format[i]].trace_header.trace_number_within_the_original_field_record 
-                                            for trace in self.streams[i]]
-                        self.shot_trace_number[i] = shot_trace_number
+                    if first_trace_idx < n_traces_i and last_trace_idx < n_traces_i and new_idx < n_traces_i:
+                        # Move traces one by one - determine order to avoid index shifting issues
+                        # If moving to earlier position, move from first to last
+                        # If moving to later position, move from last to first
+                        if new_idx < first_trace_idx:
+                            # Moving to earlier position - move from first to last
+                            for offset in range(num_traces_to_move):
+                                current_trace_num = first_trace_input + offset
+                                current_new_pos = new_idx + offset
+                                self._moveSingleTrace(i, current_trace_num, current_new_pos)
+                        else:
+                            # Moving to later position - move from last to first
+                            for offset in range(num_traces_to_move - 1, -1, -1):
+                                current_trace_num = first_trace_input + offset
+                                current_new_pos = new_idx + offset
+                                self._moveSingleTrace(i, current_trace_num, current_new_pos)
                         
-                        # Update shot_trace_number to be sequential
+                        # Update file_trace_number to be sequential
                         self._updateSequentialTraceNumbers(i)
                         # Sync headers to obspy streams immediately
                         self.syncHeadersToStreams(i)
                         
-                        QMessageBox.information(self, "Trace Moved", f"Trace #{trace_num_input} moved to position {new_position_input} for file {os.path.basename(self.currentFileName)}")
                         self.headers_modified = True  # Mark headers as modified
                     else:
                         QMessageBox.warning(self, "Invalid Trace Numbers", f"Invalid trace indices or positions")
@@ -15024,6 +15727,49 @@ class MainWindow(QMainWindow):
                 self.updateFileListDisplay()
                 self.updatePlots()
 
+    def _moveSingleTrace(self, file_idx, trace_num, new_position):
+        """Helper function to move a single trace within a file.
+        
+        Args:
+            file_idx: Index of the file
+            trace_num: Trace number to move (1-based)
+            new_position: New position index (0-based)
+        """
+        trace_idx = trace_num - 1  # Convert to 0-based
+        
+        self.streams[file_idx] = move_trace(self.streams[file_idx], trace_num, new_position)
+        
+        # Move all associated data arrays EXCEPT trace_position (spatial position stays with array index)
+        for attr in [self.trace_elevation[file_idx], self.offset[file_idx],
+                   self.file_trace_number[file_idx]]:
+            if len(attr) > trace_idx:
+                attr_val = attr[trace_idx]
+                attr[:] = np.insert(np.delete(attr, trace_idx), new_position, attr_val)
+        
+        # Move shot_trace_number array
+        if len(self.shot_trace_number[file_idx]) > trace_idx:
+            shot_val = self.shot_trace_number[file_idx][trace_idx]
+            self.shot_trace_number[file_idx] = np.insert(np.delete(self.shot_trace_number[file_idx], trace_idx), new_position, shot_val)
+        
+        # Move picks and errors
+        if self.picks[file_idx] is not None and len(self.picks[file_idx]) > trace_idx:
+            pick_val = self.picks[file_idx][trace_idx]
+            self.picks[file_idx] = np.insert(np.delete(self.picks[file_idx], trace_idx), new_position, pick_val)
+        if self.error[file_idx] is not None and len(self.error[file_idx]) > trace_idx:
+            error_val = self.error[file_idx][trace_idx]
+            self.error[file_idx] = np.insert(np.delete(self.error[file_idx], trace_idx), new_position, error_val)
+        if self.pickSeismoItems[file_idx] is not None and len(self.pickSeismoItems[file_idx]) > trace_idx:
+            pick_seismo_val = self.pickSeismoItems[file_idx][trace_idx]
+            self.pickSeismoItems[file_idx] = np.insert(np.delete(self.pickSeismoItems[file_idx], trace_idx), new_position, pick_seismo_val)
+        if self.pickLayoutItems[file_idx] is not None and len(self.pickLayoutItems[file_idx]) > trace_idx:
+            pick_layout_val = self.pickLayoutItems[file_idx][trace_idx]
+            self.pickLayoutItems[file_idx] = np.insert(np.delete(self.pickLayoutItems[file_idx], trace_idx), new_position, pick_layout_val)
+        
+        # Rebuild shot_trace_number from updated obspy headers (follows its associated trace)
+        shot_trace_number = [trace.stats[self.input_format[file_idx]].trace_header.trace_number_within_the_original_field_record 
+                            for trace in self.streams[file_idx]]
+        self.shot_trace_number[file_idx] = shot_trace_number
+
     def muteTrace(self):
         if self.streams:
             trace_numbers = self.shot_trace_number[self.currentIndex]
@@ -15046,7 +15792,6 @@ class MainWindow(QMainWindow):
                         # Sync headers to obspy streams immediately
                         self.syncHeadersToStreams(i)
                     self.headers_modified = True
-                    QMessageBox.information(self, "Trace Muted", f"Trace #{trace_numbers[selected_index]} muted for all files")
                 else:
                     selected_indices = np.where(np.array(trace_numbers) == selected_trace)[0]
                     if selected_indices.size == 0:
@@ -15058,7 +15803,6 @@ class MainWindow(QMainWindow):
                     # Sync headers to obspy streams immediately
                     self.syncHeadersToStreams(self.currentIndex)
                     self.headers_modified = True
-                    QMessageBox.information(self, "Trace Muted", f"Trace #{trace_numbers[selected_index]} muted for file {os.path.basename(self.currentFileName)}")
                 self.updatePlots()
                 self.updateFileListDisplay()
                 self.updatePlots()
@@ -15066,99 +15810,221 @@ class MainWindow(QMainWindow):
     def reverseTraces(self):
         """Reverse trace data (flip data matrix left-to-right)"""
         if self.streams:
+            n_traces = len(self.streams[self.currentIndex])
+            
+            parameters = [
+                {'label': 'First Trace #', 'initial_value': 1, 'type': 'int'},
+                {'label': 'Last Trace #', 'initial_value': n_traces, 'type': 'int'}
+            ]
+            
             dialog = GenericParameterDialog(
                 title="Reverse Trace Data",
-                parameters=[],
+                parameters=parameters,
                 add_checkbox=True,
                 checkbox_text="Apply to all shots",
                 parent=self
             )
 
             if dialog.exec_():
+                values = dialog.getValues()
+                first_trace = values['First Trace #'] - 1  # Convert to 0-based
+                last_trace = values['Last Trace #'] - 1   # Convert to 0-based
+                
+                # Validate input range
+                if first_trace > last_trace:
+                    QMessageBox.warning(self, "Invalid Range", "First trace must be less than or equal to last trace")
+                    return
+                
                 if dialog.isChecked():
                     # Reverse trace data for all files
                     for i in range(len(self.streams)):
-                        # Reverse the stream data and trace numbers (positions stay in place)
-                        self.streams[i] = reverse_traces(self.streams[i])
-                        
-                        # Reverse shot_trace_number to match the flipped trace numbers in headers
-                        self.shot_trace_number[i] = self.shot_trace_number[i][::-1]
-                        
-                        # Reverse picks and errors (they follow the data)
-                        if self.picks[i] is not None:
-                            self.picks[i] = self.picks[i][::-1]
-                        if self.error[i] is not None:
-                            self.error[i] = self.error[i][::-1]
+                        n_traces_i = len(self.streams[i])
+                        # Validate range for this file
+                        if first_trace >= n_traces_i or last_trace >= n_traces_i:
+                            continue  # Skip files that don't have enough traces
                         
-                        # Reverse pick items (they follow the data)
-                        if self.pickSeismoItems[i] is not None:
-                            self.pickSeismoItems[i] = self.pickSeismoItems[i][::-1]
-                        if self.pickLayoutItems[i] is not None:
-                            self.pickLayoutItems[i] = self.pickLayoutItems[i][::-1]
+                        self._reverseTraceSubset(i, first_trace, last_trace)
                     
-                    QMessageBox.information(self, "Trace Data Reversed", "Trace data reversed for all files")
                     self.headers_modified = True
                 else:
                     i = self.currentIndex
-                    # Reverse the stream data and trace numbers (positions stay in place)
-                    self.streams[i] = reverse_traces(self.streams[i])
-                    
-                    # Reverse shot_trace_number to match the flipped trace numbers in headers
-                    self.shot_trace_number[i] = self.shot_trace_number[i][::-1]
-                    
-                    # Reverse picks and errors (they follow the data)
-                    if self.picks[i] is not None:
-                        self.picks[i] = self.picks[i][::-1]
-                    if self.error[i] is not None:
-                        self.error[i] = self.error[i][::-1]
+                    n_traces_i = len(self.streams[i])
+                    # Validate range for this file
+                    if first_trace >= n_traces_i or last_trace >= n_traces_i:
+                        QMessageBox.warning(self, "Invalid Range", f"Trace range exceeds available traces ({n_traces_i})")
+                        return
                     
-                    # Reverse pick items (they follow the data)
-                    if self.pickSeismoItems[i] is not None:
-                        self.pickSeismoItems[i] = self.pickSeismoItems[i][::-1]
-                    if self.pickLayoutItems[i] is not None:
-                        self.pickLayoutItems[i] = self.pickLayoutItems[i][::-1]
+                    self._reverseTraceSubset(i, first_trace, last_trace)
                     
-                    QMessageBox.information(self, "Trace Data Reversed", f"Trace data reversed for file {os.path.basename(self.currentFileName)}")
                     self.headers_modified = True
 
                 self.updatePlots()
                 self.updateFileListDisplay()
                 self.updatePlots()
-
-    def batchEditFFID(self):
+    
+    def _reverseTraceSubset(self, file_idx, first_trace, last_trace):
+        """Helper function to reverse a subset of traces within a file.
+        
+        Args:
+            file_idx: Index of the file
+            first_trace: First trace index to reverse (0-based, inclusive)
+            last_trace: Last trace index to reverse (0-based, inclusive)
+        """
+        # Extract the subset of traces to reverse
+        subset_size = last_trace - first_trace + 1
+        
+        if subset_size <= 1:
+            return  # Nothing to reverse
+        
+        # Reverse the stream data for the subset
+        input_format = self.input_format[file_idx]
+        
+        # Extract data arrays and trace numbers for the subset
+        data_arrays = [self.streams[file_idx][i].data.copy() for i in range(first_trace, last_trace + 1)]
+        trace_numbers = [self.streams[file_idx][i].stats[input_format].trace_header.trace_number_within_the_original_field_record 
+                        for i in range(first_trace, last_trace + 1)]
+        
+        # Reverse them
+        data_arrays = data_arrays[::-1]
+        trace_numbers = trace_numbers[::-1]
+        
+        # Assign back to the stream
+        for idx, i in enumerate(range(first_trace, last_trace + 1)):
+            self.streams[file_idx][i].data = data_arrays[idx]
+            self.streams[file_idx][i].stats[input_format].trace_header.trace_number_within_the_original_field_record = trace_numbers[idx]
+        
+        # Reverse the corresponding portions of shot_trace_number
+        self.shot_trace_number[file_idx][first_trace:last_trace+1] = self.shot_trace_number[file_idx][first_trace:last_trace+1][::-1]
+        
+        # Reverse the corresponding portions of picks and errors (they follow the data)
+        if self.picks[file_idx] is not None:
+            self.picks[file_idx][first_trace:last_trace+1] = self.picks[file_idx][first_trace:last_trace+1][::-1]
+        if self.error[file_idx] is not None:
+            self.error[file_idx][first_trace:last_trace+1] = self.error[file_idx][first_trace:last_trace+1][::-1]
+        
+        # Reverse the corresponding portions of pick items (they follow the data)
+        if self.pickSeismoItems[file_idx] is not None:
+            self.pickSeismoItems[file_idx][first_trace:last_trace+1] = self.pickSeismoItems[file_idx][first_trace:last_trace+1][::-1]
+        if self.pickLayoutItems[file_idx] is not None:
+            self.pickLayoutItems[file_idx][first_trace:last_trace+1] = self.pickLayoutItems[file_idx][first_trace:last_trace+1][::-1]
+
+    def zeroPadTrace(self):
+        """Zero pad all traces in a shot by adding zeros at the end of the trace data."""
         if self.streams:
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
-            {'label': 'First FFID', 'initial_value': self.ffid[0], 'type': 'int'},
-            {'label': 'Increment', 'initial_value': 1, 'type': 'int'}
+                {'label': 'Pad at end (seconds)', 'initial_value': 0.0, 'type': 'float'}
             ]
-
+            
             dialog = GenericParameterDialog(
-                title="Batch Edit FFID",
+                title="Zero Pad Shot",
                 parameters=parameters,
-                add_checkbox=False,
+                add_checkbox=True,
+                checkbox_text="Apply to all shots",
                 parent=self
             )
-
+            
             if dialog.exec_():
                 values = dialog.getValues()
-                first_shot = values['First Source #'] - 1
-                last_shot = values['Last Source #']
-                first_ffid = values['First FFID']
-                increment = values['Increment']
-
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    self.ffid[i] = first_ffid + (i - first_shot) * increment
-                # Sync headers to obspy streams immediately for all files
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    self.syncHeadersToStreams(i)
-                self.headers_modified = True  # Mark headers as modified
-                QMessageBox.information(self, "FFIDs Updated", f"FFIDs set from {first_ffid} to {self.ffid[last_shot-1]} with increment {increment} for shots {first_shot+1} to {last_shot}")
-
-                self.updateTitle()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                pad_end_seconds = values['Pad at end (seconds)']
+                apply_to_all = dialog.isChecked()
+                
+                # Validate inputs
+                if pad_end_seconds < 0:
+                    QMessageBox.warning(self, "Invalid Input", "Padding value must be non-negative")
+                    return
+                
+                if pad_end_seconds == 0:
+                    QMessageBox.warning(self, "Invalid Input", "Padding value must be greater than 0")
+                    return
+                
+                # Show wait cursor while processing
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    if apply_to_all:
+                        # Pad all traces for all files
+                        for i in range(len(self.streams)):
+                            # Convert seconds to samples
+                            pad_end = int(pad_end_seconds / self.sample_interval[i])
+                            
+                            # Pad all traces in this shot
+                            for trace_num in self.shot_trace_number[i]:
+                                self.streams[i] = zero_pad_trace(self.streams[i], trace_num, 0, pad_end)
+                            
+                            # Update n_sample and time array after padding
+                            if len(self.streams[i]) > 0:
+                                self.n_sample[i] = len(self.streams[i][0].data)
+                                self.time[i] = np.arange(self.n_sample[i]) * self.sample_interval[i] + self.delay[i]
+                            # Sync headers to obspy streams immediately
+                            self.syncHeadersToStreams(i)
+                        
+                        self.headers_modified = True
+                        QMessageBox.information(self, "Zero Padding Applied", 
+                            f"All traces padded with {pad_end_seconds} seconds at end for all shots")
+                    else:
+                        # Pad all traces for current file only
+                        # Convert seconds to samples
+                        pad_end = int(pad_end_seconds / self.sample_interval[self.currentIndex])
+                        
+                        # Pad all traces in this shot
+                        for trace_num in self.shot_trace_number[self.currentIndex]:
+                            self.streams[self.currentIndex] = zero_pad_trace(self.streams[self.currentIndex], trace_num, 0, pad_end)
+                        
+                        # Update n_sample and time array after padding
+                        if len(self.streams[self.currentIndex]) > 0:
+                            self.n_sample[self.currentIndex] = len(self.streams[self.currentIndex][0].data)
+                            self.time[self.currentIndex] = np.arange(self.n_sample[self.currentIndex]) * self.sample_interval[self.currentIndex] + self.delay[self.currentIndex]
+                        # Sync headers to obspy streams immediately
+                        self.syncHeadersToStreams(self.currentIndex)
+                        
+                        self.headers_modified = True
+                        QMessageBox.information(self, "Zero Padding Applied", 
+                            f"All traces padded with {pad_end_seconds} seconds at end")
+                    
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    # Always restore cursor even if there's an error
+                    QApplication.restoreOverrideCursor()
+
+    def batchEditFFID(self):
+        if self.streams:
+            parameters = [
+            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First FFID', 'initial_value': self.ffid[0], 'type': 'int'},
+            {'label': 'Increment', 'initial_value': 1, 'type': 'int'}
+            ]
+
+            dialog = GenericParameterDialog(
+                title="Batch Edit FFID",
+                parameters=parameters,
+                add_checkbox=False,
+                parent=self
+            )
+
+            if dialog.exec_():
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
+                    first_shot = values['First Source #'] - 1
+                    last_shot = values['Last Source #'] - 1
+                    first_ffid = values['First FFID']
+                    increment = values['Increment']
+
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        self.ffid[i] = first_ffid + (i - first_shot) * increment
+                    # Sync headers to obspy streams immediately for all files
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        self.syncHeadersToStreams(i)
+                    self.headers_modified = True  # Mark headers as modified
+                    QMessageBox.information(self, "FFIDs Updated", f"FFIDs set from {first_ffid} to {self.ffid[last_shot]} with increment {increment} for shots {first_shot+1} to {last_shot+1}")
+
+                    self.updateTitle()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
     
     def batchEditDelay(self):
         if self.streams:
@@ -15176,27 +16042,31 @@ class MainWindow(QMainWindow):
             )
 
             if dialog.exec_():
-                values = dialog.getValues()
-                first_shot = values['First Source #'] - 1
-                last_shot = values['Last Source #']
-                delay = values['Delay (in s)']
-
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    # Calculate delay difference for each file individually
-                    diff_delay = delay - self.delay[i]
-                    self.delay[i] = delay
-                    self.time[i] = np.arange(self.n_sample[i]) * self.sample_interval[i] + self.delay[i]
-                    if self.picks[i] is not None:
-                        self.picks[i] = [pick + diff_delay for pick in self.picks[i]]
-                # Sync headers to obspy streams immediately for all files
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    self.syncHeadersToStreams(i)
-                self.headers_modified = True  # Mark headers as modified
-                QMessageBox.information(self, "Delays Updated", f"Delays set to {delay} s for shots {first_shot+1} to {last_shot}")
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
+                    first_shot = values['First Source #'] - 1
+                    last_shot = values['Last Source #'] - 1
+                    delay = values['Delay (in s)']
+
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        # Calculate delay difference for each file individually
+                        diff_delay = delay - self.delay[i]
+                        self.delay[i] = delay
+                        self.time[i] = np.arange(self.n_sample[i]) * self.sample_interval[i] + self.delay[i]
+                        if self.picks[i] is not None:
+                            self.picks[i] = [pick + diff_delay for pick in self.picks[i]]
+                    # Sync headers to obspy streams immediately for all files
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        self.syncHeadersToStreams(i)
+                    self.headers_modified = True  # Mark headers as modified
+                    QMessageBox.information(self, "Delays Updated", f"Delays set to {delay} s for shots {first_shot+1} to {last_shot+1}")
 
-                self.updatePlots()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
 
     def batchEditSampleInterval(self):
         if self.streams:
@@ -15214,30 +16084,34 @@ class MainWindow(QMainWindow):
             )
 
             if dialog.exec_():
-                values = dialog.getValues()
-                first_shot = values['First Source #'] - 1
-                last_shot = values['Last Source #']
-                sample_interval = values['Sample Interval (in s)']
-
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    self.sample_interval[i] = sample_interval
-                    self.time[i] = np.arange(self.n_sample[i]) * self.sample_interval[i] + self.delay[i]
-                # Sync headers to obspy streams immediately for all files
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    self.syncHeadersToStreams(i)
-                self.headers_modified = True
-                QMessageBox.information(self, "Sample Interval Updated", f"Sample intervals set to {sample_interval} s for shots {first_shot+1} to {last_shot}")
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
+                    first_shot = values['First Source #'] - 1
+                    last_shot = values['Last Source #'] - 1
+                    sample_interval = values['Sample Interval (in s)']
+
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        self.sample_interval[i] = sample_interval
+                        self.time[i] = np.arange(self.n_sample[i]) * self.sample_interval[i] + self.delay[i]
+                    # Sync headers to obspy streams immediately for all files
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        self.syncHeadersToStreams(i)
+                    self.headers_modified = True
+                    QMessageBox.information(self, "Sample Interval Updated", f"Sample intervals set to {sample_interval} s for shots {first_shot+1} to {last_shot+1}")
 
-                self.updatePlots()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
 
     def batchEditSourcePosition(self):
         if self.streams:
             parameters = [
             {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Skip every N sources', 'initial_value': 0, 'type': 'int'},
             {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'Skip every N sources', 'initial_value': 0, 'type': 'int'},
             {'label': 'First Source Position (in m)', 'initial_value': self.source_position[0], 'type': 'float'},
             {'label': 'Last Source Position (in m)', 'initial_value': '', 'type': 'float_or_empty'},
             {'label': 'Spacing (in m)', 'initial_value': np.mean(np.diff(self.source_position)), 'type': 'float'},
@@ -15252,84 +16126,93 @@ class MainWindow(QMainWindow):
             )
 
             if dialog.exec_():
-                values = dialog.getValues()
-                first_shot = values['First Source #'] - 1
-                last_shot = values['Last Source #']
-                first_source_position = values['First Source Position (in m)']
-                last_source_position = values['Last Source Position (in m)']
-                spacing = values['Spacing (in m)']
-                skip_every = max(0, values['Skip every N sources'])  # 0 = no skipping
-                num_stacks = max(1, values['Number of stacks'])  # Ensure at least 1
-                
-                num_shots = min(last_shot + 1, len(self.streams)) - first_shot
-                
-                # Calculate the step interval based on skip value
-                # If skip_every is 0, step is 1 (modify every source)
-                # If skip_every is 3, step is 4 (modify every 4th source, skipping 3 in between)
-                step = skip_every + 1 if skip_every > 0 else 1
-                
-                # Check if we have a last source position
-                if last_source_position is None or last_source_position == '':
-                    # No looping: generate positions until end of shot list
-                    # Calculate number of modified shots considering the step interval
-                    num_modified_shots = (num_shots + step - 1) // step  # Ceiling division
-                    num_unique_pos = (num_modified_shots + num_stacks - 1) // num_stacks  # Ceiling division
-                    unique_positions = np.round(np.arange(num_unique_pos) * spacing + first_source_position, self.rounding)
-                    
-                    # Repeat each position according to stack count
-                    source_pos = []
-                    for pos_idx in range(num_unique_pos):
-                        for _ in range(num_stacks):
-                            if len(source_pos) < num_modified_shots:
-                                source_pos.append(unique_positions[pos_idx])
-                    mode_info = f"from {first_source_position} m to end with spacing {spacing} m"
-                else:
-                    # Looping mode: generate positions and loop between first and last
-                    num_steps = int(np.round((last_source_position - first_source_position) / spacing)) + 1
-                    unique_positions = np.round(np.arange(num_steps) * spacing + first_source_position, self.rounding)
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
+                    first_shot = values['First Source #'] - 1
+                    last_shot_value = values['Last Source #']
+                    # Handle None or empty value - default to last source in file
+                    if last_shot_value is None:
+                        last_shot = len(self.streams) - 1
+                    else:
+                        last_shot = last_shot_value - 1
+                    first_source_position = values['First Source Position (in m)']
+                    last_source_position = values['Last Source Position (in m)']
+                    spacing = values['Spacing (in m)']
+                    skip_every = max(0, values['Skip every N sources'])  # 0 = no skipping
+                    num_stacks = max(1, values['Number of stacks'])  # Ensure at least 1
                     
-                    # Calculate number of modified shots considering the step interval
-                    num_modified_shots = (num_shots + step - 1) // step  # Ceiling division
+                    num_shots = min(last_shot + 1, len(self.streams)) - first_shot
                     
-                    # Repeat each position according to stack count, looping through all positions
-                    source_pos = []
-                    pos_cycle_idx = 0
-                    stacks_count = 0
+                    # Calculate the step interval based on skip value
+                    # If skip_every is 0, step is 1 (modify every source)
+                    # If skip_every is 3, step is 4 (modify every 4th source, skipping 3 in between)
+                    step = skip_every + 1 if skip_every > 0 else 1
                     
-                    while len(source_pos) < num_modified_shots:
-                        source_pos.append(unique_positions[pos_cycle_idx % len(unique_positions)])
-                        stacks_count += 1
+                    # Check if we have a last source position
+                    if last_source_position is None or last_source_position == '':
+                        # No looping: generate positions until end of shot list
+                        # Calculate number of modified shots considering the step interval
+                        num_modified_shots = (num_shots + step - 1) // step  # Ceiling division
+                        num_unique_pos = (num_modified_shots + num_stacks - 1) // num_stacks  # Ceiling division
+                        unique_positions = np.round(np.arange(num_unique_pos) * spacing + first_source_position, self.rounding)
+                        
+                        # Repeat each position according to stack count
+                        source_pos = []
+                        for pos_idx in range(num_unique_pos):
+                            for _ in range(num_stacks):
+                                if len(source_pos) < num_modified_shots:
+                                    source_pos.append(unique_positions[pos_idx])
+                        mode_info = f"from {first_source_position} m to end with spacing {spacing} m"
+                    else:
+                        # Looping mode: generate positions and loop between first and last
+                        num_steps = int(np.round((last_source_position - first_source_position) / spacing)) + 1
+                        unique_positions = np.round(np.arange(num_steps) * spacing + first_source_position, self.rounding)
                         
-                        # Move to next position after each stack
-                        if stacks_count >= num_stacks:
-                            pos_cycle_idx += 1
-                            stacks_count = 0
+                        # Calculate number of modified shots considering the step interval
+                        num_modified_shots = (num_shots + step - 1) // step  # Ceiling division
+                        
+                        # Repeat each position according to stack count, looping through all positions
+                        source_pos = []
+                        pos_cycle_idx = 0
+                        stacks_count = 0
+                        
+                        while len(source_pos) < num_modified_shots:
+                            source_pos.append(unique_positions[pos_cycle_idx % len(unique_positions)])
+                            stacks_count += 1
+                            
+                            # Move to next position after each stack
+                            if stacks_count >= num_stacks:
+                                pos_cycle_idx += 1
+                                stacks_count = 0
+                        
+                        mode_info = f"looping from {first_source_position} m to {last_source_position} m with spacing {spacing} m"
+
+                    # Apply source positions only to shots at step intervals
+                    source_pos_idx = 0
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        shot_offset = i - first_shot
+                        # Only modify if shot offset is at a step interval (0, step, 2*step, etc.)
+                        if shot_offset % step == 0 and source_pos_idx < len(source_pos):
+                            self.source_position[i] = source_pos[source_pos_idx]
+                            source_pos_idx += 1
+                            for j in range(len(self.trace_position[i])):    
+                                self.offset[i][j] = np.round(self.trace_position[i][j] - self.source_position[i], self.rounding)
+                    # Sync headers to obspy streams immediately for all files
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        self.syncHeadersToStreams(i)
+                    self.headers_modified = True  # Mark headers as modified
                     
-                    mode_info = f"looping from {first_source_position} m to {last_source_position} m with spacing {spacing} m"
-
-                # Apply source positions only to shots at step intervals
-                source_pos_idx = 0
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    shot_offset = i - first_shot
-                    # Only modify if shot offset is at a step interval (0, step, 2*step, etc.)
-                    if shot_offset % step == 0 and source_pos_idx < len(source_pos):
-                        self.source_position[i] = source_pos[source_pos_idx]
-                        source_pos_idx += 1
-                        for j in range(len(self.trace_position[i])):    
-                            self.offset[i][j] = np.round(self.trace_position[i][j] - self.source_position[i], self.rounding)
-                # Sync headers to obspy streams immediately for all files
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    self.syncHeadersToStreams(i)
-                self.headers_modified = True  # Mark headers as modified
-                
-                stack_info = f" with {num_stacks} stacks per position" if num_stacks > 1 else ""
-                skip_info = f" (skipping every {skip_every} sources)" if skip_every > 0 else ""
-                QMessageBox.information(self, "Source Positions Updated", f"Source positions set {mode_info}{stack_info}{skip_info} for shots {first_shot+1} to {last_shot}")
+                    stack_info = f" with {num_stacks} stacks per position" if num_stacks > 1 else ""
+                    skip_info = f" (skipping every {skip_every} sources)" if skip_every > 0 else ""
+                    QMessageBox.information(self, "Source Positions Updated", f"Source positions set {mode_info}{stack_info}{skip_info} for shots {first_shot+1} to {last_shot+1}")
 
-                self.updateMeanSpacing()
-                self.updatePlots()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                    self.updateMeanSpacing()
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
 
     def batchEditTracePosition(self):
         if self.streams:
@@ -15350,40 +16233,48 @@ class MainWindow(QMainWindow):
             )
 
             if dialog.exec_():
-                values = dialog.getValues()
-                first_shot = values['First Source #'] - 1
-                last_shot = values['Last Source #']
-                first_trace = values['First Trace #'] - 1
-                last_trace = values['Last Trace #']
-                first_trace_position = values['First Trace Position (in m)']
-                spacing = values['Spacing (in m)']
-                
-                # Create trace positions for the range of traces (0-based indexing for the array)
-                num_traces = last_trace - first_trace
-                trace_pos = np.round(np.arange(num_traces) * spacing + first_trace_position, self.rounding)
-
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    for j in range(first_trace, last_trace):
-                        # Use j - first_trace to get the correct index in trace_pos array
-                        trace_idx = j - first_trace
-                        self.trace_position[i][j] = trace_pos[trace_idx]
-                        self.offset[i][j] = np.round(self.trace_position[i][j] - self.source_position[i], self.rounding)
-                # Sync headers to obspy streams immediately for all files
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    self.syncHeadersToStreams(i)
-                self.headers_modified = True  # Mark headers as modified
-                QMessageBox.information(
-                    self,
-                    "Trace Positions Updated",
-                    f"Trace positions set from {first_trace_position} m with spacing {spacing} m for traces {first_trace+1} to {last_trace} for shots {first_shot+1} to {last_shot}"
-                )
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
+                    first_shot = values['First Source #'] - 1
+                    last_shot = values['Last Source #'] - 1
+                    first_trace = values['First Trace #'] - 1
+                    last_trace = values['Last Trace #'] - 1
+                    first_trace_position = values['First Trace Position (in m)']
+                    spacing = values['Spacing (in m)']
+                    
+                    # Create trace positions for the range of traces (0-based indexing for the array)
+                    num_traces = last_trace - first_trace + 1
+                    trace_pos = np.round(np.arange(num_traces) * spacing + first_trace_position, self.rounding)
+
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        for j in range(first_trace, last_trace + 1):
+                            # Use j - first_trace to get the correct index in trace_pos array
+                            trace_idx = j - first_trace
+                            self.trace_position[i][j] = trace_pos[trace_idx]
+                            self.offset[i][j] = np.round(self.trace_position[i][j] - self.source_position[i], self.rounding)
+                        
+                        # Reorder traces by position to maintain spatial order
+                        self._reorderTracesByPosition(i)
+                        
+                    # Sync headers to obspy streams immediately for all files
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        self.syncHeadersToStreams(i)
+                    self.headers_modified = True  # Mark headers as modified
+                    QMessageBox.information(
+                        self,
+                        "Trace Positions Updated",
+                        f"Trace positions set from {first_trace_position} m with spacing {spacing} m for traces {first_trace+1} to {last_trace+1} for shots {first_shot+1} to {last_shot+1} (traces reordered)"
+                    )
 
-                # Recalculate unique trace numbers for all files at once
-                self._updateAllUniqueTraceNumbers()
-                self.updateMeanSpacing()
-                self.updatePlots()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                    # Recalculate unique trace numbers for all files at once
+                    self._updateAllUniqueTraceNumbers()
+                    self.updateMeanSpacing()
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
 
     def batchSwapTraces(self):
         if self.streams:
@@ -15402,53 +16293,56 @@ class MainWindow(QMainWindow):
             )
 
             if dialog.exec_():
-                values = dialog.getValues()
-                first_shot = values['First Source #'] - 1
-                last_shot = values['Last Source #']
-                first_trace = values['First Trace # to swap']
-                second_trace = values['Second Trace # to swap']
-
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    n_traces = len(self.streams[i])
-                    # Validate indices
-                    if first_trace <= n_traces and second_trace <= n_traces and first_trace != second_trace:
-                        self.streams[i] = swap_traces(self.streams[i], first_trace, second_trace)
-                        
-                        # Swap picks and errors (they follow their traces)
-                        first_idx = first_trace - 1
-                        second_idx = second_trace - 1
-                        if self.picks[i] is not None:
-                            self.picks[i][first_idx], self.picks[i][second_idx] = \
-                                self.picks[i][second_idx], self.picks[i][first_idx]
-                        if self.error[i] is not None:
-                            self.error[i][first_idx], self.error[i][second_idx] = \
-                                self.error[i][second_idx], self.error[i][first_idx]
-                        
-                        # Swap pick items
-                        if self.pickSeismoItems[i] is not None:
-                            self.pickSeismoItems[i][first_idx], self.pickSeismoItems[i][second_idx] = \
-                                self.pickSeismoItems[i][second_idx], self.pickSeismoItems[i][first_idx]
-                        if self.pickLayoutItems[i] is not None:
-                            self.pickLayoutItems[i][first_idx], self.pickLayoutItems[i][second_idx] = \
-                                self.pickLayoutItems[i][second_idx], self.pickLayoutItems[i][first_idx]
-                        
-                        # Rebuild shot_trace_number from updated obspy headers (follows its associated trace)
-                        shot_trace_number = [trace.stats[self.input_format[i]].trace_header.trace_number_within_the_original_field_record 
-                                            for trace in self.streams[i]]
-                        self.shot_trace_number[i] = shot_trace_number
-                        
-                        # Update file_trace_number to be sequential and recalculate unique_trace_number
-                        self._updateSequentialTraceNumbers(i)
-                        # Sync headers to obspy streams immediately
-                        self.syncHeadersToStreams(i)
-                self.headers_modified = True
-                QMessageBox.information(self, "Traces Swapped", f"Traces {first_trace} and {second_trace} swapped for all files")
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
+                    first_shot = values['First Source #'] - 1
+                    last_shot = values['Last Source #'] - 1
+                    first_trace = values['First Trace # to swap']
+                    second_trace = values['Second Trace # to swap']
 
-                # Recalculate unique trace numbers for all files at once
-                self._updateAllUniqueTraceNumbers()
-                # Update file list and refresh plots
-                self.updateFileListDisplay()
-                self.updatePlots()
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        n_traces = len(self.streams[i])
+                        # Validate indices
+                        if first_trace <= n_traces and second_trace <= n_traces and first_trace != second_trace:
+                            self.streams[i] = swap_traces(self.streams[i], first_trace, second_trace)
+                            
+                            # Swap picks and errors (they follow their traces)
+                            first_idx = first_trace - 1
+                            second_idx = second_trace - 1
+                            if self.picks[i] is not None:
+                                self.picks[i][first_idx], self.picks[i][second_idx] = \
+                                    self.picks[i][second_idx], self.picks[i][first_idx]
+                            if self.error[i] is not None:
+                                self.error[i][first_idx], self.error[i][second_idx] = \
+                                    self.error[i][second_idx], self.error[i][first_idx]
+                            
+                            # Swap pick items
+                            if self.pickSeismoItems[i] is not None:
+                                self.pickSeismoItems[i][first_idx], self.pickSeismoItems[i][second_idx] = \
+                                    self.pickSeismoItems[i][second_idx], self.pickSeismoItems[i][first_idx]
+                            if self.pickLayoutItems[i] is not None:
+                                self.pickLayoutItems[i][first_idx], self.pickLayoutItems[i][second_idx] = \
+                                    self.pickLayoutItems[i][second_idx], self.pickLayoutItems[i][first_idx]
+                            
+                            # Rebuild shot_trace_number from updated obspy headers (follows its associated trace)
+                            shot_trace_number = [trace.stats[self.input_format[i]].trace_header.trace_number_within_the_original_field_record 
+                                                for trace in self.streams[i]]
+                            self.shot_trace_number[i] = shot_trace_number
+                            
+                            # Update file_trace_number to be sequential and recalculate unique_trace_number
+                            self._updateSequentialTraceNumbers(i)
+                            # Sync headers to obspy streams immediately
+                            self.syncHeadersToStreams(i)
+                    self.headers_modified = True
+
+                    # Recalculate unique trace numbers for all files at once
+                    self._updateAllUniqueTraceNumbers()
+                    # Update file list and refresh plots
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
 
     def batchRemoveTraces(self):
         if self.streams:
@@ -15467,53 +16361,54 @@ class MainWindow(QMainWindow):
             )
 
             if dialog.exec_():
-                values = dialog.getValues()
-                first_shot = values['First Source #'] - 1  # Convert to 0-based index
-                last_shot = values['Last Source #']  # This is 1-based user input for the LAST shot to include
-                first_trace = values['First Trace # to remove']
-                last_trace = values['Last Trace # to remove']
-
-                # Process shots from first_shot to last_shot (inclusive)
-                # last_shot is 1-based user input, so we convert it to exclusive for range: last_shot becomes last_shot+1
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    # Process traces in reverse order to avoid index shifting issues
-                    # Delete from last to first so indices don't shift for remaining deletions
-                    for trace_num in range(last_trace, first_trace-1, -1):
-                        # Find the index of this trace number in the current file
-                        trace_numbers = [trace.stats[self.input_format[i]].trace_header.trace_number_within_the_original_field_record 
-                                        for trace in self.streams[i]]
-                        # Look for the trace that matches this number
-                        found_indices = np.where(np.array(trace_numbers) == trace_num)[0]
-                        if found_indices.size == 0:
-                            continue  # Trace not found, skip
-                        
-                        selected_index = found_indices[0]
-                        # Remove the trace from the stream
-                        self.streams[i] = remove_trace(self.streams[i], trace_num)
-                        # Remove from all associated arrays
-                        self.offset[i] = np.delete(self.offset[i], selected_index)
-                        self.trace_position[i] = np.delete(self.trace_position[i], selected_index)
-                        self.trace_elevation[i] = np.delete(self.trace_elevation[i], selected_index)
-                        self.shot_trace_number[i] = np.delete(self.shot_trace_number[i], selected_index)
-                        self.file_trace_number[i] = np.delete(self.file_trace_number[i], selected_index)
-                        self.picks[i] = np.delete(self.picks[i], selected_index)
-                        self.error[i] = np.delete(self.error[i], selected_index)
-                        self.pickSeismoItems[i] = np.delete(self.pickSeismoItems[i], selected_index)
-                        self.pickLayoutItems[i] = np.delete(self.pickLayoutItems[i], selected_index)
-                    
-                    # Update file_trace_number to be sequential after all removals
-                    self._updateSequentialTraceNumbers(i)
-                    # Sync headers to obspy streams immediately after all removals for this file
-                    self.syncHeadersToStreams(i)
-                self.headers_modified = True
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
+                    first_shot = values['First Source #'] - 1  # Convert to 0-based index
+                    last_shot = values['Last Source #'] - 1  # Convert to 0-based index
+                    first_trace = values['First Trace # to remove']
+                    last_trace = values['Last Trace # to remove']
+
+                    # Process shots from first_shot to last_shot (inclusive)
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        # Process traces in reverse order to avoid index shifting issues
+                        # Delete from last to first so indices don't shift for remaining deletions
+                        for trace_num in range(last_trace, first_trace-1, -1):
+                            # Find the index of this trace number in the current file
+                            trace_numbers = [trace.stats[self.input_format[i]].trace_header.trace_number_within_the_original_field_record 
+                                            for trace in self.streams[i]]
+                            # Look for the trace that matches this number
+                            found_indices = np.where(np.array(trace_numbers) == trace_num)[0]
+                            if found_indices.size == 0:
+                                continue  # Trace not found, skip
+                            
+                            selected_index = found_indices[0]
+                            # Remove the trace from the stream
+                            self.streams[i] = remove_trace(self.streams[i], trace_num)
+                            # Remove from all associated arrays
+                            self.offset[i] = np.delete(self.offset[i], selected_index)
+                            self.trace_position[i] = np.delete(self.trace_position[i], selected_index)
+                            self.trace_elevation[i] = np.delete(self.trace_elevation[i], selected_index)
+                            self.shot_trace_number[i] = np.delete(self.shot_trace_number[i], selected_index)
+                            self.file_trace_number[i] = np.delete(self.file_trace_number[i], selected_index)
+                            self.picks[i] = np.delete(self.picks[i], selected_index)
+                            self.error[i] = np.delete(self.error[i], selected_index)
+                            self.pickSeismoItems[i] = np.delete(self.pickSeismoItems[i], selected_index)
+                            self.pickLayoutItems[i] = np.delete(self.pickLayoutItems[i], selected_index)
                         
-                QMessageBox.information(self, "Traces Removed", f"Traces {first_trace} to {last_trace} removed for all files")
+                        # Update file_trace_number to be sequential after all removals
+                        self._updateSequentialTraceNumbers(i)
+                        # Sync headers to obspy streams immediately after all removals for this file
+                        self.syncHeadersToStreams(i)
+                    self.headers_modified = True
 
-                # Recalculate unique trace numbers for all files at once
-                self._updateAllUniqueTraceNumbers()
-                self.updateMeanSpacing()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                    # Recalculate unique trace numbers for all files at once
+                    self._updateAllUniqueTraceNumbers()
+                    self.updateMeanSpacing()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
 
     def batchMoveTraces(self):
         if self.streams:
@@ -15521,6 +16416,7 @@ class MainWindow(QMainWindow):
             {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
             {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
             {'label': 'First Trace # to move', 'initial_value': 1, 'type': 'int'},
+            {'label': 'Last Trace # to move', 'initial_value': 1, 'type': 'int'},
             {'label': 'New Position', 'initial_value': 1, 'type': 'int'}
             ]
 
@@ -15532,62 +16428,56 @@ class MainWindow(QMainWindow):
             )
 
             if dialog.exec_():
-                values = dialog.getValues()
-                first_shot = values['First Source #'] - 1
-                last_shot = values['Last Source #']
-                first_trace = values['First Trace # to move']
-                new_position = values['New Position'] - 1
-
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    self.streams[i] = move_trace(self.streams[i], first_trace, new_position)
-                    # Move elements in associated arrays
-                    trace_idx = first_trace - 1  # Convert to 0-based indexing
-                    if trace_idx < len(self.trace_position[i]) and new_position < len(self.trace_position[i]):
-                        # Move elements in associated arrays using numpy operations
-                        # Store the elements to move
-                        trace_pos = self.trace_position[i][trace_idx]
-                        trace_elev = self.trace_elevation[i][trace_idx]
-                        offset_val = self.offset[i][trace_idx]
-                        shot_trace_num = self.shot_trace_number[i][trace_idx]
-                        file_trace_num = self.file_trace_number[i][trace_idx]
-                        pick = self.picks[i][trace_idx] if self.picks[i] is not None else None
-                        error = self.error[i][trace_idx] if self.error[i] is not None else None
-                        pick_seismo = self.pickSeismoItems[i][trace_idx] if self.pickSeismoItems[i] is not None else None
-                        pick_layout = self.pickLayoutItems[i][trace_idx] if self.pickLayoutItems[i] is not None else None
-                        
-                        # Remove from current position and insert at new position
-                        # NOTE: trace_position stays in place - spatial positions don't move with traces
-                        self.trace_elevation[i] = np.insert(np.delete(self.trace_elevation[i], trace_idx), new_position, trace_elev)
-                        self.offset[i] = np.insert(np.delete(self.offset[i], trace_idx), new_position, offset_val)
-                        self.shot_trace_number[i] = np.insert(np.delete(self.shot_trace_number[i], trace_idx), new_position, shot_trace_num)
-                        self.file_trace_number[i] = np.insert(np.delete(self.file_trace_number[i], trace_idx), new_position, file_trace_num)
-                        if pick is not None:
-                            self.picks[i] = np.insert(np.delete(self.picks[i], trace_idx), new_position, pick)
-                        if error is not None:
-                            self.error[i] = np.insert(np.delete(self.error[i], trace_idx), new_position, error)
-                        if pick_seismo is not None:
-                            self.pickSeismoItems[i] = np.insert(np.delete(self.pickSeismoItems[i], trace_idx), new_position, pick_seismo)
-                        if pick_layout is not None:
-                            self.pickLayoutItems[i] = np.insert(np.delete(self.pickLayoutItems[i], trace_idx), new_position, pick_layout)
-                        
-                        # Rebuild shot_trace_number from updated obspy headers (follows its associated trace)
-                        shot_trace_number = [trace.stats[self.input_format[i]].trace_header.trace_number_within_the_original_field_record 
-                                            for trace in self.streams[i]]
-                        self.shot_trace_number[i] = shot_trace_number
-                        
-                        # Update file_trace_number to be sequential
-                        self._updateSequentialTraceNumbers(i)
-                        # Sync headers to obspy streams immediately
-                        self.syncHeadersToStreams(i)
-                self.headers_modified = True
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
+                    first_shot = values['First Source #'] - 1
+                    last_shot = values['Last Source #'] - 1
+                    first_trace = values['First Trace # to move']
+                    last_trace = values['Last Trace # to move']
+                    new_position = values['New Position'] - 1
                     
-                QMessageBox.information(self, "Trace Moved", f"Trace #{first_trace} moved to position {new_position + 1} for all files")
+                    # Validate input range
+                    if first_trace > last_trace:
+                        QMessageBox.warning(self, "Invalid Range", "First trace must be less than or equal to last trace")
+                        return
+                    
+                    first_trace_idx = first_trace - 1
+                    last_trace_idx = last_trace - 1
+                    num_traces_to_move = last_trace_idx - first_trace_idx + 1
 
-                # Recalculate unique trace numbers for all files at once
-                self._updateAllUniqueTraceNumbers()
-                self.updatePlots()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        n_traces_i = len(self.streams[i])
+                        if first_trace_idx < n_traces_i and last_trace_idx < n_traces_i and new_position < n_traces_i:
+                            # Move traces one by one - determine order to avoid index shifting issues
+                            # If moving to earlier position, move from first to last
+                            # If moving to later position, move from last to first
+                            if new_position < first_trace_idx:
+                                # Moving to earlier position - move from first to last
+                                for offset in range(num_traces_to_move):
+                                    current_trace_num = first_trace + offset
+                                    current_new_pos = new_position + offset
+                                    self._moveSingleTrace(i, current_trace_num, current_new_pos)
+                            else:
+                                # Moving to later position - move from last to first
+                                for offset in range(num_traces_to_move - 1, -1, -1):
+                                    current_trace_num = first_trace + offset
+                                    current_new_pos = new_position + offset
+                                    self._moveSingleTrace(i, current_trace_num, current_new_pos)
+                            
+                            # Update file_trace_number to be sequential
+                            self._updateSequentialTraceNumbers(i)
+                            # Sync headers to obspy streams immediately
+                            self.syncHeadersToStreams(i)
+                    self.headers_modified = True
+
+                    # Recalculate unique trace numbers for all files at once
+                    self._updateAllUniqueTraceNumbers()
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
 
     def batchMuteTraces(self):
         if self.streams:
@@ -15605,45 +16495,171 @@ class MainWindow(QMainWindow):
                 parent=self
             )
 
+            if dialog.exec_():
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
+                    first_shot = values['First Source #'] - 1
+                    last_shot = values['Last Source #'] - 1
+                    first_trace = values['First Trace # to mute']
+                    last_trace = values['Last Trace # to mute']
+                    
+                    # Adjust last_trace for loop (inclusive range)
+                    last_trace_loop = last_trace + 1
+
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        # Process traces in reverse order for consistency, though muting doesn't shift indices
+                        for j in range(last_trace_loop-1, first_trace-1, -1):
+                            trace_numbers = self.shot_trace_number[i]
+                            selected_indices = np.where(np.array(trace_numbers) == j)[0]
+                            if selected_indices.size == 0:
+                                QMessageBox.information(self, "Trace Not Found", f"Trace #{j} not found in file {os.path.basename(self.fileNames[i])}")
+                                continue
+
+                            # Mute the trace for the current file
+                            self.streams[i] = mute_trace(self.streams[i], j)
+                        # Sync headers to obspy streams immediately after all mutes for this file
+                        self.syncHeadersToStreams(i)
+                    
+                    # Mark headers/traces as modified so the unsaved-changes warning appears
+                    self.headers_modified = True
+
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
+
+    def batchInsertMutedTraces(self):
+        """Batch insert zero traces for a range of shots."""
+        if self.streams:
+            n_traces = len(self.trace_position[self.currentIndex]) if self.currentIndex < len(self.trace_position) else 1
+            
+            parameters = [
+                {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
+                {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+                {'label': 'Insert after Trace # (0 for beginning)', 'initial_value': n_traces, 'type': 'int'},
+                {'label': 'Number of traces to insert', 'initial_value': 1, 'type': 'int'}
+            ]
+            
+            dialog = GenericParameterDialog(
+                title="Batch Insert Zero Traces",
+                parameters=parameters,
+                add_checkbox=False,
+                parent=self
+            )
+            
             if dialog.exec_():
                 values = dialog.getValues()
                 first_shot = values['First Source #'] - 1
-                last_shot = values['Last Source #']
-                first_trace = values['First Trace # to mute']
-                last_trace = values['Last Trace # to mute']
+                last_shot = values['Last Source #'] - 1
+                insert_after = values['Insert after Trace # (0 for beginning)']
+                num_to_insert = values['Number of traces to insert']
                 
-                # Adjust last_trace for loop (inclusive range)
-                last_trace_loop = last_trace + 1
-
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    # Process traces in reverse order for consistency, though muting doesn't shift indices
-                    for j in range(last_trace_loop-1, first_trace-1, -1):
-                        trace_numbers = self.shot_trace_number[i]
-                        selected_indices = np.where(np.array(trace_numbers) == j)[0]
-                        if selected_indices.size == 0:
-                            QMessageBox.information(self, "Trace Not Found", f"Trace #{j} not found in file {os.path.basename(self.fileNames[i])}")
-                            continue
+                # Validate inputs
+                if num_to_insert < 1:
+                    QMessageBox.warning(self, "Invalid Input", "Number of traces must be at least 1")
+                    return
+                
+                # Show wait cursor while processing
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    # Insert traces for specified range of shots
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        n_traces_i = len(self.streams[i])
+                        if insert_after > n_traces_i:
+                            continue  # Skip if position is beyond trace count
+                        
+                        self._insertMutedTracesInFile(i, insert_after, num_to_insert)
+                        # Sync headers to obspy streams immediately
+                        self.syncHeadersToStreams(i)
+                    
+                    self.headers_modified = True
+                    
+                    # Recalculate unique trace numbers for all files at once
+                    self._updateAllUniqueTraceNumbers()
+                    self.updateMeanSpacing()
+                    self.updatePlotTypeDict()
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    # Always restore cursor even if there's an error
+                    QApplication.restoreOverrideCursor()
 
-                        # Mute the trace for the current file
-                        self.streams[i] = mute_trace(self.streams[i], j)
-                    # Sync headers to obspy streams immediately after all mutes for this file
-                    self.syncHeadersToStreams(i)
+    def batchZeroPadTraces(self):
+        """Batch zero pad all traces for a range of shots."""
+        if self.streams:
+            parameters = [
+                {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
+                {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+                {'label': 'Pad at end (seconds)', 'initial_value': 0.0, 'type': 'float'}
+            ]
+            
+            dialog = GenericParameterDialog(
+                title="Batch Zero Pad Shots",
+                parameters=parameters,
+                add_checkbox=False,
+                parent=self
+            )
+            
+            if dialog.exec_():
+                values = dialog.getValues()
+                first_shot = values['First Source #'] - 1
+                last_shot = values['Last Source #'] - 1
+                pad_end_seconds = values['Pad at end (seconds)']
                 
-                # Mark headers/traces as modified so the unsaved-changes warning appears
-                self.headers_modified = True
+                # Validate inputs
+                if pad_end_seconds < 0:
+                    QMessageBox.warning(self, "Invalid Input", "Padding value must be non-negative")
+                    return
                 
-                QMessageBox.information(self, "Traces Muted", f"Traces {first_trace} to {last_trace} muted for all files")
-
-                self.updatePlots()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                if pad_end_seconds == 0:
+                    QMessageBox.warning(self, "Invalid Input", "Padding value must be greater than 0")
+                    return
+                
+                # Show wait cursor while processing
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    # Pad all traces for specified range of shots
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        # Convert seconds to samples for this file
+                        pad_end = int(pad_end_seconds / self.sample_interval[i])
+                        
+                        # Process all traces in this shot
+                        for trace_num in self.shot_trace_number[i]:
+                            self.streams[i] = zero_pad_trace(self.streams[i], trace_num, 0, pad_end)
+                        
+                        # Update n_sample and time array after padding
+                        if len(self.streams[i]) > 0:
+                            self.n_sample[i] = len(self.streams[i][0].data)
+                            self.time[i] = np.arange(self.n_sample[i]) * self.sample_interval[i] + self.delay[i]
+                        # Sync headers to obspy streams immediately after all padding for this file
+                        self.syncHeadersToStreams(i)
+                    
+                    # Mark headers/traces as modified so the unsaved-changes warning appears
+                    self.headers_modified = True
+                    
+                    QMessageBox.information(self, "Zero Padding Applied", 
+                        f"All traces padded with {pad_end_seconds} seconds at end for shots {first_shot+1} to {last_shot+1}")
+                    
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    # Always restore cursor even if there's an error
+                    QApplication.restoreOverrideCursor()
 
     def batchReverseTraces(self):
         """Batch reverse trace data (flip data matrix left-to-right) while keeping headers in place"""
         if self.streams:
+            n_traces = len(self.trace_position[self.currentIndex]) if self.currentIndex < len(self.trace_position) else 1
+            
             parameters = [
                 {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-                {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'}
+                {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+                {'label': 'First Trace #', 'initial_value': 1, 'type': 'int'},
+                {'label': 'Last Trace #', 'initial_value': n_traces, 'type': 'int'}
             ]
 
             dialog = GenericParameterDialog(
@@ -15654,35 +16670,36 @@ class MainWindow(QMainWindow):
             )
 
             if dialog.exec_():
-                values = dialog.getValues()
-                first_shot = values['First Source #'] - 1
-                last_shot = values['Last Source #']
-
-                for i in range(first_shot, min(last_shot + 1, len(self.streams))):
-                    # Reverse the stream data and trace numbers (positions stay in place)
-                    self.streams[i] = reverse_traces(self.streams[i])
-                    
-                    # Reverse shot_trace_number to match the flipped trace numbers in headers
-                    self.shot_trace_number[i] = self.shot_trace_number[i][::-1]
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    values = dialog.getValues()
+                    first_shot = values['First Source #'] - 1
+                    last_shot = values['Last Source #'] - 1
+                    first_trace = values['First Trace #'] - 1  # Convert to 0-based
+                    last_trace = values['Last Trace #'] - 1   # Convert to 0-based
                     
-                    # Reverse picks and errors (they follow the data)
-                    if self.picks[i] is not None:
-                        self.picks[i] = self.picks[i][::-1]
-                    if self.error[i] is not None:
-                        self.error[i] = self.error[i][::-1]
+                    # Validate input range
+                    if first_trace > last_trace:
+                        QMessageBox.warning(self, "Invalid Range", "First trace must be less than or equal to last trace")
+                        return
+
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        n_traces_i = len(self.streams[i])
+                        # Validate range for this file
+                        if first_trace >= n_traces_i or last_trace >= n_traces_i:
+                            continue  # Skip files that don't have enough traces
+                        
+                        self._reverseTraceSubset(i, first_trace, last_trace)
                     
-                    # Reverse pick items (they follow the data)
-                    if self.pickSeismoItems[i] is not None:
-                        self.pickSeismoItems[i] = self.pickSeismoItems[i][::-1]
-                    if self.pickLayoutItems[i] is not None:
-                        self.pickLayoutItems[i] = self.pickLayoutItems[i][::-1]
-                
-                self.headers_modified = True
-                QMessageBox.information(self, "Trace Data Reversed", f"Trace data reversed for shots {first_shot+1} to {last_shot} (headers unchanged)")
+                    self.headers_modified = True
+                    trace_range = f"Traces #{first_trace+1}-{last_trace+1}" if first_trace != last_trace else f"Trace #{first_trace+1}"
+                    QMessageBox.information(self, "Trace Data Reversed", f"{trace_range} reversed for shots {first_shot+1} to {last_shot+1} (headers unchanged)")
 
-                self.updatePlots()
-                self.updateFileListDisplay()
-                self.updatePlots()
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    QApplication.restoreOverrideCursor()
 
     def stackShots(self):
         """
@@ -16837,123 +17854,143 @@ class MainWindow(QMainWindow):
     # Top widget plot functions - mirror bottom plot functions but use self.plotWidget instead
     def plotLayoutInTopWidget(self):
         """Plot layout view in top widget"""
-        self.topPlotType = 'layout'
-        self.plotWidget.clear()
-        # Re-add crosshair lines after clear to the viewbox so they stay above images
-        self.viewBox.addItem(self.crosshair_vline, ignoreBounds=True)
-        self.viewBox.addItem(self.crosshair_hline, ignoreBounds=True)
-        self.crosshair_vline.setZValue(1000)
-        self.crosshair_hline.setZValue(1000)
-        # Set visibility based on picking_show_crosshair and plot type
-        show_crosshair = (
-            getattr(self, 'picking_show_crosshair', False)
-            and self.topPlotType in ('seismogram', 'dispersion')
-        )
-        self.crosshair_vline.setVisible(show_crosshair)
-        self.crosshair_hline.setVisible(show_crosshair)
-        # Set target widget for plotLayout to use top widget
-        self._plot_target_widget = self.plotWidget
-        self._plot_target_viewbox = self.viewBox
-        self.plotLayout()
-        # Reset target widget after plotting
-        self._plot_target_widget = None
-        self._plot_target_viewbox = None
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            self.topPlotType = 'layout'
+            self.plotWidget.clear()
+            # Re-add crosshair lines after clear to the viewbox so they stay above images
+            self.viewBox.addItem(self.crosshair_vline, ignoreBounds=True)
+            self.viewBox.addItem(self.crosshair_hline, ignoreBounds=True)
+            self.crosshair_vline.setZValue(1000)
+            self.crosshair_hline.setZValue(1000)
+            # Set visibility based on picking_show_crosshair and plot type
+            show_crosshair = (
+                getattr(self, 'picking_show_crosshair', False)
+                and self.topPlotType in ('seismogram', 'dispersion')
+            )
+            self.crosshair_vline.setVisible(show_crosshair)
+            self.crosshair_hline.setVisible(show_crosshair)
+            # Set target widget for plotLayout to use top widget
+            self._plot_target_widget = self.plotWidget
+            self._plot_target_viewbox = self.viewBox
+            self.plotLayout()
+            # Reset target widget after plotting
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+        finally:
+            QApplication.restoreOverrideCursor()
     
     def plotTravelTimeInTopWidget(self):
         """Plot travel times view in top widget"""
-        self.topPlotType = 'traveltime'
-        self.plotWidget.clear()
-        # Re-add crosshair lines after clear to the viewbox so they stay above images
-        self.viewBox.addItem(self.crosshair_vline, ignoreBounds=True)
-        self.viewBox.addItem(self.crosshair_hline, ignoreBounds=True)
-        self.crosshair_vline.setZValue(1000)
-        self.crosshair_hline.setZValue(1000)
-        # Set visibility based on picking_show_crosshair and plot type
-        show_crosshair = (
-            getattr(self, 'picking_show_crosshair', False)
-            and self.topPlotType in ('seismogram', 'dispersion')
-        )
-        self.crosshair_vline.setVisible(show_crosshair)
-        self.crosshair_hline.setVisible(show_crosshair)
-        # Set target widget for plotTravelTime to use top widget
-        self._plot_target_widget = self.plotWidget
-        self._plot_target_viewbox = self.viewBox
-        self.plotTravelTime()
-        # Reset target widget after plotting
-        self._plot_target_widget = None
-        self._plot_target_viewbox = None
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            self.topPlotType = 'traveltime'
+            self.plotWidget.clear()
+            # Re-add crosshair lines after clear to the viewbox so they stay above images
+            self.viewBox.addItem(self.crosshair_vline, ignoreBounds=True)
+            self.viewBox.addItem(self.crosshair_hline, ignoreBounds=True)
+            self.crosshair_vline.setZValue(1000)
+            self.crosshair_hline.setZValue(1000)
+            # Set visibility based on picking_show_crosshair and plot type
+            show_crosshair = (
+                getattr(self, 'picking_show_crosshair', False)
+                and self.topPlotType in ('seismogram', 'dispersion')
+            )
+            self.crosshair_vline.setVisible(show_crosshair)
+            self.crosshair_hline.setVisible(show_crosshair)
+            # Set target widget for plotTravelTime to use top widget
+            self._plot_target_widget = self.plotWidget
+            self._plot_target_viewbox = self.viewBox
+            self.plotTravelTime()
+            # Reset target widget after plotting
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+        finally:
+            QApplication.restoreOverrideCursor()
     
     def plotTopoInTopWidget(self):
         """Plot topography view in top widget"""
-        self.topPlotType = 'topo'
-        self.plotWidget.clear()
-        # Re-add crosshair lines after clear to the viewbox so they stay above images
-        self.viewBox.addItem(self.crosshair_vline, ignoreBounds=True)
-        self.viewBox.addItem(self.crosshair_hline, ignoreBounds=True)
-        self.crosshair_vline.setZValue(1000)
-        self.crosshair_hline.setZValue(1000)
-        # Set visibility based on picking_show_crosshair and plot type
-        show_crosshair = (
-            getattr(self, 'picking_show_crosshair', False)
-            and self.topPlotType in ('seismogram', 'dispersion')
-        )
-        self.crosshair_vline.setVisible(show_crosshair)
-        self.crosshair_hline.setVisible(show_crosshair)
-        # Set target widget for plotTopo to use top widget
-        self._plot_target_widget = self.plotWidget
-        self._plot_target_viewbox = self.viewBox
-        self.plotTopo()
-        # Reset target widget after plotting
-        self._plot_target_widget = None
-        self._plot_target_viewbox = None
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            self.topPlotType = 'topo'
+            self.plotWidget.clear()
+            # Re-add crosshair lines after clear to the viewbox so they stay above images
+            self.viewBox.addItem(self.crosshair_vline, ignoreBounds=True)
+            self.viewBox.addItem(self.crosshair_hline, ignoreBounds=True)
+            self.crosshair_vline.setZValue(1000)
+            self.crosshair_hline.setZValue(1000)
+            # Set visibility based on picking_show_crosshair and plot type
+            show_crosshair = (
+                getattr(self, 'picking_show_crosshair', False)
+                and self.topPlotType in ('seismogram', 'dispersion')
+            )
+            self.crosshair_vline.setVisible(show_crosshair)
+            self.crosshair_hline.setVisible(show_crosshair)
+            # Set target widget for plotTopo to use top widget
+            self._plot_target_widget = self.plotWidget
+            self._plot_target_viewbox = self.viewBox
+            self.plotTopo()
+            # Reset target widget after plotting
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+        finally:
+            QApplication.restoreOverrideCursor()
     
     def plotSpectrogramInTopWidget(self):
         """Plot spectrogram view in top widget"""
-        self.topPlotType = 'spectrogram'
-        self.plotWidget.clear()
-        # Re-add crosshair lines after clear to the viewbox so they stay above images
-        self.viewBox.addItem(self.crosshair_vline, ignoreBounds=True)
-        self.viewBox.addItem(self.crosshair_hline, ignoreBounds=True)
-        self.crosshair_vline.setZValue(1000)
-        self.crosshair_hline.setZValue(1000)
-        # Set visibility based on picking_show_crosshair and plot type
-        show_crosshair = (
-            getattr(self, 'picking_show_crosshair', False)
-            and self.topPlotType in ('seismogram', 'dispersion')
-        )
-        self.crosshair_vline.setVisible(show_crosshair)
-        self.crosshair_hline.setVisible(show_crosshair)
-        # Set target widget for plotSpectrogram to use top widget
-        self._plot_target_widget = self.plotWidget
-        self._plot_target_viewbox = self.viewBox
-        self.plotSpectrogram()
-        # Reset target widget after plotting
-        self._plot_target_widget = None
-        self._plot_target_viewbox = None
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            self.topPlotType = 'spectrogram'
+            self.plotWidget.clear()
+            # Re-add crosshair lines after clear to the viewbox so they stay above images
+            self.viewBox.addItem(self.crosshair_vline, ignoreBounds=True)
+            self.viewBox.addItem(self.crosshair_hline, ignoreBounds=True)
+            self.crosshair_vline.setZValue(1000)
+            self.crosshair_hline.setZValue(1000)
+            # Set visibility based on picking_show_crosshair and plot type
+            show_crosshair = (
+                getattr(self, 'picking_show_crosshair', False)
+                and self.topPlotType in ('seismogram', 'dispersion')
+            )
+            self.crosshair_vline.setVisible(show_crosshair)
+            self.crosshair_hline.setVisible(show_crosshair)
+            # Set target widget for plotSpectrogram to use top widget
+            self._plot_target_widget = self.plotWidget
+            self._plot_target_viewbox = self.viewBox
+            self.plotSpectrogram()
+            # Reset target widget after plotting
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+        finally:
+            QApplication.restoreOverrideCursor()
     
     def plotDispersionInTopWidget(self):
         """Plot dispersion/phase-shift view in top widget"""
-        self.topPlotType = 'dispersion'
-        self.plotWidget.clear()
-        # Re-add crosshair lines after clear to the viewbox so they stay above images
-        self.viewBox.addItem(self.crosshair_vline, ignoreBounds=True)
-        self.viewBox.addItem(self.crosshair_hline, ignoreBounds=True)
-        self.crosshair_vline.setZValue(1000)
-        self.crosshair_hline.setZValue(1000)
-        # Set visibility based on picking_show_crosshair and plot type
-        show_crosshair = (
-            getattr(self, 'picking_show_crosshair', False)
-            and self.topPlotType in ('seismogram', 'dispersion')
-        )
-        self.crosshair_vline.setVisible(show_crosshair)
-        self.crosshair_hline.setVisible(show_crosshair)
-        # Set target widget for plotDispersion to use top widget
-        self._plot_target_widget = self.plotWidget
-        self._plot_target_viewbox = self.viewBox
-        self.plotDispersion()
-        # Reset target widget after plotting
-        self._plot_target_widget = None
-        self._plot_target_viewbox = None
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            self.topPlotType = 'dispersion'
+            self.plotWidget.clear()
+            # Re-add crosshair lines after clear to the viewbox so they stay above images
+            self.viewBox.addItem(self.crosshair_vline, ignoreBounds=True)
+            self.viewBox.addItem(self.crosshair_hline, ignoreBounds=True)
+            self.crosshair_vline.setZValue(1000)
+            self.crosshair_hline.setZValue(1000)
+            # Set visibility based on picking_show_crosshair and plot type
+            show_crosshair = (
+                getattr(self, 'picking_show_crosshair', False)
+                and self.topPlotType in ('seismogram', 'dispersion')
+            )
+            self.crosshair_vline.setVisible(show_crosshair)
+            self.crosshair_hline.setVisible(show_crosshair)
+            # Set target widget for plotDispersion to use top widget
+            self._plot_target_widget = self.plotWidget
+            self._plot_target_viewbox = self.viewBox
+            self.plotDispersion()
+            # Reset target widget after plotting
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+        finally:
+            QApplication.restoreOverrideCursor()
 
     def setTracePositionPlot(self):
         self.plotTypeX = 'trace_position'
@@ -19735,139 +20772,159 @@ class MainWindow(QMainWindow):
 
     def onPseudoSectionFreqLambdaToggled(self, state):
         """Toggle between frequency and wavelength display"""
-        self.pseudosection_use_wavelength = bool(state)
-        # Replot whichever view is showing pseudo-section
-        if getattr(self, 'bottomPlotType', None) == "pseudosection":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotPseudoSection()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
-        if getattr(self, 'topPlotType', None) == "pseudosection":
-            self._plot_target_widget = self.plotWidget
-            self._plot_target_viewbox = self.viewBox
-            self.plotPseudoSection()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            self.pseudosection_use_wavelength = bool(state)
+            # Replot whichever view is showing pseudo-section
+            if getattr(self, 'bottomPlotType', None) == "pseudosection":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotPseudoSection()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+            if getattr(self, 'topPlotType', None) == "pseudosection":
+                self._plot_target_widget = self.plotWidget
+                self._plot_target_viewbox = self.viewBox
+                self.plotPseudoSection()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+        finally:
+            QApplication.restoreOverrideCursor()
 
     def onPseudoSectionInterpToggled(self, state):
         """Toggle between picked and interpolated curve display in pseudo-section"""
-        is_checked = bool(state)
-        self.pseudosection_show_interpolated = is_checked
-        
-        # Synchronize with dispersion view interpolate checkbox (block signals to avoid recursion)
-        if hasattr(self, 'dispersionLiveInterpolateCheckbox'):
-            self.dispersionLiveInterpolateCheckbox.blockSignals(True)
-            self.dispersionLiveInterpolateCheckbox.setChecked(is_checked)
-            self.dispersionLiveInterpolateCheckbox.blockSignals(False)
-        
-        if is_checked:
-            # ENABLE INTERPOLATION: Compute for all shots and both views
-            
-            # 1. Interpolate all shots for pseudo-section display
-            self._interpolateAllShotsForPseudoSection()
-            
-            # 2. Interpolate current dispersion view for all modes
-            view = self._get_active_dispersion_view()
-            if view:
-                if self.dispersionShowAllModesCheckbox.isChecked():
-                    # Interpolate all modes
-                    self.interpolateAllDispersionCurves(view)
-                else:
-                    # Interpolate only current mode
-                    mode_data = self._get_current_mode_data(view)
-                    if len(mode_data['picked_points']) >= 2:
-                        self.interpolateDispersionCurve(view)
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            is_checked = bool(state)
+            self.pseudosection_show_interpolated = is_checked
             
-            # 3. Update pseudo-section display
-            self._updatePseudoSectionIfVisible()
-        else:
-            # DISABLE INTERPOLATION: Remove curves and errors from both views
+            # Synchronize with dispersion view interpolate checkbox (block signals to avoid recursion)
+            if hasattr(self, 'dispersionLiveInterpolateCheckbox'):
+                self.dispersionLiveInterpolateCheckbox.blockSignals(True)
+                self.dispersionLiveInterpolateCheckbox.setChecked(is_checked)
+                self.dispersionLiveInterpolateCheckbox.blockSignals(False)
             
-            # 1. Remove from dispersion view
-            view = self._get_active_dispersion_view()
-            if view:
-                plot_widget = self.plotWidget if view == 'top' else self.bottomPlotWidget
-                state_dict = self.dispersion_picking_state[view]
+            if is_checked:
+                # ENABLE INTERPOLATION: Compute for all shots and both views
                 
-                for mode_num, mode_data in state_dict['modes'].items():
-                    # Remove interpolated curve
-                    if mode_data['curve_line'] is not None:
-                        try:
-                            plot_widget.removeItem(mode_data['curve_line'])
-                        except:
-                            pass
-                        mode_data['curve_line'] = None
+                # 1. Interpolate all shots for pseudo-section display
+                self._interpolateAllShotsForPseudoSection()
+                
+                # 2. Interpolate current dispersion view for all modes
+                view = self._get_active_dispersion_view()
+                if view:
+                    if self.dispersionShowAllModesCheckbox.isChecked():
+                        # Interpolate all modes
+                        self.interpolateAllDispersionCurves(view)
+                    else:
+                        # Interpolate only current mode
+                        mode_data = self._get_current_mode_data(view)
+                        if len(mode_data['picked_points']) >= 2:
+                            self.interpolateDispersionCurve(view)
+                
+                # 3. Update pseudo-section display
+                self._updatePseudoSectionIfVisible()
+            else:
+                # DISABLE INTERPOLATION: Remove curves and errors from both views
+                
+                # 1. Remove from dispersion view
+                view = self._get_active_dispersion_view()
+                if view:
+                    plot_widget = self.plotWidget if view == 'top' else self.bottomPlotWidget
+                    state_dict = self.dispersion_picking_state[view]
                     
-                    # Remove interpolated error fill (can be single item or list)
-                    if mode_data['interp_error_fill'] is not None:
-                        try:
-                            items = mode_data['interp_error_fill'] if isinstance(mode_data['interp_error_fill'], list) else [mode_data['interp_error_fill']]
-                            for item in items:
-                                if item is not None:
-                                    plot_widget.removeItem(item)
-                        except:
-                            pass
-                        mode_data['interp_error_fill'] = None
+                    for mode_num, mode_data in state_dict['modes'].items():
+                        # Remove interpolated curve
+                        if mode_data['curve_line'] is not None:
+                            try:
+                                plot_widget.removeItem(mode_data['curve_line'])
+                            except:
+                                pass
+                            mode_data['curve_line'] = None
+                        
+                        # Remove interpolated error fill (can be single item or list)
+                        if mode_data['interp_error_fill'] is not None:
+                            try:
+                                items = mode_data['interp_error_fill'] if isinstance(mode_data['interp_error_fill'], list) else [mode_data['interp_error_fill']]
+                                for item in items:
+                                    if item is not None:
+                                        plot_widget.removeItem(item)
+                            except:
+                                pass
+                            mode_data['interp_error_fill'] = None
+                        
+                        # Clear curve_data but keep picked_points
+                        mode_data['curve_data'] = None
                     
-                    # Clear curve_data but keep picked_points
-                    mode_data['curve_data'] = None
+                    # Refresh to update display (will redraw picked errors if Show Errors is checked)
+                    self._refreshDispersionPicksDisplay()
                 
-                # Refresh to update display (will redraw picked errors if Show Errors is checked)
-                self._refreshDispersionPicksDisplay()
-            
-            # 2. Update pseudo-section display (will revert to picked points)
-            self._updatePseudoSectionIfVisible()
+                # 2. Update pseudo-section display (will revert to picked points)
+                self._updatePseudoSectionIfVisible()
+        finally:
+            QApplication.restoreOverrideCursor()
     
     def onPseudoSectionInvertYToggled(self, state):
         """Toggle Y-axis inversion for pseudo-section"""
-        self.pseudosection_invert_y = bool(state)
-        # Replot whichever view is showing pseudo-section
-        if getattr(self, 'bottomPlotType', None) == "pseudosection":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotPseudoSection()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
-        if getattr(self, 'topPlotType', None) == "pseudosection":
-            self._plot_target_widget = self.plotWidget
-            self._plot_target_viewbox = self.viewBox
-            self.plotPseudoSection()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            self.pseudosection_invert_y = bool(state)
+            # Replot whichever view is showing pseudo-section
+            if getattr(self, 'bottomPlotType', None) == "pseudosection":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotPseudoSection()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+            if getattr(self, 'topPlotType', None) == "pseudosection":
+                self._plot_target_widget = self.plotWidget
+                self._plot_target_viewbox = self.viewBox
+                self.plotPseudoSection()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+        finally:
+            QApplication.restoreOverrideCursor()
     
     def onPseudoSectionModeChanged(self, value):
         """Handle pseudo-section mode spinbox change"""
-        self.pseudosection_mode = int(value)
-        # Replot whichever view is showing pseudo-section
-        if getattr(self, 'bottomPlotType', None) == "pseudosection":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotPseudoSection()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
-        if getattr(self, 'topPlotType', None) == "pseudosection":
-            self._plot_target_widget = self.plotWidget
-            self._plot_target_viewbox = self.viewBox
-            self.plotPseudoSection()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            self.pseudosection_mode = int(value)
+            # Replot whichever view is showing pseudo-section
+            if getattr(self, 'bottomPlotType', None) == "pseudosection":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotPseudoSection()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+            if getattr(self, 'topPlotType', None) == "pseudosection":
+                self._plot_target_widget = self.plotWidget
+                self._plot_target_viewbox = self.viewBox
+                self.plotPseudoSection()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+        finally:
+            QApplication.restoreOverrideCursor()
 
     def onPseudoSectionUseSourceXToggled(self, state):
         """Toggle use of source position/FFID for pseudo-section X-axis"""
-        self.pseudosection_use_source_x = bool(state)
-        if getattr(self, 'bottomPlotType', None) == "pseudosection":
-            self._plot_target_widget = self.bottomPlotWidget
-            self._plot_target_viewbox = self.bottomViewBox
-            self.plotPseudoSection()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
-        if getattr(self, 'topPlotType', None) == "pseudosection":
-            self._plot_target_widget = self.plotWidget
-            self._plot_target_viewbox = self.viewBox
-            self.plotPseudoSection()
-            self._plot_target_widget = None
-            self._plot_target_viewbox = None
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            self.pseudosection_use_source_x = bool(state)
+            if getattr(self, 'bottomPlotType', None) == "pseudosection":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotPseudoSection()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+            if getattr(self, 'topPlotType', None) == "pseudosection":
+                self._plot_target_widget = self.plotWidget
+                self._plot_target_viewbox = self.viewBox
+                self.plotPseudoSection()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+        finally:
+            QApplication.restoreOverrideCursor()
     
     def _interpolateAllShotsForPseudoSection(self):
         """Legacy function - now uses unified interpolation.
@@ -19978,23 +21035,27 @@ class MainWindow(QMainWindow):
         
         # Only update display if click actually changed currentIndex
         if self.streams and self.currentIndex is not None:
-            # Restore trace ranges for the new shot from memory
-            self._restoreTraceRangesFromMemory()
-            
-            # Set flag to update file display
-            self.update_file_flag = True
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            try:
+                # Restore trace ranges for the new shot from memory
+                self._restoreTraceRangesFromMemory()
+                
+                # Set flag to update file display
+                self.update_file_flag = True
 
-            # Temporarily disconnect the signal to prevent conflicts
-            self.fileListWidget.itemSelectionChanged.disconnect(self.onFileSelectionChanged)
-            
-            # Update file list display to sync the selection
-            self.updateFileListDisplay()
-            
-            # Reconnect the signal
-            self.fileListWidget.itemSelectionChanged.connect(self.onFileSelectionChanged)
+                # Temporarily disconnect the signal to prevent conflicts
+                self.fileListWidget.itemSelectionChanged.disconnect(self.onFileSelectionChanged)
+                
+                # Update file list display to sync the selection
+                self.updateFileListDisplay()
+                
+                # Reconnect the signal
+                self.fileListWidget.itemSelectionChanged.connect(self.onFileSelectionChanged)
 
-            # Batch the updates to improve performance
-            self.updatePlots()
+                # Batch the updates to improve performance
+                self.updatePlots()
+            finally:
+                QApplication.restoreOverrideCursor()
 
     def _layoutViewClick(self, event, viewbox):
         """
@@ -21265,8 +22326,191 @@ Failed to match: {skipped_no_trace_found}"""
         
         return picks_matched, len(sources_with_picks), max_pick_time
 
+    def _loadPicksFromLST(self, lst_file, verbose=False):
+        """
+        Load picks from a Rayfract .LST file.
+        
+        Parameters
+        ----------
+        lst_file : str
+            Path to .LST file
+        verbose : bool
+            Print debug information
+        
+        Returns
+        -------
+        tuple
+            (n_picks_in_file, n_matched_picks)
+        """
+        from .pick_io import read_lst_file, match_lst_picks_to_geometry
+        
+        try:
+            # Read LST file
+            lst_data = read_lst_file(lst_file, verbose=verbose)
+            
+            if lst_data['n_picks'] == 0:
+                QMessageBox.warning(self, "No Picks", f"No valid picks found in {os.path.basename(lst_file)}")
+                return 0, 0
+            
+            # Calculate position scaling factor
+            # Compare median geophone spacing in LST to mean_dg in seismic data
+            position_scale = 1.0
+            
+            # Calculate median spacing from LST positions
+            all_positions = [pos for _, _, pos, _ in lst_data['picks']]
+            if len(all_positions) > 1:
+                unique_positions = sorted(set(all_positions))
+                if len(unique_positions) > 1:
+                    spacings = [unique_positions[i+1] - unique_positions[i] 
+                               for i in range(len(unique_positions)-1)]
+                    median_spacing_lst = np.median(spacings)
+                    
+                    # Use self.mean_dg from seismic data
+                    if hasattr(self, 'mean_dg') and self.mean_dg is not None and self.mean_dg > 0:
+                        if median_spacing_lst > 0:
+                            position_scale = self.mean_dg / median_spacing_lst
+                            print(f"\nDetected position scaling:")
+                            print(f"  Median LST spacing: {median_spacing_lst:.2f}")
+                            print(f"  Seismic mean_dg: {self.mean_dg:.2f}")
+                            print(f"  Scaling factor: {position_scale:.2f}")
+            
+            # Match picks to current geometry
+            matched = match_lst_picks_to_geometry(
+                lst_data,
+                self.trace_position,
+                self.source_position,
+                shot_number_offset=0,  # Could be made configurable via dialog
+                position_tolerance=0.1,  # Could be made configurable via dialog
+                position_scale=position_scale,
+                verbose=True  # Always print diagnostic info for now
+            )
+            
+            # Apply matched picks
+            for i, (pick_list, error_list) in enumerate(zip(matched['picks'], matched['errors'])):
+                if self.picks[i] is None:
+                    self.picks[i] = [np.nan] * len(pick_list)
+                if self.error[i] is None:
+                    self.error[i] = [0.001] * len(error_list)
+                
+                for j, (pick, error) in enumerate(zip(pick_list, error_list)):
+                    if not np.isnan(pick):
+                        self.picks[i][j] = pick
+                        self.error[i][j] = error
+            
+            # Mark picks as modified
+            self.picks_modified = True
+            
+            # Trigger pick update
+            self.update_pick_flag = True
+            
+            # Count sources with picks
+            sources_with_picks = sum(1 for pick_list in matched['picks'] 
+                                    if any(not np.isnan(p) for p in pick_list))
+            
+            if matched['n_matched'] == 0:
+                QMessageBox.warning(self, "No Matches",
+                                  f"Could not match any picks from {os.path.basename(lst_file)} to current geometry.\n\n"
+                                  f"File contains {matched['n_total']} picks but none matched.")
+            
+            return lst_data['n_picks'], matched['n_matched']
+            
+        except Exception as e:
+            QMessageBox.critical(self, "Error Loading LST File",
+                               f"Error reading {os.path.basename(lst_file)}:\n\n{str(e)}")
+            if verbose:
+                import traceback
+                traceback.print_exc()
+            return 0, 0
+
+    def _loadPicksFromVS(self, vs_file, verbose=False):
+        """
+        Load picks from a SeisImager/PickWin .vs file.
+        
+        Parameters
+        ----------
+        vs_file : str
+            Path to .vs file
+        verbose : bool
+            Print debug information
+        
+        Returns
+        -------
+        tuple
+            (n_picks_in_file, n_matched_picks)
+        """
+        from .pick_io import read_vs_file, match_vs_picks_to_geometry
+        
+        try:
+            # Read VS file
+            vs_data = read_vs_file(vs_file, verbose=verbose)
+            
+            if vs_data['n_picks'] == 0:
+                QMessageBox.warning(self, "No Picks", f"No valid picks found in {os.path.basename(vs_file)}")
+                return 0, 0
+            
+            # Calculate position scaling factor
+            # Compare VS spacing to mean_dg in seismic data
+            position_scale = 1.0
+            median_spacing_vs = vs_data.get('spacing', 1.0)
+            
+            # Use self.mean_dg from seismic data
+            if hasattr(self, 'mean_dg') and self.mean_dg is not None and self.mean_dg > 0:
+                if median_spacing_vs > 0:
+                    position_scale = self.mean_dg / median_spacing_vs
+                    print(f"\nDetected position scaling:")
+                    print(f"  VS spacing: {median_spacing_vs:.2f}")
+                    print(f"  Seismic mean_dg: {self.mean_dg:.2f}")
+                    print(f"  Scaling factor: {position_scale:.2f}")
+            
+            # Match picks to current geometry
+            matched = match_vs_picks_to_geometry(
+                vs_data,
+                self.trace_position,
+                self.source_position,
+                offset_tolerance=0.5,  # Could be made configurable via dialog
+                position_scale=position_scale,
+                verbose=True  # Always print diagnostic info for now
+            )
+            
+            # Apply matched picks
+            for i, (pick_list, error_list) in enumerate(zip(matched['picks'], matched['errors'])):
+                if self.picks[i] is None:
+                    self.picks[i] = [np.nan] * len(pick_list)
+                if self.error[i] is None:
+                    self.error[i] = [0.001] * len(error_list)
+                
+                for j, (pick, error) in enumerate(zip(pick_list, error_list)):
+                    if not np.isnan(pick):
+                        self.picks[i][j] = pick
+                        self.error[i][j] = error
+            
+            # Mark picks as modified
+            self.picks_modified = True
+            
+            # Trigger pick update
+            self.update_pick_flag = True
+            
+            # Count sources with picks
+            sources_with_picks = sum(1 for pick_list in matched['picks'] 
+                                    if any(not np.isnan(p) for p in pick_list))
+            
+            if matched['n_matched'] == 0:
+                QMessageBox.warning(self, "No Matches",
+                                  f"Could not match any picks from {os.path.basename(vs_file)} to current geometry.\n\n"
+                                  f"File contains {matched['n_total']} picks but none matched.")
+            
+            return vs_data['n_picks'], matched['n_matched']
+            
+        except Exception as e:
+            QMessageBox.critical(self, "Error Loading VS File",
+                               f"Error reading {os.path.basename(vs_file)}:\n\n{str(e)}")
+            if verbose:
+                import traceback
+                traceback.print_exc()
+            return 0, 0
+
     def loadPicks(self, fname=None, verbose=False):
-        # Load picks from single or multiple pygimli .sgt files
+        # Load picks from .sgt (PyGimli), .LST (Rayfract), or .vs (SeisImager/PickWin) files
         
         # Check if seismic data is loaded first
         if not self.streams:
@@ -21276,7 +22520,7 @@ Failed to match: {skipped_no_trace_found}"""
         # The first argument returned is the filename(s) and path(s)
         if fname is None or not fname:
             fnames, _ = QFileDialog.getOpenFileNames(
-                self, 'Open file(s)', filter='Source-Geophone-Time file (*.sgt)')
+                self, 'Open file(s)', filter='Pick files (*.sgt *.LST *.lst *.vs);;SGT files (*.sgt);;LST files (*.LST *.lst);;VS files (*.vs)')
         else:
             # If fname is provided, ensure it's a list for consistent processing
             if isinstance(fname, str):
@@ -21287,7 +22531,7 @@ Failed to match: {skipped_no_trace_found}"""
         if fnames:
             # Initialize counters for all files
             total_picks_loaded = 0
-            total_picks_in_files = 0  # Track total picks across all SGT files
+            total_picks_in_files = 0  # Track total picks across all files
             total_sources_loaded = 0
             overall_max_picked_time = 0
             
@@ -21296,6 +22540,28 @@ Failed to match: {skipped_no_trace_found}"""
                 if verbose:
                     print(f"\nProcessing file {file_idx + 1}/{len(fnames)}: {fname}")
                 
+                # Detect file type by extension
+                file_ext = fname.lower().split('.')[-1]
+                
+                if file_ext == 'lst':
+                    # Load LST (Rayfract) file
+                    n_picks_file, n_matched = self._loadPicksFromLST(fname, verbose=verbose)
+                    total_picks_in_files += n_picks_file
+                    total_picks_loaded += n_matched
+                    if n_matched > 0:
+                        total_sources_loaded += 1
+                    continue  # Skip to next file
+                
+                if file_ext == 'vs':
+                    # Load VS (SeisImager/PickWin) file
+                    n_picks_file, n_matched = self._loadPicksFromVS(fname, verbose=verbose)
+                    total_picks_in_files += n_picks_file
+                    total_picks_loaded += n_matched
+                    if n_matched > 0:
+                        total_sources_loaded += 1
+                    continue  # Skip to next file
+                
+                # Default: Load SGT (PyGimli) file
                 with open(fname, 'r') as f:
                     # Read number of stations
                     n_stations = int(f.readline().split('#')[0].strip())