PaIRS-UniNa 0.2.7__cp312-cp312-macosx_11_0_universal2.whl → 0.2.10__cp312-cp312-macosx_11_0_universal2.whl

PaIRS_UniNa/FolderLoop.py

@@ -1,6 +1,6 @@
 import sys
 from PySide6.QtWidgets import (
-    QApplication, QDialog, QVBoxLayout, QLabel, QHBoxLayout, QWidget, QSpacerItem,
+    QApplication, QDialog, QVBoxLayout, QLabel, QHBoxLayout, QWidget, QSpacerItem, QTreeWidget, QTreeWidgetItem,
     QPushButton, QProgressBar, QSizePolicy,
     QFileDialog, QListView, QAbstractItemView, QTreeView,  QFileSystemModel
 )
@@ -83,14 +83,18 @@ class FolderLoopDialog(QDialog):
         self.tooltips = {
             "copy": "Copy the item",
             "link": "Link the item",
-            "change_folder": "Change the folder"
+            "change_folder": "Change the folder",
+            "auto_purge": "Auto-remove missing-image pairs",
+            "rescan": "Re-scan destination paths"
         }
 
         # Icons for the buttons
         self.icons = {
             "copy": [QIcon(icons_path + "copy_process.png"), QIcon(icons_path + "copy_process_off.png")],
             "link": [QIcon(icons_path + "link.png"), QIcon(icons_path + "unlink.png")],
-            "change_folder": [QIcon(icons_path + "change_folder.png"), QIcon(icons_path + "change_folder_off.png")]
+            "change_folder": [QIcon(icons_path + "change_folder.png"), QIcon(icons_path + "change_folder_off.png")],
+            "auto_purge": [QIcon(icons_path + "folder_loop_cleanup.png"), QIcon(icons_path + "folder_loop_cleanup_off.png")],
+            "rescan": [QIcon(icons_path + "scan_path_loop.png"), QIcon(icons_path + "scan_path_loop_off.png")],
         }
         self.options_list=list(self.icons)
 
@@ -109,7 +113,8 @@ class FolderLoopDialog(QDialog):
         self.header_icon.setFixedSize(self.icon_size)
         header_layout.addWidget(self.header_icon)
 
-        self.header_label = QLabel(process_name)
+        header_text=process_name[:48]+f"{'...' if len(process_name)>50 else ''}"
+        self.header_label = QLabel(header_text)
         self.header_label.setFont(self.title_font)
         self.header_label.setAlignment(Qt.AlignmentFlag.AlignLeft|Qt.AlignmentFlag.AlignVCenter)
         self.header_label.setFixedHeight(self.title_height)
@@ -191,6 +196,82 @@ class FolderLoopDialog(QDialog):
 
             layout.addWidget(widget)
 
+        # --- Cleanup row ---
+        cleanup_spacing = 5
+        self.cleanup_widget = QWidget()
+        cw_layout = QHBoxLayout(self.cleanup_widget)
+        cw_layout.setContentsMargins(0, cleanup_spacing, 0, cleanup_spacing)
+        cw_layout.setSpacing(5)
+
+        self.cleanup_button = QPushButton(self)
+        self.cleanup_button.setCheckable(True)
+        self.cleanup_button.setChecked(False)
+        self.cleanup_button.setIcon(self.icons["auto_purge"][1])
+        self.cleanup_button.setFixedSize(self.button_size)
+        self.cleanup_button.setStyleSheet("QPushButton{border: none;}")
+        self.cleanup_button.setCursor(QCursor(Qt.PointingHandCursor))
+        self.cleanup_button.setToolTip(self.tooltips["auto_purge"])
+        self.cleanup_button.setIconSize(self.icon_size_off)
+
+        self.cleanup_label = QLabel("", self)
+        self.cleanup_label_font = parent.font()
+        self.cleanup_label_font.setPixelSize(fontPixelSize)
+        self.cleanup_label_font.setItalic(True)
+        self.cleanup_label.setFont(self.cleanup_label_font)
+        self.cleanup_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
+
+        self.cleanup_button.toggled.connect(self.on_cleanup_toggled)
+        cw_layout.addItem(QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Minimum))
+        cw_layout.addWidget(self.cleanup_label)
+        cw_layout.addWidget(self.cleanup_button)
+
+
+        # --- Rescan row ---
+        rescan_spacing = 5
+        self.rescan_widget = QWidget()
+        rw_layout = QHBoxLayout(self.rescan_widget)
+        rw_layout.setContentsMargins(0, rescan_spacing, 0, rescan_spacing)
+        rw_layout.setSpacing(5)
+
+        self.rescan_button = QPushButton(self)
+        self.rescan_button.setCheckable(True)
+        self.rescan_button.setChecked(False)
+        self.rescan_button.setIcon(self.icons["rescan"][1])
+        self.rescan_button.setFixedSize(self.button_size)
+        self.rescan_button.setStyleSheet("QPushButton{border: none;}")
+        self.rescan_button.setCursor(QCursor(Qt.PointingHandCursor))
+        self.rescan_button.setToolTip(self.tooltips["rescan"])
+        self.rescan_button.setIconSize(self.icon_size_off)
+
+        self.rescan_label = QLabel("", self)
+        self.rescan_label_font = parent.font()
+        self.rescan_label_font.setPixelSize(fontPixelSize)
+        self.rescan_label_font.setItalic(True)
+        self.rescan_label.setFont(self.rescan_label_font)
+        self.rescan_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
+
+        self.rescan_button.toggled.connect(self.on_rescan_toggled)
+        rw_layout.addItem(QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Minimum))
+        rw_layout.addWidget(self.rescan_label)
+        rw_layout.addWidget(self.rescan_button)
+
+        # --- Container for both rows ---
+        self.extra_opts_widget = QWidget()
+        eo_layout = QVBoxLayout(self.extra_opts_widget)
+        eo_layout.setContentsMargins(0, 5, 0, 50)  # top=10, bottom=10
+        eo_layout.setSpacing(5)
+        eo_layout.addWidget(self.rescan_widget)
+        eo_layout.addWidget(self.cleanup_widget)
+        self.extra_opts_widget.setFixedHeight(self.button_size.height()*2+60)
+
+        self.extra_opts_widget.setVisible(False)
+        self.widgets.append(self.extra_opts_widget)
+
+        # Add container to parent layout
+        layout.addWidget(self.extra_opts_widget)
+        
+        self.warnings=[False]*len(self.paths)
+
         # Progress bar and final buttons (Cancel, Proceed)
         progress_widget = QWidget()
         progress_layout = QHBoxLayout()
@@ -228,8 +309,13 @@ class FolderLoopDialog(QDialog):
         self.setLayout(layout)
 
         # Set window maximum height and margins
+        self.on_cleanup_toggled(self.cleanup_button.isChecked())
+        self.on_rescan_toggled(self.rescan_button.isChecked())
+        self.update_extraopts_visibility(FlagAnimation=False)
         self.setFixedHeight(self.max_height)
         self.setContentsMargins(self.margin_size*2, self.margin_size, self.margin_size*2, self.margin_size)
+        self.setMinimumWidth(640)
+        self.setMaximumWidth(800)
 
         # Timer for progress
         self.iteration = 0
@@ -271,6 +357,51 @@ class FolderLoopDialog(QDialog):
                 button.setIconSize(self.icon_size)
                 button.setIcon(self.icons[self.options_list[k]][0])  # Checked state icon
                 self.step_options[index]=k
+                self.update_extraopts_visibility() 
+
+    def update_extraopts_visibility(self,FlagAnimation=True):
+        """Show extra row if any row has 'change_folder' checked; hide otherwise."""
+        try:
+            idx_change = self.options_list.index("change_folder")
+        except ValueError:
+            idx_change = -1
+
+        show = (idx_change >= 0) and any(
+            (opt == idx_change) for opt in self.step_options if isinstance(opt, int)
+        )
+
+        if self.extra_opts_widget.isVisible() != show:
+            self.extra_opts_widget.setVisible(show)
+            extra_opts_widget = self.extra_opts_widget.height()
+            maxHeight = self.nstep * (self.button_size.height() + self.row_spacing) + int(show)*extra_opts_widget + self.min_height
+            if FlagAnimation:
+                self.window_resize(maxHeight)
+            self.max_height = maxHeight
+
+    def on_cleanup_toggled(self, checked: bool):
+        """Sync icon/size and label text when the extra toggle is changed."""
+        self.cleanup_button.setIcon(self.icons["auto_purge"][0 if checked else 1])
+        self.cleanup_button.setIconSize(self.icon_size if checked else self.icon_size_off)
+        self.cleanup_label.setText(
+            "Image-missing pairs will be removed automatically."
+            if checked else
+            "Image-missing pairs are kept; batch copy may raise warnings."
+        )
+        self.cleanup_label.setStyleSheet("color: none;" if checked else "color: rgb(125,125,125);")
+        self.cleanup_enabled = bool(checked)
+
+    def on_rescan_toggled(self, checked: bool):
+        """Sync icon/size and label text when the rescan toggle is changed."""
+        self.rescan_button.setIcon(self.icons["rescan"][0 if checked else 1])
+        self.rescan_button.setIconSize(self.icon_size if checked else self.icon_size_off)
+
+        self.rescan_label.setText(
+            "The input folder will be re-scanned; input image list may differ or trigger warnings."
+            if checked else
+            "No folder scan; images identified in the master process will be used."
+        )
+        self.rescan_label.setStyleSheet("color: none;" if checked else "color: rgb(125,125,125);")
+        self.rescan_enabled = bool(checked)
 
     def on_proceed(self):
         """Start or stop the progress loop depending on the button state."""
@@ -300,14 +431,17 @@ class FolderLoopDialog(QDialog):
         """Update the progress bar on each timer tick."""
         if self.iteration < self.progress_bar.maximum():
             timesleep(time_sleep_loop)
-            self.title_label.setText(self.paths[self.iteration])
-            self.func(self.iteration,self.step_options)
+            title_text=self.paths[self.iteration][:48]+f"{'...' if len(self.paths[self.iteration])>50 else ''}"
+            self.title_label.setText(title_text)
+            self.warnings[self.iteration]=self.func(self.iteration,self.step_options,self.cleanup_enabled,self.rescan_enabled)
             self.progress_bar.setValue(self.iteration)
             self.iteration += 1
             if self.loop_running: self.timer.start(0) 
         else:
             self.progress_bar.setValue(self.progress_bar.maximum())
             self.stop_progress()
+            self.hide()
+            self.show_batch_issues_dialog()
             if not self.animation: self.done(0)  # Closes the dialog when complete
 
     def cancel(self):
@@ -332,6 +466,62 @@ class FolderLoopDialog(QDialog):
 
     def window_resize(self, h):
         self.setFixedHeight(h)
+        
+    def show_batch_issues_dialog(self):
+        """Show a summary dialog listing all destination folders with warnings=True."""
+        issues=[(i,p) for i,p in enumerate(self.paths) if i<len(self.warnings) and self.warnings[i]]
+        if not issues: return
+
+        dlg=QDialog(self); dlg.setWindowTitle("Batch copy issues")
+        font=dlg.font()
+        font.setPixelSize(fontPixelSize)
+        dlg.setFont(font)
+        lay=QVBoxLayout(dlg)
+
+       # --- Warning header with icon ---
+        icon_width=96
+        warn_layout = QHBoxLayout()
+        warn_icon = QLabel()
+        warn_pix = QPixmap(icons_path + "warning.png").scaled(
+            icon_width, icon_width, Qt.KeepAspectRatio, Qt.SmoothTransformation
+        )
+        warn_icon.setPixmap(warn_pix)
+        warn_icon.setScaledContents(False)
+        #warn_icon.setAlignment(Qt.AlignTop)
+        warn_icon.setFixedWidth(icon_width)
+
+        head = QLabel(
+            f"{len(issues)} destination folder{'s' if len(issues)>1 else ''} could require attention: "
+            "potential warnings during batch copy or image-set mismatch!\n\n"
+            "Please note that the interface may not explicitly flag these cases. "
+            "Copy the paths below if you wish to inspect the corresponding processes.\n",
+            dlg
+        )
+        head.setWordWrap(True)
+
+        warn_layout.addWidget(warn_icon)
+        warn_layout.addWidget(head)
+        lay.addLayout(warn_layout)
+
+        tree=QTreeWidget(dlg); tree.setHeaderHidden(True)
+        tree.header().setStretchLastSection(True)
+        for _,p in issues:
+            item=QTreeWidgetItem([p])
+            item.setToolTip(0,p)
+            tree.addTopLevelItem(item)
+        lay.addWidget(tree)
+
+        # actions
+        btns=QHBoxLayout()
+        def _copy():
+            txt="\n".join(p for _,p in issues)
+            QApplication.clipboard().setText(txt)
+        copy_btn=QPushButton("Copy paths"); copy_btn.clicked.connect(_copy)
+        close_btn=QPushButton("Close"); close_btn.clicked.connect(dlg.accept)
+        btns.addWidget(copy_btn); btns.addStretch(1); btns.addWidget(close_btn)
+        lay.addLayout(btns)
+
+        dlg.resize(720, 360); dlg.exec()
 
 if __name__ == "__main__":
     import random

PaIRS_UniNa/Input_Tab.py

@@ -71,13 +71,14 @@ class INPpar(TABpar):
             self.inp_cam        = 1
             self.ind_in         = 0
             self.npairs         = 0 
-            self.step           = 0
+            self.step           = 1
             self.FlagTR_Import  = False
             self.FlagImport     = True
 
     FlagAutoList   = True
     FlagAutoFrame  = True
     FlagExample    = True
+    pathCompleter  = basefold_DEBUGOptions
 
     def __init__(self,Process=ProcessTypes.null,Step=StepTypes.null):
         self.setup(Process,Step)
@@ -104,7 +105,7 @@ class INPpar(TABpar):
         self.inp_cam        = 1
         self.ind_in         = 0
         self.npairs         = 0 
-        self.step           = 0
+        self.step           = 1
         self.FlagTR_Import  = False
         
         self.nExImTree      = 3
@@ -132,11 +133,10 @@ class INPpar(TABpar):
 
         #self.FlagDISP       = Step==StepTypes.disp
         #self.dispFile       = ''
-        
-        self.pathCompleter=basefold_DEBUGOptions
-        
+
 class Input_Tab(gPaIRS_Tab):
     class Import_Tab_Signals(gPaIRS_Tab.Tab_Signals):
+        tooltipRequested = Signal(str)
         pass
 
     def __init__(self,parent: QWidget =None, flagInit= __name__ == "__main__"):
@@ -148,11 +148,33 @@ class Input_Tab(gPaIRS_Tab):
         #------------------------------------- Graphical interface: widgets
         self.TABname='Input'
         self.ui: Ui_InputTab
-        self.exImTree=self.ui.exImTree=GlobalImageTree(self,FlagNum=True)
-        self.ui.g_ImSet_layout.insertWidget(2,self.exImTree)    
+        self.exImTree=self.ui.exImTree=GlobalImageTree(self,FlagNum=True)    
         self.exImTree.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.exImTree.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
         self.exImTree.setSelectionBehavior(QTreeWidget.SelectionBehavior.SelectRows)
-        self.exImTree.setHeaderHidden(True)
+        #self.exImTree.setHeaderHidden(True)
+        self.exImTree.header().setVisible(True)
+        self.hbarExImTree = QScrollBar(Qt.Horizontal)
+        self.hbarExImTree.setStyleSheet("""
+        QScrollBar::handle:horizontal {
+            min-width: 40px;             
+        }
+        """)
+        self.exImTree.setVisible(True)
+        self.hbarExImTree.setVisible(True)
+        # Sync ranges and values
+        origHbar = self.exImTree.horizontalScrollBar()
+        origHbar.rangeChanged.connect(self.hbarExImTree.setRange)
+        origHbar.valueChanged.connect(self.hbarExImTree.setValue)
+        self.hbarExImTree.valueChanged.connect(origHbar.setValue)
+        # Layout
+        self.containerExImTree = QWidget()
+        layoutExImTree = QVBoxLayout(self.containerExImTree)
+        layoutExImTree.setContentsMargins(0,0,0,0)
+        layoutExImTree.setSpacing(0)
+        layoutExImTree.addWidget(self.exImTree)
+        layoutExImTree.addWidget(self.hbarExImTree)
+        self.ui.g_ImSet_layout.insertWidget(2,self.containerExImTree)
 
         #necessary to change the name and the order of the items
         for g in list(globals()):
@@ -170,6 +192,8 @@ class Input_Tab(gPaIRS_Tab):
         self.pixmap_wait  = QPixmap(''+ icons_path +'sandglass.png')
         self.pixmap_warn  = QPixmap(u""+ icons_path +"warning.png")
         
+        self.signals.tooltipRequested.connect(self.show_import_tooltip)
+
         #------------------------------------- Declaration of parameters 
         self.INPpar_base=INPpar()
         self.INPpar:INPpar=self.TABpar
@@ -291,11 +315,39 @@ class Input_Tab(gPaIRS_Tab):
     def scanImList(self,ind=None):
         if ind: INP:INPpar=self.TABpar_at(ind)
         else: INP:INPpar=self.INPpar
+        FlagWarning=False
         for c in range(len(INP.imList)):  #INP.ncam
             for f in range(2): 
                 for k in range(len(INP.imList[0][0])):  #INP.nimg
                     #ex=INP.imEx[c][f][k]
                     INP.imEx[c][f][k]=os.path.exists(INP.path+INP.imList[c][f][k]) if INP.imList[c][f][k] else False
+                    if not FlagWarning and not INP.imEx[c][f][k]: FlagWarning=True
+        return FlagWarning
+
+    def purgeImList(self, ind=None):
+        """Drop every k where any INP.imEx[c][f][k] is False; remove k from both imEx and imList across all c,f."""
+        INP = self.INPpar if ind is None else self.TABpar_at(ind)
+        if not hasattr(INP,"imEx") or not hasattr(INP,"imList"): return 0
+
+        # Collect all k to drop if False appears anywhere at that k
+        ks_to_drop=set()
+        for c in range(len(INP.imEx)):
+            for f in range(len(INP.imEx[c])):
+                row=INP.imEx[c][f]
+                for k, ex in enumerate(row):
+                    if not ex: ks_to_drop.add(k)
+
+        if not ks_to_drop: return 0
+        ks_sorted=sorted(ks_to_drop, reverse=True)
+
+        # Delete k across all c,f for both imEx and imList (bounds-checked, ragged-safe)
+        for c in range(len(INP.imEx)):
+            for f in range(len(INP.imEx[c])):
+                for k in ks_sorted:
+                    if k < len(INP.imEx[c][f]): del INP.imEx[c][f][k]
+                    if c < len(INP.imList) and f < len(INP.imList[c]) and k < len(INP.imList[c][f]):
+                        del INP.imList[c][f][k]
+        return len(ks_to_drop)
 
 #*************************************************** Layout
     def setINPlayout(self):
@@ -320,9 +372,9 @@ class Input_Tab(gPaIRS_Tab):
         self.ui.spin_inp_cam.setEnabled(self.INPpar.inp_ncam>1)
         self.ui.spin_inp_cam.setMaximum(self.INPpar.inp_ncam)
         self.setImageNumberSpinLimits()
-        self.exImTree.setVisible(INPpar.FlagExample)
+        self.containerExImTree.setVisible(INPpar.FlagExample)
         self.layoutExampleImageList()        
-        self.ui.button_import.setEnabled(not self.INPpar.FlagImport)
+        #self.ui.button_import.setEnabled(not self.INPpar.FlagImport)
 
         """
         if self.INPpar.ind[-1]<len(self.TABpar_prev_at(self.INPpar.ind))-1:
@@ -397,13 +449,13 @@ class Input_Tab(gPaIRS_Tab):
     def line_edit_path_preaction(self):
         currpath=myStandardPath(self.ui.line_edit_path.text())    
         self.FlagScanPath=os.path.normpath(self.INPpar.path)!=currpath
-        directory_path = myStandardPath(os.getcwd())
-        if directory_path in currpath:
-            currpath=currpath.replace(directory_path,'./')        
-        if os.path.exists(currpath):
-            if currpath in self.INPpar.pathCompleter: self.INPpar.pathCompleter.remove(currpath)
-            self.INPpar.pathCompleter.insert(0,currpath)
-            if len(self.INPpar.pathCompleter)>10: self.INPpar.pathCompleter=self.INPpar.pathCompleter[:10]
+        currpath=relativizePath(currpath)
+        if os.path.exists(currpath) and currpath!='./':
+            pathCompleter=INPpar.pathCompleter  #self.INPpar.pathCompleter
+            if currpath in pathCompleter: pathCompleter.remove(currpath)
+            pathCompleter.insert(0,currpath)
+            if len(pathCompleter)>pathCompleterLength: 
+                INPpar.pathCompleter=pathCompleter[:pathCompleterLength]
         self.ui.line_edit_path.setText(currpath)
 
     def line_edit_path_action_future(self):
@@ -426,15 +478,7 @@ class Input_Tab(gPaIRS_Tab):
         self.line_edit_path_action_future()
 
     def button_scan_path_action(self):
-        self.INPpar.imSet.scanPath(self.INPpar.path)
-        if self.INPpar.imSet.count:
-            self.INPpar.frame_1[0]=0
-            self.INPpar.frame_1,self.INPpar.frame_2=self.automaticFrames()
-        else:
-            self.INPpar.frame_1=[-1]*self.INPpar.inp_ncam
-            self.INPpar.frame_2=[-1]*self.INPpar.inp_ncam
-        self.INPpar.ind_in, _, self.INPpar.npairs, _= self.getIndNpairs()
-        self.INPpar.step=1 if self.INPpar.npairs else 0
+        self.scanInputPath()
         if INPpar.FlagAutoList: 
             self.button_import_action()
         else:
@@ -442,20 +486,65 @@ class Input_Tab(gPaIRS_Tab):
             self.ui.imTreeWidget.imTree.scanLists()
             self.INPpar.imEx=self.ui.imTreeWidget.imTree.imEx
 
-    def automaticFrames(self):
-        cam=self.INPpar.inp_cam-1
-        if not self.INPpar.imSet.nimg:
-            return self.INPpar.frame_1,self.INPpar.frame_2
-        f1=self.INPpar.frame_1[cam]
-        link1=self.INPpar.imSet.link[f1]
+    def scanInputPath(self,ind=None,patterns=None,FlagNoWarning=True):
+        INP = self.INPpar if ind is None else self.TABpar_at(ind)
+        INP.imSet.scanPath(INP.path)
+        ncam = INP.inp_ncam
+
+        FlagAutomaticFrames=True
+        if patterns and len(patterns)==2 and INP.imSet.count:
+            A,B = patterns  # lists of patterns (len <= ncam)
+            INP.frame_1 = [-1]*ncam
+            INP.frame_2 = [-1]*ncam
+
+            # Build first-occurrence lookup: pattern -> index in slave's INP.imSet.pattern
+            pat_list = getattr(INP.imSet, "pattern", [])
+            idx_map = {}
+            for idx,p in enumerate(pat_list):
+                if p not in idx_map: idx_map[p]=idx
+
+            # Assign frames by matching patterns; leave -1 if not found
+            def _assign(dst, src, ind0=0):
+                for k in range(ncam):
+                    key = src[k] if k < len(src) else None
+                    dst[k] = idx_map.get(key, -1)
+                    if ind0 and key is not None: dst[k]+=ind0
+
+            _assign(INP.frame_1, A)
+            _assign(INP.frame_2, B, 1)
+
+            valid=any(f>-1 for f in INP.frame_1) or any(f>0 for f in INP.frame_2)
+            if not valid and FlagNoWarning:
+                FlagAutomaticFrames = True
+            else:
+                FlagAutomaticFrames = False
+        
+        if FlagAutomaticFrames:
+            if INP.imSet.count:
+                INP.frame_1[0]=0
+                INP.frame_1,INP.frame_2=self.automaticFrames(ind)
+            else:
+                INP.frame_1=[-1]*INP.inp_ncam
+                INP.frame_2=[-1]*INP.inp_ncam
+        # Update derived indices and safety on step
+        INP.ind_in, _, INP.npairs, _= self.getIndNpairs(ind)
+        if INP.npairs<1: INP.step=1
+
+    def automaticFrames(self,ind=None):
+        INP = self.INPpar if ind is None else self.TABpar_at(ind)
+        cam=INP.inp_cam-1
+        if not INP.imSet.nimg:
+            return INP.frame_1,INP.frame_2
+        f1=INP.frame_1[cam]
+        link1=INP.imSet.link[f1]
         nlink1=len(link1)
-        frame_1=[f1]*self.INPpar.inp_ncam
-        frame_2=[f1+1]*self.INPpar.inp_ncam
+        frame_1=[f1]*INP.inp_ncam
+        frame_2=[f1+1]*INP.inp_ncam
         frame_2[0]=link1[0]+1 if link1[0]!=f1 else 0
-        for c in range(1,self.INPpar.inp_ncam):
+        for c in range(1,INP.inp_ncam):
             flagValid=c<nlink1-1
             frame_1[c]=f1c=link1[c] if flagValid else -1
-            frame_2[c]=self.INPpar.imSet.link[f1c][0]+1 if flagValid else -1
+            frame_2[c]=INP.imSet.link[f1c][0]+1 if flagValid else -1
         if cam:
             frame_1=frame_1[-cam:]+frame_1[:-cam]
             frame_2=frame_2[-cam:]+frame_2[:-cam]
@@ -511,7 +600,7 @@ class Input_Tab(gPaIRS_Tab):
         INPpar.FlagAutoFrame=self.ui.button_automatic_frame.isChecked()
         return True
         
-    def combo_frame_a_action(self):
+    def combo_frame_a_action(self): 
         self.INPpar.frame_1[self.INPpar.inp_cam-1]=self.ui.combo_frame_a.currentIndex()
         if INPpar.FlagAutoFrame:
             self.INPpar.frame_1,self.INPpar.frame_2=self.automaticFrames()
@@ -522,7 +611,8 @@ class Input_Tab(gPaIRS_Tab):
 
     def button_example_list_action(self):
         INPpar.FlagExample=self.ui.button_example_list.isChecked()
-        self.exImTree.setVisible(INPpar.FlagExample)
+        self.layoutExampleImageList()
+        self.containerExImTree.setVisible(INPpar.FlagExample)
         return True
 
     def spin_inp_cam_action(self):
@@ -538,16 +628,24 @@ class Input_Tab(gPaIRS_Tab):
                 item.setSelected(True)
         
     def button_import_action(self):
-        INPpar.FlagExample=False
         self.INPpar.imList,self.INPpar.imEx=self.INPpar.imSet.genListsFromFrame(self.INPpar.frame_1,self.INPpar.frame_2,self.INPpar.ind_in,self.INPpar.npairs,self.INPpar.step,self.INPpar.FlagTR_Import)
-        self.INPpar.selection=[1,1,1]
-        self.InputAdjustSelection()
         if self.INPpar.isDifferentFrom(self.INPpar_old,fields=['imList','imEx']):
+            INPpar.FlagExample=False
+            self.INPpar.selection=[1,1,1]
+            self.InputAdjustSelection()
             self.INPpar.FlagImport=True
             self.INPpar.importPar.copyfrom(self.INPpar,exceptions=['name','surname'])
-        self.ui.CollapBox_ImSet.toggle_button.click()
-        self.ui.imTreeWidget.setFocus()
+            self.ui.CollapBox_ImSet.toggle_button.click()
+            self.ui.imTreeWidget.setFocus()
+        else:
+            # --- Tooltip warning ---
+            msg = "No changes to be applied to the image list!"
+            self.signals.tooltipRequested.emit(msg)   # thread-safe
   
+    @Slot(str)
+    def show_import_tooltip(self, msg: str):
+        show_mouse_tooltip(self,msg)
+
 #******************** Settings
     """
     def button_box_set(self):
@@ -577,7 +675,7 @@ class Input_Tab(gPaIRS_Tab):
             ind_in, ind_fin, npairs, npairs_max= self.getIndNpairs()
             self.INPpar.ind_in=min([max([ind_in,self.INPpar.ind_in]),ind_fin])
             self.INPpar.npairs=npairs if self.INPpar.isDifferentFrom(self.INPpar_old,fields=['FlagTR_Import']) else min([self.INPpar.npairs,npairs])
-            self.INPpar.step=min([self.INPpar.step,npairs])
+            self.INPpar.step=max([min([self.INPpar.step,npairs]),1])
 
             self.ui.spin_ind_in.setMinimum(ind_in)
             self.ui.spin_ind_in.setMaximum(ind_fin)
@@ -596,27 +694,28 @@ class Input_Tab(gPaIRS_Tab):
         #ind_in=self.INPpar.imSet.ind_in[self.INPpar.frame_a]
         pass
 
-    def getIndNpairs(self):
-        if self.INPpar.imSet.count:
-            l=[self.INPpar.imSet.ind_in[f] for f in self.INPpar.frame_1 if f>-1]
+    def getIndNpairs(self,ind=None):
+        INP = self.INPpar if ind is None else self.TABpar_at(ind)
+        if INP.imSet.count:
+            l=[INP.imSet.ind_in[f] for f in INP.frame_1 if f>-1]
             ind_in_1=min(l) if l else None
-            l=[self.INPpar.imSet.ind_in[f-1] for f in self.INPpar.frame_2  if f>0]
+            l=[INP.imSet.ind_in[f-1] for f in INP.frame_2  if f>0]
             ind_in_2=min(l) if l else ind_in_1 if ind_in_1 is not None else None
             ind_in=min([ind_in_1,ind_in_2]) if ind_in_2 is not None else 0
 
-            l=[self.INPpar.imSet.ind_fin[f] for f in self.INPpar.frame_1 if f>-1]
+            l=[INP.imSet.ind_fin[f] for f in INP.frame_1 if f>-1]
             ind_fin_1=max(l) if l else None
-            l=[self.INPpar.imSet.ind_fin[f-1] for f in self.INPpar.frame_2  if f>0]
+            l=[INP.imSet.ind_fin[f-1] for f in INP.frame_2  if f>0]
             ind_fin_2=max(l) if l else ind_fin_1 if ind_fin_1 is not None else None
             ind_fin=min([ind_fin_1,ind_fin_2]) if ind_fin_2 is not None else -1
         else: 
             ind_in=ind_in_2=0
             ind_fin=-1
         npairs=nimg=ind_fin-ind_in+1 
-        if not all(self.INPpar.frame_2): 
+        if not all(INP.frame_2): 
             npairs=int(npairs/2)
-        if self.INPpar.FlagTR_Import: 
-            npairs=2*npairs-1+nimg%2   #(1+int(any(self.INPpar.frame_2)))*npairs-1
+        if INP.FlagTR_Import: 
+            npairs=2*npairs-1+nimg%2   #(1+int(any(INP.frame_2)))*npairs-1
         if npairs==0: ind_in=ind_fin=0
         npairs_max=npairs
         return ind_in, ind_fin, npairs, npairs_max
@@ -655,6 +754,14 @@ class Input_Tab(gPaIRS_Tab):
         self.exImTree.setMaximumHeight(height)
         self.exImTree.verticalScrollBar().setMinimumHeight(height)
         self.exImTree.verticalScrollBar().setMaximumHeight(height)
+        if self.hbarExImTree.maximum()==self.hbarExImTree.minimum():
+            self.hbarExImTree.setVisible(False)
+            containerHeight=height
+        else:
+            self.hbarExImTree.setVisible(True)
+            containerHeight=height+self.hbarExImTree.height()
+        self.containerExImTree.setMinimumHeight(containerHeight)
+        self.containerExImTree.setMaximumHeight(containerHeight)
         self.ui.CollapBox_ImSet.heightArea=height+110 if INPpar.FlagExample else 110
         self.ui.CollapBox_ImSet.heightOpened=self.ui.CollapBox_ImSet.heightArea+20
         self.ui.CollapBox_ImSet.on_click()