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

PaIRS_UniNa/Explorer.py

@@ -14,11 +14,11 @@ MONTH_ABBREVIATIONS = {
     1: "Jan", 2: "Feb", 3: "Mar", 4: "Apr", 5: "May", 6: "Jun",
     7: "Jul", 8: "Aug", 9: "Sep", StepTypes.cal: "Oct", 11: "Nov", 12: "Dec"
 }
-projectActionButtonSize=[20,24]
-processActionButtonSize=[20,24]
+projectActionButtonSize=[20,25]
+processActionButtonSize=[20,25]
 actionButtonSpacing=3
-processButtonSize=[40,40]  #icon, button
-stepButtonSize=[32,32]
+processButtonSize=[40,50]  #icon, button
+stepButtonSize=[32,40]
 headerHeight=24
 titleHeight=22
 subtitleHeight=14
@@ -323,12 +323,28 @@ class ModernSwitch(QWidget):
             self._checked = True
         par.FlagQueue=self._checked
 
+        # --- HOVER SETUP ---
+        self.setAttribute(Qt.WA_Hover, True)
+        self.setMouseTracking(True)
+        self._hovered = False
+        self._border_width = 1
+        self._border_width_hover = 2
+        self._border_color = QColor(0, 0, 0)
+        self._border_color_hover = QColor(240, 116, 35)  # highlight
+
         # Load image for the handle and scale it to fit the ellipse
         self.handle_image = QPixmap(icons_path+"gear.png")  # Replace with your image path
         self.handle_image = self.handle_image.scaledToHeight(self.height() - self.handleMargin*2, Qt.SmoothTransformation)
 
         self.setCursor(QCursor(QtCore.Qt.PointingHandCursor))
         self.FlagAnimation=False
+
+        self.FlagRunning = False
+        self.gearMovie: QMovie = None
+
+        self._bg_color = QColor(46, 204, 113) if self._checked else QColor(175, 175, 175, 128)
+        self._handle_position = 0  # inizializzato in setSwitchLayout()
+
         self.setSwitchLayout()
 
         self.animation = QPropertyAnimation(self, b"handle_position", self)
@@ -357,20 +373,35 @@ class ModernSwitch(QWidget):
         if par and self.gui.procdata: 
             if self.gui.procdata.ind[:-2]==par.ind[:-2]:
                 self.startTimer()
-        #self.timer.start(50)  # Aggiorna ogni 50 ms
 
+    # ----------------- Hover events -----------------
+    def enterEvent(self, event):
+        self._hovered = True
+        self.update()
+        super().enterEvent(event)
+
+    def leaveEvent(self, event):
+        self._hovered = False
+        self.update()
+        super().leaveEvent(event)
+
+    # ----------------- Timer control -----------------
     def startTimer(self):
         if not self.FlagRunning and hasattr(self.gui,'gearMovie'):
             self.FlagRunning=True
             self.gearMovie=self.gui.gearMovie
             self.timer.start(self.timerTime)
-            pri.Coding.yellow('Start switch timer')
+            try:
+                pri.Coding.yellow('Start switch timer')
+            except Exception:
+                pass
 
     def stopTimer(self):
         if self.FlagRunning:
             self.FlagRunning=False
             self.timer.stop()
 
+    # ----------------- Property animation -----------------
     def set_handle_position(self, pos):
         self._handle_position = pos
         self.update()
@@ -380,90 +411,98 @@ class ModernSwitch(QWidget):
 
     handle_position = Property(int, fget=get_handle_position, fset=set_handle_position)
 
+    # ----------------- Painting -----------------
     def paintEvent(self, event):
         painter = QPainter(self)
         painter.setRenderHint(QPainter.Antialiasing)
 
-        # Draw background ellipse with border
-        bg_rect = QRect(0, 0, self.width(), self.height())
-    
-        # Draw filled background ellipse
+        # Background rect (rounded)
+        bg_rect = QRect(0, 0, self.width(), self.height()).adjusted(1, 1, -1, -1)
+
+        # Border pen (changes on hover)
+        if not self.isEnabled():
+            pen = QPen(self._border_color)
+            pen.setWidth(self._border_width)
+        else:
+            pen = QPen(self._border_color_hover if self._hovered else self._border_color)
+            pen.setWidth(self._border_width_hover if self._hovered else self._border_width)
+
+        painter.setPen(pen)
         painter.setBrush(self._bg_color)
-        painter.drawRoundedRect(bg_rect.adjusted(1, 1, -1, -1), self.height() / 2, self.height() / 2)
+        painter.drawRoundedRect(bg_rect, self.height() / 2, self.height() / 2)
 
-        # Calculate position and scale for image
+        # Handle position and size
         handle_x = self._handle_position
         handle_y = self.handleMargin
-        handle_width = self.handle_image.width()
-        handle_height = self.handle_image.height()
+        handle_w = self.handle_image.width()
+        handle_h = self.handle_image.height()
+        handle_rect = QRect(handle_x, handle_y, handle_w, handle_h)
 
-        """
-        if self._checked:
-            # Draw handle image
-            handle_rect = QRect(handle_x, handle_y, handle_width, handle_height)
-            painter.drawPixmap(handle_rect, self.handle_image)
-        else:
-            # Draw handle circle
-            handle_radius = self.height() - self.handleMargin*2
-            handle_rect = QRect(self._handle_position, self.handleMargin, handle_radius, handle_radius)
-            painter.setBrush(Qt.white)
-            painter.drawEllipse(handle_rect)
-        """    
-        handle_rect = QRect(handle_x, handle_y, handle_width, handle_height)
-        #painter.drawPixmap(handle_rect, self.handle_image)
-        if self.FlagRunning:
-            painter.drawImage(handle_rect,self.gearMovie.currentImage())
+        # Draw gear (static or animated)
+        if self.FlagRunning and self.gearMovie is not None:
+            painter.drawImage(handle_rect, self.gearMovie.currentImage())
         else:
-            painter.drawImage(handle_rect,self.handle_image.toImage())
-        
+            painter.drawImage(handle_rect, self.handle_image.toImage())
+
+        # Draw label text
         if self.FlagAnimation:
             self.text_label.setText("")
         else:
             if self._checked:
                 self.text_label.setText("run ")
-                self.text_label.move(self.handleMargin*2, (self.height() - self.text_label.height()) // 2)
+                self.text_label.adjustSize()
+                self.text_label.move(self.handleMargin * 2, (self.height() - self.text_label.height()) // 2)
             else:
                 self.text_label.setText("skip")
-                self.text_label.move(self.width() - self.height() - self.handleMargin*2, (self.height() - self.text_label.height()) // 2)
+                self.text_label.adjustSize()
+                self.text_label.move(self.width() - self.height() - self.handleMargin * 2,
+                                     (self.height() - self.text_label.height()) // 2)
 
+    # ----------------- Interaction -----------------
     def mousePressEvent(self, event):
-        if event.button() == Qt.LeftButton and not self.FlagAnimation:
+        if event.button() == Qt.LeftButton and not self.FlagAnimation and self.isEnabled():
             self.toggle()
 
     def toggle(self):
         self._checked = not self._checked
-        if self.par: self.par.FlagQueue = self._checked
+        if self.par:
+            self.par.FlagQueue = self._checked
+
         self.toggled.emit(self._checked)
+
+        self.animation.stop()
+        self.animation.setStartValue(self._handle_position)
         self.animation.setEndValue(self.switchHandlePosition())
-        self.FlagAnimation=True
+        self.FlagAnimation = True
         self.animation.start()
-    
+
+    # ----------------- Layout helpers -----------------
     def switchHandlePosition(self):
         if self._checked:
-            handle_position = self.width() - self.height() + self.handleMargin
-        else:
-            handle_position = self.handleMargin
-        return handle_position
+            return self.width() - self.height() + self.handleMargin
+        return self.handleMargin
 
     def setSwitchLayout(self):
-        self.FlagAnimation=False
+        self.FlagAnimation = False
         if self._checked:
-            self._bg_color = QColor(46, 204, 113)    #QColor(0, 122, 204) ù
-            tip=f'{self.name if self.name else "Item"} added to run queue.'
+            self._bg_color = QColor(46, 204, 113)
+            tip = f'{self.name if self.name else "Item"} added to run queue.'
         else:
-            tip=f'{self.name if self.name else "Item"} excluded from run queue.'
-            #text_color = self.palette().color(QPalette.WindowText)
             self._bg_color = QColor(175, 175, 175)
-            self._bg_color.setAlpha(0.5)
+            self._bg_color.setAlpha(64)
+            tip = f'{self.name if self.name else "Item"} excluded from run queue.'
+
         self.setToolTip(tip)
         self.setStatusTip(tip)
         self.set_handle_position(self.switchHandlePosition())
 
-    def setSwitch(self,FlagChecked):
-        if FlagChecked!=self._checked:
-            self._checked=FlagChecked
+    def setSwitch(self, FlagChecked: bool):
+        if FlagChecked != self._checked:
+            self._checked = FlagChecked
+            if self.par:
+                self.par.FlagQueue = self._checked
             self.setSwitchLayout()
-
+                       
 class ActionButtonBar(QWidget):
     FlagShortCuts = True
 
@@ -495,7 +534,7 @@ class ActionButtonBar(QWidget):
                 setattr(self,'sep_'+icon_name[1:],separator)
                 self.buttonLayout.addWidget(separator)
             else:
-                b = QToolButton(self)
+                b = HoverZoomToolButton(self)
                 b.setObjectName('button_'+icon_name)
                 b.setCursor(Qt.CursorShape.PointingHandCursor)
                 if FlagInvisible:
@@ -560,6 +599,7 @@ class ActionButtonBar(QWidget):
         tree.FlagContexMenu=True
 
         menu=QMenu(tree)
+        menu.setStyleSheet(self.window().ui.menu.styleSheet())
         name=[]
         act=[]
         fun=[]
@@ -578,7 +618,7 @@ class ActionButtonBar(QWidget):
                     if FlagNamedBar and 'class' in bar.buttonData[type]:
                         if 'PIV'!=nameAction[:3]: nameAction=nameAction[:1].lower()+nameAction[1:]
                         if b.isCheckable():
-                            nameAction=f"{'De-activate' if b.isChecked() else 'Activate'} {nameAction}"
+                            nameAction=b.toolTip()
                         else:
                             nameAction='Add '+nameAction
                     act.append(QAction(b.icon(),nameAction,self))
@@ -1039,7 +1079,63 @@ class ProjectTree(PaIRSTree):
         self.actionBar.button_close.setEnabled(FlagEnabled)
         self.actionBar.button_clean.setEnabled(self.topLevelItemCount()>0)
 
-class DraggableButton(QToolButton):
+class HoverZoomToolButton(QToolButton):
+    def __init__(self, parent=None, base_icon=24, zoom=1.25):
+        super().__init__(parent)
+
+        self.zoom_factor = zoom
+        self.base_size = QSize(base_icon, base_icon)
+        self.zoom_size = QSize(
+            int(base_icon * zoom),
+            int(base_icon * zoom)
+        )
+
+        self.setIconSize(self.base_size)
+
+        self.anim = QPropertyAnimation(self, b"iconSize", self)
+        self.anim.setDuration(120)
+        self.anim.setEasingCurve(QEasingCurve.OutCubic)
+
+    # --- OVERRIDE ---
+    def setIconSize(self, size: QSize):
+        """
+        Override setIconSize to automatically update base and zoom sizes.
+        """
+        super().setIconSize(size)
+        self.updateFromCurrentIconSize()
+
+    def updateFromCurrentIconSize(self, zoom: float | None = None):
+        """
+        Recompute base_size and zoom_size starting from the current iconSize().
+        Optionally updates the zoom factor.
+        """
+        if zoom is not None:
+            self.zoom_factor = zoom
+
+        current = self.iconSize()
+        self.base_size = QSize(current.width(), current.height())
+        self.zoom_size = QSize(
+            int(current.width() * self.zoom_factor),
+            int(current.height() * self.zoom_factor)
+        )
+
+    def enterEvent(self, event):
+        if self.isEnabled():
+            self.anim.stop()
+            self.anim.setStartValue(self.iconSize())
+            self.anim.setEndValue(self.zoom_size)
+            self.anim.start()
+        super().enterEvent(event)
+
+    def leaveEvent(self, event):
+        if self.isEnabled():
+            self.anim.stop()
+            self.anim.setStartValue(self.iconSize())
+            self.anim.setEndValue(self.base_size)
+            self.anim.start()
+        super().leaveEvent(event)
+
+class DraggableButton(HoverZoomToolButton):
     def __init__(self, data: dict = {}, buttonSize: list = processButtonSize, FlagInvisible=True, parent=None):
         super().__init__(parent)
         self.buttonData = data
@@ -1052,6 +1148,7 @@ class DraggableButton(QToolButton):
         self.setIconSize(QSize(self.buttonSize[0], self.buttonSize[0]))
         self.setIcon(self.buttonIcon)
         self.setFixedSize(self.buttonSize[1], self.buttonSize[1])
+
         if FlagInvisible:
             self.setCursor(Qt.CursorShape.OpenHandCursor)
             self.setStyleSheet("QToolButton { border: none; background: none;} QToolButton::menu-indicator { image: none; }")
@@ -1103,7 +1200,7 @@ class ProcessButtonBar(QWidget):
         super().__init__()
         self.buttonLayout = QHBoxLayout()
         self.buttonLayout.setContentsMargins(0, 0, 0, 0)
-        self.buttonLayout.setSpacing(int(buttonSize[0] / 2))
+        self.buttonLayout.setSpacing(int(buttonSize[0]/4))
         self.setLayout(self.buttonLayout)
         self.buttonData=buttonData
         self.buttonSize = buttonSize
@@ -1123,7 +1220,7 @@ class StepButtonBar(QWidget):
         super().__init__()
         self.buttonLayout = QVBoxLayout()
         self.buttonLayout.setContentsMargins(10, headerHeight+5, 0, 10)
-        self.buttonLayout.setSpacing(int(buttonSize[0]/2))
+        self.buttonLayout.setSpacing(int(buttonSize[0]/4))
         self.setLayout(self.buttonLayout)
         self.buttonData=buttonData
         self.buttonSize = buttonSize
@@ -1135,8 +1232,7 @@ class StepButtonBar(QWidget):
             data=buttonData[type]
             
             if all([f in list(data) for f in ('icon', 'name', 'type')]):
-                button = QToolButton(self)
-                button.setIconSize(QSize(self.buttonSize[0], self.buttonSize[0]))
+                button = HoverZoomToolButton(self, base_icon=self.buttonSize[0], zoom=1.25)
                 button.setFixedSize(self.buttonSize[1], self.buttonSize[1])
                 
                 if FlagInvisible:
@@ -1223,7 +1319,7 @@ class ProcessTree(PaIRSTree):
         
         if self.FlagBin:
             columns=["#","Deleted processes"] 
-            self.setStyleSheet("""
+            self.setStyleSheet(self.styleSheet() + """
                 QHeaderView::section {
                     color: red;
                 }
@@ -1452,8 +1548,8 @@ class ProcessTree(PaIRSTree):
             ITE.FlagQueue=self.TREpar.FlagQueue
             ITE.ind=[self.TREpar.project,int(self.FlagBin),ind,0,0]
             
+            processNames=[item[0].name for item in self.itemList[0]]+[item[0].name for item in self.restoreTree.itemList[0]]
             if name is None:
-                processNames=[item[0].name for item in self.itemList[0]]+[item[0].name for item in self.restoreTree.itemList[0]]
                 nameInd=1
                 ITE.name=f'{ITE.basename} {nameInd}'
                 while ITE.name in processNames:
@@ -1461,6 +1557,10 @@ class ProcessTree(PaIRSTree):
                     ITE.name=f'{ITE.basename} {nameInd}'
             else:
                 ITE.name=name
+                nameInd=1
+                while ITE.name in processNames:
+                    nameInd+=1
+                    ITE.name=f'{name} ({nameInd})'
             self.createParPrevs(ITE)
             self.itemList[0].insert(ind,[ITE])
         else:
@@ -1917,12 +2017,12 @@ class ProcessTree(PaIRSTree):
                 pixmap_list.append(icons_path+ITE.icon)
                 name_list.append(ITE.name)
                 flag_list.append(ITE.Step!=StepTypes.cal)
-            func=lambda i, opts: self.process_loop(paths,processType,ind,ITEs[0].name,i,opts)
+            func=lambda i, opts, cleanup_flag, rescan_flag: self.process_loop(paths,processType,ind,ITEs[0].name,i,opts,cleanup_flag,rescan_flag)
             dialog = FolderLoopDialog(pixmap_list, name_list, flag_list, parent=self, paths=paths, func=func, process_name=ITEs[0].name)
             dialog.exec()
         return
     
-    def process_loop(self,paths,processType,ind,name0,i,opts):
+    def process_loop(self,paths,processType,ind,name0,i,opts,cleanup_flag,rescan_flag):
         nProcess=self.topLevelItemCount()
         path=paths[i]
         name=name0+f" (.../{os.path.basename(path)}/)"
@@ -1933,6 +2033,7 @@ class ProcessTree(PaIRSTree):
         ind_slave[2]=nProcess
         ind_slave[-1]=0
         
+        FlagWarning=False
         for j in range(len(opts)):
             ind_master[3]=j
             ind_slave[3]=j
@@ -1944,10 +2045,17 @@ class ProcessTree(PaIRSTree):
                 if opts[j]==2:
                     INP: INPpar=self.gui.w_Input.TABpar_at(ind_new)
                     INP.path=myStandardPath(path)
-                    self.gui.w_Input.scanImList(ind_new)
+                    if rescan_flag: 
+                        flagWarning=self.rescanInputPath(ind_master,ind_new,cleanup_flag)
+                    else: 
+                        flagWarning=self.gui.w_Input.scanImList(ind_new)
+                    if cleanup_flag: self.gui.w_Input.purgeImList(ind_new)
+                    INP.nimg=0
+                    if len(INP.imList[0]):
+                        if len(INP.imList[0][0]):
+                            INP.nimg=len(INP.imList[0][0])
                     self.gui.w_Input.checkINPpar(ind_new)
                     self.gui.w_Input.setINPwarn(ind_new)
-                    self.Explorer.setITElayout(ITE)
 
                     TABname=self.gui.w_Input.TABname
                     self.gui.bridge(TABname,ind_new)
@@ -1966,12 +2074,54 @@ class ProcessTree(PaIRSTree):
                                 w.TABpar.copyfrom(currpar)
                                 self.gui.bridge(w.TABname,ind_new)
                     TABpar.FlagSettingPar=FlagSettingPar
+                    self.Explorer.setITElayout(ITE)
+                    FlagWarning=FlagWarning or flagWarning or ITE.OptionDone==0
+
                     #item_child=item.child(j)
                     #item_child.setSelected(True)
                     #self.setCurrentItem(item_child)
             else:
                 self.gui.link_pars(ind_slave,ind_master,FlagSet=False)
-        return
+        return FlagWarning
+
+    def rescanInputPath(self, ind_master, ind_new, FlagNoWarning):
+        """Rescan input on slave using master patterns, then rebuild imList/imEx."""
+        INP: INPpar  = self.gui.w_Input.TABpar_at(ind_new)     # slave
+        INPm: INPpar = self.gui.w_Input.TABpar_at(ind_master)  # master
+
+        # Build A (for frame_1) and B (for frame_2) from master's pattern at master's frames
+        patm = getattr(INPm.imSet, "pattern", [])
+        ncam = INP.inp_ncam
+        def _pat_list(frames,ind0=0):
+            out=[]; 
+            for k in range(ncam):
+                f = frames[k]-ind0 if k < len(frames) else -1
+                out.append(patm[f] if isinstance(f,int) and 0 <= f < len(patm) else None)
+            return out
+        A = _pat_list(INPm.frame_1)
+        B = _pat_list(INPm.frame_2,1)
+
+        # Rescan slave input path with patterns=A,B (maps patterns -> frame indices on slave)
+        self.gui.w_Input.scanInputPath(ind_new, patterns=[A, B], FlagNoWarning=FlagNoWarning)
+
+        # Rebuild imList/imEx from frames computed on slave
+        INP.imList, INP.imEx = INP.imSet.genListsFromFrame(
+            INP.frame_1, INP.frame_2, INP.ind_in, INP.npairs, INP.step, INP.FlagTR_Import
+        )
+        # Compare slave vs master lists
+        def _lists_differ(a, b):
+            if len(a) != len(b): return True
+            for x, y in zip(a, b):
+                if x != y: return True
+            return False
+
+        FlagWarning = (
+            _lists_differ(INP.imList, INPm.imList) or
+            _lists_differ(INP.imEx,   INPm.imEx)
+        )
+
+        return FlagWarning
+
 
     def button_delete_action(self):
         self.blockSignals(True)
@@ -2296,7 +2446,8 @@ class PaIRS_Explorer(gPaIRS_Tab):
         self.main_layout.addWidget(self.Explorer_main_splitter)   
         
         # Creazione del pulsante checkable
-        self.binButton = QToolButton(self.processButtonBar)
+        self.binButton = HoverZoomToolButton(self.processButtonBar)
+        self.binButton.setObjectName('binButton')
         self.binButton.setIconSize(QSize(self.processButtonBar.buttonSize[0], self.processButtonBar.buttonSize[0]))
         self.binButton.setFixedSize(self.processButtonBar.buttonSize[1], self.processButtonBar.buttonSize[1])
         if self.processButtonBar.FlagInvisible:
@@ -2377,7 +2528,7 @@ class PaIRS_Explorer(gPaIRS_Tab):
                 tree.setCurrentItem(child)
                 self.processTree_item_selection(tree)
             else:
-                showTip(self,'Current step is disabled! Please, reset the subsequemt step in the process to access it.')
+                show_mouse_tooltip(self,'Current step is disabled! Please, reset the subsequemt step in the process to access it.')
         for t,b in self.stepButtonBar.buttons.items():
             b:QToolButton
             b.clicked.connect(lambda flag, butt=b, type=t: stepButtonAction(butt, type))
@@ -2492,13 +2643,22 @@ class PaIRS_Explorer(gPaIRS_Tab):
                     if item.childCount()>ind:
                         item_child=item.child(ind)
                         item_child.setHidden(not ITEs[ind+1].active)
-                    b.setVisible(c not in ITEs[0].mandatory) #b.setVisible(True)
-                    lab.setVisible(c in ITEs[0].mandatory)
+                    b.setVisible(True)
+                    #b.setVisible(c not in ITEs[0].mandatory) #b.setVisible(True)
+                    #lab.setVisible(c in ITEs[0].mandatory)
                     flagRunnable=all([ITEs[j].flagRun==0 for j in range(ind+2,nsteps+1)]) if ind<nsteps else True
                     flagRunnable=flagRunnable and ITEs[ind+1].flagRun==0 and ITEs[0].flagRun!=-2 #and len(ITEs[ind+1].link)==0
                     b.setEnabled(flagRunnable)
-                    lab.setEnabled(flagRunnable)
+                    #lab.setEnabled(flagRunnable)
                     b.setChecked(ITEs[ind+1].active)
+                    nameAction=ITEs[ind+1].name
+                    if 'PIV'!=nameAction[:3]: nameAction=nameAction[:1].lower()+nameAction[1:]
+                    if c not in ITEs[0].mandatory:
+                        nameAction=f"{'De-activate' if b.isChecked() else 'Activate'} {nameAction}"
+                    else:
+                        nameAction=f"{'Go to and edit'} {nameAction}"
+                    b.setToolTip(nameAction)
+                    b.setStatusTip(nameAction)
                 else:
                     flagRunnable=False
                     b.setVisible(False)
@@ -2508,10 +2668,27 @@ class PaIRS_Explorer(gPaIRS_Tab):
                     b.setChecked(False)
                 b.setButtonIcon()
                 if self.stepPage: 
-                    self.stepPage.items[c].setVisible(c in ITEs[0].children) #and b.isChecked())
+                    FlagChild=c in ITEs[0].children
+                    self.stepPage.items[c].setVisible(FlagChild) #and b.isChecked())
+                    FlagEnabled=b.isEnabled() or b.isChecked()
+                    self.stepPage.items[c].setEnabled(FlagEnabled)
                     pageButton:QPushButton=self.stepPage.items[c].findChildren(QPushButton)[0]  
+
+                    if FlagChild:
+                        ind=list(ITEs[0].children).index(c)
+                        nameAction=ITEs[ind+1].name
+                        nameAction_lowerCase=nameAction[:1].lower()+nameAction[1:] if 'PIV'!=nameAction[:3] else nameAction
+                        if b.isEnabled():
+                            toolTip="Go to and edit " + nameAction_lowerCase if b.isChecked() else b.toolTip()
+                        else:
+                            toolTip="Go to and view " + nameAction_lowerCase if b.isChecked() else nameAction+" step was excluded from the process!"
+                        self.stepPage.items[c].setToolTip(toolTip)
+                        self.stepPage.items[c].setStatusTip(toolTip)
+
+                        self.stepPage.setProcessTextActive(not (b.isEnabled() and not b.isChecked()),c)
+
                     if flagRunnable:    
-                        pageButton.setIcon(b.icon())
+                        pageButton.setIcon(b.icon())    
                     else:
                         pageButton.setIcon(b.iconOn)         
         else: 
@@ -2953,13 +3130,21 @@ class StartingPage(QFrame):
         button_margin=self.ITEM_HEIGHT-self.ICON_SIZE-self.BUTTON_LAYOUT_TOP_MARGIN
         CAPTION_HEIGHT=self.ITEM_HEIGHT-self.NAME_LABEL_HEIGHT-self.TEXT_LAYOUT_SPACING
         self.items={}
+        self.textItems={}
         # Itera sui dizionari nella lista
         for n, process in processes.items():
             # Layout orizzontale per ogni processo
             widget=QWidget()
+            widget.setObjectName("process_item")
+            widget.setStyleSheet("""
+            QWidget#process_item:hover {
+                background-color: rgba(0, 116, 255, 0.1); 
+                border-radius: 10px;
+            }
+            """)
             process_layout = QHBoxLayout(widget)
             process_layout.setSpacing(self.LAYOUT_SPACING)
-            process_layout.setContentsMargins(0, 0, 0, 0)
+            process_layout.setContentsMargins(10, 10, 10, 0)
 
             # Pulsante con icona
             button_layout = QHBoxLayout()
@@ -2967,6 +3152,7 @@ class StartingPage(QFrame):
             button_layout.setContentsMargins(0, self.BUTTON_LAYOUT_TOP_MARGIN, 0, button_margin)
 
             icon_button = QPushButton()
+            icon_button.setObjectName("StartingPage_Button")
             pixmap = QPixmap(icons_path+process['icon']).scaled(self.ICON_SIZE, self.ICON_SIZE, mode=Qt.TransformationMode.SmoothTransformation)
             icon_button.setIcon(pixmap)
             icon_button.setIconSize(pixmap.size())
@@ -3007,13 +3193,15 @@ class StartingPage(QFrame):
             caption_text_edit.setFont(caption_font)
             caption_text_edit.setAlignment(Qt.AlignmentFlag.AlignJustify)
             caption_text_edit.setReadOnly(True)
+            caption_text_edit.setTextInteractionFlags(Qt.NoTextInteraction)
+            caption_text_edit.viewport().setCursor(Qt.PointingHandCursor)
             caption_text_edit.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
             caption_text_edit.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
             caption_text_edit.setFrameStyle(QFrame.NoFrame)
             #caption_text_edit.setFixedWidth(self.CAPTION_WIDTH)
             caption_text_edit.setStyleSheet("background: transparent;")
             caption_text_edit.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
-
+            
             # Adjust height to content
             caption_text_edit.document().setTextWidth(caption_text_edit.viewport().width())
             caption_text_edit.setFixedHeight(CAPTION_HEIGHT)#caption_text_edit.document().size().height())
@@ -3029,7 +3217,30 @@ class StartingPage(QFrame):
             # Aggiungi il layout orizzontale al layout principale
             self.main_layout.addWidget(widget)
 
+            # --- Make the whole row clickable (icon + labels + background) ---
+            if buttonBar:
+
+                def make_clickable(w, callback):
+                    w.setCursor(Qt.PointingHandCursor)
+
+                    def mouseReleaseEvent(event, cb=callback, ww=w):
+                        if event.button() == Qt.LeftButton:
+                            cb()
+                        # call base implementation to keep default behaviour
+                        QWidget.mouseReleaseEvent(ww, event)
+
+                    w.mouseReleaseEvent = mouseReleaseEvent
+
+                # entire row + title + caption all trigger the same action
+                make_clickable(widget, action(n))
+                #make_clickable(name_label, click_callback)
+                #make_clickable(caption_text_edit, click_callback)
+            
             self.items[n]=widget
+            self.textItems[n]={
+                "name_label": name_label,
+                "caption": caption_text_edit,
+            }
 
         self.main_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding))
 
@@ -3054,6 +3265,31 @@ class StartingPage(QFrame):
             caption_font.setPixelSize(CAPTION_FONT_SIZE)
             c.setFont(caption_font)         
 
+    def setProcessTextActive(self, active: bool, key=None):
+        """
+        If active=True -> black text (active)
+        If active=False -> light bluish text (inactive)
+        If key is None -> apply to all items
+        If key is provided -> apply only to that process key
+        """
+        active_color = "none"
+        inactive_color = "rgb(150, 150, 255)"
+
+        color = active_color if active else inactive_color
+
+        def apply_to(item):
+            item["name_label"].setStyleSheet(f"color: {color};")
+            # QTextEdit draws text in its viewport -> set color on QTextEdit itself is fine
+            item["caption"].setStyleSheet(f"color: {color}; background: transparent;")
+
+        if key is None:
+            for item in self.textItems.values():
+                apply_to(item)
+        else:
+            if key in self.textItems:
+                apply_to(self.textItems[key])
+
+
 if __name__ == "__main__":
     app = QApplication([])
     app.setStyle('Fusion')