PaIRS-UniNa 0.2.0__cp310-cp310-win_amd64.whl → 0.2.8__cp310-cp310-win_amd64.whl

PaIRS_UniNa/gPaIRS.py

@@ -28,9 +28,10 @@ from .Saving_tools import*
 
 import concurrent.futures
 
-from .__init__ import __version__,__subversion__,__year__,__mail__,__website__
+from .__init__ import __version__,__subversion__,__year__,__date__,__mail__,__website__
 
 version=__version__
+subversion=__subversion__
 year=__year__
 mail=__mail__
 website=__website__
@@ -47,7 +48,14 @@ class FloatingObject(QMainWindow):
         
     def __init__(self,parent,tab):
         super().__init__()
-        self.gui:gPaIRS=parent
+        if parent is None:
+            self.gui=self.window()
+        else:
+            if hasattr(parent,'gui'):
+                self.gui:gPaIRS=parent.gui
+            else:
+                self.gui:gPaIRS=parent.window()
+
         self.name=''
         self.button=None
         self.tab=tab
@@ -114,14 +122,23 @@ class infoPaIRS(QMainWindow):
         self.ui=ui
         setupWid(self)
         
-        infotext=self.ui.info.text().replace('#.#.#',version)
+        subv=f"(.{subversion})" if int(subversion) else ""
+        infotext=self.ui.info.text().replace('#.#.#',version+subv)
         infotext=infotext.replace('yyyy',year)
+        infotext=infotext.replace('dddd/dd/dd',__date__)
         mailString=f'<a href="mailto:{mail}"><span style=" text-decoration: underline; color:#0000ff; font-size:11pt">{mail}</a>'
         infotext=infotext.replace('mmmm',mailString)
         websiteString=f'<a href="{website}"><span style=" text-decoration: underline; color:#0000ff; font-size:11pt">{website}</a>'
         infotext=infotext.replace('wwww',websiteString)
         self.ui.info.setText(infotext)
-
+        if Flag_ISEXE:
+            #self.ui.tabWidget.removeTab(3)
+            self.ui.tabWidget.setTabText(3,'Packages')
+            self.ui.req.setText(self.distPackages())
+        else:
+            self.ui.tabWidget.setTabText(3,'Requirements')
+            self.ui.req.setText(self.requirements())
+        
         self.fontPixelSize=gui.GPApar.fontPixelSize
         self.setFontSizeText()
 
@@ -133,8 +150,8 @@ class infoPaIRS(QMainWindow):
                         if w.hasFocus():
                             #pri.Info.yellow(w)
                             type(w).keyPressEvent(w,e)
-                            if not e.key() in self.gui.blockedKeys:
-                                self.gui.keyPressEvent(e)
+                            #if not e.key() in self.gui.blockedKeys:
+                            #    self.gui.keyPressEvent(e)
                     return KeyPressFun
                 w.keyPressEvent=createKeyPressFun(w)
 
@@ -147,14 +164,128 @@ class infoPaIRS(QMainWindow):
         setFontSizeText(self.ui.tom_cv,[fPixSize+1])
         setFontSizeText(self.ui.list_ref,[fPixSize+1])
 
-#********************************************* GPaIRS
+    def distPackages(self):
+        # Read the contents of the file and split by lines
+        with open(rqrdpckgs_filename, 'r') as file:
+            lines = file.readlines()
+
+        # Introductory sentence
+        intro_text = """
+                <p style="font-size: 12pt; font-weight: normal; text-align: justify;">
+                    Python packages included in the current executable:
+                </p>
+                <p>
+
+                </p>
+            """
+
+        # Start the HTML table with improved styling
+        html_table = intro_text + """
+        <table border="1" style="width: 100%; align-items: center;">
+                <thead>
+                <tr>
+                    <th style="padding: 10px; font-size: 11pt; font-weight: bold;">Package</th>
+                    <th style="padding: 10px; font-size: 11pt; font-weight: bold;">Version</th>
+                </tr>
+            </thead>
+            <tbody>
+        """
+
+        # Iterate over each line in the file
+        for line in lines:
+            # Split each line into package name, min vers11pt max version, and other info
+            package_info = line.strip().split()
+            
+            # Ensure the line has the expected format
+            if len(package_info) >= 3:
+                package_name = package_info[0]
+                if package_name[0]=='#': continue
+                max_version = package_info[2]
+                
+                # Append a row to the HTML table
+                html_table += f"""
+                <tr>
+                    <td style="padding: 10px; font-size: 11pt">{package_name}</td>
+                    <td style="padding: 10px; font-size: 11pt">{max_version}</td>
+                </tr>
+                """
+
+        # Close the table tags
+        html_table += """
+            </tbody>
+        </table>
+        """
+        return html_table
 
+    def requirements(self):
+        # Read the contents of the file and split by lines
+        with open(rqrdpckgs_filename, 'r') as file:
+            lines = file.readlines()
+
+        # Introductory sentence
+        intro_text = """
+                <p style="font-size: 12pt; font-weight: normal; text-align: justify;">
+                    Required Python packages with their minimum and maximum supported versions:
+                </p>
+                <p>
+
+                </p>
+            """
+
+        # Start the HTML table with improved styling
+        html_table = intro_text + """
+        <table border="1" style="width: 100%; align-items: center;">
+                <thead>
+                <tr>
+                    <th style="padding: 10px; font-size: 11pt; font-weight: bold;">Package</th>
+                    <th style="padding: 10px; font-size: 11pt; font-weight: bold;">Minimum version</th>
+                    <th style="padding: 10px; font-size: 11pt; font-weight: bold;">Maximum version</th>
+                    <th style="padding: 10px; font-size: 11pt; font-weight: bold;">Installed version</th>
+                </tr>
+            </thead>
+            <tbody>
+        """
+
+        # Iterate over each line in the file
+        for line in lines:
+            # Split each line into package name, min vers11pt max version, and other info
+            package_info = line.strip().split()
+            
+            # Ensure the line has the expected format
+            if len(package_info) >= 3:
+                package_name = package_info[0]
+                if package_name[0]=='#': continue
+                min_version = package_info[1]
+                max_version = package_info[2]
+                curr_version = package_info[3]
+                
+                # Append a row to the HTML table
+                html_table += f"""
+                <tr>
+                    <td style="padding: 10px; font-size: 11pt">{package_name}</td>
+                    <td style="padding: 10px; font-size: 11pt">{min_version}</td>
+                    <td style="padding: 10px; font-size: 11pt">{max_version}</td>
+                    <td style="padding: 10px; font-size: 11pt">{curr_version}</td>
+                </tr>
+                """
+
+        # Close the table tags
+        html_table += """
+            </tbody>
+        </table>
+        """
+        return html_table
+    
+#********************************************* GPaIRS
 class gPaIRS(QMainWindow):
 
     def eventFilter(self, obj, event:QKeyEvent):
         # Check if the event is a KeyPress event
         if event.type() == QEvent.KeyPress:
             if event.modifiers() & Qt.KeyboardModifier.ControlModifier:
+                if event.modifiers() & Qt.KeyboardModifier.ShiftModifier and event.key() == Qt.Key.Key_F:
+                    self.setDefaultSizes()
+                    return True
                 FlagSetFont=False
                 if event.key() == Qt.Key.Key_0:
                     FlagSetFont=self.GPApar.fontPixelSize!=fontPixelSize
@@ -184,11 +315,16 @@ class gPaIRS(QMainWindow):
     def resizeEvent(self,event):
         if self.FlagGeometryInit:
             self.FlagGeometryInit=False
-            return
-        self.setFontPixelSize()
+        #self.setFontPixelSize()
         super().resizeEvent(event)
         #self.updateGPAparGeom()     
 
+    def showEvent(self, event):
+        super().showEvent(event)
+        if event.type() == QEvent.Show:
+            QTimer.singleShot(0, lambda: self.ui.tabAreaWidget.setSPLlayout())
+            pass
+
     def closeEvent(self,event):
         if self.completingTask!=self.correctClose:
             self.pauseQuestion('quitting',self.correctClose,FlagFirstQuestion=True)
@@ -201,7 +337,7 @@ class gPaIRS(QMainWindow):
         self.save_last_workspace()
         self.closeAll()
         if self.GPApar.FlagOutDated:
-            warningLatestVersion(self,self.app,flagExit=1,flagWarning=self.GPApar.FlagOutDated==1)
+            warningLatestVersion(self,self.app,flagExit=1,flagWarning=self.GPApar.FlagOutDated in (-1,1,-1000))
         self.close()
         self.app.processEvents()
         self.app.SecondaryThreads=self.SecondaryThreads
@@ -223,9 +359,9 @@ class gPaIRS(QMainWindow):
         guiInit=Signal()
         setMapVar=Signal()
         pause_proc=Signal()
-        printOutDated=Signal(bool)
+        printOutDated=Signal()
 
-    def __init__(self,flagDebug=False,app=None):
+    def __init__(self,flagDebug=False,app=None, standardPalette=None):
         self.app:QApplication=app
         self.name='PaIRS'
         self.flagSimpleFor=False # normally false, True only if you are checking the c library or the parpool therefore I have added a long print at the end of this function
@@ -238,12 +374,18 @@ class gPaIRS(QMainWindow):
         #------------------------------------- Launching Parallel Pool
         self.previousPlotTime=time() #previous time for plotting
         self.FlagGeometryInit=True
+        self.FlagOpenedWorkspace=False
         
         self.FlagGuiInit=False
         self.signals=self.gPaIRS_signals()
-        self.numUsedThreadsPIV=NUMTHREADS_PIV
+        #self.numUsedThreadsPIV=NUMTHREADS_MAX #now is called numMaxProcs
+        
+        self.numMaxProcs=NUMTHREADS_MAX #number of cores that the user has selected should be larger than numUsedProcs*numPivOmpCores
+        self.numUsedProcs=NUMTHREADS_MAX #number of  really used processor (Threads parfor)
+        self.numPivOmpCores=1 # number of PIV internal cores used by omp
+        
         self.FlagParPoolInit=False
-        self.launchParPool(NUMTHREADS_PIV_MAX)
+        self.launchParPool(NUMTHREADS_MAX)
         
         self.procdata:dataTreePar=None
         self.currind:list=None
@@ -251,6 +393,8 @@ class gPaIRS(QMainWindow):
         self.numCallBackTotOk=0 # Callbacks that are relative to a normal termination 
         self.SecondaryThreads=[]
 
+        self.FlagPackIssue=False
+
         #------------------------------------- Graphical interface: widgets
         ui=Ui_gPairs()
         ui.setupUi(self)
@@ -269,15 +413,17 @@ class gPaIRS(QMainWindow):
         self.cfgname=lastcfgname
         self.FlagHappyLogo=False
         self.setupLogo()
+        self.startHappyLogoWatcher()
 
         self.GPApar_old=GPApar()
         self.GPApar=GPApar()
-        self.GPApar.NumCores=self.numUsedThreadsPIV
+        self.GPApar.NumCores=self.numMaxProcs
         self.TABpar=self.GPApar
 
         pri.Time.blue(2,f'gPaIRS inizio generazione tabs')
         self.defineTabs()
         self.defineMenuActions()
+        self.ui.title_workspace.updateLabel=self.updateWorkspaceTitle
 
         setupWid(self) #---------------- IMPORTANT
         self.setFurtherFontPixelSizes(fontPixelSize)
@@ -303,9 +449,10 @@ class gPaIRS(QMainWindow):
                     return KeyPressFun
                 w.keyPressEvent=createKeyPressFun(w)
         """
-        self.ui.spin_nworkers.setValue(self.numUsedThreadsPIV)
+        self.ui.spin_nworkers.setValue(self.numMaxProcs)
         self.ui.spin_nworkers.setMinimum(1)
-        self.ui.spin_nworkers.setMaximum(NUMTHREADS_PIV_MAX)
+        self.ui.spin_nworkers.setMaximum(NUMTHREADS_MAX)
+        self.ui.spin_nworkers.valueChanged.connect(self.spin_nworkers_action)
 
         self.ui.button_pause.hide()
         self.ui.w_progress_Proc.hide()
@@ -317,8 +464,6 @@ class gPaIRS(QMainWindow):
         #window.close()
         self.maximumGeometry=self.app.primaryScreen().geometry()
         
-        self.setDefaultSizes()
-
         self.minW=self.minimumWidth()
         self.maxW=self.maximumGeometry.width()
         self.ui.Explorer.setMinimumWidth(0)
@@ -328,10 +473,24 @@ class gPaIRS(QMainWindow):
         self.splash=None
         
         #------------------------------------- Graphical interface: miscellanea
+        self.flaticon_PaIRS_download=QIcon()
+        self.flaticon_PaIRS_download.addFile(icons_path+'flaticon_PaIRS_download.png')
+        self.flaticon_PaIRS_download_warning=QIcon()
+        self.flaticon_PaIRS_download_warning.addFile(icons_path+'flaticon_PaIRS_download_warning.png')
+        self.flaticon_PaIRS_beta=QIcon()
+        self.flaticon_PaIRS_beta.addFile(icons_path+'flaticon_PaIRS_beta.png')
+
         self.icon_play=QIcon()
         self.icon_play.addFile(u""+ icons_path +"play.png", QSize(), QIcon.Normal, QIcon.Off)
         self.icon_pause=QIcon()
         self.icon_pause.addFile(u""+ icons_path +"pause.png", QSize(), QIcon.Normal, QIcon.Off)
+        self.icon_save_and_stop=QIcon()
+        self.icon_save_and_stop.addFile(u""+ icons_path +"save_and_stop.png", QSize(), QIcon.Normal, QIcon.Off)
+
+        self.ui.tabAreaWidget.icon_link=QIcon()
+        self.ui.tabAreaWidget.icon_link.addFile(u""+ icons_path +"link.png", QSize(), QIcon.Normal, QIcon.Off)
+        self.ui.tabAreaWidget.icon_unlink=QIcon()
+        self.ui.tabAreaWidget.icon_unlink.addFile(u""+ icons_path +"unlink.png", QSize(), QIcon.Normal, QIcon.Off)
 
         self.updating_import_gif = QMovie(u""+ icons_path +"updating_import.gif")
         self.updating_import_gif.setScaledSize(self.ui.label_updating_import.size())
@@ -355,10 +514,11 @@ class gPaIRS(QMainWindow):
         self.gearMovie.setScaledSize(QSize(StepItemWidget.label_size,StepItemWidget.label_size))
         self.gearMovie.start()
         
-        self.palettes=[lightPalette(),darkPalette(),None]
+        self.palettes=[lightPalette(),darkPalette(),standardPalette]
         self.paletteNames=['Light','Dark','System']
         #self.ui.logo.contextMenuEvent=self.paletteContextMenuEvent
         self.ui.button_colormode.mousePressEvent=self.paletteContextMenuEvent
+        self.ui.button_packissue.mousePressEvent=lambda e: checkRequiredPackages(self,FlagDisplay=True)
         self.ui.logo.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
         self.ui.logo.mousePressEvent=lambda e: self.about()
         #self.ui.logo.mousePressEvent=self.paletteContextMenuEvent
@@ -368,10 +528,16 @@ class gPaIRS(QMainWindow):
 
         self.aboutDialog=None
         self.logChanges:Log_Tab=None
-        self.fontPixelSize=fontPixelSize
+        self.whatsNew=lambda: whatsNew(self)
+        
         self.ui.button_PaIRS_download.setCursor(Qt.CursorShape.PointingHandCursor)
         self.ui.button_PaIRS_download.setVisible(False)
-        self.signals.printOutDated.connect(lambda flagOutDated: self.ui.button_PaIRS_download.setVisible(flagOutDated))
+        self.signals.printOutDated.connect(self.setButtonDownload)
+
+        self.fontPixelSize=fontPixelSize
+        self.setDefaultSizes()
+
+        self.ui.title_workspace.bullet=GPApar().saveBullet()
 
         #------------------------------------- Declaration of parameters 
         self.PaIRS_threadpool=QThreadPool()
@@ -410,14 +576,26 @@ class gPaIRS(QMainWindow):
         self.ui.workspace_icon.pressed.connect(lambda btn=self.ui.workspace_icon: btn.setStyleSheet("border: none; background: #dcdcdc;"))
         self.ui.workspace_icon.released.connect(lambda btn=self.ui.workspace_icon: btn.setStyleSheet("border: none; background: none;"))
         pixmap_workspace=QPixmap(icons_path+'workspace.png')
-        self.ui.workspace_icon.clicked.connect(lambda: self.warningDialog(self.GPApar.InfoMessage(),pixmap=pixmap_workspace))
+        self.ui.workspace_icon.clicked.connect(lambda: self.warningDialog(self.GPApar.InfoMessage(),pixmap=pixmap_workspace,title='Workspace information'))
 
         self.currITEpar=self.TREpar
         self.ui.title_icon.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
         self.ui.title_icon.pressed.connect(lambda btn=self.ui.title_icon: btn.setStyleSheet("border: none; background: #dcdcdc;"))
         self.ui.title_icon.released.connect(lambda btn=self.ui.title_icon: btn.setStyleSheet("border: none; background: none;"))
         pixmap_workspace=QPixmap(icons_path+'workspace.png')
-        self.ui.title_icon.clicked.connect(lambda: self.warningDialog(self.currITEpar.InfoMessage(),pixmap=TreeIcons.pixmaps[self.currITEpar.icon]))
+        self.ui.title_icon.clicked.connect(lambda: self.warningDialog(self.currITEpar.InfoMessage(),pixmap=TreeIcons.pixmaps[self.currITEpar.icon],title=f"{self.currITEpar.basename} information"))
+
+        class RCLbar:
+            buttons={0: self.ui.button_reset_step,
+                     1: self.ui.button_step_inherit,
+                     2: self.ui.button_copy_step,
+                     3: self.ui.button_link_step}
+            buttonData={0: {'name': 'Reset step'}, 
+                        1: {'name': 'Copy input/output data from...'}, 
+                        2: {'name': 'Copy step from...'}, 
+                        3: {'name': 'Link step to...'}}
+        self.RCLbar=RCLbar()
+        self.ui.Explorer.processActionBar.additionalButtonBars['items'].append(self.RCLbar)
 
         self.installEventFilter(self)
 
@@ -456,199 +634,9 @@ class gPaIRS(QMainWindow):
             self.open_workspace(filename=lastcfgname,FlagSetGeometry=True)
             self.GPApar_old.copyfrom(self.GPApar)   
         else:
-            self.adjustProjectSelection()
+            self.adjustProjectSelection()  
+            self.setGPaIRSPalette()          
         return
-    
-    def setFontPixelSize(self):
-        if self.fontPixelSize==self.GPApar.fontPixelSize: return
-        fPixSize=self.GPApar.fontPixelSize
-        font=QFont()
-        font.setFamily(fontName)
-        font.setPixelSize(fPixSize)
-        if self.app: self.app.setFont(font)
-        setFontPixelSize(self,fPixSize)
-        self.setFurtherFontPixelSizes(fPixSize)
-        if self.aboutDialog:
-            self.aboutDialog.fontPixelSize=self.GPApar.fontPixelSize
-            self.aboutDialog.setFontSizeText()
-        if self.logChanges: self.logChanges.setFontPixelSize(fPixSize)
-        if self.menuDebug: self.menuDebug.setFont(self.ui.menuFile.font())
-        self.fontPixelSize=fPixSize
-    
-    def setFurtherFontPixelSizes(self,fPixSize):
-        self.setTabFontPixelSize(fPixSize)
-
-        lab:QLabel=self.ui.title
-        fPixSize_TabNames=min([fPixSize*2,30])
-        font=lab.font()
-        font.setFamily(fontName)
-        font.setPixelSize(fPixSize_TabNames)
-        lab.setFont(font)
-        self.ui.title_workspace.setFont(font)
-        
-        lab:QLabel=self.ui.subtitle
-        font=lab.font()
-        font.setFamily(fontName)
-        font.setPixelSize(fPixSize+4)
-        lab.setFont(font)
-        self.ui.subtitle_workspace.setFont(font)
-
-        lab:QLabel=self.onlyReadLabel
-        font=lab.font()
-        font.setFamily(fontName)
-        font.setPixelSize(fPixSize+4)
-        lab.setFont(font)
-
-        self.ui.projectPage.setFontPixelSize(fPixSize)
-        self.ui.processPage.setFontPixelSize(fPixSize)
-        self.ui.stepPage.setFontPixelSize(fPixSize)
-
-        self.w_Log.setLogFont(fontPixelSize-dfontLog)
-        self.w_Vis_CalVi.setLogFont(fontPixelSize-dfontLog)
-
-    def setTabFontPixelSize(self,fPixSize):
-        fPixSize_TabNames=min([fPixSize*2,30])
-        for w in self.ui.tabAreaWidget.widgets:
-            setFontPixelSize(w,fPixSize)
-            w:gPaIRS_Tab
-            for lab in w.findChildren(QLabel):
-                lab:QLabel
-                if 'name_tab' in lab.objectName():
-                    #lab:QLabel=w.ui.name_tab
-                    font=lab.font()
-                    font.setPixelSize(fPixSize_TabNames)
-                    lab.setFont(font)
-
-    def falseShow(self):
-        FlagHidden=not self.isVisible()
-        total_rect = QGuiApplication.primaryScreen().geometry()
-        for screen in QGuiApplication.screens():
-            total_rect = total_rect.united(screen.geometry())
-        self.move(total_rect.right() + 100, total_rect.bottom() + 100)
-        self.updateGeometry()
-        self.show()
-        self.repaint()
-        return FlagHidden
-    
-    def setDefaultSizes(self):
-        margins=self.ui.centralLayout.contentsMargins()
-        main_splitter_sizes=[self.ui.w_Managing_Tabs.baseSize().width(),self.ui.tabAreaWidget.widgetMinimumWidth*2+self.ui.tabAreaWidget.margin*2+self.ui.tabAreaWidget.handleWidth*2] #processTree, main_sep, tabAreaWidget
-        w=margins.left()+self.ui.main_splitter.handleWidth()*2+sum(main_splitter_sizes)+margins.right()
-        h=margins.top()+self.ui.w_header.minimumHeight()+self.ui.tabAreaWidget.tabAreaHeight+self.ui.tabAreaWidget.buttonSize[1]+self.ui.tabAreaWidget.buttonSpacing+self.ui.tabAreaWidget.margin*2+self.ui.w_Operating_Tabs.layout().spacing()+self.ui.statusbar.minimumHeight()+margins.bottom()
-        self.resize(w,h)
-        self.ui.main_splitter.setSizes(main_splitter_sizes)
-        x=(self.maximumGeometry.width()-w)*0.5
-        y=(self.maximumGeometry.height()-h)*0.5
-        if self.falseShow(): self.hide()
-        self.move(x,y)
-        self.app.processEvents()
-        self.updateGPAparGeometry()
-        
-    def adjustProcessSelection(self):
-        FlagVisible=[False,False,False,False]
-        if self.TREpar.project is None:
-            FlagVisible[0]=True
-        else:
-            if self.TREpar.process is None:
-                FlagVisible[1]=True
-            else:
-                if self.TREpar.step is None or self.TREpar.step==0:
-                    FlagVisible[2]=True
-                else:
-                    FlagVisible[3]=True
-        self.ui.projectPage.setVisible(FlagVisible[0])
-        self.ui.processPage.setVisible(FlagVisible[1])
-        self.ui.stepPage.setVisible(FlagVisible[2])
-        self.ui.tabAreaWidget.setVisible(FlagVisible[3])
-        #if FlagVisible[3]:
-        #    self.ui.tabAreaWidget.scrollArea.splitter.splitterResize()
-        
-        self.adjustWorkspaceHeader()
-        self.adjustTitleHeader()
-        self.adjustSwitches()
-    
-    def setGPaIRSTitle(self):
-        cfgString=f': {self.GPApar.outName}' if self.GPApar.outName and self.GPApar.outName!=lastcfgname else ''
-        if not self.GPApar.FlagSaved: cfgString+='*'
-        if Flag_DEBUG:#TA per non incasinarmi
-            windowTitle=f'PaIRS (v{version}.{__subversion__}) -- cfg v{uicfg_version} -- PIV {self.PIVvers} -- {platform.system()}'
-        else:
-            windowTitle=f'PaIRS (v{version})'
-        windowTitle+=cfgString
-        self.setWindowTitle(windowTitle)
-
-    def adjustWorkspaceHeader(self):
-        if self.GPApar.outName and self.GPApar.outName!=lastcfgname:
-            title=self.GPApar.name+self.GPApar.saveBullet()
-            subtitle=self.GPApar.date
-            icon=self.GPApar.icon
-        else:
-            title=''
-            subtitle=''
-            icon=None
-        self.ui.title_workspace.setText(title)
-        self.ui.subtitle_workspace.setText(subtitle)
-        
-        InfoMessage=self.GPApar.InfoMessage()
-        self.ui.title_workspace.setToolTip(InfoMessage)
-        self.ui.title_workspace.setStatusTip(InfoMessage)
-        self.ui.subtitle_workspace.setToolTip(InfoMessage)
-        self.ui.subtitle_workspace.setStatusTip(InfoMessage)
-
-        self.ui.workspace_icon.setVisible(icon is not None)
-        self.setGPaIRSTitle()
-        self.adjustMenuFile()
-            
-    def adjustTitleHeader(self):
-        if self.TREpar.project is None:
-            title='Welcome to PaIRS'
-            subtitle='Particle Image Reconstruction Software'
-            icon=None
-            self.currITEpar=None
-        else:
-            title=self.TREpar.name+self.TREpar.saveBullet()
-            if self.TREpar.step is None:
-                subtitle=self.TREpar.date
-                icon=self.TREpar.icon
-                self.currITEpar=self.TREpar
-            else:
-                ITEs:ITEpar=self.ui.Explorer.ITEsfromTRE(self.TREpar)
-                title+=': '+ITEs[0].name
-                subtitle=self.TREpar.date
-                icon=ITEs[self.TREpar.step].icon
-                self.currITEpar=ITEs[self.TREpar.step]
-        self.ui.title.setText(title)
-        self.ui.subtitle.setText(subtitle)
-
-        if self.currITEpar:
-            InfoMessage=self.currITEpar.InfoMessage()
-        else:
-            InfoMessage=''
-        self.ui.title.setToolTip(InfoMessage)
-        self.ui.title.setStatusTip(InfoMessage)
-        self.ui.subtitle.setToolTip(InfoMessage)
-        self.ui.subtitle.setStatusTip(InfoMessage)
-
-        self.ui.title_icon.setVisible(icon is not None)
-        self.ui.title_icon.setIcon(TreeIcons.icons[icon])
-        
-    def adjustProjectSelection(self):
-        self.adjustProcessSelection()
-        self.ui.Explorer.adjustProjectSelection()
-        
-    def adjustSwitches(self):
-        for k in range(len(self.projectTree.itemList[0])):
-            FlagVisible=any([i[0].flagRun<=0 and i[0].Process!=ProcessTypes.cal for i in self.projectTree.itemList[1][k][0]])
-            self.projectTree.itemList[0][k].FlagRunnable=FlagVisible
-            topLevelItem=self.projectTree.topLevelItem(k)
-            itemWidget=self.projectTree.itemWidget(topLevelItem,1)
-            if itemWidget:
-                switch:ModernSwitch=itemWidget.findChildren(ModernSwitch)[0]
-                if switch:
-                    switch.setVisible(FlagVisible)
-                    #switch.setEnabled(self.FlagRun==0)
-        #self.swithcEnabled(self.FlagRun==0)
-        self.setButtonRunVisible()
 
     def disableDropping(self,FlagDisableed=True):
         self.projectTree.setDragEnabled(not FlagDisableed)
@@ -679,22 +667,12 @@ class gPaIRS(QMainWindow):
             self.ui.progress_Proc.setValue(0)
             self.ui.time_stamp.setText('Initializing...')
         else:
-            FlagButtonRun=self.ui.progress_Proc.value()==0 and self.FlagRun==0
+            FlagButtonRun=self.ui.progress_Proc.value() in (0,self.ui.progress_Proc.maximum()) and self.FlagRun==0
             self.ui.button_Run.setVisible(FlagButtonRun)
             self.ui.button_pause.setVisible(not FlagButtonRun)
             self.ui.w_progress_Proc.setVisible(not FlagButtonRun)
+        self.ui.tabAreaWidget.display_controls()
     
-    def adjustMenuFile(self):
-        self.ui.actionSave.setEnabled(not self.GPApar.FlagSaved)
-        self.ui.actionClose.setEnabled(self.GPApar.outName not in ('',lastcfgname))
-        """
-        bar=self.projectTree.actionBar
-        for n in ['Save','Saveas','Close']:
-            button:QPushButton=getattr(bar,'button_'+n.lower())
-            action:QAction=getattr(self.ui,'action'+n)
-            action.setEnabled(button.isEnabled())
-        """
-
     def editingFinished(self,tree):
         self.ui.Explorer.arrangeCurrentProcess(tree)
         self.adjustProcessSelection()
@@ -741,6 +719,7 @@ class gPaIRS(QMainWindow):
 
         icons=[w.TABname.split('_')[0].lower()+'_logo' for w in self.tabWidgets]
         self.ui.tabAreaWidget.setupTabArea(self.tabWidgets,icons)
+        self.ui.tabAreaWidget.gui=self
         self.tabWidgets=self.tabWidgets+[self.ui.tabAreaWidget]
         self.tabNames=[tab.TABname for tab in self.tabWidgets]
 
@@ -760,6 +739,11 @@ class gPaIRS(QMainWindow):
         self.binTree=self.ui.Explorer.binTree
         self.TREpar=self.ui.Explorer.TREpar
 
+        self.ui.Explorer.gui=self
+        self.projectTree.gui=self
+        self.processTree.gui=self
+        self.binTree.gui=self
+
         for w in self.tabWidgets:
             w:gPaIRS_Tab
             w.TABpar_prev=[]
@@ -808,6 +792,13 @@ class gPaIRS(QMainWindow):
         self.w_Input.ui.button_forward.clicked.disconnect()
         self.w_Input.display_controls=lambda:None
 
+        self.ui.w_header.layout().removeWidget(self.ui.button_restore_undo)
+        self.ui.tabAreaWidget.buttonBar_layout.addWidget(self.ui.button_restore_undo)
+        self.ui.button_restore_undo.setFixedWidth(TabAreaWidget.buttonSize[1])
+        self.ui.button_restore_undo.setFixedHeight(TabAreaWidget.buttonSize[1])
+        self.ui.button_restore_undo.clicked.connect(self.fullCallback)
+        self.ui.tabAreaWidget.ui.button_restore_undo=self.ui.button_restore_undo
+
         self.ui.tabAreaWidget.FlagDisplayControls=True
         self.ui.tabAreaWidget.ui.button_back=self.w_Input.ui.button_back
         self.ui.tabAreaWidget.ui.button_back.clicked.connect(lambda: self.button_back_forward_action(-1))
@@ -820,21 +811,37 @@ class gPaIRS(QMainWindow):
         self.onlyReadLabel=QLabel('Read-Only')
         font=self.onlyReadLabel.font()
         font.setBold(True)
+        font.setItalic(True)
+        font.setPixelSize(fontPixelSize)
         self.onlyReadLabel.setFont(font)
         self.onlyReadLabel.setStyleSheet('color: rgb(51, 102, 255)')  #('color: rgb(255,51,51);')
-        self.ui.tabAreaWidget.buttonBar_layout.addWidget(self.onlyReadLabel)
+        #self.ui.tabAreaWidget.buttonBar_layout.addWidget(self.onlyReadLabel)
         self.ui.tabAreaWidget.onlyReadLabel=self.onlyReadLabel
         self.ui.tabAreaWidget.button_reset_step=self.ui.button_reset_step
+        self.ui.tabAreaWidget.button_step_inherit=self.ui.button_step_inherit
         self.ui.tabAreaWidget.button_copy_step=self.ui.button_copy_step
         self.ui.tabAreaWidget.button_link_step=self.ui.button_link_step
 
-        for b in [self.ui.button_reset_step,self.ui.button_copy_step,self.ui.button_link_step]:
+        self.w_RCL = QWidget(self)  #CLR: copy, link, reset
+        self.RCL_layout = QHBoxLayout()
+        self.RCL_layout.setContentsMargins(0, 0, 0, 0)
+        self.RCL_layout.setSpacing(actionButtonSpacing*2)
+        self.w_RCL.setLayout(self.RCL_layout)
+
+        self.RCL_layout.addSpacerItem(QSpacerItem(projectActionButtonSize[1], projectActionButtonSize[1], QSizePolicy.Expanding, QSizePolicy.Minimum))
+        self.RCL_layout.addWidget(self.onlyReadLabel)
+        self.RCL_layout.addSpacerItem(QSpacerItem(5, projectActionButtonSize[1], QSizePolicy.Minimum, QSizePolicy.Minimum))
+        for b in [self.ui.button_reset_step,self.ui.button_step_inherit,self.ui.button_copy_step,self.ui.button_link_step]:
             self.ui.w_header.layout().removeWidget(b)
-            self.ui.tabAreaWidget.buttonBar_layout.addWidget(b)
-            b.setFixedSize(TabAreaWidget.buttonSize[1],TabAreaWidget.buttonSize[1])
-            b.setIconSize(QSize(TabAreaWidget.buttonSize[1]-8,TabAreaWidget.buttonSize[1]-8))
+            #self.ui.tabAreaWidget.buttonBar_layout.addWidget(b)
+            #b.setFixedSize(TabAreaWidget.buttonSize[1],TabAreaWidget.buttonSize[1])
+            #b.setIconSize(QSize(TabAreaWidget.buttonSize[1]-8,TabAreaWidget.buttonSize[1]-8))
+            self.RCL_layout.addWidget(b)
+            b.setFixedSize(projectActionButtonSize[1],projectActionButtonSize[1])
+            b.setIconSize(QSize(projectActionButtonSize[0],projectActionButtonSize[0]))
             if hasattr(self,b.objectName()+'_action'):
                 b.clicked.connect(getattr(self,b.objectName()+'_action'))
+        self.ui.Explorer.processTree_layout.addWidget(self.w_RCL)
 
         self.w_Input.ui.button_back.setFixedSize(TabAreaWidget.buttonSize[1],TabAreaWidget.buttonSize[1])
         self.w_Input.ui.button_back.setIconSize(QSize(TabAreaWidget.buttonSize[1]-2,TabAreaWidget.buttonSize[1]-2))
@@ -846,8 +853,29 @@ class gPaIRS(QMainWindow):
         self.ui.tabAreaWidget.FlagPrevPropagation=FlagPrevPropagationTabSplitter
         self.ui.Explorer.inheritance=self.inheritance
 
+        self.brush_icon=QIcon(icons_path+"brush_cursor.png")
+        self.w_Vis.ui.icon.addfuncclick['copy_VIS']=lambda: self.copy_link_action(self.w_Vis.ui.name_tab,lambda isl,ima: self.copy_VIS(isl,ima),menuTitle='Copy graphical settings from...',icon=self.brush_icon)
+        self.w_Vis.ui.icon.setCustomCursor()
+
         self.defineTABbridges()
-   
+
+        for c in self.findChildren(PaIRSTree):
+            c:PaIRSTree
+            c.gui=self
+    
+    def fullCallback(self):
+        for w in self.tabWidgets:
+            w:gPaIRS_Tab
+            TABpar_ind=w.TABpar_at(w.TABpar.ind[:-1]+[-1])
+            if TABpar_ind:
+                if w.TABpar.isDifferentFrom(TABpar_ind,exceptions=w.TABpar.unchecked_fields+['ind']):
+                    w.TABpar.ind[-1]=-1
+                    w.fullCallback('Restored configuration')
+                    break
+        ind=[i for i in w.TABpar.ind]
+        ind[-1]=-1
+        self.setTABpars_at(ind)
+
     def defineMenuActions(self):
         self.projectTree.button_open_action=self.open_project
         self.projectTree.button_save_action=self.save_project
@@ -872,6 +900,10 @@ class gPaIRS(QMainWindow):
         self.showChanges=lambda: changes(self,Log_Tab,fileChanges)
         self.ui.actionChanges.triggered.connect(self.showChanges)
         self.ui.actionGuide.triggered.connect(self.guide)
+        self.ui.actionDownload.setVisible(not Flag_ISEXE)
+        if not Flag_ISEXE: 
+            self.ui.menuHelp.insertSeparator(self.ui.actionDownload)
+            self.ui.actionDownload.triggered.connect(self.downloadApp)
         self.ui.actionAbout.triggered.connect(self.about)
 
         self.ui.button_PaIRS_download.clicked.connect(lambda: button_download_PaIRS_action(self,self.app))
@@ -889,6 +921,8 @@ class gPaIRS(QMainWindow):
         self.w_Input.ui.button_back.setEnabled(not Flag)
         self.w_Input.ui.button_forward.setEnabled(not Flag)
 
+        self.ui.menubar.setEnabled(not Flag)
+
         #evita TABpar.FlagSettingPar=Flag così che sai dove FlagSettingPar è settato True o False
         ImageTreeWidget.disableTab(self.w_Input.ui.imTreeWidget,Flag)    
 
@@ -902,12 +936,25 @@ class gPaIRS(QMainWindow):
                 ind=w.TABpar.ind
                 ind[-1]+=step
                 w.TABpar.copyfrom(w.TABpar_at(ind))
-        FlagAdjustPar=w.TABpar.ind[-1]==0
-        FlagBridge=False
+        FlagAdjustPar=w.TABpar.FlagInit==False or w.TABpar.Process==ProcessTypes.cal #w.TABpar.ind[-1]==0
+        FlagBridge=w.TABpar.Process==ProcessTypes.cal #False
+        if FlagAdjustPar or FlagBridge:
+            for w in self.tabWidgets:
+                if not w.TABpar.FlagNone:
+                    w:gPaIRS_Tab
+                    if FlagAdjustPar: 
+                        FlagSettingPar=TABpar.FlagSettingPar
+                        TABpar.FlagSettingPar=True
+                        w.adjustTABpar()
+                        TABpar.FlagSettingPar=FlagSettingPar
+                    if FlagBridge: self.bridge(w.TABname)
+            FlagAdjustPar=False
+            FlagBridge=False
         for w in self.tabWidgets:
             w:gPaIRS_Tab
             if not w.TABpar.FlagNone:
                 w.setTABpar(FlagAdjustPar,FlagBridge) 
+        self.ui.Explorer.setITElayout()
         return 
     
     def bfContextMenu(self,bf,event):
@@ -1006,103 +1053,57 @@ class gPaIRS(QMainWindow):
             self.adjustItemWidgets(ind)
 
             self.inheritance(ind)
+            self.IOVinheritance(ind)
             self.adjustDependencies(ITE)
             #self.checkFutureProc()
         tab.add_TABpar_bridge=add_TABpar_bridge
 
-    def adjustDependencies(self,ITE:ITEpar):
-        for ind_slave in ITE.dependencies:
-            self.copy_pars(ind_slave,ITE.ind,FlagSet=False)
-            self.inheritance(ind_slave)
-            self.setLinks(ind_slave,ITE.ind)
-
-    def adjustItemWidgets(self,ind=None):
-        if ind is None: ind=[self.TREpar.project, self.TREpar.tree, self.TREpar.process, self.TREpar.step, -1]
-        TRE:TREpar=self.projectTree.itemList[0][ind[0]]
-        topLevelItem=self.projectTree.topLevelItem(ind[0])
-        itemWidget=self.projectTree.itemWidget(topLevelItem,1)
-        if itemWidget:
-            title:QLabel=itemWidget.findChildren(QLabel,'title_project')[0]
-            title.setText(TRE.name+TRE.saveBullet())
-            subtitle:QLabel=itemWidget.findChildren(QLabel,'subtitle_project')[0]
-            subtitle.setText(TRE.date)
-            InfoMessage=TRE.InfoMessage()
-            title.setToolTip(InfoMessage)
-            title.setStatusTip(InfoMessage)
-            subtitle.setToolTip(InfoMessage)
-            subtitle.setStatusTip(InfoMessage)
-        if self.TREpar.project==ind[0] and self.TREpar.tree==ind[1] and self.TREpar.process is not None:
-            self.adjustTitleHeader()
-            self.projectTree.actionBar.button_save.setEnabled(not self.TREpar.FlagSaved)
-            topLevelItem=self.processTree.topLevelItem(ind[2])
-            itemWidget=self.processTree.itemWidget(topLevelItem,1)
-            if itemWidget:
-                title:QLabel=itemWidget.findChildren(QLabel,'title_process')[0]
-                subtitle:QLabel=itemWidget.findChildren(QLabel,'subtitle_process')[0]
-                subtitle.setText(TRE.date)
-                ITE:ITEpar=self.ui.Explorer.ITEfromTRE(TRE)
-                InfoMessage=ITE.InfoMessage()
-                title.setToolTip(InfoMessage)
-                title.setStatusTip(InfoMessage)
-                subtitle.setToolTip(InfoMessage)
-                subtitle.setStatusTip(InfoMessage)
-            self.adjustTitleHeader()
-        self.adjustWorkspaceHeader()
-
-    def updateProjectItemWidget(self):
-        TRE:TREpar=self.projectTree.itemList[0][self.TREpar.project]
-        TRE.modifiedDate=currentTimeString()
-        TRE.date=f'Modified: {TRE.modifiedDate}'
-        TRE.FlagSaved=False
-        self.TREpar.copyfrom(TRE)
-
-        self.GPApar.modifiedDate=TRE.modifiedDate
-        self.GPApar.date=TRE.date
-        self.GPApar.FlagSaved=False
-
-        self.adjustItemWidgets()
-
-    def updateWorkspace(self):
-        self.GPApar.modifiedDate=currentTimeString()
-        self.GPApar.date=f'Modified: {self.GPApar.modifiedDate}'
-        self.GPApar.FlagSaved=False
-        
-        self.adjustWorkspaceHeader()
-
     def define_setTABpar_bridge(self,tab:gPaIRS_Tab):
         def setTABpar_bridge(FlagAdjustPar,FlagCallback=False):
             focusWidget=self.focusWidget()
             TABname=tab.TABname
             self.bridge(TABname)
             if FlagAdjustPar:
+                FlagSettingPar=TABpar.FlagSettingPar
+                TABpar.FlagSettingPar=True
                 for w in self.tabWidgets:
                     if w.TABpar.FlagNone: continue
                     w:gPaIRS_Tab
                     if w!=tab:
                         w.adjustTABpar()
                         self.bridge(w.TABname)
+                TABpar.FlagSettingPar=FlagSettingPar
                 FlagAdjustPar=False
             FlagBridge=False
+            FlagDisplayControls=False
             for w in self.tabWidgets:
                 w:gPaIRS_Tab
                 if  not w.TABpar.FlagNone and w!=self.w_Log:
                     if w.TABpar_old.isDifferentFrom(w.TABpar,exceptions=['ind'],FlagStrictDiff=True):
-                        w.setTABpar(FlagAdjustPar,FlagBridge,FlagCallback)  #setting parameters without bridge
+                        w.setTABpar(FlagAdjustPar,FlagBridge,FlagCallback,FlagDisplayControls)  #setting parameters without bridge
                     else:
                         if w==self.w_Vis_CalVi and w.TABpar.plane and w.TABpar.cam: 
                             self.w_Vis_CalVi.calibView.show()
-                        w.TABpar_old.copyfromfields(w.TABpar,['ind'])
+                        w.TABpar_old.copyfrom(w.TABpar,exceptions=['ind'])
                     if not FlagCallback: 
                         w.adjustTABparInd()
-            self.logBridge()
-            if self.w_Log.TABpar_old.isDifferentFrom(self.w_Log.TABpar):
-                self.w_Log.setTABpar(FlagAdjustPar,FlagBridge,FlagCallback)
-            else:
-                self.w_Log.TABpar_old.copyfromfields(self.w_Log.TABpar,['ind'])
-            if not FlagCallback: self.w_Log.adjustTABparInd()
             self.ui.Explorer.ITEpar.FlagInit=False
             self.ui.Explorer.setITElayout()
-            if not FlagCallback: self.inheritance(tab.TABpar.ind)
+            if not self.w_Log.TABpar.FlagNone:
+                if self.w_Log.LOGpar.flagRun!=-2:
+                    self.logBridge()
+                    if self.w_Log.TABpar_old.isDifferentFrom(self.w_Log.TABpar,FlagStrictDiff=True):
+                        self.w_Log.setTABpar(FlagAdjustPar,FlagBridge,FlagCallback)
+                    else:
+                        self.w_Log.TABpar_old.copyfrom(self.w_Log.TABpar,exceptions=['ind'])
+                    if not FlagCallback: self.w_Log.adjustTABparInd()
+                else:
+                    self.w_Log.setTABpar(FlagAdjustPar=False,FlagBridge=False,FlagCallback=False)
+            if not FlagCallback: 
+                self.inheritance(tab.TABpar.ind)
+                ITE_ind:ITEpar=self.ui.Explorer.ITEfromInd(tab.TABpar.ind)
+                self.adjustDependencies(ITE_ind)
+            self.ui.tabAreaWidget.display_controls()
 
             if focusWidget:
                 self.app.processEvents()
@@ -1110,7 +1111,9 @@ class gPaIRS(QMainWindow):
         tab.setTABpar_bridge=setTABpar_bridge
 
     def logBridge(self):
+        OUT:OUTpar = self.w_Output.TABpar
         LOG:LOGpar = self.w_Log.TABpar
+        VIS:VISpar = self.w_Vis.TABpar
         ITE:ITEpar = self.ui.Explorer.ITEpar #self.ui.Explorer.ITEfromTRE(self.TREpar)
 
         if ITE.flagRun==0:
@@ -1131,6 +1134,23 @@ class gPaIRS(QMainWindow):
             if errorText: 
                 errorText='\n\n'+ITE.procdata.headerSection('CRITICAL ISSUES',errorText,'X')  
             LOG.text=PaIRS_Header+ITE.procdata.itemname+warnigText+errorText
+            if VIS.FlagView:
+                outPathRoot=myStandardRoot(OUT.path+OUT.subfold+OUT.root)
+                logfile=ITE.procdata.procOutName()+'.log'
+                if ITE.procdata.outPathRoot=='': logfile=outPathRoot+logfile
+                border='o' #·●⦁᛫
+                headerWidth=54
+                result_text = '\n\n\n\n\n'+ITE.procdata.eyeHeaderSection('EXISTING PROCESS LOG',width=headerWidth,border=border) +f"\nLog file: '{os.path.basename(logfile)}'\n\n"
+                if os.path.isfile(logfile):
+                    try:
+                        with open(logfile, 'r', encoding='utf-8') as f:
+                            log_content = f.read()
+                        result_text += "\n" + log_content
+                    except Exception as e:
+                        result_text += f"\nError reading log file '{os.path.basename(logfile)}:'\n{e}"
+                else:
+                    result_text += f"\nLog file '{os.path.basename(logfile)}' not found!"
+                LOG.text+=result_text+'\n\n'+ITE.procdata.headerSection('END of EXISTING PROCESS LOG',' ',border,headerWidth)  
         else:
             LOG.text=ITE.procdata.Log
 
@@ -1178,7 +1198,7 @@ class gPaIRS(QMainWindow):
                             for k in range(len(INP.imList[c][f])):
                                 if INP.imEx[c][f][k]: 
                                     OUT.imageFile=INP.imList[c][f][k]
-                                    break
+                                    break                    
 
                 VIS.img=INP.selection[0]
                 VIS.cam=INP.selection[1]
@@ -1203,7 +1223,7 @@ class gPaIRS(QMainWindow):
                     imListMin=[]
                     outPathRoot=myStandardRoot(OUT.path+OUT.subfold+OUT.root)
                     for c in range(INP.ncam):
-                        imListMin.append([outPathRoot+f'_cam{c+1}_a_min.png',outPathRoot+f'_cam{c+1}_a_min.png'])
+                        imListMin.append([outPathRoot+f'_cam{c+1}_a_min.png',outPathRoot+f'_cam{c+1}_b_min.png'])
 
                     INP.FlagMIN = True
                     INP.FlagTR = PRO_Min.FlagTR
@@ -1220,36 +1240,37 @@ class gPaIRS(QMainWindow):
                 VIS.FlagTR=PRO_Min.FlagTR
                 VIS.LaserType=PRO_Min.LaserType
             elif TABname=='Process_Disp':
-                if VIS.Pro.isDifferentFrom(PRO_Disp):
-                    VIS.Pro.copyfrom(PRO_Disp)
+                if VIS.Pro.isDifferentFrom(PRO_Disp,exceptions=['FlagBordo']):
+                    VIS.Pro.copyfrom(PRO_Disp,exceptions=['FlagBordo'])
                 VIS.Nit=PRO_Disp.Nit if VIS.flagRun!=-2 else ITE.procdata.numFinalized
             elif TABname=='Process':
                 if VIS.Pro.isDifferentFrom(PRO):
                     VIS.Pro.copyfrom(PRO)
             elif TABname=='Vis':
                 INP.selection=[VIS.img,VIS.cam,VIS.frame]
+                self.w_Input.InputAdjustSelection(INP)
                 pass                
         elif ITE.Step in [StepTypes.cal]:
             INP_CalVi.FlagReadCalib=PRO_CalVi.CalibProcType>=2
             INP_CalVi.CalibProcType=PRO_CalVi.CalibProcType
             if TABname=='Calibration':
                 #FlagPrev=CAL.ind[-1]==len(self.w_Calibration.TABpar_prev_at(CAL.ind))-1
-                self.ui.logo_CalVi.setVisible(CAL.FlagCalVi and CAL.flagRun==0) #and FlagPrev)
-                self.ui.button_Run_CalVi.setVisible(CAL.FlagCalVi and CAL.flagRun==0) #and FlagPrev)
+                self.ui.logo_CalVi.setVisible(CAL.FlagCalVi and CAL.flagRun==0 and not CAL.link) #and FlagPrev)
+                self.ui.button_Run_CalVi.setVisible(CAL.FlagCalVi and CAL.flagRun==0 and not CAL.link) #and FlagPrev)
                 if CAL.isDifferentFrom(self.w_Calibration.CALpar_old,fields=['FlagCalVi','flagRun']) or not INP_CalVi.FlagInit:
                     for w in [self.w_Input_CalVi,self.w_Process_CalVi,self.w_Vis_CalVi]:
                         k=self.ui.tabAreaWidget.widgets.index(w)
                         SPL.FlagVisible[k]=CAL.FlagCalVi
                         w.buttonTab.setVisible(CAL.FlagCalVi)
-                    self.ui.tabAreaWidget.splitterResize()
+                    self.ui.tabAreaWidget.splitterResize(FlagReleased=False)
                     width=sum([s if f else 0 for s,f in zip(SPL.sizes,SPL.FlagVisible)])
                     if width<self.ui.tabAreaWidget.width():
                         SPL.sizes[-1]= self.ui.tabAreaWidget.width()-width
                     else: SPL.sizes[-1]=0
-                ITE.ncam=CAL.ncam
-                ITE.progress=len(CAL.calList)
+                #ITE.ncam=CAL.ncam
+                #ITE.progress=len(CAL.calList)
             elif TABname=='Input_CalVi':
-                VIS_CalVi.plane=INP_CalVi.row+1
+                VIS_CalVi.plane=int(INP_CalVi.row)*(1+PRO_CalVi.TargetType)+1
                 VIS_CalVi.FlagResetLevels=INP_CalVi.isDifferentFrom(self.w_Input_CalVi.INPpar_old,fields=['path']) or len(self.w_Input_CalVi.INPpar_old.filenames)==0
                 VIS_CalVi.FlagResetZoom=INP_CalVi.isDifferentFrom(self.w_Input_CalVi.INPpar_old,fields=['x','y','w','h','W','H']) or len(self.w_Input_CalVi.INPpar_old.filenames)==0
                 pass
@@ -1264,12 +1285,10 @@ class gPaIRS(QMainWindow):
                         for k,p in enumerate(INP_CalVi.plapar):
                             if len(p)>1:
                                 INP_CalVi.plapar[k]=[p[-1]]
-                if PRO_CalVi.isDifferentFrom(self.w_Process_CalVi.PROpar_old,exceptions=['ind']) or INP_CalVi.isDifferentFrom(self.w_Input_CalVi.INPpar_old,exceptions=['ind']) or not self.w_Vis_CalVi.FlagInitData or not PRO_CalVi.FlagInit: 
-                    self.initDataAndSetImgFromGui(INP_CalVi,PRO_CalVi)
                 pass
             elif TABname=='Vis_CalVi':
                 if VIS_CalVi.plane-1!=INP_CalVi.row:
-                    INP_CalVi.row=VIS_CalVi.plane-1
+                    INP_CalVi.row=int( (VIS_CalVi.plane-1)/(1+PRO_CalVi.TargetType) )
                     INP_CalVi.rows=[INP_CalVi.row]
                     #INP_CalVi.col=0
                     #INP_CalVi.cols=[INP_CalVi.col]
@@ -1278,6 +1297,12 @@ class gPaIRS(QMainWindow):
                 pass
         return
 
+    def getInheritance(self, ind):
+        indpar=[j for j in ind]
+        for j in range(indpar[-2]):
+            indpar[-2]=j
+            self.inheritance(indpar)
+
     def inheritance(self,indpar):
         ITE:ITEpar = self.ui.Explorer.ITEfromInd(indpar) #self.ui.Explorer.ITEfromTRE(self.TREpar)
         if ITE.FlagNone: return
@@ -1296,35 +1321,31 @@ class gPaIRS(QMainWindow):
                 imListMin=[]
                 outPathRoot=myStandardRoot(OUT.path+OUT.subfold+OUT.root)
                 for c in range(INP.ncam):
-                    imListMin.append([outPathRoot+f'_cam{c+1}_a_min.png',outPathRoot+f'_cam{c+1}_a_min.png'])
+                    imListMin.append([outPathRoot+f'_cam{c+1}_a_min.png',outPathRoot+f'_cam{c+1}_b_min.png'])
+                imageFileMin=INP.path
+                FlagImage=False
+                for c in range(len(INP.imList)):
+                    for f in range(len(INP.imList[c])):
+                        if INP.imList[c][f]:
+                            imageFileMin+=INP.imList[c][f][0]
+                            FlagImage=True
+                            break
+                    if FlagImage: break
             else:
                 FlagMIN=False
                 FlagTR=False
                 LaserType=0 #0 single, 1 double
                 imListMin=[]
+                imageFileMin=None
             if Process==ProcessTypes.piv:
                 children=[+1] #piv step
             else:
                 children=[+1,+2]  #disparity, spiv steps
-            FlagInit=True
             for c in children:
                 ind_child=copy.deepcopy(ind)
                 ind_child[-2]+=c
                 TABpar_prev=self.w_Input.TABpar_prev_at(ind_child)
 
-                FlagInit=FlagInit and len(TABpar_prev)==1 and TABpar_prev[0].flagRun==0 and ITE.active
-                if FlagInit:
-                    ind_child[-1]=0
-                    INP_child:INPpar=self.w_Input.TABpar_at(ind_child)
-                    INP_child.copyfrom(INP,exceptions=['Process','Step']+INP_child.parFields)
-                    #self.bridge('Input',ind_child)
-                    OUT_child:OUTpar=self.w_Output.TABpar_at(ind_child)
-                    OUT_child.copyfrom(OUT,exceptions=['Process','Step']+OUT_child.parFields)
-                    #self.bridge('Output',ind_child)
-                    VIS:VISpar = self.w_Vis.TABpar_at(ind)
-                    VIS_child:VISpar=self.w_Vis.TABpar_at(ind_child)
-                    VIS_child.copyfrom(VIS,exceptions=['Process','Step']+VIS_child.parFields)
-
                 for d in range(len(TABpar_prev)):
                     ind_child[-1]=d
                     INP_child:INPpar=self.w_Input.TABpar_at(ind_child)
@@ -1334,6 +1355,9 @@ class gPaIRS(QMainWindow):
                     INP_child.imListMin = deep_duplicate(imListMin)  
                     #INP_child.FlagInit  = False
                     
+                    OUT_child:OUTpar=self.w_Output.TABpar_at(ind_child)
+                    OUT_child.imageFileMin = imageFileMin
+
                     VIS_child:VISpar=self.w_Vis.TABpar_at(ind_child)
                     VIS_child.FlagMIN = ITE.procdata.flagRun>0
                     VIS_child.FlagTR = FlagTR
@@ -1356,6 +1380,7 @@ class gPaIRS(QMainWindow):
             for c in children:
                 ind_child=copy.deepcopy(ind)
                 ind_child[-2]+=c
+
                 for d in range(len(self.w_Input.TABpar_prev_at(ind_child))):
                     ind_child[-1]=d
 
@@ -1370,16 +1395,38 @@ class gPaIRS(QMainWindow):
                     VIS_child.calList = copy.deepcopy(calList)
                     VIS_child.calEx   = copy.deepcopy(calEx)
                     #VIS_child.FlagInit = False
-        
+
+        elif Process == ProcessTypes.spiv and Step == StepTypes.disp:
+            if ITE.active:
+                FlagDISP=True
+            else:
+                FlagDISP=False
+            children=[+1]  #disparity, spiv steps
+            for c in children:
+                ind_child=copy.deepcopy(ind)
+                ind_child[-2]+=c
+                TABpar_prev=self.w_Input.TABpar_prev_at(ind_child)
+
+                for d in range(len(TABpar_prev)):
+                    ind_child[-1]=d
+                    OUT_child:OUTpar=self.w_Output.TABpar_at(ind_child)
+                    OUT_child.FlagDISP = FlagDISP
+        """
         elif Process == ProcessTypes.spiv and Step == StepTypes.disp:
             if ITE.active:
                 FlagDISP=True
                 INP:INPpar = self.w_Input.TABpar_at(ind)
                 OUT:OUTpar = self.w_Output.TABpar_at(ind)
+                zconst=OUT.zconst
+                xterm=OUT.xterm 
+                yterm=OUT.yterm 
                 outPathRoot=myStandardRoot(OUT.path+OUT.subfold+OUT.root)
                 dispFile=outPathRoot+'.clz'
             else:
                 FlagDISP=False
+                zconst=0.0
+                xterm=0.0
+                yterm=0.0
                 dispFile=''
             children=[+1]  #disparity, spiv steps
             FlagInit=True
@@ -1388,105 +1435,454 @@ class gPaIRS(QMainWindow):
                 ind_child[-2]+=c
                 TABpar_prev=self.w_Input.TABpar_prev_at(ind_child)
 
-                FlagInit=FlagInit and len(TABpar_prev)==1 and TABpar_prev[0].flagRun==0 and ITE.active
+                for d in range(len(TABpar_prev)):
+                    ind_child[-1]=d
+
+                    INP_child:INPpar=self.w_Input.TABpar_at(ind_child)
+                    INP_child.FlagDISP = FlagDISP
+                    INP_child.dispFile = dispFile
+                    #INP_child.FlagInit = False
+
+                    OUT_child:OUTpar=self.w_Output.TABpar_at(ind_child)
+                    OUT_child.FlagDISP = FlagDISP
+                    OUT_child.zconst= zconst
+                    OUT_child.xterm = xterm 
+                    OUT_child.yterm = yterm 
+
+                    VIS_child:VISpar=self.w_Vis.TABpar_at(ind_child)
+                    VIS_child.FlagDISP = FlagDISP
+                    VIS_child.dispFile = dispFile
+                    #VIS_child.FlagInit = False
+
+            pass
+        """
+
+        ITEs=self.ui.Explorer.ITEsfromInd(indpar)
+        #currInd=list(ITEs[0].children).index(ITE.Step)+1
+        for c in range(len(ITEs)):  #range(currInd+1,len(ITEs))
+            ITE_ind:ITEpar=ITEs[c]
+            self.checkProcesses(FlagInit=True,ind=ITE_ind.ind)
+            #self.checkProcesses(FlagInit=False,ind=ITE_ind.ind)
+            self.ui.Explorer.setITElayout(ITE_ind)
+        return
+
+    def IOVinheritance(self,indpar):
+        ITE:ITEpar = self.ui.Explorer.ITEfromInd(indpar) #self.ui.Explorer.ITEfromTRE(self.TREpar)
+        if ITE.FlagNone: return
+        ind=copy.deepcopy(ITE.ind)
+        Step=ITE.Step
+        #inverse inheritance 
+        if Step not in (StepTypes.cal,) and ITE.active:
+            INP:INPpar = self.w_Input.TABpar_at(ind)
+            OUT:OUTpar = self.w_Output.TABpar_at(ind)
+            VIS:VISpar = self.w_Vis.TABpar_at(ind)
+
+            #children=[-2, -1] if Step==StepTypes.spiv else [-1]  #disparity, spiv steps #*
+            for c in range(len(processData[ITE.Process]['children'])): #in children: #*
+                ind_child=copy.deepcopy(ind)
+                #ind_child[-2]+=c #*
+                ind_child[-2]=c
+                TABpar_prev=self.w_Input.TABpar_prev_at(ind_child)
+                if TABpar_prev[0] is None: continue
+
+                FlagInit=len(TABpar_prev)==1 and TABpar_prev[0].flagRun==0
                 if FlagInit:
                     ind_child[-1]=0
                     INP_child:INPpar=self.w_Input.TABpar_at(ind_child)
                     INP_child.copyfrom(INP,exceptions=['Process','Step']+INP_child.parFields)
-                    #self.bridge('Input',ind_child)
+
                     OUT_child:OUTpar=self.w_Output.TABpar_at(ind_child)
                     OUT_child.copyfrom(OUT,exceptions=['Process','Step']+OUT_child.parFields)
-                    #self.bridge('Output',ind_child)
-                    VIS:VISpar = self.w_Vis.TABpar_at(ind)
+                    
                     VIS_child:VISpar=self.w_Vis.TABpar_at(ind_child)
                     VIS_child.copyfrom(VIS,exceptions=['Process','Step']+VIS_child.parFields)
+                    
+                    self.checkProcesses(FlagInit=True,ind=ind_child)
+                    self.checkProcesses(FlagInit=False,ind=ind_child)
+                    ITE_ind:ITEpar = self.ui.Explorer.ITEfromInd(ind_child)
+                    self.ui.Explorer.setITElayout(ITE_ind)
+                    self.inheritance(ind_child)
+
+    def IOVcopy(self,ind_slave,ind_master):
+        ITE:ITEpar = self.ui.Explorer.ITEfromInd(ind_master) #self.ui.Explorer.ITEfromTRE(self.TREpar)
+        if ITE.FlagNone: return
 
-                for d in range(len(TABpar_prev)):
-                    ind_child[-1]=d
+        #Input/Output/Vis inheritance 
+        INP:INPpar = self.w_Input.TABpar_at(ind_master)
+        OUT:OUTpar = self.w_Output.TABpar_at(ind_master)
+        VIS:VISpar = self.w_Vis.TABpar_at(ind_master)
 
-                    INP_child:INPpar=self.w_Input.TABpar_at(ind_child)
-                    INP_child.FlagDISP = FlagDISP
-                    INP_child.dispFile = dispFile
-                    #INP_child.FlagInit = False
+        self.w_Input.INPpar.copyfrom(INP,exceptions=['Process','Step']+INP.parFields)
+        self.w_Output.OUTpar.copyfrom(OUT,exceptions=['Process','Step']+OUT.parFields)
+        self.w_Vis.VISpar.copyfrom(VIS,exceptions=['Process','Step']+VIS.parFields)
+
+        FlagNewPar=self.w_Input.isNewPar() or self.w_Output.isNewPar()
+        ind_slave=self.w_Input.add_TABpar('Copy input/output data from step',FlagNewPar)
+        self.setTABpars_at(ind_slave,FlagAdjustPar=True,FlagBridge=True,widget=self.w_Input)
+
+        ITE_slave:ITEpar = self.ui.Explorer.ITEfromInd(ind_slave) #self.ui.Explorer.ITEfromTRE(self.TREpar)
+        self.ui.Explorer.setITElayout(ITE_slave)
+        return
+
+#*************************************************** Update workspace and projects
+    def updateWorkspace(self):
+        self.GPApar.modifiedDate=currentTimeString()
+        self.GPApar.date=f'Modified: {self.GPApar.modifiedDate}'
+        self.GPApar.FlagSaved=False
+        
+        self.adjustWorkspaceHeader()
+
+    def adjustWorkspaceHeader(self):
+        if self.GPApar.outName and self.GPApar.outName!=lastcfgname:
+            title=self.GPApar.name+self.GPApar.saveBullet()
+            subtitle=self.GPApar.date
+            icon=self.GPApar.icon
+            FlagVisible=True
+        else:
+            title=''
+            subtitle=''
+            icon=None
+            FlagVisible=False
+        self.ui.title_workspace.setVisible(FlagVisible)
+        self.ui.subtitle_workspace.setVisible(FlagVisible)
+        self.ui.title_workspace.setText(title)
+        self.ui.subtitle_workspace.setText(subtitle)
+        
+        InfoMessage=self.GPApar.InfoMessage()
+        self.ui.title_workspace.setToolTip(InfoMessage)
+        self.ui.title_workspace.setStatusTip(InfoMessage)
+        self.ui.subtitle_workspace.setToolTip(InfoMessage)
+        self.ui.subtitle_workspace.setStatusTip(InfoMessage)
+
+        self.ui.workspace_icon.setVisible(icon is not None)
+        self.adjustMenuFile()
+
+        self.setGPaIRSTitle()
+
+    def adjustMenuFile(self):
+        self.ui.actionSave.setEnabled(not self.GPApar.FlagSaved)
+        self.ui.actionClose.setEnabled(self.GPApar.outName not in ('',lastcfgname))
+
+    def updateProjectItemWidget(self):
+        TRE:TREpar=self.projectTree.itemList[0][self.TREpar.project]
+        TRE.modifiedDate=currentTimeString()
+        TRE.date=f'Modified: {TRE.modifiedDate}'
+        TRE.FlagSaved=False
+        self.TREpar.copyfrom(TRE)
+
+        self.GPApar.modifiedDate=TRE.modifiedDate
+        self.GPApar.date=TRE.date
+        self.GPApar.FlagSaved=False
+
+        self.adjustItemWidgets()
+
+    def adjustItemWidgets(self,ind=None):
+        if ind is None: ind=[self.TREpar.project, self.TREpar.tree, self.TREpar.process, self.TREpar.step, -1]
+        TRE:TREpar=self.projectTree.itemList[0][ind[0]]
+        topLevelItem=self.projectTree.topLevelItem(ind[0])
+        itemWidget=self.projectTree.itemWidget(topLevelItem,1)
+        if itemWidget:
+            title:QLabel=itemWidget.findChildren(QLabel,'title_project')[0]
+            title.setText(TRE.name+TRE.saveBullet())
+            subtitle:QLabel=itemWidget.findChildren(QLabel,'subtitle_project')[0]
+            subtitle.setText(TRE.date)
+            InfoMessage=TRE.InfoMessage()
+            title.setToolTip(InfoMessage)
+            title.setStatusTip(InfoMessage)
+            subtitle.setToolTip(InfoMessage)
+            subtitle.setStatusTip(InfoMessage)
+        if self.TREpar.project==ind[0] and self.TREpar.tree==ind[1] and self.TREpar.process is not None:
+            self.adjustTitleHeader()
+            self.projectTree.actionBar.button_save.setEnabled(not self.TREpar.FlagSaved)
+            topLevelItem=self.processTree.topLevelItem(ind[2])
+            itemWidget=self.processTree.itemWidget(topLevelItem,1)
+            if itemWidget:
+                title:QLabel=itemWidget.findChildren(QLabel,'title_process')[0]
+                subtitle:QLabel=itemWidget.findChildren(QLabel,'subtitle_process')[0]
+                subtitle.setText(TRE.date)
+                ITE:ITEpar=self.ui.Explorer.ITEfromTRE(TRE)
+                InfoMessage=ITE.InfoMessage()
+                title.setToolTip(InfoMessage)
+                title.setStatusTip(InfoMessage)
+                subtitle.setToolTip(InfoMessage)
+                subtitle.setStatusTip(InfoMessage)
+            self.adjustTitleHeader()
+        self.adjustWorkspaceHeader()
+
+    def adjustTitleHeader(self):
+        if self.TREpar.project is None:
+            title='Welcome to PaIRS'
+            subtitle='Particle Image Reconstruction Software'
+            icon=None
+            self.currITEpar=None
+        else:
+            title=self.TREpar.name+self.TREpar.saveBullet()
+            if self.TREpar.process is None or self.TREpar.step is None:
+                subtitle=self.TREpar.date
+                icon=self.TREpar.icon
+                self.currITEpar=self.TREpar
+            else:
+                ITEs:ITEpar=self.ui.Explorer.ITEsfromTRE(self.TREpar)
+                title+=': '+ITEs[0].name
+                subtitle=self.TREpar.date
+                icon=ITEs[self.TREpar.step].icon
+                self.currITEpar=ITEs[self.TREpar.step]
+        self.ui.title.setText(title)
+        self.ui.subtitle.setText(subtitle)
+
+        if self.currITEpar:
+            InfoMessage=self.currITEpar.InfoMessage()
+        else:
+            InfoMessage=''
+        self.ui.title.setToolTip(InfoMessage)
+        self.ui.title.setStatusTip(InfoMessage)
+        self.ui.subtitle.setToolTip(InfoMessage)
+        self.ui.subtitle.setStatusTip(InfoMessage)
+
+        self.ui.title_icon.setVisible(icon is not None)
+        self.ui.title_icon.setIcon(TreeIcons.icons[icon])
+    
+    def adjustProcessSelection(self):
+        FlagVisible=[False,False,False,False]
+        if self.TREpar.project is None:
+            FlagVisible[0]=True
+            self.ui.Explorer.hideStepButtons()
+        else:
+            if self.TREpar.process is None:
+                FlagVisible[1]=True
+                self.ui.Explorer.hideStepButtons()
+            else:
+                if self.TREpar.step is None or self.TREpar.step==0:
+                    FlagVisible[2]=True
+                else:
+                    FlagVisible[3]=True            
+        self.ui.projectPage.setVisible(FlagVisible[0])
+        self.ui.processPage.setVisible(FlagVisible[1])
+        self.ui.stepPage.setVisible(FlagVisible[2])
+        self.ui.tabAreaWidget.setVisible(FlagVisible[3])
+        self.w_RCL.setVisible(FlagVisible[3])
+        #if FlagVisible[3]:
+        #    self.ui.tabAreaWidget.scrollArea.splitter.splitterResize()
+        
+        self.adjustWorkspaceHeader()
+        self.adjustTitleHeader()
+        self.adjustSwitches()
+
+        self.ui.Explorer.cancelUndo()
+
+    def adjustProjectSelection(self):
+        self.adjustProcessSelection()
+        self.ui.Explorer.adjustProjectSelection()
+        
+    def adjustSwitches(self):
+        for k in range(len(self.projectTree.itemList[0])):
+            topLevelItem=self.projectTree.topLevelItem(k)
+            itemWidget=self.projectTree.itemWidget(topLevelItem,1)
+            if itemWidget:
+                switch:ModernSwitch=itemWidget.findChildren(ModernSwitch)[0]
+                if switch:
+                    FlagVisible=any([i[0].flagRun<=0 and i[0].Process!=ProcessTypes.cal for i in self.projectTree.itemList[1][k][0]])
+                    self.projectTree.itemList[0][k].FlagRunnable=FlagVisible
+                    if not self.FlagRun:
+                        FlagQueue=len(self.projectTree.itemList[1][k][0])==0 or not FlagVisible or any([i[0].flagRun<=0 and i[0].Process!=ProcessTypes.cal and i[0].FlagQueue for i in self.projectTree.itemList[1][k][0]])
+                    else:
+                        FlagQueue=switch._checked
+
+                    switch.setVisible(FlagVisible)
+                    switch.setSwitch(FlagQueue)
+                    self.projectTree.itemList[0][k].FlagQueue=FlagQueue
+                    if self.TREpar.project==k:
+                        self.TREpar.FlagQueue=FlagQueue
+                    #switch.setEnabled(self.FlagRun==0)
+        if len(self.processTree.itemList):
+            for k,i in enumerate(self.processTree.itemList[0]):
+                topLevelItem=self.processTree.topLevelItem(k)
+                itemWidget=self.processTree.itemWidget(topLevelItem,1)
+                if itemWidget:
+                    switch:ModernSwitch=itemWidget.findChildren(ModernSwitch)[0]
+                    if switch:
+                        ITE:ITEpar=i[0]
+                        switch.setVisible(ITE.flagRun<=0 and ITE.Process!=ProcessTypes.cal and any([j.active and len(j.link)==0 for j in i[1:]]))
+        #self.swithcEnabled(self.FlagRun==0)
+        self.setButtonRunVisible()
 
-                    VIS_child:VISpar=self.w_Vis.TABpar_at(ind_child)
-                    VIS_child.FlagDISP = FlagDISP
-                    VIS_child.dispFile = dispFile
-                    #VIS_child.FlagInit = False
+#*************************************************** Link and copy
+    def adjustDependencies(self,ITE:ITEpar):
+        for ind_slave in ITE.dependencies:
+            self.copy_pars(ind_slave,ITE.ind)
+            #self.inheritance(ind_slave) #useless, already performed in copy_pars
+            self.setLinks(ind_slave,ITE.ind)
 
-            pass
-        
-        ITEs=self.ui.Explorer.ITEsfromInd(indpar)
-        currInd=list(ITEs[0].children).index(ITE.Step)+1
-        for c in range(currInd+1,len(ITEs)):
-            ITE_ind:ITEpar=ITEs[c]
-            self.ui.Explorer.setITElayout(ITE_ind)
-        return
-            
     def button_reset_step_action(self):
-        if self.questionDialog('Are you sure you want to reset the current process step? This operation is irreversible!'):
+        if self.questionDialog('Are you sure you want to reset the current process step? This operation will affect all the subsequent steps in the process and it is irreversible!'):
             self.reset_step(self.ui.Explorer.ITEpar.ind)
         return
 
     def reset_step(self,ind):
         FlagSettingPar=TABpar.FlagSettingPar
         TABpar.FlagSettingPar=True
-        ITE_ind:ITEpar=self.ui.Explorer.ITEfromInd(ind)
-        ITE_ind.procdata=data=dataTreePar(ITE_ind.Process,ITE_ind.Step)
-        ITE_ind.procdata.ind=ITE_ind.ind
-        ITE_ind.progress=0
-        self.setFlagRun(data,0)
-        self.setTABpars_at(ITE_ind.ind,FlagAdjustPar=True,widget=self.w_Vis)
+        ITEs_ind:ITEpar=self.ui.Explorer.ITEsfromInd(ind)
+        ind_child=copy.deepcopy(ind)
+        for j in range(ind[-2],0,-1):
+            ind_child[-2]=j-1
+            ITE_ind:ITEpar=ITEs_ind[j]
+            if not ITE_ind.active and ITE_ind.flagRun<0:
+                ITE_ind.procdata=data=dataTreePar(ITE_ind.Process,ITE_ind.Step)
+                ITE_ind.procdata.ind=ITE_ind.ind
+                ITE_ind.progress=0
+                self.setFlagRun(data,0,flagPrev=True)
+            else:
+                break
+        for j in range(len(ITEs_ind)-1,ind[-2],-1):
+            ind_child[-2]=j-1
+            ITE_ind:ITEpar=ITEs_ind[j]
+            ITE_ind.procdata=data=dataTreePar(ITE_ind.Process,ITE_ind.Step)
+            ITE_ind.procdata.ind=ITE_ind.ind
+            ITE_ind.progress=0
+            self.setFlagRun(data,0,flagPrev=True)
+            self.adjustDependencies(ITE_ind)
+            self.inheritance(ind_child)
+            ind_child[-1]=-1
+            LOG_ind:LOGpar=self.w_Log.TABpar_at(ind_child)
+            if LOG_ind: 
+                LOG_ind.progress=0
+                if self.w_Log.LOGpar.ind[:-1]==LOG_ind.ind[:-1]:
+                    self.w_Log.setLOGlayout()
+        self.ui.progress_Proc.setValue(0)
+        self.setTABpars_at(ITE_ind.ind,FlagAdjustPar=True,widget=self.w_Calibration if ITE_ind.Step==StepTypes.cal else self.w_Vis)
         if data.ind[:-2]==self.ui.tabAreaWidget.TABpar.ind[:-2]:
             self.ui.Explorer.arrangeCurrentProcess(self.processTree)
-        self.adjustDependencies(ITE_ind)
+        
+        self.adjustSwitches()
+
         TABpar.FlagSettingPar=FlagSettingPar
     
-    def copy_link_action(self,button:QPushButton,fun=lambda ind_slave, ind_master:None, FlagExcludeLinked=False):
-        menu = QMenu(self)
+    def IOVheritableSteps(self):
         ITE=self.ui.Explorer.ITEpar
         stepList={}
-        for process in self.processTree.itemList[0]:
-            ITE0:ITEpar=process[0]
-            for step in process[1:]:
+        if len(self.processTree.itemList) and ITE.ind[2]<len(self.processTree.itemList[0]):
+            for step in self.processTree.itemList[0][ITE.ind[2]]:
                 step:ITEpar
-                FlagNoOverLink=True if not FlagExcludeLinked else len(step.link)==0
-                if step.Step==ITE.Step and ITE.ind[:-2]!=ITE0.ind[:-2] and FlagNoOverLink:
-                    stepList[f'{step.ind[-3]+1}: '+ITE0.name]={'ind': step.ind, 'icon': ITE0.icon}
+                if step.active and ITE.ind[:-1]!=step.ind[:-1]:
+                    INP:INPpar = self.w_Input.TABpar_at(step.ind)
+                    OUT:OUTpar = self.w_Output.TABpar_at(step.ind)
+                    VIS:VISpar = self.w_Vis.TABpar_at(step.ind)
+                    if INP is not None and OUT is not None and VIS is not None:
+                        stepList[step.name]={'ind': step.ind, 'icon': step.icon}
+        return stepList
+    
+    def linkableSteps(self,FlagExcludeLinked=False):
+        ITE=self.ui.Explorer.ITEpar
+        stepList={}
+        if len(self.processTree.itemList):
+            for process in self.processTree.itemList[0]:
+                ITE0:ITEpar=process[0]
+                for step in process[1:]:
+                    step:ITEpar
+                    FlagNoOverLink=True if not FlagExcludeLinked else len(step.link)==0
+                    if step.active and step.Step==ITE.Step and ITE.ind[:-2]!=ITE0.ind[:-2] and FlagNoOverLink:
+                        stepList[f'{step.ind[-3]+1}: '+ITE0.name]={'ind': step.ind, 'icon': ITE0.icon}
+        return stepList
+
+    def copy_link_action(self,button:QPushButton, fun=lambda ind_slave, ind_master:None, FlagExcludeLinked=False, menuTitle='Copy step from...',icon=None,message='No process step available!', stepListType=0):
+        if stepListType==1:
+            stepList=self.IOVheritableSteps()
+        else:
+            stepList=self.linkableSteps(FlagExcludeLinked=FlagExcludeLinked)
+        ITE=self.ui.Explorer.ITEpar
         if len(stepList)==0:
-            QToolTip.showText(button.mapToGlobal(button.rect().topLeft()), 'No unlinked process step available!')
+            showTip(self,message)
             return None
+        menu = QMenu(self)
+        title_action = QAction(menuTitle, self)
+        if icon: title_action.setIcon(icon)
+        title_action.setDisabled(True)  # Disabilita l'azione per evitare l'interazione
+        menu.addAction(title_action)
+        menu.addSeparator()
         for key, item in stepList.items():
             #for colormap in VIS_ColorMaps[colorMapClass]:
             nameItem=' '+key
             action:QAction = menu.addAction(TreeIcons.icons[item['icon']], nameItem)
-            action.triggered.connect(lambda _, name=nameItem: fun(ITE.ind,item['ind']))   
-        return menu.exec(button.mapToGlobal(button.rect().bottomLeft()))
+            action.triggered.connect(lambda _, name=key: fun(ITE.ind,stepList[name]['ind']))   
+        return menu.exec(QCursor.pos()) #menu.exec(button.mapToGlobal(button.rect().bottomLeft()))
 
-    def button_copy_step_action(self):
-        self.copy_link_action(self.ui.button_link_step,lambda isl,ima: self.copy_pars(isl,ima,FlagNew=True))
+    def button_step_inherit_action(self):
+        self.copy_link_action(self.ui.button_step_inherit,lambda isl,ima: self.IOVcopy(isl,ima),menuTitle='Copy input/output data from...', message='No process step available!', stepListType=1)
 
-    def copy_pars(self,ind_slave,ind_master,FlagNew=False,FlagSet=True):
+    def button_copy_step_action(self):
+        self.copy_link_action(self.ui.button_copy_step,lambda isl,ima: self.copy_pars_proc(isl,ima,FlagNew=True))
+    
+    def checkCamCompatibility(self,ind_slave,ind_master):
+        ITE_slave:ITEpar=self.ui.Explorer.ITEfromInd(ind_slave)
+        isCompatible=True
+        if ITE_slave.Step==StepTypes.min:
+            INP_slave:INPpar=self.w_Input.TABpar_at(ind_slave)
+            ncam_slave=INP_slave.ncam
+            INP_master:INPpar=self.w_Input.TABpar_at(ind_master)
+            ncam_master=INP_master.ncam
+            isCompatible=ncam_slave==ncam_master
+        elif ITE_slave.Step==StepTypes.cal:
+            CAL_slave:CALpar=self.w_Calibration.TABpar_at(ind_slave)
+            ncam_slave=CAL_slave.ncam
+            CAL_master:CALpar=self.w_Calibration.TABpar_at(ind_master)
+            ncam_master=CAL_master.ncam
+            isCompatible=ncam_slave==ncam_master
+        if not isCompatible:
+            warningMessage=f'The number of cameras in the current step (={ncam_slave}) is different from that in the selected step (={ncam_master}). Please, select a different step or modify the number of cameras in the selected step before proceeding!'
+            self.warningDialog(warningMessage)
+        return isCompatible
+    
+    def copy_pars(self,ind_slave,ind_master,FlagNew=False):
         ind_new=[i for i in ind_slave]
         if FlagNew: ind_new[-1]+=1
         for w in self.tabWidgets:
             w:gPaIRS_Tab
-            if not w.TABpar.FlagNone: 
-                if FlagNew: w.gen_TABpar(ind_new)
+            TAB_slave_curr:TABpar=w.TABpar_at(ind_slave)
+            if TAB_slave_curr: 
+                if FlagNew: w.gen_TABpar(ind_new,Process=TAB_slave_curr.Process,Step=TAB_slave_curr.Step)
                 TAB_slave:TABpar=w.TABpar_at(ind_new)
-                TAB_slave.copyfrom(w.TABpar_at(ind_master),exceptions=['ind','link'])
+                TAB_slave.copyfrom(w.TABpar_at(ind_master),exceptions=['ind','link','Process'])
         ITE_master:ITEpar=self.ui.Explorer.ITEfromInd(ind_master)
         ITE_slave:ITEpar=self.ui.Explorer.ITEfromInd(ind_new)
         ITE_slave.ind=[i for i in ind_new]
-        ITE_slave.copyfrom(ITE_master,exceptions=['procdata','ind','link','dependencies'])
-        ITE_slave.procdata.copyfrom(ITE_master.procdata,exceptions=['ind','link'])
+        ITE_slave.copyfrom(ITE_master,exceptions=['procdata','ind','link','Process','dependencies'])
+        ITE_slave.procdata.copyfrom(ITE_master.procdata,exceptions=['ind','link','Process'])
+        self.getInheritance(ind_slave)
+        self.ui.Explorer.undoInd=None
+        self.inheritance(ind_slave)
         self.ui.Explorer.setITElayout(ITE_slave)
-        if FlagSet: self.setTABpars_at(ind_new)
+        self.adjustSwitches()   #useless?
+        return ind_new
+    
+    def copy_pars_proc(self,ind_slave,ind_master,FlagNew=False,FlagSet=True):
+        if not self.checkCamCompatibility(ind_slave,ind_master): return
+        ITEs_slave=self.ui.Explorer.ITEsfromInd(ind_slave)
+        ITEs_master=self.ui.Explorer.ITEsfromInd(ind_master)
+        for c in range(ind_slave[-2]+1):
+            ind_slave=ITEs_slave[c+1].ind
+            ind_master=ITEs_master[c+1].ind
+            ind_new=self.copy_pars(ind_slave,ind_master,FlagNew=True)
+
+        if FlagSet:
+            self.ui.Explorer.arrangeCurrentProcess(self.ui.Explorer.processTree)
+            self.ui.Explorer.selectStep()
+        self.adjustSwitches()
+        return ind_new
+    
+    def copy_VIS(self,ind_slave,ind_master):
+        ind_new=[i for i in ind_slave]
+        w=self.w_Vis
+        w:gPaIRS_Tab
+        TAB_slave_curr:VISpar=w.TABpar_at(ind_slave)
+        if TAB_slave_curr: 
+            TAB_slave:VISpar=w.TABpar_at(ind_new)
+            TAB_slave.copyfromfields(w.TABpar_at(ind_master),fields=TAB_slave.graphics_fields)
+        self.w_Vis.setTABpar_at(ind_new,FlagAdjustPar=True,FlagBridge=True)
         return ind_new
         
     def button_link_step_action(self):
         if self.ui.button_link_step.isChecked():
-           result=self.copy_link_action(self.ui.button_link_step,self.link_pars,FlagExcludeLinked=True)
+           result=self.copy_link_action(self.ui.button_link_step,self.link_pars,FlagExcludeLinked=True,menuTitle='Link step to...')
            FlagUnlink=result is None
         else:
             FlagUnlink=True
@@ -1495,10 +1891,25 @@ class gPaIRS(QMainWindow):
             self.unlink_pars(ITE.ind)
             self.ui.button_link_step.setChecked(False)
            
-    def link_pars(self,ind_slave,ind_master):
-        ind_new=self.copy_pars(ind_slave,ind_master,FlagNew=True,FlagSet=False)
-        self.setLinks(ind_new,ind_master)
-        self.setTABpars_at(ind_new)
+    def link_pars(self,ind_slave,ind_master,FlagSet=True):
+        if not self.checkCamCompatibility(ind_slave,ind_master): return
+        ITEs_slave=self.ui.Explorer.ITEsfromInd(ind_slave)
+        ITEs_master=self.ui.Explorer.ITEsfromInd(ind_master)
+        for c in range(ind_slave[-2]+1):
+            ind_slave=ITEs_slave[c+1].ind
+            ind_master=ITEs_master[c+1].ind
+            ind_new=self.copy_pars(ind_slave,ind_master,FlagNew=True)
+            self.setLinks(ind_new,ind_master)
+        #item=self.processTree.topLevelItem(ind_new[2])
+        #child=item.child(ind_new[3])
+        #child.setIcon(0,self.processTree.linkedIcon)
+
+        #self.setTABpars_at(ind_new)
+        if FlagSet:
+            self.ui.Explorer.arrangeCurrentProcess(self.ui.Explorer.processTree)
+            self.ui.Explorer.selectStep()
+        self.adjustSwitches()
+        return ind_new
 
     def setLinks(self,ind_slave,ind_master,FlagUnlink=False,ind_slave_new=None,ind_master_new=None):
         if ind_slave_new is None: ind_slave_new=copy.deepcopy(ind_slave)
@@ -1530,7 +1941,11 @@ class gPaIRS(QMainWindow):
         ind_master=ITE_slave.link
         if ind_master:
             self.setLinks(ind_slave,ind_master,FlagUnlink=True)
+            #item=self.processTree.topLevelItem(ind_slave[2])
+            #child=item.child(ind_slave[3])
+            #child.setIcon(0,QIcon())
             self.setTABpars_at(ind_slave)
+            self.adjustSwitches()
 
 #*************************************************** PROCESS
 #********************************** Launching
@@ -1552,78 +1967,127 @@ class gPaIRS(QMainWindow):
     
     def setButtonPause(self,flagPlay):
         if flagPlay:
+            self.ui.label_updating_pairs.setVisible(False)
             self.ui.button_pause.setIcon(self.icon_play)
             stringa='Restart'
         else:
+            self.ui.label_updating_pairs.setVisible(True)
             self.ui.button_pause.setIcon(self.icon_pause)
             stringa='Pause'
         tip=f'{stringa} process queue'+' ('+self.ui.button_pause.shortcut().toString(QKeySequence.NativeText)+')'
         self.ui.button_pause.setToolTip(tip)
         self.ui.button_pause.setStatusTip(tip)
+        self.setButtonRunVisible()
+        self.processTree.setProcessActionButtonLayout()
+        """
         FlagButtonRun=self.ui.progress_Proc.value()==0
         self.ui.button_Run.setVisible(FlagButtonRun)
         self.ui.button_pause.setVisible(not FlagButtonRun)
         self.ui.w_progress_Proc.setVisible(not FlagButtonRun)
-    
+        """
+        
     def run(self):
-        self.ui.button_pause.show()
-        self.ui.w_progress_Proc.show()
-        self.ui.button_Run.hide()
-        self.ui.label_updating_pairs.setVisible(True)
         self.setSwitchEnabled(False)
         self.disableDropping(True)
         if self.initializeWorkers():
             self.indProc=-1
             self.updateIndProc()
         else:
-            self.button_run_pause_action()
+            self.FlagRun=0
+            self.setButtonPause(True)
+            #self.button_run_pause_action()
             self.stopProcs()
     
     def updateIndProc(self):
+        self.indWorker+=1
+        data=self.dataQueue[self.indWorker]
+        self.initialize_proc(data)  
+        ITE_ind:ITEpar=self.ui.Explorer.ITEfromInd(data.ind)
+        self.ui.Explorer.setITElayout(ITE_ind)
+
         self.indProc+=1
         data:dataTreePar
         self.ui.Explorer.updateSwitchMovies(self.currind,FlagStart=False)
         self.procdata=None
         self.procdata=data=self.dataQueue[self.indProc]
         self.currind=data.ind
+        self.checkProcesses(FlagInit=True,ind=self.currind)
+        ITE:ITEpar=self.ui.Explorer.ITEfromInd(data.ind)
+        self.ui.Explorer.setITElayout(ITE)
+        if ITE.OptionDone==0:
+            self.stopProcs()
+            self.nextProc()
+            return
+
         self.procdata.uncopied_fields+=self.procFields
         self.ui.Explorer.updateSwitchMovies(self.currind,FlagStart=True)
 
         self.resetProc(data)
         self.setProgressBar(data)
         data.resetLog()
+        try:
+            with open(data.stepOutName()+'.log', 'w') as file:
+                file.write(data.Log)
+        except:
+            pri.Error.red(f'Error while trying to save the process log file: {data.stepOutName()}.log.\n{traceback.format_exc()}\n') 
 
         self.FlagResetPlot=True
         self.setFlagRun(data,-2)
+        self.ui.Explorer.setITElayout(ITE)
+        ITEs_ind:ITEpar=self.ui.Explorer.ITEsfromInd(self.currind)
+        ind_child=copy.deepcopy(self.currind)
+        for j in range(1,self.currind[-2]+1):
+            ind_child[-2]=j-1
+            ITE_child:ITEpar=ITEs_ind[j]
+            data_child=ITE_child.procdata
+            if data_child.flagRun==0:
+                self.setFlagRun(data_child,-1)
+                self.checkProcesses(FlagInit=True,ind=ind_child)
+                self.ui.Explorer.setITElayout(ITE_child)
+                if data_child.ind==self.ui.tabAreaWidget.TABpar.ind:
+                    self.w_Log.LOGpar.text=data_child.Log
+                    self.setTABpars_at(data_child.ind,FlagAdjustPar=True)    
 
         FlagCurrent=data.ind==self.ui.tabAreaWidget.TABpar.ind
         if FlagCurrent: 
             self.w_Log.LOGpar.text=data.Log
             self.setTABpars_at(data.ind,FlagAdjustPar=True)    
             self.w_Log.buttonAction()
-        else:
-            ITE:ITEpar=self.ui.Explorer.ITEfromInd(data.ind)
-            self.ui.Explorer.setITElayout(ITE)
         self.FlagProcInit=True
         self.signals.indProc.emit(self.indProc)
         if  data.flagRun==0:#not launched
           data.resetTimeStat() 
         data.onStartTimeStat()
 
-    def setFlagRun(self,data:dataTreePar,flagRun):
+    def setFlagRun(self,data:dataTreePar,flagRun,flagPrev=False):
         data.flagRun=flagRun  #come ultimo o comunque dopo resetProc    
         for w in self.tabWidgets:
             w:gPaIRS_Tab
-            TABpar_ind:TABpar=w.TABpar_at(data.ind)
-            if TABpar_ind: TABpar_ind.flagRun=flagRun
+            if flagPrev:
+                TABpar_prev=w.TABpar_prev_at(data.ind)
+                for TABpar_ind in TABpar_prev: 
+                    if TABpar_ind: TABpar_ind.flagRun=flagRun
+            else:
+                TABpar_ind:TABpar=w.TABpar_at(data.ind)
+                if TABpar_ind: TABpar_ind.flagRun=flagRun
         ITE_ind:ITEpar=self.ui.Explorer.ITEfromInd(data.ind)
         ITE_ind.flagRun=flagRun
-
+        
+        self.ui.Explorer.setProcessFlagRun(data.ind)
+        return
+    
     def nextProc(self):
         self.UpdatingImage=True
 
         if self.indProc<self.nProc-1 and self.FlagRun==1:
-            self.updateIndProc()
+            try:
+                self.updateIndProc()
+            except:
+                errMessage=f"{traceback.format_exc()}"
+                self.procdata.warnings[0]+='\n\n'+self.procdata.headerSection('CRITICAL ERROR',errMessage,'X') 
+                self.store_proc(self.procdata)
+                self.stopProcs()
+                self.nextProc()
         else:
             self.ui.button_pause.setEnabled(False) 
 
@@ -1643,7 +2107,7 @@ class gPaIRS(QMainWindow):
         self.ui.progress_Proc.setMaximum(data.nsteps)
         self.ui.progress_Proc.setValue(data.numFinalized) 
         self.w_Log.TABpar_at(data.ind).nimg=data.nsteps
-        ITE:ITEpar=self.ui.Explorer.ITEfromInd(data.ind)
+        #ITE:ITEpar=self.ui.Explorer.ITEfromInd(data.ind)
         return
         
     def setLogProgressBar(self,data:dataTreePar):
@@ -1675,27 +2139,38 @@ class gPaIRS(QMainWindow):
                     nTot+=int(process[0].FlagQueue and step.active)
                     nError+=int(process[0].FlagQueue and step.active and step.flagRun<=0 and step.Step!=StepTypes.cal and step.OptionDone==0)
                     nValid+=int((process[0].FlagQueue and step.active and step.flagRun>0) or step.Step==StepTypes.cal)
-                    if process[0].FlagQueue and step.active and step.flagRun<=0 and step.Step!=StepTypes.cal and step.OptionDone!=0: 
+                    if process[0].FlagQueue and step.active and step.flagRun<=0 and step.Step!=StepTypes.cal and step.OptionDone!=0 and len(step.link)==0: 
                         self.nProc+=1
-                        self.indWorker+=1
                         data=step.procdata
                         data.ind=step.ind
-                        self.initialize_proc(data)
                         self.dataQueue.append(data)
-                    elif step.Step==StepTypes.cal and step.OptionDone==1:
+                    elif step.Process!=ProcessTypes.cal and step.Step==StepTypes.cal and step.OptionDone==1:
                         data=step.procdata
                         data.ind=step.ind
                         self.setFlagRun(data,2)
+                        CAL:CALpar=self.w_Calibration.TABpar_at(step.ind)
+                        CAL.FlagCalVi=False
         if self.nProc==0 and nValid==0:
             self.warningDialog('No valid process found in the present projects!\nPlease, check for critical issues related to each step of the defined processes.',pixmap=icons_path+'issue.png')
         elif self.nProc==0 and nError>0:
             self.warningDialog(f'{nError} process step{"s" if nError>1 else ""} present{"" if nError>1 else "s"} critical issues!\nNo further valid process found in the present projects.\nPlease, check before running again.',pixmap=icons_path+'issue.png')
         elif self.nProc>0 and nError>0:
-            self.warningDialog(f'{nError} process step{"s" if nError>1 else ""} present{"" if nError>1 else "s"} critical issues!\n{"They" if nError>1 else "It"} will not be executed.',pixmap=icons_path+'warning.png')
+            if not self.questionDialog(f'{nError} process step{"s" if nError>1 else ""} present{"" if nError>1 else "s"} critical issues!\n{"They" if nError>1 else "It"} will not be executed. Do you want to proceed with processing?'): 
+                self.contProc=self.nProc-1 #necessario per far funzionare stopProc in run quando il risultato di questa funzione è False
+                return False
         elif self.nProc==0:
             self.warningDialog(f'All the processes found in the present projects have been already executed!',pixmap=icons_path+'completed.png')
         FlagQueue=len(self.dataQueue)!=0
-        self.contProc=-1 if not FlagQueue else 0    
+        self.contProc=-1 if not FlagQueue else 0  
+        self.putStepsInQueue()
+        """
+        for data in self.dataQueue:
+            data:dataTreePar
+            self.indWorker+=1
+            self.initialize_proc(data)  
+            ITE_ind:ITEpar=self.ui.Explorer.ITEfromInd(data.ind)
+            self.ui.Explorer.setITElayout(ITE_ind)
+        """
         return FlagQueue
     
     def initialize_proc(self,data:dataTreePar):
@@ -1710,17 +2185,24 @@ class gPaIRS(QMainWindow):
             try:
                 os.mkdir(currpath)
             except Exception as inst:
-                pri.Error.red(f'It was not possible to make the output folder:\n{traceback.print_exc}\n\n{inst}')
+                pri.Error.red(f'It was not possible to make the directory {currpath}:\n{traceback.format_exc()}\n\n{inst}')
         pfPool = None if self.flagSimpleFor else self.pfPool
         if data.Step==StepTypes.min:
-            procWorker=MIN_ParFor_Worker(data,self.indWorker,self.indProc,self.numUsedThreadsPIV,pfPool,self.parForMul)
-        elif data.Step ==StepTypes.piv:
-            procWorker=PIV_ParFor_Worker(data,self.indWorker,self.indProc,self.numUsedThreadsPIV,pfPool,self.parForMul)
+            self.numUsedProcs=self.numMaxProcs
+            data.numPivOmpCores=1
+            data.numUsedProcs=self.numMaxProcs
+            procWorker=MIN_ParFor_Worker(data,self.indWorker,self.indProc,self.numMaxProcs,pfPool,self.parForMul)
+        elif data.Step ==StepTypes.piv or  data.Step ==StepTypes.spiv:
+            data.numPivOmpCores,data.numUsedProcs=optimalPivCores(self.numMaxProcs,data.nimg,penCore=0.95)
+            #data.numUsedProcs=3 # data.numUsedProcs is used for output should be the number of parfor threads used 
+            #data.numPivOmpCores=7#self.numMaxProcs   
+            self.numUsedProcs=data.numUsedProcs
+            procWorker=PIV_ParFor_Worker(data,self.indWorker,self.indProc,self.numMaxProcs,pfPool,self.parForMul)
         elif data.Step ==StepTypes.disp:
-            procWorker=StereoDisparity_ParFor_Worker(data,self.indWorker,self.indProc,self.numUsedThreadsPIV,pfPool,self.parForMul)
-        elif data.Step ==StepTypes.spiv:
-            procWorker=StereoPIV_ParFor_Worker(data,self.indWorker,self.indProc,self.numUsedThreadsPIV,pfPool,self.parForMul)
-
+            data.numPivOmpCores=NUMTHREADS_MAX
+            data.numUsedProcs=1
+            procWorker=StereoDisparity_ParFor_Worker(data,self.indWorker,self.indProc,self.numMaxProcs,pfPool,self.parForMul)
+        
 
         procWorker.signals.progress.connect(self.progress_proc)
         self.signals.progress.connect(procWorker.setNumCallBackTot)
@@ -1735,14 +2217,11 @@ class gPaIRS(QMainWindow):
         self.procWorkers.append(procWorker)
         self.PaIRS_threadpool.start(procWorker)
         
-    
     def set_proc(self,data:dataTreePar,ind=None,FlagLog=True):
         if ind is None: ind=data.ind
-        if data.flagRun==0:  
-            indpar=[j for j in ind]
-            for j in range(indpar[-2]):
-                indpar[-2]=j
-                self.inheritance(indpar)
+        k=self.dataQueue.index(data)
+        if self.dataFlagRuns[k]==0:  
+            self.getInheritance(ind)
             data.namesPIV=NamesPIV(Process=data.Process,Step=data.Step)
             INP_ind=self.w_Input.TABpar_at(ind)
             OUT_ind=self.w_Output.TABpar_at(ind)
@@ -1750,6 +2229,7 @@ class gPaIRS(QMainWindow):
             PRO_Min_ind=self.w_Process_Min.TABpar_at(ind)
             PRO_Disp_ind=self.w_Process_Disp.TABpar_at(ind)
             data.setProc(INP_ind,OUT_ind,PRO_ind,PRO_Min_ind,PRO_Disp_ind)
+            data.assignDataName()
 
             if FlagLog:
                 ITE_ind:ITEpar=self.ui.Explorer.ITEfromInd(ind)
@@ -1772,7 +2252,7 @@ class gPaIRS(QMainWindow):
         
         if i<0:  return  #When restarting a process return  immediately if the images have been already processed
         #******************** Updating Log
-        data.Log+=stampa
+        data.Log+=stampa+'\n'
         self.w_Log.TABpar_at(data.ind).text=data.Log
 
         data.list_print[i]=stampa
@@ -1795,6 +2275,7 @@ class gPaIRS(QMainWindow):
             ITE_ind.progress=data.numFinalized
         LOG_ind.nimg=data.nsteps
         self.ui.Explorer.updateItemWidget(ITE_ind)
+        self.adjustDependencies(ITE_ind)
 
         flagSelected=data.hasIndexOf(self.ui.Explorer.ITEpar)
         if flagSelected:
@@ -1814,7 +2295,6 @@ class gPaIRS(QMainWindow):
         if data.flagParForCompleted: return
         #******************** updating log
         if flagSelected: 
-          LOG_ind.text=data.Log
           self.w_Log.LOGpar.text=data.Log
           self.w_Log.setLogText(FlagMoveToBottom=True)
         
@@ -1822,7 +2302,7 @@ class gPaIRS(QMainWindow):
         # prLock ha smesso di funzionare perchè?
         #prLock(f'progress_proc {i} data.numProcOrErrTot={data.numProcOrErrTot}  self.numCallBackTotOk={self.numCallBackTotOk}')
 
-        if self.FlagRun==0 or (procId%self.numUsedThreadsPIV and data.Step!=StepTypes.disp): return   #evitare aggiornamento tempo
+        if self.FlagRun==0 or (procId%self.numUsedProcs and data.Step!=StepTypes.disp): return   #evitare aggiornamento tempo
         #if self.FlagRun==0: return   #evitare aggiornamento tempo
         #******************** Updating time counter and stats
         actualTime=time()
@@ -1845,6 +2325,7 @@ class gPaIRS(QMainWindow):
         if data is None:
             data=self.procdata
         try:
+            FlagCurrent=data.hasIndexOf(self.ui.Explorer.ITEpar)
             VIS_ind:VISpar=self.w_Vis.TABpar_at(data.ind)
             if data.Step==StepTypes.min:
                 if i>-1: 
@@ -1854,6 +2335,10 @@ class gPaIRS(QMainWindow):
                     VIS_ind.FlagMIN = True
                     VIS_ind.image_file_Current=''
                     self.w_Vis.image_Current_raw=None
+                    #if Var: #todo GP: per i==-1 Var deve essere l'immagine giusta
+                    #    self.w_Vis.getImageInfo(Var,data.ind)
+                    #    self.w_Vis.resetAllLevels(data.ind)
+                    #    self.w_Vis.resetAllXYLims(data.ind)
 
                 if self.FlagResetPlot:
                     VIS_ind.img=0
@@ -1861,7 +2346,7 @@ class gPaIRS(QMainWindow):
                     VIS_ind.variable=self.namesPIV.combo_dict[self.namesPIV.img]
                     VIS_ind.variableKey=self.namesPIV.combo_dict_keys[VIS_ind.variable]
                     VIS_ind.FlagResetLevels=VIS_ind.FlagResetSizes=True
-                    self.FlagResetPlot=False
+                    self.FlagResetPlot=False                   
                 pass
             elif data.Step in (StepTypes.piv,StepTypes.disp,StepTypes.spiv): 
                 if i>-1: 
@@ -1875,14 +2360,17 @@ class gPaIRS(QMainWindow):
                     result={}
                     for f,v in zip(fields,Var):
                         result[f]=v
-                    if data.Step==StepTypes.piv:
-                        result[data.namesPIV.Mod]=np.sqrt(result[data.namesPIV.u]**2+result[data.namesPIV.v]**2)
-                    elif data.Step==StepTypes.spiv:
-                        result[data.namesPIV.Mod]=np.sqrt(result[data.namesPIV.u]**2+result[data.namesPIV.v]**2+result[data.namesPIV.w]**2)
+                    result=self.w_Vis.calcMagnitude(result)
+                    FlagUnit=VIS_ind.Out.xres!=1.0 or VIS_ind.Out.pixAR!=1.0
+                    result=self.w_Vis.calcZVorticity(result,FlagUnit)
                     self.w_Vis.result_Current=result
                 else:
                     VIS_ind.result_file_Current=''
                     self.w_Vis.result_Current=None
+                    #if Var: #todo GP: per i==-1 Var deve essere result
+                    #    self.w_Vis.getResultInfo(result,data.ind)
+                    #    self.w_Vis.resetAllLevels(data.ind)
+                    #    self.w_Vis.resetAllXYLims(data.ind)
 
                 if self.FlagResetPlot:
                     VIS_ind.img=0
@@ -1898,7 +2386,7 @@ class gPaIRS(QMainWindow):
             else: 
                 pri.Info.red(f'Current process type ({data.Step}) has no plot function available!')
                 return
-            if data.hasIndexOf(self.ui.Explorer.ITEpar):
+            if FlagCurrent:
                 self.w_Vis.FlagReset=i==-1
                 self.setTABpars_at(data.ind,FlagAdjustPar=True,widget=self.w_Vis)
                 pri.Process.yellow(f'{"*"*50} Result plotted!')
@@ -1946,8 +2434,9 @@ class gPaIRS(QMainWindow):
     def store_proc(self,data_worker:dataTreePar):
         data=self.procdata #self.w_Tree.TABpar_prev[idata.indTree][idata.indItem][-1]
         for f in self.procFields:
-            i=self.procdata.uncopied_fields.index(f)
-            self.procdata.uncopied_fields.pop(i)
+            if f in self.procdata.uncopied_fields:
+                i=self.procdata.uncopied_fields.index(f)
+                self.procdata.uncopied_fields.pop(i)
         #Aggiusto ciò che deve essere aggiornato
         #if not data.numFinalized:  return
         pri.Time.yellow(f'{"-"*100} store PROC')
@@ -1968,30 +2457,38 @@ class gPaIRS(QMainWindow):
             OUT_ind.res=data.res
             if OUT_ind.unit==0: 
                 OUT_ind.xres=data.res
+            if 'zconst' in data.OUT_dict and 'xterm' in data.OUT_dict and 'yterm' in data.OUT_dict:
+                OUT_ind.zconst=data.OUT_dict['zconst']
+                OUT_ind.xterm=data.OUT_dict['xterm']
+                OUT_ind.yterm=data.OUT_dict['yterm']
             indpar[-2]+=1
             indpar[-1]=-1
             OUT_ind:OUTpar=self.w_Output.TABpar_at(indpar)
             OUT_ind.res=data.res
             if OUT_ind.unit==0: 
                 OUT_ind.xres=data.res
+            if 'zconst' in data.OUT_dict and 'xterm' in data.OUT_dict and 'yterm' in data.OUT_dict:
+                OUT_ind.zconst=data.OUT_dict['zconst']
+                OUT_ind.xterm=data.OUT_dict['xterm']
+                OUT_ind.yterm=data.OUT_dict['yterm']
             ITE_ind:ITEpar=self.ui.Explorer.ITEfromInd(indpar)
             ITE_ind.procdata.res=data.res
             ITE_ind.procdata.laserConst=[const for const in data_worker.laserConst]
+            if 'zconst' in data.OUT_dict and 'xterm' in data.OUT_dict and 'yterm' in data.OUT_dict:
+                ITE_ind.procdata.OUT_dict['zconst']=data.OUT_dict['zconst']
+                ITE_ind.procdata.OUT_dict['xterm']=data.OUT_dict['xterm']
+                ITE_ind.procdata.OUT_dict['yterm']=data.OUT_dict['yterm']
 
         #Aggiusto ciò che deve essere aggiornato
-        data.warnings[1]=''
-        data.setCompleteLog()
         if data.nsteps==data.numCallBackTotOk: #data.FlagFinished:   #todo TA da GP: secondo te è corretto?
             flagRun=int(data.numFinalized==data.nsteps)+1
         else: 
             flagRun=-1  
         self.setFlagRun(data,flagRun)
+        data.warnings[1]=''
+        data.setCompleteLog()
+        self.adjustSwitches()
 
-        with open(data.outPathRoot+'.log', 'a') as file:
-             file.write(data.Log)
-        if data.Step in (StepTypes.piv,StepTypes.spiv):
-            data.writeCfgProcPiv()
-        
         Process=[]
         for l in self.projectTree.itemList[1:]:
             Process.append([ l[data.ind[0]][data.ind[1]][data.ind[2]] ])
@@ -1999,10 +2496,22 @@ class gPaIRS(QMainWindow):
         try:
             saveList(Process,filename)
         except Exception as inst:
-            warningDialog(self,f'Error while saving the configuration file {filename}!\nPlease, retry.')
+            #warningDialog(self,f'Error while saving the configuration file {filename}!')
             pri.Error.red(f'Error while saving the configuration file {filename}!\n{inst}')
 
-        
+        try:
+            with open(data.outPathRoot+'.log', 'a') as file:
+                file.write(data.Log)
+        except:
+            pri.Error.red(f'Error while trying to save the process log file: {data.outPathRoot}.log.\n{traceback.format_exc()}\n')
+        try:
+            with open(data.stepOutName()+'.log', 'w') as file:
+                file.write(data.Log)
+        except:
+            pri.Error.red(f'Error while trying to save the process log file: {data.stepOutName()}.log.\n{traceback.format_exc()}\n') 
+        if data.Step in (StepTypes.piv,StepTypes.spiv):
+            data.writeCfgProcPiv()
+          
         LOG_ind:LOGpar=self.w_Log.TABpar_at(data.ind)
         LOG_ind.text=data.Log
         self.w_Log.setLogText(FlagMoveToBottom=True)
@@ -2011,7 +2520,11 @@ class gPaIRS(QMainWindow):
         #if not data.hasIndexOf(self.ui.Explorer.ITEpar):
         ITE:ITEpar=self.ui.Explorer.ITEfromInd(data.ind)
         self.ui.Explorer.setITElayout(ITE)
+        self.inheritance(data.ind)
+        self.adjustDependencies(ITE)
         self.ui.time_stamp.setText('')
+        
+        self.adjustSwitches()
 
         pri.Time.yellow(f'{"-"*100} store PROC  END')
 
@@ -2026,7 +2539,8 @@ class gPaIRS(QMainWindow):
         if self.procdata:
             pri.Time.red(f'stopProcs     self.contProc={self.contProc}/{self.nProc}   self.numCallBackTotOk={self.numCallBackTotOk}  numFinalized={self.procdata.numFinalized}  {self.FlagRun}')
         
-        if self.contProc==self.nProc:
+        FlagEnd = self.contProc==self.indProc+1 if self.FlagRun==2 else self.contProc==self.nProc
+        if FlagEnd: 
             self.ui.Explorer.updateSwitchMovies(self.currind,FlagStart=False)
             self.setSwitchEnabled(True)
             self.disableDropping(False)
@@ -2036,21 +2550,41 @@ class gPaIRS(QMainWindow):
             self.setEnabled(True)
             self.procWorkers=[]
             self.FlagRun=0
+            self.putStepsInQueue()
             self.ui.button_pause.setEnabled(True)
             self.ui.button_Run.setEnabled(True)
             self.setButtonPause(True)
            
-            self.ui.label_updating_pairs.setVisible(False)
-            if self.waitingDialog:
-                self.waitingDialog.done(0)
-                self.waitingDialog=None
-            if self.completingTask:
-                self.completingTask()
-                self.completingTask=None
-
-            if self.FlagClosing[0]:
-                self.correctClose()
-            
+            self.closeIfRequested()
+
+    def putStepsInQueue(self):
+        if self.FlagRun:
+            self.dataFlagRuns=[]
+        for k,data in enumerate(self.dataQueue):
+            if self.FlagRun:
+                self.dataFlagRuns.append(data.flagRun)
+                self.setFlagRun(data,-10)
+            elif data.flagRun==-10:
+                self.setFlagRun(data,self.dataFlagRuns[k])
+            else:
+                continue
+            ITE_ind:ITEpar=self.ui.Explorer.ITEfromInd(data.ind)
+            self.ui.Explorer.setITElayout(ITE_ind)
+        self.ui.Explorer.arrangeCurrentProcess(self.processTree)
+        
+    def closeIfRequested(self):
+        self.ui.label_updating_pairs.setVisible(False)
+        if self.waitingDialog:
+            self.waitingDialog.done(0)
+            self.waitingDialog=None
+        if self.completingTask:
+            self.completingTask()
+            self.completingTask=None
+        """
+        if self.FlagClosing[0]:
+            self.correctClose()
+        """
+
 #********************************************* CalVi
     def runCalVi(self):
         self.w_Vis_CalVi.VISpar.FlagRunning=not self.w_Vis_CalVi.VISpar.FlagRunning
@@ -2078,7 +2612,7 @@ class gPaIRS(QMainWindow):
                 else:
                     cams=[-1]
                 data=self.w_Vis_CalVi.calibView.calib.cal.data
-                varName=f'{data.percorsoOut}{data.NomeFileOut}{camString}{outExt.cal}'
+                varName=f'{data.percorsoOut}{data.NomeFileOut}{camString}{outExt.calvi}'
                 questionMessage=f'The calibration result file:\n{varName}\nalready exists in the current output path. The above error could arise from the attempt of loading such a file.\n\nDo you want to remove the file from the disk?\n\n(Please, consider to choose a different output name root for your process)'
                 if questionDialog(self,questionMessage):
                     os.remove(varName)
@@ -2118,7 +2652,7 @@ class gPaIRS(QMainWindow):
             
             if self.w_Vis_CalVi.FlagResume>-1: 
                 self.saveCal()
-                if (self.w_Process_CalVi.PROpar.FlagPlane or self.w_Process_CalVi.PROpar.CamMod==4) and self.w_Vis_CalVi.calibView.calib.FlagCalibration:
+                if self.w_Vis_CalVi.calibView.calib.FlagCalibration and ( (self.w_Process_CalVi.PROpar.FlagPlane and not self.w_Process_CalVi.PROpar.CalibProcType==0) or self.w_Process_CalVi.PROpar.CamMod==4 ):
                     if self.w_Input_CalVi.INPpar.FlagOptPlane: self.savePlanePar()
                     self.updateINPpar()
                     self.saveCal('_Mod')
@@ -2128,6 +2662,8 @@ class gPaIRS(QMainWindow):
             #self.actualBridge('Import',indTree,indItem,ind)
             self.initDataAndSetImgFromGui(self.w_Input_CalVi.INPpar,self.w_Process_CalVi.PROpar)
             self.w_Vis_CalVi.stopCalVi()
+
+            self.closeIfRequested()
             
     def abortCalVi(self):
         self.w_Vis_CalVi.FlagResume=-1
@@ -2152,11 +2688,13 @@ class gPaIRS(QMainWindow):
             outFiles=[f'{data.percorsoOut}{data.NomeFileOut}{c}.cal' for c in INP.cams]
         else:
             outFiles=[f'{data.percorsoOut}{data.NomeFileOut}{1}.cal']
+        appendedFiles=[f for f in outFiles if f not in self.w_Calibration.CALpar.calList]
         self.w_Calibration.buttonAction()
+        if len(appendedFiles)==0: return
         if self.w_Calibration.CALpar.ncam==len(self.w_Calibration.CALpar.calList):
             warningDialog(self,f'The calibration file list already contains a number of files equal to the number of cameras specified ({self.w_Calibration.CALpar.ncam}). The results of the current CalVi process will not be appended to the list.')
         else:
-            self.w_Calibration.ui.calTree.importLists(outFiles)
+            self.w_Calibration.ui.calTree.importLists(appendedFiles)
             self.w_Calibration.copyListsFromTree()
             #self.w_Calibration.nullCallback()
             self.w_Calibration.adjustTABparInd()
@@ -2175,32 +2713,48 @@ class gPaIRS(QMainWindow):
                 VIS.angAndMask.append([])
                 VIS.spotDistAndRemoval.append([])
 
-                VIS.orPosAndShift[p].append(calVect.XOr[p] - data.ColPart)
-                VIS.orPosAndShift[p].append(calVect.YOr[p] - data.RigaPart)
-                VIS.orPosAndShift[p].append(calVect.xOrShift[p])
-                VIS.orPosAndShift[p].append(calVect.yOrShift[p])
+                VIS.orPosAndShift[p].append(float(calVect.XOr[p] - data.ColPart))
+                VIS.orPosAndShift[p].append(float(calVect.YOr[p] - data.RigaPart))
+                VIS.orPosAndShift[p].append(float(calVect.xOrShift[p]))
+                VIS.orPosAndShift[p].append(float(calVect.yOrShift[p]))
                 
-                VIS.angAndMask[p].append(calVect.angCol[p])
-                VIS.angAndMask[p].append(calVect.angRow[p])
+                VIS.angAndMask[p].append(float(calVect.angCol[p]))
+                VIS.angAndMask[p].append(float(calVect.angRow[p]))
                 for i in self.w_Vis_CalVi.calibView.calib.cal.getPuTrovaCC(p):
-                    VIS.angAndMask[p].append(i)
-
-                VIS.spotDistAndRemoval[p].append(calVect.dColPix[p])
-                VIS.spotDistAndRemoval[p].append(calVect.dRigPix[p])
-                VIS.spotDistAndRemoval[p].append(calVect.remPointsUp[p])
-                VIS.spotDistAndRemoval[p].append(calVect.remPointsDo[p])
-                VIS.spotDistAndRemoval[p].append(calVect.remPointsLe[p])
-                VIS.spotDistAndRemoval[p].append(calVect.remPointsRi[p])
+                    VIS.angAndMask[p].append(float(i))
+
+                VIS.spotDistAndRemoval[p].append(float(calVect.dColPix[p]))
+                VIS.spotDistAndRemoval[p].append(float(calVect.dRigPix[p]))
+                VIS.spotDistAndRemoval[p].append(float(calVect.remPointsUp[p]))
+                VIS.spotDistAndRemoval[p].append(float(calVect.remPointsDo[p]))
+                VIS.spotDistAndRemoval[p].append(float(calVect.remPointsLe[p]))
+                VIS.spotDistAndRemoval[p].append(float(calVect.remPointsRi[p]))
         
         INP=self.w_Input_CalVi.INPpar
         camString=''
         if INP.FlagCam: 
             if len(INP.cams)==1: camString=f'_cam{INP.cams[0]}'
-        varName=f'{data.percorsoOut}{data.NomeFileOut}{camString}{add_str}{outExt.cal}'
+        varName=f'{data.percorsoOut}{data.NomeFileOut}{camString}{add_str}{outExt.calvi}'
         var=[INP,self.w_Process_CalVi.PROpar,VIS,myStandardPath(os.path.dirname(varName))]
-        with open(varName,'wb') as file:
-            pickle.dump(var,file)
-            pri.Info.blue(f'>>> Saving calibration process file {varName}')            
+        try:
+            with open(varName,'wb') as file:
+                pickle.dump(var,file)
+                pri.Info.blue(f'>>> Saving calibration process file {varName}')    
+        except:
+            pri.Error.red(f'Error while trying to save the calibration process file: {varName}.\n{traceback.format_exc()}\n')   
+
+        self.w_Input_CalVi.adjustTABparInd()
+        self.w_Process_CalVi.adjustTABparInd()
+        self.w_Vis_CalVi.adjustTABparInd()     
+        Process=[]
+        for l in self.projectTree.itemList[1:]:
+            Process.append([ l[INP.ind[0]][INP.ind[1]][INP.ind[2]] ])
+        filename=f'{data.percorsoOut}{data.NomeFileOut}{camString}{add_str}{outExt.cal}'
+        try:
+            saveList(Process,filename)
+        except Exception as inst:
+            #warningDialog(self,f'Error while saving the configuration file {filename}!')
+            pri.Error.red(f'Error while saving the configuration file {filename}!\n{inst}')
         return
     
     def savePlanePar(self):
@@ -2216,8 +2770,11 @@ class gPaIRS(QMainWindow):
             for p,v in zip(plapar_names,c):
                 dp[p]=v
             plaparName=plaparRad+f"{i+1:d}_z{dp['z (mm)']:.2f}{outExt.pla}"
-            with open(plaparName,'w') as file:
-                file.write(str(dp).replace('{','{\n ').replace(',',',\n').replace('}','\n}'))
+            try:
+                with open(plaparName,'w') as file:
+                    file.write(str(dp).replace('{','{\n ').replace(',',',\n').replace('}','\n}'))
+            except:
+                pri.Error.red(f'Error while trying to save the plane parameter file: {plaparName}.\n{traceback.format_exc()}\n')  
             pri.Info.blue(f'    Saving plane data file {plaparName}')
 
     def setRunCalViButtonText(self,FlagRunning=True):
@@ -2231,11 +2788,16 @@ class gPaIRS(QMainWindow):
                 s=''
             text='Run'
             button.setIcon(self.icon_play)
+            tooltip=f'Run CalVi{" (some issues detected!)" if flag else ""}'
         else:
             s=''
-            text='Stop'
-            button.setIcon(self.icon_pause)
+            text='Save'
+            button.setIcon(self.icon_save_and_stop)
+            tooltip='Quit CalVi and save results'
         button.setText(text+s)
+        tooltip+=' ('+button.shortcut().toString(QKeySequence.NativeText)+')'
+        button.setToolTip(tooltip)
+        button.setStatusTip(tooltip)
 
     def disableTab_Vis(self,Flag=True):
         self.ui.w_Managing_Tabs.setEnabled(not Flag)
@@ -2245,10 +2807,12 @@ class gPaIRS(QMainWindow):
                 w.setEnabled(not Flag)
         self.w_Input.ui.button_back.setEnabled(not Flag)
         self.w_Input.ui.button_forward.setEnabled(not Flag)
+        self.ui.button_Run_CalVi.setVisible(not Flag)
         self.ui.button_Abort_CalVi.setVisible(Flag)
         self.setRunCalViButtonText(FlagRunning=Flag)
 
         self.ui.tabAreaWidget.FlagDisplayControls=not Flag
+        self.ui.tabAreaWidget.ui.button_restore_undo.setVisible(not Flag)
         self.ui.tabAreaWidget.ui.button_back.setVisible(not Flag)
         self.ui.tabAreaWidget.ui.button_forward.setVisible(not Flag)
         self.ui.tabAreaWidget.display_controls()
@@ -2259,7 +2823,7 @@ class gPaIRS(QMainWindow):
         self.w_Vis_CalVi.initDataFromGui(INP,PRO)
         inddel=self.w_Vis_CalVi.setImgFromGui()
         if len(inddel): #todo GP: migliorare? (setto due volte le immagini e faccio in calib il check)
-            Message=f'The following image files have sizes not compatible with the first image file of the list ({self.w_Input_CalVi.INPpar.filenames[0]}):\n'
+            Message=f'The following image files encountered issues while importing (they may have incompatible sizes with the first image file of the list "{self.w_Input_CalVi.INPpar.filenames[0]}" or be not in grayscale format):\n'
             for k in inddel:
                 if k==inddel[-1]: colon='.'
                 else: colon=';'
@@ -2276,7 +2840,6 @@ class gPaIRS(QMainWindow):
             self.w_Vis_CalVi.initDataFromGui(INP,PRO)
             self.w_Vis_CalVi.setImgFromGui()
 
-
 #********************************************* LEGACY
     def setUpdatingState(self,flagUpdating):
         if Flag_DISABLE_onUpdate: 
@@ -2318,7 +2881,7 @@ class gPaIRS(QMainWindow):
           parForMul.sleepTime=ParFor_sleepTime #time between calls of callBack
           self.pfPool=pfPool
           self.parForMul=parForMul
-          self.parForMul.numUsedCores=self.numUsedThreadsPIV # =NUMTHREADS_PIV#potrebbe essere minore di NUMTHREADS_PIV_MAX con cui è stato impostato
+          self.parForMul.numUsedCores=self.numMaxProcs # =NUMTHREADS_MAX#potrebbe essere minore di NUMTHREADS_PIV_MAX con cui è stato impostato
           self.FlagParPoolInit=True
           self.signals.parPoolInit.emit()
         f3.add_done_callback(initParForComplete)
@@ -2349,28 +2912,62 @@ class gPaIRS(QMainWindow):
     def spin_nworkers_action(self):
         val=self.ui.spin_nworkers.value() 
         self.GPApar.NumCores=val
-        if val <=NUMTHREADS_PIV_MAX:
-            self.numUsedThreadsPIV=val 
+        if val <=NUMTHREADS_MAX:
+            self.numMaxProcs=val 
 
 #*************************************************** Warnings
-    def warningDialog(self,Message,time_milliseconds=0,flagScreenCenter=False,icon=QIcon(),palette=None,pixmap=None,title='Warning!',flagRichText=False,flagNoButtons=False):
-        return warningDialog(self,Message,time_milliseconds,flagScreenCenter,icon,palette,pixmap,title,flagRichText,flagNoButtons)
+    def warningDialog(self,Message,time_milliseconds=0,flagScreenCenter=False,icon=QIcon(),palette=None,pixmap=None,title='Warning!',flagRichText=False,flagNoButtons=False,addButton:dict=None):
+        return warningDialog(self,Message,time_milliseconds,flagScreenCenter,icon,palette,pixmap,title,flagRichText,flagNoButtons,addButton)
 
     def questionDialog(self,Message):
         flagYes=questionDialog(self,Message)
         return flagYes
 
+#*************************************************** Checking
+    def checkProcesses(self,FlagInit=False,ind=None):
+        FlagCheck=ind is None
+        if ind is not None: projects=self.projectTree.itemList[1][ind[0]:ind[0]+1]
+        else: projects=self.projectTree.itemList[1]
+        for ITEs_project in projects:
+            if ind is not None: ITEs_project_ind=ITEs_project[ind[1]:ind[1]+1]
+            else: ITEs_project_ind=ITEs_project
+            for ITEs_tree in ITEs_project_ind:
+                if ind is not None: ITEs_tree_ind=ITEs_tree[ind[2]:ind[2]+1]
+                else: ITEs_tree_ind=ITEs_tree
+                for ITEs in ITEs_tree_ind:
+                    if ind is not None: ITEs_ind=ITEs[ind[3]+1:ind[3]+2]
+                    else: ITEs_ind=ITEs
+                    for ITE in ITEs_ind:
+                        ITE:ITEpar
+                        ITE.FlagInit=FlagInit
+                        indITE=ITE.ind
+                        if  ind is not None: FlagCheck=True
+                        for w in self.tabWidgets: 
+                            w:gPaIRS_Tab
+                            TABpar_ind:TABpar=w.TABpar_at(indITE)
+                            if TABpar_ind:
+                                if FlagInit:
+                                    w.checkTABpar(indITE)
+                                    w.setTABwarn(indITE)
+                                    TABpar_ind.FlagInit=True
+                                else:
+                                    TABpar_ind.FlagInit=False
+        return FlagCheck
+    
 #*************************************************** Projects
     def pauseQuestion(self,taskDescription='continuing',task=lambda:None,FlagFirstQuestion=False):
         if FlagFirstQuestion:
             if not self.questionDialog(f'Are you sure you want to proceed with {taskDescription}?'): 
                 return
-        if self.FlagRun:
-            if self.questionDialog(f'PaIRS is currently executing the processes in the current workspace. Do you want to pause them before {taskDescription}?'): 
+        if self.FlagRun or self.w_Vis_CalVi.VISpar.FlagRunning:
+            if self.FlagRun: currentTaskDescription='PaIRS is currently executing the processes in the current workspace. '
+            elif self.w_Vis_CalVi.VISpar.FlagRunning: currentTaskDescription='CalVi is currently running. '
+            if self.questionDialog(f'{currentTaskDescription}Do you want to pause them before {taskDescription}?'): 
                 if self.FlagRun: self.button_run_pause_action()
                 self.setEnabled(False)
                 self.completingTask=task
                 self.waitingDialog=self.warningDialog('Please, wait while stopping the running processes!',pixmap=''+ icons_path +'sandglass.png',flagNoButtons=True)
+                if self.w_Vis_CalVi.VISpar.FlagRunning: self.abortCalVi()
         else:
             task()
         return
@@ -2381,15 +2978,19 @@ class gPaIRS(QMainWindow):
                 #dir=self.w_Input.INPpar.path,\
                 options=optionNativeDialog)
         if not filename: return
+        errorString=''
         try:
-            data=loadList(filename)
-        except Exception as inst:
+            data, errorMessage=loadList(filename)
+            errorString+=errorMessage
+        except:
+            errorString+=traceback.format_exc()
+        if errorString:
             WarningMessage=f'Error with loading the file: {filename}\n'
             warningDialog(self,WarningMessage)
-            pri.Error.red(f'{WarningMessage}\n{traceback.format_exc()}\n')
+            pri.Error.red(f'{WarningMessage}\n{errorString}\n')
         try:
             ind=self.projectTree.topLevelItemCount()
-            insert_at_depth(self.projectTree.itemList,self.projectTree.listDepth,[ind],data)
+            insert_at_depth(self.projectTree.itemList,self.projectTree.listDepth,ind,data)
             self.modifyWorkspace()
             TRE:TREpar=self.projectTree.itemList[0][ind]
             TRE.project=ind
@@ -2418,6 +3019,11 @@ class gPaIRS(QMainWindow):
             filename=filename+ext
         if FlagSave:saveList(filename)
         return filename
+
+    def updateWorkspaceTitle(self):
+        self.GPApar.name=self.ui.title_workspace.label.text().replace(self.GPApar.saveBullet(),'')
+        self.GPApar.FlagSaved=False
+        self.adjustWorkspaceHeader()
         
     def save_current_project(self,filename):
         Project=[]
@@ -2473,18 +3079,21 @@ class gPaIRS(QMainWindow):
             self.pauseQuestion('copying the selected process',lambda: ProcessTree.button_copy_action(self.processTree))
 
     def delete_process(self):
-        if self.ui.Explorer.ITEpar.FlagQueue and self.ui.Explorer.currentTree==self.processTree:
+        if self.ui.Explorer.currentTree==self.processTree:
+            #if self.ui.Explorer.ITEpar.FlagQueue: self.ui.Explorer.ITEpar.FlagQueue=False
             self.pauseQuestion('deleting the selected process',lambda: ProcessTree.button_delete_action(self.processTree))
     
     def clean_processes(self):
         if self.ui.Explorer.currentTree==self.processTree:
             self.pauseQuestion('cleaning the whole process list',lambda: ProcessTree.button_clean_action(self.processTree))
 
-#*************************************************** Menus
-#********************* File
+#*************************************************** Sizes, font & layout
     def updateGPAparGeometry(self):
         self.GPApar.Geometry=self.saveGeometry().toBase64().data().decode()
         self.GPApar.WindowState=self.saveState().toBase64().data().decode()
+        #g=self.geometry()
+        #self.GPApar.Geometry=[g.x(), g.y(), g.width(), g.height()]
+        #self.GPApar.WindowState=[self.windowState().value,self.windowState().name]
         splitterSizes={}
         for s in self.ui.Explorer.findChildren(QSplitter)+[self.ui.main_splitter,self.ui.Operating_Tabs_splitter]:
             s:QSplitter
@@ -2498,13 +3107,129 @@ class gPaIRS(QMainWindow):
             scrollAreaValues[a.objectName()]=[a.horizontalScrollBar().value(),a.verticalScrollBar().value()]
         self.GPApar.ScrollAreaValues=scrollAreaValues
         return
+        
+    def setFontPixelSize(self):
+        if self.fontPixelSize==self.GPApar.fontPixelSize: return
+        fPixSize=self.GPApar.fontPixelSize
+        font=QFont()
+        font.setFamily(fontName)
+        font.setPixelSize(fPixSize)
+        if self.app: self.app.setFont(font)
+        setFontPixelSize(self,fPixSize)
+        self.setFurtherFontPixelSizes(fPixSize)
+        if self.aboutDialog:
+            self.aboutDialog.fontPixelSize=self.GPApar.fontPixelSize
+            self.aboutDialog.setFontSizeText()
+        if self.logChanges: self.logChanges.setFontPixelSize(fPixSize)
+        if self.menuDebug: self.menuDebug.setFont(self.ui.menuFile.font())
+        self.fontPixelSize=fPixSize
+    
+    def setFurtherFontPixelSizes(self,fPixSize):
+        self.setTabFontPixelSize(fPixSize)
+
+        lab:QLabel=self.ui.title
+        fPixSize_TabNames=min([fPixSize*2,30])
+        font=lab.font()
+        font.setFamily(fontName)
+        font.setPixelSize(fPixSize_TabNames)
+        lab.setFont(font)
+        self.ui.title_workspace.setFont(font)
+        
+        lab:QLabel=self.ui.subtitle
+        font=lab.font()
+        font.setFamily(fontName)
+        font.setPixelSize(fPixSize+4)
+        lab.setFont(font)
+        self.ui.subtitle_workspace.setFont(font)
+
+        lab:QLabel=self.onlyReadLabel
+        font=lab.font()
+        font.setFamily(fontName)
+        font.setPixelSize(fPixSize+1)
+        lab.setFont(font)
+
+        self.ui.projectPage.setFontPixelSize(fPixSize)
+        self.ui.processPage.setFontPixelSize(fPixSize)
+        self.ui.stepPage.setFontPixelSize(fPixSize)
+
+        self.w_Log.setLogFont(fontPixelSize-dfontLog)
+        self.w_Vis_CalVi.setLogFont(fontPixelSize-dfontLog)
+
+    def setTabFontPixelSize(self,fPixSize):
+        fPixSize_TabNames=min([fPixSize*2,30])
+        for w in self.ui.tabAreaWidget.widgets:
+            setFontPixelSize(w,fPixSize)
+            w:gPaIRS_Tab
+            for lab in w.findChildren(QLabel):
+                lab:QLabel
+                if 'name_tab' in lab.objectName():
+                    #lab:QLabel=w.ui.name_tab
+                    font=lab.font()
+                    font.setPixelSize(fPixSize_TabNames)
+                    lab.setFont(font)
+
+    def falseShow(self):
+        FlagHidden=not self.isVisible()
+        total_rect = QGuiApplication.primaryScreen().geometry()
+        for screen in QGuiApplication.screens():
+            total_rect = total_rect.united(screen.geometry())
+        self.move(total_rect.right() + 100, total_rect.bottom() + 100)
+        self.updateGeometry()
+        self.show()
+        self.repaint()
+        return FlagHidden
+    
+    def setDefaultSizes(self):
+        margins=self.ui.centralLayout.contentsMargins()
+        main_splitter_sizes=[self.ui.w_Managing_Tabs.baseSize().width(),self.ui.tabAreaWidget.widgetMinimumWidth*2+self.ui.tabAreaWidget.margin*2+self.ui.tabAreaWidget.handleWidth*2] #processTree, main_sep, tabAreaWidget
+        w=margins.left()+self.ui.main_splitter.handleWidth()*2+sum(main_splitter_sizes)+margins.right()
+        h=margins.top()+self.ui.w_header.minimumHeight()+self.ui.tabAreaWidget.tabAreaHeight+self.ui.tabAreaWidget.buttonSize[1]+self.ui.tabAreaWidget.buttonSpacing+self.ui.tabAreaWidget.margin*2+self.ui.w_Operating_Tabs.layout().spacing()+self.ui.statusbar.minimumHeight()+margins.bottom()
+        self.resize(w,h)
+        self.ui.main_splitter.setSizes(main_splitter_sizes)
+        self.updateGeometry()
+        x=(self.maximumGeometry.width()-w)*0.5
+        y=(self.maximumGeometry.height()-h)*0.5
+        if self.falseShow(): self.hide()
+        self.move(x,y)
+        self.app.processEvents()
+        self.updateGPAparGeometry()
+        
+    def setGPaIRSTitle(self):
+        cfgString=f': {self.GPApar.outName}' if self.GPApar.outName and self.GPApar.outName!=lastcfgname else ''
+        if not self.GPApar.FlagSaved: cfgString+='*'
+        if Flag_DEBUG:#TA per non incasinarmi
+            windowTitle=f'PaIRS (v{version}.{__subversion__} - {__date__}) -- cfg v{uicfg_version} -- PIV {self.PIVvers} -- {platform.system()} -- Python {platform.python_version()}'
+        else:
+            windowTitle=f'PaIRS (v{version})'
+        windowTitle+=cfgString
+        self.setWindowTitle(windowTitle)
 
+#*************************************************** Menus
+#********************* File
     def setGPAlayout(self):
+        self.setFontPixelSize()
+        self.setGPaIRSPalette()
+    
         geometry=QByteArray.fromBase64(self.GPApar.Geometry.encode())
         self.restoreGeometry(geometry)
+        #if isinstance(self.GPApar.Geometry,list) and len(self.GPApar.Geometry)==4:
+        #    g=self.GPApar.Geometry
+        #    try:
+        #        self.setGeometry(g[0],g[1],g[2],g[3])
+        #    except:
+        #        pri.Info.yellow(f'Error while restoring geometry:\n{traceback.format_exc()}\n\nDefault sizes will be set!\n\n')
+        #       self.setDefaultSizes()
+        #else:
+        #    self.setDefaultSizes()
+        
         windowState = QByteArray.fromBase64(self.GPApar.WindowState.encode())
         self.restoreState(windowState)
-        
+        #try:
+        #    s=self.GPApar.WindowState
+        #    self.setWindowState(Qt.WindowState(s[0]))
+        #except:
+        #    pri.Info.yellow(f'Error while restoring window state:\n{traceback.format_exc()}\n\nDefault window state will be set!\n\n')
+            
         for s in self.ui.Explorer.findChildren(QSplitter)+[self.ui.main_splitter,self.ui.Operating_Tabs_splitter]:
             s:QSplitter
             if s.objectName() in self.GPApar.SplitterSizes:
@@ -2515,13 +3240,11 @@ class gPaIRS(QMainWindow):
                 scrollAreaValues=self.GPApar.ScrollAreaValues[a.objectName()]
                 a.horizontalScrollBar().setValue(scrollAreaValues[0])
                 a.verticalScrollBar().setValue(scrollAreaValues[1])
-        self.setFontPixelSize()
-        self.setGPaIRSPalette()
         self.setNumCores()
 
     def setNumCores(self):
-        if self.GPApar.NumCores >NUMTHREADS_PIV_MAX:
-            self.GPApar.NumCores=NUMTHREADS_PIV_MAX
+        if self.GPApar.NumCores >NUMTHREADS_MAX:
+            self.GPApar.NumCores=NUMTHREADS_MAX
         self.numTotUsedThreads=self.GPApar.NumCores  
         self.ui.spin_nworkers.setValue(self.GPApar.NumCores) 
 
@@ -2560,32 +3283,27 @@ class gPaIRS(QMainWindow):
                     #dir=self.w_Input.INPpar.path,\
                     options=optionNativeDialog)
         if not filename: return
-        waitingWindow=warningDialog(self,'Please, wait while retrieving previous workspace!\nIf this action takes too much time, please consider to close the workspace before quitting PaIRS next time)',pixmap=''+ icons_path +'sandglass.png',flagNoButtons=True,flagScreenCenter=True)
+        waitingWindow=warningDialog(self,'Please, wait while retrieving previous workspace!\n(If this action takes too much time, please consider to close the workspace before quitting PaIRS next time.)',pixmap=''+ icons_path +'sandglass.png',flagNoButtons=True,flagScreenCenter=True)
         self.app.processEvents()
+        errorString=''
         try:
-            data=loadList(filename)
+            data, errorMessage=loadList(filename)
+            errorString+=errorMessage
             pri.Time.cyan('Open workspace: load')
-        except Exception as inst:
+        except:
+            errorString+=traceback.format_exc()
+        if errorString:
             WarningMessage=f'Error with loading the file: {filename}\n'
             warningDialog(self,WarningMessage)
-            pri.Error.red(f'{WarningMessage}\n{traceback.format_exc()}\n')
+            pri.Error.red(f'{WarningMessage}\n{errorString}\n')
         try:
             self.projectTree.clean_action()
-            all_indexes=[i for i in range(len(data[2]))]
-            insert_at_depth(self.projectTree.itemList,self.projectTree.listDepth,all_indexes,data[2])
-            for ITEs_project in self.projectTree.itemList[1]:
-                for ITEs_tree in ITEs_project:
-                    for ITEs in ITEs_tree:
-                        for ITE in ITEs:
-                            ITE:ITEpar
-                            ITE.FlagInit=False
-                            for w in self.tabWidgets:
-                                w:gPaIRS_Tab
-                                TABpar_ind:TABpar=w.TABpar_at(ITE.ind)
-                                if TABpar_ind: TABpar_ind.FlagInit=False
+            #all_indexes=[i for i in range(len(data[2]))]
+            insert_at_depth(self.projectTree.itemList,self.projectTree.listDepth,0,data[2])
+            self.checkProcesses()
             self.ui.Explorer.ITEpar.FlagInit=False
-            for ind in range(len(self.projectTree.itemList[0])):
-                self.projectTree.createProjectItem(ind,FlagNewItem=False)
+            for _ in range(len(self.projectTree.itemList[0])):
+                self.projectTree.createProjectItem(FlagNewItem=False)
             """
             item=self.projectTree.topLevelItem(0)
             self.projectTree.setCurrentItem(item)
@@ -2599,11 +3317,12 @@ class gPaIRS(QMainWindow):
             #    self.move(0, -1e6) #todo: capire come aggiornare la geometria senza lo show
             #    self.show()
             pri.Time.cyan('Open workspace: set data')
-            self.TREpar.step=None
+            #self.TREpar.step=None
+            #FlagShown=self.falseShow()
+            if FlagSetGeometry: self.setGPAlayout()
             self.adjustProjectSelection()
-            #self.ui.Explorer.selectStep()
+            #if FlagShown: self.hide()
             pri.Time.cyan('Open workspace: selection')
-            if FlagSetGeometry: self.setGPAlayout()
             pri.Time.cyan('Open workspace: geometry (end)')
         except Exception as inst:
             if filename==lastcfgname:
@@ -2626,7 +3345,10 @@ class gPaIRS(QMainWindow):
 
     def save_current_workspace(self,filename,FlagAdjustHeader=True):
         self.updateGPAparGeometry()
-        if filename!=lastcfgname: self.GPApar.outName=filename
+        if filename!=lastcfgname: 
+            if not self.GPApar.outName:
+                self.GPApar.name=os.path.splitext(os.path.basename(filename))[0]
+            self.GPApar.outName=filename
         self.GPApar.savedDate=currentTimeString()
         self.GPApar.FlagSaved=True
         Workspace=[self.GPApar.duplicate(),self.TREpar.duplicate(),self.projectTree.itemList]
@@ -2676,6 +3398,11 @@ class gPaIRS(QMainWindow):
         url = QUrl("https://www.pairs.unina.it/web/PaIRS-UniNa-v020-Guide.pdf")
         QDesktopServices.openUrl(url)
 
+    def downloadApp(self):
+        #url = QUrl("http://wpage.unina.it/etfd/PaIRS/PaIRS-UniNa-Guide.pdf")
+        url = QUrl(EXEurl)
+        QDesktopServices.openUrl(url)
+
     def about(self):
         if self.aboutDialog:
             self.aboutDialog.hide()
@@ -2702,16 +3429,26 @@ class gPaIRS(QMainWindow):
 
         self.ui.aDeleteLastCfg = self.menuDebug.addAction("Delete lastWorkspace"+outExt.cfg)
         def delete_lastcfg():
-            os.remove(lastcfgname)
-            pri.Info.white(f'    xxxxx Deleting last ui configuration file:\t{lastcfgname}')
+            if os.path.exists(lastcfgname):
+                os.remove(lastcfgname)
+                pri.Info.white(f'    xxxxx Deleting last ui configuration file:\t{lastcfgname}')
+            else:
+                 pri.Info.white(f'    xxxxx Last ui configuration file:\t{lastcfgname}\t already deleted!')
         self.delete_lastcfg=delete_lastcfg
         self.ui.aDeleteLastCfg.triggered.connect(delete_lastcfg)
 
+        self.ui.aReloadLastCfg = self.menuDebug.addAction("Reload lastWorkspace"+outExt.cfg)
+        def reloadLastCfg():
+            if os.path.exists(lastcfgname): self.initialize()
+            else: self.new_workspace_debug()
+        self.ui.aReloadLastCfg.triggered.connect(reloadLastCfg)
+
         #--------------------------- printings
         self.menuDebug.addSeparator()
         self.ui.printMenu=self.menuDebug.addMenu('Print')
         printTypes_list=list(self.GPApar.printTypes)
         printActions=[]
+        printCallbacks=[]
         def setPrint(name,act,k):
             flag=act.isChecked()
             self.GPApar.printTypes[name]=flag
@@ -2728,8 +3465,13 @@ class gPaIRS(QMainWindow):
             n=name
             a=act
             j=k
-            return lambda: setPrint(n,a,j)
+            def callback():
+                setPrint(n,a,j)
+                self.menuDebug.popup(self.menuDebug.pos())
+                self.ui.printMenu.exec_()
+            return callback
         for k,name in enumerate(printTypes_list):
+            if not hasattr(pri,name): continue
             flagFullDebug=getattr(getattr(pri,name),'flagFullDebug')
             if flagFullDebug and not Flag_fullDEBUG: continue
             act=self.ui.printMenu.addAction(name)
@@ -2738,8 +3480,22 @@ class gPaIRS(QMainWindow):
             flag=self.GPApar.printTypes[name]
             act.setChecked(flag)
             setPrint(name,act,k)
-            act.triggered.connect(genCallback(name,act,k))
-
+            printCallbacks.append(genCallback(name,act,k))
+            act.triggered.connect(printCallbacks[-1])
+        self.ui.printMenu.addSeparator()
+        allPrintsAct=self.ui.printMenu.addAction('All printings')
+        allPrintsAct.setCheckable(True)
+        def setAllPrints():
+            flag=allPrintsAct.isChecked()
+            for a in printActions:
+                a:QAction
+                a.setChecked(flag)
+                setPrint(a.text(),a,None)   
+            self.menuDebug.popup(self.menuDebug.pos())
+            self.ui.printMenu.exec_()
+            return  
+        allPrintsAct.triggered.connect(setAllPrints)
+        
         #--------------------------- operation
         if Flag_fullDEBUG:
             self.menuDebug.addSeparator()
@@ -2760,14 +3516,25 @@ class gPaIRS(QMainWindow):
                 self.ui.button_PaIRS_download.setVisible(not self.ui.button_PaIRS_download.isVisible())
             self.ui.aShowDownload.triggered.connect(aShowDownload)
 
+            self.ui.aBetaDownload = self.menuDebug.addAction("Change download button icon")
+            def aBetaDownload():
+                b=self.ui.button_PaIRS_download
+                if  b.icon().pixmap(b.size()).toImage()==self.flaticon_PaIRS_download.pixmap(b.size()).toImage():
+                    b.setIcon(self.flaticon_PaIRS_beta)
+                else:
+                    b.setIcon(self.flaticon_PaIRS_download)
+            self.ui.aBetaDownload.triggered.connect(aBetaDownload)
+
             self.ui.aResetFlagOutDated = self.menuDebug.addAction("Reset FlagOutDated")
             def aResetFlagOutDated():
-                self.GPApar.FlagOutDated=0 if self.GPApar.currentVersion==self.GPApar.latestVersion else 1
+                self.GPApar.FlagOutDated=0 if self.GPApar.currentVersion==self.GPApar.latestVersion else 1 if self.GPApar.FlagOutDated>0 else -1
                 packageName='PaIRS-UniNa'
                 currentVersion=self.GPApar.currentVersion
                 latestVersion=self.GPApar.latestVersion
                 if self.GPApar.FlagOutDated==1:
                     sOut=f'{packageName} the current version ({currentVersion}) of {packageName} is obsolete! Please, install the latest version: {latestVersion} by using:\npython -m pip install --upgrade {packageName}'
+                elif self.GPApar.FlagOutDated==1:
+                    sOut=f'The version of the current instance of {packageName} ({currentVersion}) is newer than the latest official releas ({latestVersion})!\nYou should contact Tommaso and Gerardo if you are a developer and some relevant change is made by yourself!\nIf you are a user, enjoy this beta version and please report any issue!'
                 else:
                     sOut=f'{packageName} The current version ({currentVersion}) of {packageName} is up-to-date! Enjoy it!'
                 pri.Info.yellow(f'[{self.GPApar.FlagOutDated}] '+sOut) 
@@ -2792,7 +3559,7 @@ class gPaIRS(QMainWindow):
 
             self.ui.aShowWhatsNew = self.menuDebug.addAction("Show What's new window")
             def aShowWhatsNew():
-                whatsNew(self)
+                self.whatsNew()
             self.ui.aShowWhatsNew.triggered.connect(aShowWhatsNew)
 
             self.menuDebug.addSeparator()
@@ -2805,14 +3572,40 @@ class gPaIRS(QMainWindow):
 
             self.ui.aFocusWid = self.menuDebug.addAction("Print widget with focus")
             def aFocusWid():
-                pri.General.yellow(f"The widget with focus is:   {self.focusWidget()}")
+                pri.Info.yellow(f"The widget with focus is:   {self.focusWidget()}")
             self.aCheckConnections=aFocusWid
             self.ui.aFocusWid.triggered.connect(aFocusWid)
+
+            if not Flag_ISEXE:
+                self.menuDebug.addSeparator()
+                self.ui.aResetRequiredPackagesFile = self.menuDebug.addAction("Reset rqrdpckgs.txt file")
+                def aResetRequiredPackagesFile():
+                    resetRequiredPackagesFile()
+                self.ui.aResetRequiredPackagesFile.triggered.connect(aResetRequiredPackagesFile)
+                
+                self.ui.aCheckRequiredPackages = self.menuDebug.addAction("Requirements' version check")
+                def aCheckRequiredPackages():
+                    checkRequiredPackages(self,FlagDisplay=True)
+                self.ui.aCheckRequiredPackages.triggered.connect(aCheckRequiredPackages)
+
+                self.ui.aShowPackIssue = self.menuDebug.addAction("Show/hide version check button")
+                def aShowPackIssue():
+                    self.FlagPackIssue=not self.FlagPackIssue
+                    self.ui.button_packissue.setVisible(self.FlagPackIssue)
+                self.ui.aShowPackIssue.triggered.connect(aShowPackIssue)
+
+                self.ui.aTryCheckRequiredPackages = self.menuDebug.addAction("Try requirements' version check")
+                def aTryCheckRequiredPackages():
+                    checkRequiredPackages(self,FlagDisplay=True,FlagForcePrint=True)
+                self.ui.aTryCheckRequiredPackages.triggered.connect(aTryCheckRequiredPackages)
         
         #--------------------------- graphics
         if Flag_fullDEBUG:
             self.menuDebug.addSeparator()
 
+            self.ui.aDefSizes = self.menuDebug.addAction("Set default sizes")
+            self.ui.aDefSizes.triggered.connect(self.setDefaultSizes)
+
             self.ui.aUndock = self.menuDebug.addAction("Undock a widget")
             self.ui.aUndock.triggered.connect(self.extractWidget)
 
@@ -2835,7 +3628,9 @@ class gPaIRS(QMainWindow):
     def extractWidget(self):
         title="Undock a widget"
         label="Enter the widget name:"
-        words = ["self.w_Import", "self.w_Export", 
+        words = ["self.w_Input", 
+        "self.w_Input.ui.CollapBox_ImSet",
+        "self.w_Output", 
         "self.w_Process", 
         "self.w_Process.ui.CollapBox_IntWind",
         "self.w_Process.ui.CollapBox_FinIt",
@@ -2843,9 +3638,12 @@ class gPaIRS(QMainWindow):
         "self.w_Process.ui.CollapBox_Interp",
         "self.w_Process.ui.CollapBox_Validation",
         "self.w_Process.ui.CollapBox_Windowing",
-        "self.w_Vis","self.w_Vis.ui.CollapBox_PlotTools", 
-        "self.ui.w_Managing_Tabs","self.w_Tree",
-        "self.w_Log","self.ui.w_Buttons",
+        "self.w_Vis", "self.w_Vis.ui.CollapBox_PlotTools", 
+        "self.w_Process", "self.w_Log",
+        "self.w_Process_Min","self.w_Process_Disp",
+        "self.w_Calibration",
+         "self.w_Input_CalVi", "self.w_Process_CalVi", "self.w_Vis_CalVi",
+        "self.ui.w_Managing_Tabs",
         ]
         
         ok,text=inputDialog(self,title,label,completer_list=words,width=500)
@@ -2882,6 +3680,19 @@ class gPaIRS(QMainWindow):
         self.setGPaIRSTitle()
         self.menuDebug.menuAction().setVisible(Flag)
 
+    def setButtonDownload(self,):
+        self.ui.button_PaIRS_download.setVisible(self.GPApar.FlagOutDated!=0)
+        if self.GPApar.FlagOutDated>0:
+            self.ui.button_PaIRS_download.setIcon(self.flaticon_PaIRS_download)
+            self.ui.button_PaIRS_download.setToolTip("Download the latest version of PaIRS-UniNa.")
+        elif self.GPApar.FlagOutDated==-1000:
+            self.ui.button_PaIRS_download.setIcon(self.flaticon_PaIRS_download_warning)
+            self.ui.button_PaIRS_download.setToolTip("Issue with verifying the latest release!")
+        else:
+            self.ui.button_PaIRS_download.setIcon(self.flaticon_PaIRS_beta)
+            self.ui.button_PaIRS_download.setToolTip("A beta version is currently used!")
+        self.ui.button_PaIRS_download.setStatusTip(self.ui.button_PaIRS_download.toolTip())
+
 #*************************************************** Greetings
     def setupLogo(self):
         today = datetime.date.today()
@@ -2892,6 +3703,8 @@ class gPaIRS(QMainWindow):
             ['05/02/1969', 'Happy birthday to Tommaso! 🎈🎂🍾'],
             ['11/07/1987', 'Happy birthday to Carlo! 🎈🎂🍾'],
             ['19/09/1963', 'Happy birthday to Gennaro! 🎈🎂🍾'],
+            ['27/11/1940', 'Happy birthday to prof. Carlomagno! 🎈🎂🍾'],
+            ['01/12/1969', 'Happy birthday to Giuseppe S.! 🎈🎂🍾'],
             ['18/10/1985', 'Happy birthday to Stefano! 🎈🎂🍾'],
             ['13/08/1985', 'Happy birthday to Andrea! 🎈🎂🍾'],
             ['22/12/1988', 'Happy birthday to Jack! 🎈🎂🍾'],
@@ -2899,6 +3712,13 @@ class gPaIRS(QMainWindow):
             ['03/11/1989', 'Happy birthday to Massimo! 🎈🎂🍾'],
             ['15/06/1991', 'Happy birthday to Mattia! 🎈🎂🍾'],
             ['14/07/1993', 'Happy birthday to Mirko! 🎈🎂🍾'],
+            ['13/03/1997', 'Happy birthday to Giosuè! 🎈🎂🍾'],
+            ['24/09/1998', 'Happy birthday to Piergiorgio! 🎈🎂🍾'],
+            ['15/01/1999', 'Happy birthday to Alessandro! 🎈🎂🍾'],
+            ['20/02/1999', 'Happy birthday to Cristina! 🎈🎂🍾'],
+            ['20/09/2000', 'Happy birthday to Antonio M.! 🎈🎂🍾'],
+            ['21/09/2000', 'Happy birthday to Gabriele! 🎈🎂🍾'],
+            ['16/11/2000', 'Happy birthday to Antonio D.! 🎈🎂🍾'],
             ['01/01', 'Happy New Year! 🎊🧨'],
             ['25/12', 'Merry Christmas! 🎄✨'],
             ['31/10', 'Happy Halloween! 🎃👻'],
@@ -2921,6 +3741,34 @@ class gPaIRS(QMainWindow):
             self.ui.logo.setPixmap(QPixmap(u""+ icons_path +"logo_PaIRS_rect.png"))
             self.ui.lab_happy_days.hide()
 
+    def startHappyLogoWatcher(self):
+        """Re-check date at next midnight and periodically as keep-alive."""
+        # one-shot timer to just-after-midnight (00:01)
+        def _schedule_midnight():
+            now=QDateTime.currentDateTime()
+            next_day = now.date().addDays(1)
+            next_midnight = QDateTime(next_day, QTime(0, 0))        
+            msec=now.msecsTo(next_midnight.addSecs(60))     # 00:01
+            if msec<60_000: msec=60_000                    # safety minimum
+            self._happy_midnight=QTimer(self)
+            self._happy_midnight.setSingleShot(True)
+            self._happy_midnight.timeout.connect(_on_tick)
+            self._happy_midnight.start(msec)
+
+        def _on_tick():
+            # Re-apply logo state and reschedule
+            self.setupLogo()
+            _schedule_midnight()
+
+        # keep-alive each few hours (handles sleep/wake or clock drift)
+        self._happy_keepalive=QTimer(self)
+        self._happy_keepalive.setInterval(3*60*60*1000)     # 3h
+        self._happy_keepalive.timeout.connect(self.setupLogo)
+        self._happy_keepalive.start()
+
+        # initial schedule
+        _schedule_midnight()
+
     def happyLogo(self):
         self.FlagHappyLogo=not self.FlagHappyLogo
         if self.FlagHappyLogo:
@@ -2930,7 +3778,7 @@ class gPaIRS(QMainWindow):
         else:
             self.ui.logo.setPixmap(QPixmap(u""+ icons_path +"logo_PaIRS_rect.png"))
             self.ui.lab_happy_days.hide()
-
+    
 #*************************************************** Palette
     def setGPaIRSPalette(self):
         setAppGuiPalette(self,self.palettes[self.GPApar.paletteType])
@@ -2967,7 +3815,7 @@ def launchPaIRS(flagDebug=False,flagInputDebug=False):
             import ctypes
             ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID('PaIRS')
     except:
-        pri.General.red('It was not possible to set the application icon')
+        pri.Info.red('It was not possible to set the application icon')
 
     if not flagDebug or Flag_SHOWSPLASH:
         splash=showSplash()
@@ -2983,15 +3831,16 @@ def launchPaIRS(flagDebug=False,flagInputDebug=False):
         if p.flagFullDebug and not Flag_fullDEBUG:
             p.prio=PrintTAPriority.never
             p.setPrints()
+    
+    if FlagAddMotherBoard and Flag_fullDEBUG:
+        pri.Info.yellow(f"{'-'*50}\nHi, developer!\nMaybe it could be useful for you to add the current computer identifier:\n{currentID}\nto the 'developerIDs' dictionary in PaIRS_pypacks.py!\n{'-'*50}\n")
         
     if flagInputDebug:
         _,text=inputDialog(None,'Debug','Insert password for debug mode:',icon=icon,palette=standardPalette,width=300)
         flagDebug=text==pwddbg
         if not flagDebug:
             warningDialog(None,'Password for debug mode is wrong!\nPaIRS will be started in normal mode.',icon=icon,time_milliseconds=5000)
-    gui=gPaIRS(flagDebug,app)
-    gui.palettes[2]=standardPalette
-    gui.setGPaIRSPalette()
+    gui=gPaIRS(flagDebug,app, standardPalette)
 
     currentVersion=__version__ #if __subversion__=='0' else  __version__+'.'+__subversion__
     flagStopAndDownload=checkLatestVersion(gui,currentVersion,app,splash)
@@ -3016,7 +3865,12 @@ def launchPaIRS(flagDebug=False,flagInputDebug=False):
         splashAnimation(splash,gui.ui.logo)
         #QTimer.singleShot(time_showSplashOnTop,splash.hide)
     print('\nWelcome to PaIRS!\nEnjoy it!')
-    if os.path.exists(fileWhatsNew[0]): whatsNew(gui)
+    if not getattr(sys, 'frozen', False): #made by pyInstaller
+        checkRequiredPackages(gui)
+    else:
+        gui.FlagPackIssue=False
+    gui.ui.button_packissue.setVisible(gui.FlagPackIssue)
+    if os.path.exists(fileWhatsNew[0]): gui.whatsNew()
     app.exec()
     return [app,gui,True]
 
@@ -3041,7 +3895,7 @@ def splashAnimation(self:QLabel,logo:QLabel):
     self.anim_group.finished.connect(self.hide)
     self.anim_group.finished.connect(logo.show)
     self.anim_group.start()
-    
+
 def quitPaIRS(app:QApplication,flagPrint=True):
     app.setWindowIcon(app.pyicon)
     app.quit()