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

PaIRS_UniNa/TabTools.py

@@ -8,55 +8,82 @@ Num_Prevs_back_forw=10
 FlagAsyncCallbacks=True
 FlagSimulateError=False
 globExecutor = concurrent.futures.ThreadPoolExecutor(max_workers=10)  
+
+indParGlob=0
 class TABpar:
-    def __init__(self,*args): 
-        if len(args):
-            self.name=args[0]
-        else:
-            self.name=str(uuid.uuid4())[:8]
-        if len(args)>1:
-            self.surname=args[1]
-        else:
-            self.surname=str(uuid.uuid4())[:8]
-        self.ind=0   #fondamentale che sia 0
-        self.indItem=0
-        self.indTree=0
+    #indParGlob=0
+    FlagSettingPar=False
+    FlagInit=False
+
+    def __init__(self,name=str(uuid.uuid4())[:8],surname=str(uuid.uuid4())[:8]): 
+        self.uiFields=[f for f,_ in self.__dict__.items()]
+
+        self.name=name
+        self.surname=surname
+        self.ind=[0,0,0,0,0]   #project, tree, item, subitem, do/undo
         self.tip='...'
+        self.parentTab=None
+        self.FlagNone=False
+        self.flagRun=0      #0:not launched yet, 1:completed, -1:interrupted, -2:running
+        self.link=[]
+        
+        self.parFields=[f for f,_ in self.__dict__.items() if f not in self.uiFields ]
+        self.uncopied_fields=['tip']
+        self.unchecked_fields=['name','surname','parentTab']+self.uncopied_fields
+        
+        self.OptionDone=1
+        self.warningMessage=''
 
         self.fields=[f for f,_ in self.__dict__.items()]
-        self.uncopied_fields=['tip']
-        self.unchecked_fields=['name','surname']+self.uncopied_fields
         pass
 
-    def printPar(self,*args):
+    def setNone(self):
+        for f in self.fields:
+            setattr(self,f,None)
+
+    def printPar(self,before='',after=''):
         before=after=''
-        if len(args)>0: before=args[0]
-        if len(args)>1: after=args[1]
         print(before+str(self.__dict__)+after)
 
     def duplicate(self):
-        newist=type(self)()
+        if hasattr(self,'Process') and hasattr(self,'Step'):
+            newist=type(self)(Process=self.Process,Step=self.Step)
+        else:
+            newist=type(self)()
         for f in self.fields:
+            if f in self.uncopied_fields: continue
             a=getattr(self,f)
             if  hasattr(a,'duplicate'): #type(a)==patternInfoList:
                 setattr(newist,f,a.duplicate())
             else:
                 setattr(newist,f,copy.deepcopy(a))
         return newist
+    
+    def copyfromdiz(self,diz:dict):
+        for f,a in diz.items():
+            if hasattr(a,'duplicate'):
+                if hasattr(a,'isDifferentFrom') and hasattr(self,f): 
+                    b=getattr(self,f)
+                    flag=a.isDifferentFrom(b,FlagPrint=False)
+                else: flag=True
+                if flag: setattr(self,f,a.duplicate())
+            else:
+                setattr(self,f,copy.deepcopy(a))
 
-    def copyfrom(self,newist,*args):
-        """
-        #args=exceptions
-        """
-        self.copyfromdiz(newist,self.fields,*args)
+    def copyfrom(self,newist,exceptions=None):
+        if newist is None:
+            self.FlagNone=True
+        else:
+            self.copyfromfields(newist,self.fields,exceptions)
 
-    def copyfromdiz(self,newist,diz,*args):
+    def copyfromfields(self,newist,fields=None,exceptions=None):
         """
-        #args=exceptions
+        exceptions=[] --> no exceptions
         """
-        exceptions=self.uncopied_fields
-        if len(args): exceptions=args[0]
-        for f in diz:
+        newist:TABpar
+        if exceptions is None:
+            exceptions=self.uncopied_fields
+        for f in fields:
             if f in exceptions: continue
             if not hasattr(self,f):
                 pri.Error.red(f'copyfromdiz: field <{f}> is missing in {self.name} par structure!')
@@ -65,29 +92,24 @@ class TABpar:
                 pri.Error.red(f'copyfromdiz: field <{f}> is missing in {newist.name} par structure!')
                 continue
             a=getattr(newist,f)
-            b=getattr(self,f)
             if hasattr(a,'duplicate'): #type(a)==patternInfoList:
-                if hasattr(a,'isDifferentFrom'): flag=a.isDifferentFrom(b,[],[])
+                if hasattr(a,'isDifferentFrom') and hasattr(self,f):
+                    b=getattr(self,f)
+                    flag=a.isDifferentFrom(b,FlagPrint=False)
                 else: flag=True
                 if flag: setattr(self,f,a.duplicate())
             else:
-                if a!=f:
-                    setattr(self,f,copy.deepcopy(a))
+                setattr(self,f,copy.deepcopy(a))
     
-    def isDifferentFrom(self,v,*args):
-        """
-        #args=exceptions,fields,FlagStrict
-        """
-        exceptions=[]
-        fields=self.fields
-        FlagStrictDiff=False 
-        if len(args): 
-            exceptions=args[0]
-            if len(args)>1: 
-                if len(args[1]):
-                    fields=args[1]           
-            if len(args)>2: FlagStrictDiff=args[2] 
-        if FlagStrictDiff: exceptions+=self.unchecked_fields
+    def isDifferentFrom(self,v,exceptions:list=[],fields:list=[],FlagStrictDiff=False,FlagPrint=True):
+        if not FlagStrictDiff: 
+            exceptions+=self.unchecked_fields
+            exceptions=list(set(exceptions))
+        if not fields:
+            fields=self.fields
+        else:
+            [exceptions.remove(f) for f in fields if f in exceptions]
+
         Flag=False
         for f in fields:
             if f in exceptions: continue
@@ -106,47 +128,31 @@ class TABpar:
                         break
                 else:
                     if hasattr(a,'isDifferentFrom'): #in ('Pinfo','pinfo'):
-                        if hasattr(a,'fields'):
-                            Flag=a.isDifferentFrom(b,exceptions,a.fields,FlagStrictDiff)
-                        else:
-                            Flag=a.isDifferentFrom(b,exceptions)
-                        if Flag: 
-                            break
+                        Flag=a.isDifferentFrom(b,exceptions,FlagStrictDiff=FlagStrictDiff)
+                        if Flag: break
                     else:
                         if a!=b:
                             Flag=True
                             break
-        if len(args)<2:
+        if FlagPrint:
             if Flag:  
-                pri.Callback.red(f'{self.name} is different in {f}:\t {b}   -->   {a}')
+                pri.TABparDiff.red(f'{self.name} is different in {f}:\t {b}   -->   {a}')
             else: 
-                pri.Callback.green(f'{self.name} is unchanged')
+                pri.TABparDiff.green(f'{self.name} is unchanged')
         return Flag
     
-    def isEqualTo(self,v,*args):
-        """
-        #args=exceptions,fields,FlagStrict
-        """
-        Flag=not self.isDifferentFrom(v,*args)
+    def isEqualTo(self,v,exceptions=[],fields=[],FlagStrictDiff=False,FlagPrint=False):
+        Flag=bool(not self.isDifferentFrom(v,exceptions,fields,FlagStrictDiff,FlagPrint))
         return Flag
     
-    def printDifferences(self,v,*args):
-        """
-        #args=exceptions,fields,FlagStrict
-        """
-        exceptions=[]
-        fields=self.fields
-        FlagStrictDiff=False 
-        if len(args): 
-            exceptions=args[0]
-            if len(args)>1: 
-                if len(args[1]):
-                    fields=args[1]           
-            if len(args)>2: FlagStrictDiff=args[2] 
-        FlagStrictDiff=False 
-        if len(args): FlagStrictDiff=args[0]
+    def printDifferences(self,v,exceptions=[],fields=[],FlagStrictDiff=False):
         if FlagStrictDiff: exceptions+=self.unchecked_fields
-        df=''
+        if not fields:
+            fields=self.fields
+        else:
+            [exceptions.remove(f) for f in fields if f in exceptions]
+        printing=''
+        df=[]
         for f in fields:
             if f in exceptions: continue
             if not hasattr(self,f):
@@ -163,45 +169,47 @@ class TABpar:
             else:
                 if hasattr(a,'isDifferentFrom'): #in ('Pinfo','pinfo'):
                     if hasattr(a,'fields'):
-                        Flag=a.isDifferentFrom(b,[],a.fields,FlagStrictDiff)
+                        Flag=a.isDifferentFrom(b,[],a.fields,FlagStrictDiff,FlagPrint=False)
                         if Flag:
                             a.printDifferences(b,[],a.fields,FlagStrictDiff)
                     else:
-                        Flag=a.isDifferentFrom(b,[])
+                        Flag=a.isDifferentFrom(b,[],FlagPrint=False)
                 else:
                     if a!=b: Flag=True
             if Flag: 
-                if not df: df=f'{self.name} differences in:'
-                df=df+f'\n*\t{f}:\t {str(a)[:100]}   -->   {str(b)[:100]}'
-        if not df: df=f'{self.name} no differences!'
-        pri.Callback.magenta(df)
-
+                df.append(f)
+                if not printing: printing=f'{self.name} differences in:'
+                printing=printing+f'\n*\t{f}:\t {str(a)[:100]}   -->   {str(b)[:100]}'
+        if not printing: printing=f'{self.name} no differences!'
+        pri.Info.magenta(printing)
+        return df
+    
     def hasIndexOf(self,d):
       """ check if the indexes are the same """
-      return self.indexes()==d.indexes()            
-
-    def indexes(self):
-        """
-        indTree,indItem,ind=TABpar.indexes()
-        """
-        return self.indTree, self.indItem, self.ind
-        
-                        
+      return self.ind==d.ind            
+                              
 class gPaIRS_Tab(QWidget):
-    indTreeGlob=0
-    indItemGlob=0
+    indGlob=(0,0,0,0)
     FlagGlob=False
 
     class Tab_Signals(QObject):
-        setTABpar_final=Signal(int,int,int)
+        callback2_end=Signal(str,bool,bool)
 
         def __init__(self, parent):
             super().__init__(parent)
-            self.setTABpar_final.connect(parent.setTABpar_final)
+            self.callback2_end.connect(parent.callback2_end)
 
     def __init__(self,parent=None,UiClass=None,ParClass=TABpar):
         super().__init__()
-         
+        from .gPaIRS import gPaIRS
+        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.TABname='Tab'
         self.signals=self.Tab_Signals(self)
         self.father=parent
@@ -209,25 +217,35 @@ class gPaIRS_Tab(QWidget):
         self.ParClass=ParClass
         self.TABpar=self.ParClass()            #current configuration 
         self.TABpar_old=self.ParClass()        #last configuration in the current tab
-        self.TABpar_prev=[[[self.ParClass()]],[],[]] #queue of previous configurations, alias undos/redos (indTree,indItem,ind)
-        self.FlagAddingPar=[[[False]],[],[]]     #while executing add_TABpar function it is set to False to avoid recursion
-        self.FlagAsyncCall=[[[False]],[],[]]   #while executing async callback part (fun2) it is set to True to avoid updating of parameters  
+        self.TABpar_prev=[]
+        self.gen_TABpar(self.TABpar.ind,FlagEmptyPrev=True) #queue of previous configurations, alias undos/redos (indTree,indItem,ind)
         self.Num_Prevs_Max=Num_Prevs_Max
 
-        self.FlagNoWrapper=False  #if True, the addParWrapper is ineffective, thus no addition to "prev", no updating of last configuration
         self.FlagAddPrev=True     #if False, no further par are added to the queue of undos/redos "prev"
+        self.FlagBridge=True      #if False, no bridge is executed during setting of parameters
+        self.FlagPrevPropagation=False
+
+        #self.setTABpar_prev=lambda itree,iitem,i,flagBridge: None
+        self.TABsettings=[]
+
+        self.FlagSettingPar=False
+        self.FlagAsyncCallEvaluation=False
+        self.disableTab=lambda flag: None
 
-        self.setTABpar=lambda flagBridge: None
-        self.setTABpar_prev=lambda itree,iitem,i,flagBridge: None
-        self.set_TABpar_bridge=lambda: None
-        self.set_TABpar_prev_bridge=lambda  itree,iitem,i: None
-        self.add_TABpar_bridge=lambda tip,itree,iitem,i: None
+        self.adjustTABpar=lambda: None
+        self.setTABlayout=lambda: None
+        self.checkTABpar=lambda ind: None
+        self.setTABwarn=lambda ind: None
+        self.setTABpar_bridge=lambda fLagAdjustPar, flagCallback: None
+        self.add_TABpar_bridge=lambda tip, ind: None
 
-        self.fUpdatingTabs=lambda flag: None
+        self.buttonTab=None
 
         #Controls
         if UiClass!=None:
             self.ui=UiClass()
+        if not hasattr(self,'ui'):
+            self.ui=self
         if hasattr(self.ui,'setupUi'):
             self.ui.setupUi(self)
         if hasattr(self.ui,'name_tab'):
@@ -235,6 +253,11 @@ class gPaIRS_Tab(QWidget):
         else:
             self.name_tab=''
 
+        
+        #------------------------------------- Graphical interface: miscellanea
+        self.pixmap_warnc = QPixmap(u""+ icons_path +"warning_circle.png")
+        self.pixmap_done  = QPixmap(u""+ icons_path +"completed.png")
+        
         self.undo_icon=QIcon()
         self.undo_icon.addFile(u""+ icons_path +"undo.png", QSize(), QIcon.Normal, QIcon.Off)  
         self.redo_icon=QIcon()
@@ -247,21 +270,430 @@ class gPaIRS_Tab(QWidget):
             setattr(self.ui,'button_forward',QPushButton(self))
         else:
             self.ui.button_forward.contextMenuEvent=lambda e: self.bfContextMenu(+1,e)
+        if not hasattr(self.ui,'button_restore_undo'): 
+            setattr(self.ui,'button_restore_undo',QPushButton(self))
         if not hasattr(self.ui,'label_number'): 
             setattr(self.ui,'label_number',QLabel(self))
         if hasattr(self.ui,'button_close_tab'):
             b:QPushButton=self.ui.button_close_tab
             b.setCursor(Qt.CursorShape.PointingHandCursor)
-
-        self.ui.button_back.clicked.connect(self.button_back_callback)
-        self.ui.button_forward.clicked.connect(self.button_forward_callback)
+        self.onlyReadLabel:QLabel=None
+        self.button_reset_step:QPushButton=None
+        self.button_step_inherit:QPushButton=None
+        self.button_copy_step:QPushButton=None
+        self.button_link_step:QPushButton=None
 
         self.FlagDisplayControls=True  #if False, undo and redo buttons are hidden and so not usable
         self.ui.button_forward.hide()
         self.ui.button_back.hide()
+        self.ui.button_restore_undo.hide()
+        self.ui.button_back.clicked.connect(self.button_back_action)
+        self.ui.button_forward.clicked.connect(self.button_forward_action)
         self.ui.label_number.setText('')
         self.ui.label_number.hide()
 
+        if hasattr(self.ui,'spin_x'):
+            self.ui.spin_x.valueChanged.connect(self.spin_x_changing)
+        if hasattr(self.ui,'spin_y'):
+            self.ui.spin_y.valueChanged.connect(self.spin_y_changing)
+        
+        self.spins_valueChanged=[]
+
+        self.nullCallback=lambda f='Null Callback': self.wrappedCallback(f,lambda: True)()
+        self.fullCallback=lambda f='Full Callback': self.wrappedCallback(f,lambda: None)()
+
+#*************************************************** Widgets
+    def defineWidgets(self):        
+        def wDict(types,signals):
+            l=[]
+            for t in types: 
+                for c in self.findChildren(t): l.append(c) if c not in l else None
+            d={'widgets': l, 'signals': signals}
+            return d
+                       
+        widgets={
+                'spin':     wDict([MyQSpin,MyQDoubleSpin],['addfuncout','addfuncreturn']),
+                'check':    wDict([QCheckBox],['toggled']),
+                'radio':    wDict([QRadioButton],['toggled']),
+                'line_edit': wDict([QLineEdit,MyQLineEdit,MyQLineEditNumber],['addfuncout','returnPressed']),
+                'button' :  wDict([QPushButton,QToolButton,MyToolButton],['clicked']),
+                'combo' :   wDict([QComboBox],['activated']),
+                }
+        self.widgetTypes=list(widgets)
+        self.widgets=[]
+        self.widgetSignals=[]
+        for w in self.widgetTypes:
+            self.widgets.append(widgets[w]['widgets'])
+            self.widgetSignals.append(widgets[w]['signals'])
+        self.widgetsOfType=lambda t: self.widgets[self.widgetTypes.index(t)]
+
+        for c in self.widgetsOfType('combo'):
+            c:QComboBox
+            nameCombo=c.objectName().split('combo_')[-1]
+            if hasattr(self,nameCombo+'_items'):
+                itemsCombo=getattr(self,nameCombo+'_items')
+            else: continue
+            if hasattr(self,nameCombo+'_order'):
+                orderCombo=getattr(self,nameCombo+'_order')
+            else: orderCombo=[i for i in range(len(itemsCombo))]
+            c.clear()
+            for i in orderCombo:
+                c.addItem(itemsCombo[i])
+
+#*************************************************** Widget callbacks
+    def defaultCallback(self,wName,wtype):
+        widget=getattr(self.ui,wtype+'_'+wName)
+        if wName=='x_min':
+            pass
+        if wtype=='spin': 
+            def callbackSpin(s:MyQSpin):
+                setattr(self.TABpar,wName,s.value())
+            default_callback=lambda: callbackSpin(widget)
+        elif (wtype=='check' or wtype=='radio') and hasattr(self.TABpar,'Flag'+wName): 
+            def callbackCheck(c:QCheckBox):
+                setattr(self.TABpar,'Flag'+wName,c.isChecked())
+            default_callback=lambda: callbackCheck(widget)
+        elif wtype=='combo':
+            def callbackCombo(c:QComboBox):
+                if hasattr(self,wName+'_items'):
+                    itemsCombo:list=getattr(self,wName+'_items')
+                else:
+                    itemsCombo=[c.itemText(i) for i in range(c.count())]
+                if len(itemsCombo):
+                    setattr(self.TABpar,wName,itemsCombo.index(c.currentText()))
+                else: 
+                    setattr(self.TABpar,wName,-1)
+            default_callback=lambda: callbackCombo(widget)
+        elif wtype=='line_edit':
+            def callbackLineEdit(l:MyQLineEdit):
+                setattr(self.TABpar,wName,l.text())
+            default_callback=lambda: callbackLineEdit(widget)
+        else:
+            default_callback=None
+        return default_callback
+                    
+    def defineCallbacks(self):
+        def buildCallback(wName,wtype,tip):
+            if not hasattr(self.ui,wtype+'_'+wName): return   
+            callback01=callback02=callback03=callback1=callback2=None
+
+            #callback01: _preaction method in the class: particular callback that is fast and can be executed on the main thread instead of as concurrent future before the default callback
+            a=wtype+'_'+wName+'_preaction'
+            if hasattr(self,a): callback01=getattr(self,a)
+
+            #callback02: callback common to all widgets of the same type (avoid code repetition)
+            if hasattr(self.TABpar,wName) or ((wtype=='check' or wtype=='radio') and hasattr(self.TABpar,'Flag'+wName)): 
+                callback02=self.defaultCallback(wName,wtype)
+
+            #callback03: _action method in the class: particular callback that is fast and can be executed on the main thread instead of as concurrent future after the default callback
+            a=wtype+'_'+wName+'_action'
+            if hasattr(self,a): callback03=getattr(self,a)
+
+            if callback01 or callback02 or callback03:
+                def callback1():
+                    name=wName
+                    flag=None
+                    if callback01: callback01()
+                    if callback02: callback02()
+                    if callback03: flag=callback03()
+                    return flag
+            else: callback1=None
+
+            #callback1: _action_future method in the class: particular callback that is fast and can be executed on the main thread instead of as concurrent future
+            a=wtype+'_'+wName+'_action_future'
+            if hasattr(self,a): 
+                callback2=getattr(self,a)
+
+            if callback1 or callback2:
+                callback=self.wrappedCallback(tip,callback1,callback2)
+                setattr(self,wtype+'_'+wName+'_callback',callback)
+            else:
+                callback=None
+            return callback
+        
+        self.widgetCallbacks=[]
+        for l,wtype in zip(self.widgets,self.widgetTypes):
+            missing_tips=[]
+            if hasattr(self,wtype+'_tips'):
+                d=getattr(self,wtype+'_tips')
+            else:
+                d=None
+                pri.Coding.red(f'*** [{self.TABname}]  - {wtype}_tips -  missing dictionary!')
+            widgetCallbacks=[]
+            for c in l:
+                c:QObject
+                if c.objectName() in ('button_back','button_forward','button_close_tab'): 
+                    callback=None
+                    widgetCallbacks.append(callback)
+                    continue
+                if '_' in c.objectName(): wName=c.objectName().split(wtype+'_')[-1]
+                else:  wName=c.objectName()
+                if d!=None:
+                    if wName in list(d): tip=d[wName]
+                    else: 
+                        tip=f"{wtype} {wName}"
+                        if wName and not (wtype=='line_edit' and wName in ('qt_spinbox_lineedit') ) and \
+                            not (wtype=='button' and wName in ('back','forward','close_tab') ):
+                            missing_tips.append(f"'{wName}'")
+                else: tip=f"{wtype} {wName}"
+                callback=buildCallback(wName,wtype,tip)
+                widgetCallbacks.append(callback)
+            if len(missing_tips):
+                pri.Coding.blue(f'*** [{self.TABname}]  - {wtype}_tips -  missing tips:\n\t'+"\n\t".join(missing_tips))
+            elif d:
+                pri.Coding.green(f'✔️ [{self.TABname}]  - {wtype}_tips -  complete dictionary!')
+            self.widgetCallbacks.append(widgetCallbacks)
+
+    def wrappedCallback(self,tip='',callback1=None,callback2=None):
+         def debugFun(fun,message=''):
+            try:
+                out=fun()
+            except Exception as inst:
+                out=None
+                pri.Error.red(f"{'!'*100}\n{message}:\n{traceback.format_exc()}\n{'!'*100}")
+                printException()
+                #if Flag_DEBUG: raise Exception("!!! Debug stop !!!") 
+            return out
+         async def callback2_async(fun2):
+            if Flag_DEBUG: timesleep(time_callback2_async)
+            if fun2: debugFun(fun2,f'Asyncronus function error callback2 ({tip}): ')
+            return
+         def callback():
+            FlagSettingPar=self.FlagSettingPar or TABpar.FlagSettingPar
+            if FlagSettingPar: 
+                return
+            else:
+                self.FlagSettingPar=True
+            try:
+                FlagPreventAddPrev=False
+                if callback1: FlagPreventAddPrev=debugFun(callback1,f'Error callback1 ({tip}): ')
+                if callback2: 
+                    self.FlagAsyncCallEvaluation=True
+                    self.disableTab(True)
+            
+                    if FlagAsyncCallbacks:
+                        f3=globExecutor.submit(asyncio.run,callback2_async(callback2))
+                        def f3callback(_f3):
+                            self.signals.callback2_end.emit(tip,FlagSettingPar,FlagPreventAddPrev)
+                        f3.add_done_callback(f3callback)
+                    else:
+                        debugFun(callback2,f'Error callback2 ({tip}): ')
+                        self.callback2_end(tip,FlagSettingPar,FlagPreventAddPrev)
+                else:
+                    self.callback2_end(tip,FlagSettingPar,FlagPreventAddPrev)
+            except Exception as inst:
+                pri.Error.red(f"Error in wrapped callback ({tip}):\n{traceback.format_exc()}")
+                printException()
+                self.FlagSettingPar=FlagSettingPar
+            return 
+         return callback
+        
+    @Slot(str)
+    def callback2_end(self,tip,FlagSettingPar,FlagPreventAddPrev):
+        pri.Coding.green(f'{"*"*50}\nCallback <{self.TABname}>: {tip}')
+        if tip=='Null Callback':
+            pass
+        try:
+            if self.FlagAsyncCallEvaluation==True:
+                self.FlagAsyncCallEvaluation=False
+                self.disableTab(False)
+            try:
+                TABpar_ind=self.TABpar_at(self.TABpar.ind)
+                if TABpar_ind and self.TABpar.isEqualTo(TABpar_ind,FlagStrictDiff=True): return
+                FlagNewPar=self.isNewPar()
+                flagRun=self.TABpar_at(self.TABpar.ind).flagRun
+                if FlagNewPar and (flagRun!=0 or len(self.TABpar.link)>0):
+                    #FlagNewPar=not self.FlagAddPrev
+                    if len(self.TABpar.link)>0:
+                        ITE0_master=self.gui.ui.Explorer.ITEsfromInd(self.TABpar.link)[0]
+                        linkInfo=f'{ITE0_master.ind[2]+1}: {ITE0_master.name}'
+                        Messagge=f'This process step is linked to process {linkInfo}. To modify it, you need to unlink the process step.'
+                        if flagRun!=0 or ITE0_master.flagRun!=0:
+                            Messagge+=' After unlinking the process will be reset!'
+                        def unlink_pars_online():
+                            TABpar_ind.copyfrom(self.TABpar)
+                            self.gui.unlink_pars(self.TABpar.ind)
+                            if self.TABpar.flagRun!=0 or ITE0_master.flagRun!=0:
+                                self.gui.reset_step(self.TABpar.ind)
+                        warningDialog(self.gui,Messagge,addButton={'Unlink step!': unlink_pars_online})
+                    elif flagRun==-10:
+                         Messagge='This process step is in the queue for process execution. To modify it, you need to stop processing and then reset it and all the subsequent steps.'
+                         warningDialog(self.gui,Messagge)
+                    elif flagRun==-2:
+                         Messagge='This process step is currently in execution. To modify it, you need to stop processing and then reset it and all the subsequent steps.'
+                         warningDialog(self.gui,Messagge)
+                    elif flagRun!=0:
+                        if self.gui.FlagRun:
+                            Messagge='This process step has already been executed. To modify it, you need to stop processing and then reset it and all the subsequent steps.'
+                            warningDialog(self.gui,Messagge)               
+                        else:    
+                            Messagge='This process step has already been executed. To modify it, you need to reset the current step and all the subsequent ones.'
+                            def reset_step_online():
+                                TABpar_ind.copyfrom(self.TABpar)
+                                self.gui.reset_step(self.TABpar.ind)
+                                return
+                            warningDialog(self.gui,Messagge,addButton={'Reset step!': reset_step_online})
+                    
+
+                    if flagRun!=0 or len(self.TABpar.link)>0:
+                        self.TABpar.copyfrom(TABpar_ind)
+                        originalStyleSheet=self.gui.styleSheet()
+                        self.gui.setStyleSheet(f'background: {self.palette().color(QPalette.ColorRole.Text).name()} ;') #dcdcdc
+                        self.repaint()
+                        try:
+                            self.setTABpar(FlagAdjustPar=False,FlagBridge=False,FlagCallback=False)
+                        finally:
+                            timesleep(.01)
+                            self.gui.setStyleSheet(originalStyleSheet)
+                    else:
+                        return
+                else:
+                    self.setTABpar(FlagAdjustPar=True,FlagBridge=self.FlagBridge,FlagCallback=True)
+            except:
+                pri.Error.red(f'Error in callback2_end ({tip}):\n        |-> Error in setting the parameters')
+                pri.Error.red(f'{traceback.format_exc()}')
+                printException()
+            else:
+                try:  
+                    FlagNewPar=FlagNewPar and not FlagPreventAddPrev and self.TABpar.flagRun==0 and len(self.TABpar.link)==0
+                    self.add_TABpar(tip,FlagNewPar)
+                except:
+                    pri.Error.red(f'Error in callback2_end ({tip}):\n        |-> Error in adding parameters to redos/undos {tip}')    
+                    printException()
+        except Exception as inst:
+                pri.Error.red(f"Error in callback2_end ({tip}):\n{traceback.format_exc()}")
+                printException()
+        finally:
+            self.FlagSettingPar=FlagSettingPar
+        pri.Coding.green(f'Callback <{self.TABname}>: {tip}\n{"*"*50}\n')
+
+    def connectCallbacks(self):
+        for W,S,CB in zip(self.widgets,self.widgetSignals,self.widgetCallbacks):
+            for w,cb in zip(W,CB):
+                if cb==None: continue
+                for s in S:
+                    sig=getattr(w,s)
+                    if hasattr(sig,'connect'):
+                        sig.connect(cb)
+                    elif s in ('addfuncout','addfuncreturn'):
+                        if w in self.spins_valueChanged:
+                            if s=='addfuncout': w.valueChanged.connect(cb)
+                        else:
+                            sig['callback']=cb
+
+#*************************************************** Setting parameters to widgets
+    def defaultSetting(self,wName,wtype):
+        if not hasattr(self.ui,wtype+'_'+wName): return  
+        widget=getattr(self.ui,wtype+'_'+wName)
+        if wtype=='spin': 
+            def settingSpinValue(s:MyQSpin):
+                s.setValue(getattr(self.TABpar,wName))
+            default_setting=lambda: settingSpinValue(widget)
+        elif (wtype=='check' or wtype=='radio') and hasattr(self.TABpar,'Flag'+wName): 
+            def settingChecked(c:QCheckBox):
+                try:
+                    c.setChecked(getattr(self.TABpar,'Flag'+wName))
+                except:
+                    pass
+            default_setting=lambda: settingChecked(widget)
+        elif wtype=='combo':
+            widget:QComboBox
+            def settingComboIndex(c:QComboBox):
+                items=[c.itemText(i) for i in range(c.count())]
+                if hasattr(self,wName+'_items'):
+                    itemsCombo:list=getattr(self,wName+'_items')
+                else:
+                    itemsCombo=items
+                ind=getattr(self.TABpar,wName)
+                if ind>-1: c.setCurrentIndex(items.index(itemsCombo[ind]))
+            default_setting=lambda: settingComboIndex(widget)
+        elif wtype=='line_edit':
+            def settingText(l:MyQLineEdit):
+                l.setText(getattr(self.TABpar,wName))
+            default_setting=lambda: settingText(widget)
+        else:
+            default_setting=None
+        return default_setting
+
+    def defineSettings(self):
+        def buildSetting(wName,wtype):
+            setting0=default_setting=setting2=None
+            #setting0: _preset method in the class: setting to be done before standard setting (0)
+            a=wtype+'_'+wName+'_preset'
+            if hasattr(self,a): setting0=getattr(self,a) 
+
+            #setting1: setting common to all widgets of the same type (avoid code repetition)
+            if hasattr(self.TABpar,wName) or ((wtype=='check' or wtype=='radio') and hasattr(self.TABpar,'Flag'+wName)): 
+                default_setting=self.defaultSetting(wName,wtype)
+                
+            #callback2: _set method in the class: setting to be done before standard setting (1)
+            a=wtype+'_'+wName+'_set'
+            if hasattr(self,a): setting2=getattr(self,a)
+
+            def setting():
+                name=wName
+                if setting0: setting0()
+                if default_setting: default_setting()
+                if setting2: setting2()
+                return
+            setattr(self,wtype+'_'+wName+'_setting',setting)
+            self.TABsettings.append(setting)
+            return
+        
+        self.TABsettings=[]
+        for l,wtype in zip(self.widgets,self.widgetTypes):
+            for c in l:
+                wName=c.objectName().split(wtype+'_')[-1]
+                buildSetting(wName,wtype)
+                if wtype=='line_edit':
+                    if hasattr(c,'addfuncout'):
+                        c.addfuncout['setting']=self.TABsettings[-1]
+                    else:
+                        def focusOutEvent(obj, event):
+                            type(obj).focusOutEvent(obj,event) #to preserve classical behaviour before adding the below
+                            self.TABsettings[-1]()
+                        c.focusOutEvent=focusOutEvent
+
+    def setTABpar(self,FlagAdjustPar=True,FlagBridge=True,FlagCallback=False,FlagDisplayControls=None):
+        if self.TABpar.FlagNone and self.TABpar_at(self.TABpar.ind) is None: return
+        pri.Coding.magenta(f'    --- setting {self.TABpar.name} {self.TABpar.ind}')
+
+        self.FlagSettingPar=True
+        FlagSettingPar=TABpar.FlagSettingPar
+        TABpar.FlagSettingPar=True
+
+        if FlagAdjustPar:
+            self.adjustTABpar()
+            
+        self.setTABlayout() 
+        for f in self.TABsettings:
+            f()
+        #self.TABpar_old.copyfrom(self.TABpar)
+        self.TABpar.FlagInit=True
+
+        if FlagBridge:
+            self.setTABpar_bridge(FlagAdjustPar,FlagCallback)
+        
+        self.TABpar_old.copyfrom(self.TABpar)
+        
+        if FlagDisplayControls is None: FlagDisplayControls=not FlagBridge
+        if FlagDisplayControls:
+            self.display_controls()
+        
+        TABpar.FlagSettingPar=FlagSettingPar 
+        self.FlagSettingPar=False
+
+        if not FlagCallback: 
+            self.adjustTABparInd()
+
+    def setTABpar_at(self,ind,FlagAdjustPar=False,FlagBridge=False):
+        pri.Coding.green(f'{":"*50}\nSetting previous par <{self.TABname}>: {ind}')
+        TABpar_ind:TABpar=self.TABpar_at(ind)
+        if not TABpar_ind.FlagNone:
+            self.TABpar.copyfrom(TABpar_ind)  
+            self.setTABpar(FlagAdjustPar,FlagBridge)
+        pri.Coding.green(f'Setting previous par <{self.TABname}>: {ind}\n{":"*50}\n')
+
     def setupWid(self):
         setupWid(self)  
         fPixSize_TabNames=30
@@ -273,256 +705,253 @@ class gPaIRS_Tab(QWidget):
             font.setPixelSize(fPixSize_TabNames)
             lab.setFont(font)    
 
+    def setTABWarnLabel(self):
+        self.ui.name_tab.setFixedWidth(self.ui.name_tab.sizeHint().width())
+        self.ui.label_done.setPixmap(self.pixmap_done if self.TABpar.OptionDone==1 else self.pixmap_warnc)
+        self.ui.label_done.setToolTip(self.TABpar.warningMessage)
+        
 #*************************************************** Undo/redo
-    def addParWrapper(self,fun,name,*args):  
-        async def fun2_async(fun2,TABpar_prev):
-            pri.Callback.magenta(f'{"#"*60}  async callback in {self.TABname} [{TABpar_prev.indTree}][{TABpar_prev.indItem}][{TABpar_prev.ind}]    --- start')
-            if Flag_DEBUG: timesleep(time_fun2_async)
-            try:
-                TABpar_prev=fun2(TABpar_prev)
-            except Exception as inst:
-                funcname=''
-                if hasattr(fun,'__func__'): 
-                        if hasattr(fun.__func__,'__name__'):
-                            funcname=f' [{fun.__func__.__name__}]'
-                pri.Error.red(f"{'!'*100}\naddParWrapper Error fun2{funcname}:\n{traceback.format_exc()}\n\n{inst}\n{'!'*100}")
-                if Flag_DEBUG: raise Exception("!!! Debug stop !!!") 
-            return TABpar_prev
-        def callbackfun():
-            if self.FlagAddingPar[self.TABpar.indTree][self.TABpar.indItem][self.TABpar.ind]: return
-            if self.FlagAsyncCall[self.TABpar.indTree][self.TABpar.indItem][self.TABpar.ind]: 
-                pri.Callback.red(f'{"*"*30} callback from [{name}] {self.TABname} [{self.TABpar.indTree}][{self.TABpar.indItem}][{self.TABpar.ind}]    --- skipped')
-                self.TABpar.copyfrom(self.TABpar_prev[self.TABpar.indTree][self.TABpar.indItem][self.TABpar.ind])
-                self.setTABpar(False)   #setting parameters with bridge
-                return
-            else:
-                pri.Callback.green(f'{"*"*30} callback from [{name}] {self.TABname} [{self.TABpar.indTree}][{self.TABpar.indItem}][{self.TABpar.ind}]    --- executing')
-                pass
-            if fun==None: 
-                self.add_TABpar(name)
-                self.setTABpar(True)   #setting parameters with bridge
+    def adjustTABparInd(self):
+        TABpar_ind=self.TABpar_at(self.TABpar.ind)
+        if TABpar_ind: 
+            TABpar_ind.copyfrom(self.TABpar)
+
+    def gen_TABpar(self,ind,FlagSet=True,FlagEmptyPrev=False,FlagNone=False,FlagInsert=-1,Process=None,Step=None):
+        Prev=prev=self.TABpar_prev if FlagSet else []
+
+        for i in range(len(ind)):
+            if i<len(ind)-1:
+                if i==FlagInsert:
+                    prev.insert(ind[i],[])
+                else:
+                    while ind[i]>len(prev)-1:
+                        prev.append([])
+                prev=prev[ind[i]]
             else:
-                try: 
-                    output=fun(*args)
-                    if output!=None:
-                        flagAddPar=output[0]
-                        fun2=output[1]
+                if not FlagEmptyPrev:
+                    if i==FlagInsert:
+                        if ind[i]<len(prev):
+                            if FlagNone:
+                                prev[ind[i]]=None
+                            else:
+                                if Process is not None and Step is not None:
+                                    par=self.ParClass(Process=Process,Step=Step)
+                                else:
+                                    par=self.ParClass()
+                                par.ind=ind
+                                prev[ind[i]]=par
+                                pri.Coding.cyan(f'[gen_TABpar] {par.surname} {par.ind} ---> {self.TABpar_at(ind).ind}')
+                        else:
+                            if FlagNone:
+                                prev.insert(ind[i],None)
+                            else:
+                                if Process is not None and Step is not None:
+                                    par=self.ParClass(Process=Process,Step=Step)
+                                else:
+                                    par=self.ParClass()
+                                par.ind=ind
+                                prev.insert(ind[i],par)
+                                pri.Coding.cyan(f'[gen_TABpar] {par.surname} {par.ind} ---> {self.TABpar_at(ind).ind}')
                     else:
-                        flagAddPar=1
-                        fun2=None
-                except Exception as inst:
-                    funcname=''
-                    if hasattr(fun,'__func__'): 
-                        if hasattr(fun.__func__,'__name__'):
-                            funcname=f' [{fun.__func__.__name__}]'
-                    pri.Error.red(f"{'!'*100}\naddParWrapper Error fun{funcname}:\n{traceback.format_exc()}\n\n{inst}\n{'!'*100}")
-                    flagAddPar=0
-                    fun2=None
-                    if Flag_DEBUG: raise Exception("!!! Debug stop !!!") 
-                finally:
-                    if self.FlagNoWrapper: 
-                        return
-                    try:  
-                        if flagAddPar>0:
-                            self.add_TABpar(name)  #adding parameters to prev
-                        if flagAddPar>-1:
-                            self.TABpar_prev[self.TABpar.indTree][self.TABpar.indItem][self.TABpar.ind].copyfrom(self.TABpar)
-                            self.setTABpar(True)   #setting parameters with bridge
-                        if fun2!=None:
-                            TABpar_prev=self.TABpar_prev[self.TABpar.indTree][self.TABpar.indItem][self.TABpar.ind]
-                            self.FlagAsyncCall[self.TABpar.indTree][self.TABpar.indItem][self.TABpar.ind]=True
-                            self.fUpdatingTabs(True)
-
-                            if FlagAsyncCallbacks:
-                                f3=globExecutor.submit(asyncio.run,fun2_async(fun2,TABpar_prev))
-                                def f3callback(_f3):
-                                    self.signals.setTABpar_final.emit(self.TABpar.indTree,self.TABpar.indItem,self.TABpar.ind)
-                                f3.add_done_callback(f3callback)
+                        while ind[i]>len(prev)-1:
+                            if FlagNone:
+                                prev.append(None)
                             else:
-                                fun2(TABpar_prev)
-                                self.setTABpar_final(self.TABpar.indTree,self.TABpar.indItem,self.TABpar.ind)
-                    except Exception as inst:
-                        pri.Error.red(f"{'!'*100}\naddParWrapper Error in AddPar block::\n{traceback.format_exc()}\n\n{inst}\n{'!'*100}")
-            return 
-        return callbackfun
-
-    @Slot(int,int,int)
-    def setTABpar_final(self,indTree,indItem,ind):
-        pri.Callback.magenta(f'{"#"*60}  async callback in {self.TABname} [{indTree}][{indItem}][{ind}]     --- end')
-        if self.TABpar.indTree==indTree and self.TABpar.indItem==indItem and self.TABpar.ind==ind:
-            self.setTABpar_prev(indTree,indItem,ind,True) #True=with bridge
-        self.FlagAsyncCall[indTree][indItem][ind]=False
-        self.fUpdatingTabs(False)
+                                if Process is not None and Step is not None:
+                                    par=self.ParClass(Process=Process,Step=Step)
+                                else:
+                                    par=self.ParClass()
+                                par.ind=ind
+                                prev.append(par)
+                                pri.Coding.cyan(f'[gen_TABpar] {par.surname} {par.ind} ---> {self.TABpar_at(ind).ind}')
+        return Prev
         
-    def display_controls(self):
-        if not self.FlagDisplayControls: return
-        lprev=len(self.TABpar_prev[self.TABpar.indTree][self.TABpar.indItem])
-        ind=self.TABpar.ind
-        if lprev>1:
-            self.ui.button_forward.show()
-            self.ui.button_back.show()
-        else:
-            self.ui.button_forward.hide()
-            self.ui.button_back.hide()
-        if ind==lprev-1 or ind==-1:
-            self.ui.button_forward.setEnabled(False)
-        else:
-            self.ui.button_forward.setEnabled(True)
-        if ind==0:
-            self.ui.button_back.setEnabled(False)
-        else:
-            self.ui.button_back.setEnabled(True)
-        if ind==lprev-1 or ind==-1:
-            self.ui.label_number.setText('')
-        elif ind>=0:
-            self.ui.label_number.setText("(-"+str(lprev-1-ind)+")")
+    def TABpar_at(self,ind):
+        if ind[0]<len(self.TABpar_prev):
+            p:TABpar=self.TABpar_prev[ind[0]]
+        else: 
+            p=None
+        if p:
+            for i in range(1,len(ind)):
+                if ind[i]<len(p):
+                    p=p[ind[i]]
+                else:
+                    p=None
+                    break
+        return p
+    
+    def TABpar_prev_at(self,ind):
+        if len(self.TABpar_prev)-1<ind[0]:
+            return []
         else:
-            self.ui.label_number.setText("(-"+str(ind+1)+")")
+            p:TABpar=self.TABpar_prev[ind[0]]
+            for i in range(1,len(ind)-1):
+                if len(p)-1<ind[i]:
+                    p=[]
+                    break
+                else:
+                    p=p[ind[i]]
+            return p
 
-    def add_TABpar(self,tip):
-        if self.FlagAddPrev:
-            indTree,indItem=self.getTABpar_prev()
-        else:
-            indTree=self.TABpar.indTree
-            indItem=self.TABpar.indItem
-        TABpar_prev=self.TABpar_prev[indTree][indItem]
-        if not len(TABpar_prev):
-            flagNewPar=True
-        else:
-            flagNewPar=self.TABpar.isDifferentFrom(TABpar_prev[-1],self.TABpar.unchecked_fields+['ind','indItem','indTree']) #* see below
-        if flagNewPar:
-            if self.FlagAddPrev: #something changed
-                self.add_TABpar_copy(tip,indTree,indItem)
-                self.add_TABpar_bridge(tip,indTree,indItem,-1)  #should create a copy of the other tabs' parameters (see gPaIRS)
-            else:
-                TABpar_prev[self.TABpar.ind].copyfrom(self.TABpar) #* see above flagNewPar: if there are changes in unchecked_fields this par is updated in any case
+    def isNewPar(self):
+        ind=self.TABpar.ind
+        TABpar_prev=self.TABpar_prev_at(ind)
+        if len(TABpar_prev)>0:
+            FlagNewPar=self.FlagAddPrev and self.TABpar.isDifferentFrom(TABpar_prev[-1],exceptions=self.TABpar.unchecked_fields+['ind']) #see below
+            self.TABpar.printDifferences(TABpar_prev[-1],exceptions=self.TABpar.unchecked_fields+['ind']) 
         else:
-            self.TABpar.copyfrom(TABpar_prev[-1])
+            FlagNewPar=self.FlagAddPrev
+        return FlagNewPar
 
-    def getTABpar_prev(self):
-        if self.FlagGlob:
-            indTree=self.indTreeGlob
-            indItem=self.indItemGlob
+    def add_TABpar(self,tip,FlagNewPar=True):
+        ind=self.TABpar.ind
+        TABpar_prev=self.TABpar_prev_at(ind)
+        if (FlagNewPar or len(TABpar_prev)==0) and self.FlagAddPrev: #something changed
+            if len(TABpar_prev): TABpar_prev[-1].printDifferences(self.TABpar,self.TABpar.unchecked_fields+['ind'])
+            self.add_TABpar_copy(tip,ind)
+            self.add_TABpar_bridge(tip,ind)  #should create a copy of the other tabs' parameters (see gPaIRS)
+            ind[-1]=TABpar_prev[-1].ind[-1]
         else:
-            indTree=self.TABpar.indTree
-            indItem=self.TABpar.indItem
-        #nItem=len(self.TABpar_prev[indTree])
-        #if nItem-1<indItem:
-        #    nadd=(nItem-indItem+1)
-        #    self.TABpar_prev[indTree]+=[[]]*nadd
-        #    self.FlagAddingPar[indTree]+=[[]]*nadd
-        #    self.FlagAsyncCall[indTree]+=[[]]*nadd
-        return indTree,indItem
-
-    def add_TABpar_copy(self,name,*args):
-        if len(args)>1: 
-            indTree=args[0]
-            indItem=args[1]
+            self.adjustTABparInd()
+        
+        if self.FlagPrevPropagation:
+            #pri.Time.blue('Propagation par init')
+            TABpar_prev=self.TABpar_prev_at(self.TABpar.ind)
+            for p in TABpar_prev:
+                p:TABpar
+                p.copyfrom(TABpar_prev[self.TABpar.ind[-1]],exceptions=['ind','tip'])
+            #pri.Time.blue('Propagation par end')
+        return ind
+
+    def add_TABpar_copy(self,name,ind):
+        TABpar_prev:list=self.TABpar_prev_at(ind)
+        if not self.TABpar.FlagNone:
+            TABpar_new=self.TABpar.duplicate()
+            if len(TABpar_prev)>self.Num_Prevs_Max:
+                TABpar_prev.pop(0)
+                for k,p in enumerate(TABpar_prev):
+                    p.ind[-1]=k
+            else:
+                TABpar_new.ind[-1]=len(TABpar_prev)
+            TABpar_new.tip=name
+            self.TABpar.ind=copy.deepcopy(TABpar_new.ind)  #in this way, we move to the last added par in the "prev"
+            pri.Coding.yellow(f'   |-> +++ {self.TABpar.name}: new par {TABpar_new.ind} <{name}>')
         else:
-            indTree,indItem=self.getTABpar_prev()
-        TABpar_prev=self.TABpar_prev[indTree][indItem]
-        TABpar_new=self.TABpar.duplicate()
+            TABpar_new=None
         TABpar_prev.append(TABpar_new)
-        self.FlagAddingPar[indTree][indItem].append(False)
-        self.FlagAsyncCall[indTree][indItem].append(False)
-        if len(TABpar_prev)>self.Num_Prevs_Max:
-            TABpar_prev.pop(0)
-            self.FlagAddingPar[indTree][indItem].pop(0)
-            self.FlagAsyncCall[indTree][indItem].pop(0)
-            for k,p in enumerate(TABpar_prev):
-                p.ind=k
-        else:
-            TABpar_new.ind=len(TABpar_prev)-1
-        TABpar_new.indItem=indItem
-        TABpar_new.indTree=indTree
-        TABpar_new.tip=name
-        self.TABpar.ind=ind=len(TABpar_prev)-1  #in this way, we move to the last added par in the "prev"
-        self.TABpar.indItem=indItem
-        self.TABpar.indTree=indTree
-
-        pri.Callback.yellow(f'   |-> +++ {self.TABpar.name}: new par [{indTree}][{indItem}][{ind}] <{name}>')
-
-    def defineSetTABpar(self,setParFun):
-        def setTABpar(FlagBridge):
-            pri.Callback.magenta(f'    --- setting {self.TABpar.name} [{self.TABpar.indTree}][{self.TABpar.indItem}][{self.TABpar.ind}]')
-            #pri.Time.blue(0,'')
-            fAddingPar=self.FlagAddingPar[self.TABpar.indTree][self.TABpar.indItem][self.TABpar.ind]
-            self.FlagAddingPar[self.TABpar.indTree][self.TABpar.indItem][self.TABpar.ind]=True
-            try:
-                setParFun()
-                self.TABpar_prev[self.TABpar.indTree][self.TABpar.indItem][self.TABpar.ind].copyfrom(self.TABpar) #updating in case TABpar is changed in setParFun (not a good practice, actually)
-                self.TABpar_old.copyfrom(self.TABpar) #for async callback and other checks
-                if FlagBridge:
-                    self.set_TABpar_bridge()
-            except:
-                pri.Error.red(f'        |-> Error in setting the parameters')
-                printException()
-            finally:
-                self.FlagAddingPar[self.TABpar.indTree][self.TABpar.indItem][self.TABpar.ind]=fAddingPar
-                self.display_controls()
-            #pri.Time.blue(0,'')
-        def setTABpar_prev(indTree,indItem,ind,FlagBridge):
-            pri.Callback.magenta(f'    --- setting {self.TABpar.name}_prev[{indTree}][{indItem}][{ind}]')
-            #pri.Time.blue(0,'')
-            fAddingPar=self.FlagAddingPar[indTree][indItem][ind]
-            self.FlagAddingPar[indTree][indItem][ind]=True
-            try:
-                self.TABpar.copyfrom(self.TABpar_prev[indTree][indItem][ind]) 
-                setParFun()
-                self.TABpar_prev[indTree][indItem][ind].copyfrom(self.TABpar)  #updating in case TABpar is changed in setParFun (not a good practice, actually)
-                self.TABpar_old.copyfrom(self.TABpar)        #for async callback and other checks
-                if FlagBridge:
-                    self.set_TABpar_prev_bridge(indTree,indItem,ind)
-            except:
-                pri.Error.red(f'        |-> Error in setting the parameters')
-                printException()
-            finally:
-                try:
-                    self.FlagAddingPar[indTree][indItem][ind]=fAddingPar
-                except:
-                    iterateList(self.FlagAddingPar,False)
-                    pri.Error.red(f'{"*"*50}\rError in setting self.FlagAddingPar: restored!\r{"*"*50}')
-                self.display_controls()
-            #pri.Time.blue(0,'')
-        self.setTABpar=setTABpar
-        self.setTABpar_prev=setTABpar_prev
-
-    def defineTABbridge(self,bridgeFun,bridgeFun_prev):
-        def TABbridge():
-            pri.Callback.green(f'::: bridge of {self.TABpar.name} [{self.TABpar.indTree}][{self.TABpar.indItem}][{self.TABpar.ind}]')
-            bridgeFun()
-        def TABbridge_prev(indTree,indItem,ind):
-            pri.Callback.green(f'::: bridge of {self.TABpar.name}_prev[{indTree}][{indItem}][{ind}]')
-            bridgeFun_prev(indTree,indItem,ind)
-        self.set_TABpar_bridge=TABbridge
-        self.set_TABpar_prev_bridge=TABbridge_prev
-
-    def button_back_callback(self):
-        ind=self.TABpar.ind-1
-        self.setTABpar_prev(self.TABpar.indTree,self.TABpar.indItem,ind,True) #True=with bridge
+        self.display_controls()
+        ind_new=[i for i in ind]
+        ind_new[-1]=len(TABpar_prev)-1
+        return ind_new
+
+    def display_controls(self):
+        if not self.FlagDisplayControls: return
+        FlagVisible=self.TABpar.flagRun==0 and len(self.TABpar.link)==0 
+        self.ui.button_restore_undo.setVisible(FlagVisible)
+        self.ui.button_back.setVisible(FlagVisible)
+        self.ui.button_forward.setVisible(FlagVisible)
+        lprev=len(self.TABpar_prev_at(self.TABpar.ind))
+        if self.onlyReadLabel:
+            if len(self.TABpar.link)==0:
+                if lprev:
+                    ITE0=self.gui.ui.Explorer.ITEsfromInd(self.TABpar.ind)[0]
+                    if ITE0.flagRun==0:
+                        self.onlyReadLabel.setText('')
+                    else:
+                        self.onlyReadLabel.setText('read-only')
+                else:
+                    self.onlyReadLabel.setText('')
+                self.button_link_step.setToolTip('Link current process step to another in the same project')
+                self.button_link_step.setIcon(self.icon_link)
+                self.gui.RCLbar.buttonData[3]['name']='Link step to...'
+            else:
+                if hasattr(self.gui,'ui') and hasattr(self.gui.ui,'Explorer'):
+                    ITE0_master=self.gui.ui.Explorer.ITEsfromInd(self.TABpar.link)[0]
+                    linkInfo=f'linked to {ITE0_master.ind[2]+1}: {ITE0_master.name}'
+                    self.onlyReadLabel.setText(linkInfo)
+                else:
+                    self.onlyReadLabel.setText('')
+                self.button_link_step.setToolTip('Unlink current process step')
+                self.button_link_step.setIcon(self.icon_unlink)
+                self.gui.RCLbar.buttonData[3]['name']='Unlink step'
+            self.button_link_step.setStatusTip(self.button_link_step.toolTip())
+            self.button_link_step.setChecked(len(self.TABpar.link)!=0)
+
+            if self.gui.ui.Explorer.TREpar.step is None:
+                FlagProcessTree=False
+            else:
+                FlagProcessTree=self.gui.ui.Explorer.currentTree==self.gui.ui.Explorer.processTree and self.gui.ui.Explorer.TREpar.step>0
+            FlagLabel=(self.TABpar.flagRun!=0 and len(self.TABpar.link)==0) or len(self.TABpar.link)>0
+            FlagReset=self.TABpar.flagRun!=0 and len(self.TABpar.link)==0
+            FlagInherit=self.TABpar.flagRun==0 and len(self.TABpar.link)==0 and len(self.gui.IOVheritableSteps())>0
+            FlagCopy=self.TABpar.flagRun==0 and len(self.TABpar.link)==0 and len(self.gui.linkableSteps(FlagExcludeLinked=True))>0
+            FlagLink=(len(self.TABpar.link)==0 and self.TABpar.flagRun==0 and len(self.gui.linkableSteps(FlagExcludeLinked=True))>0) or len(self.TABpar.link)>0
+            if FlagProcessTree and (FlagLabel or FlagReset or FlagInherit or FlagCopy or FlagLink):
+                self.gui.w_RCL.setVisible(True)
+                self.onlyReadLabel.setVisible(FlagLabel)
+                self.button_reset_step.setVisible(FlagReset)
+                self.button_step_inherit.setVisible(FlagInherit)
+                self.button_copy_step.setVisible(FlagCopy)
+                self.button_link_step.setVisible(FlagLink)
+            else:
+                self.gui.w_RCL.setVisible(False)
+            FlagEnabled = not self.gui.FlagRun
+            self.button_reset_step.setEnabled(FlagEnabled)
+            self.button_step_inherit.setEnabled(FlagEnabled)
+            self.button_copy_step.setEnabled(FlagEnabled)
+            self.button_link_step.setEnabled(FlagEnabled)
+
+        if self.TABpar.flagRun or len(self.TABpar.link)>0: return
+
+        i=self.TABpar.ind[-1]
+        self.ui.button_restore_undo.setVisible(lprev>1)
+        self.ui.button_forward.setVisible(lprev>1)
+        self.ui.button_back.setVisible(lprev>1)
+        self.ui.button_restore_undo.setEnabled(not (i==lprev-1 or i==-1))
+        self.ui.button_forward.setEnabled(not (i==lprev-1 or i==-1))
+        self.ui.button_back.setEnabled(i!=0)
+        if self.ui.label_number.isVisible():
+            if i==lprev-1 or i==-1:
+                self.ui.label_number.setText('')
+            elif i>=0:
+                self.ui.label_number.setText("(-"+str(lprev-1-i)+")")
+            else:
+                self.ui.label_number.setText("(-"+str(i+1)+")")
+
+    def button_back_action(self):
+        ind=self.TABpar.ind
+        ind[-1]-=1
+        self.FlagSettingPar=True
         self.setFocus()
+        self.FlagSettingPar=False
+        self.setTABpar_at(ind,FlagAdjustPar=ind[-1]==0,FlagBridge=True) #True=with bridge
+        return False
 
-    def button_forward_callback(self):
-        ind=self.TABpar.ind+1
-        self.setTABpar_prev(self.TABpar.indTree,self.TABpar.indItem,ind,True) #True=with bridge
+    def button_forward_action(self):
+        ind=self.TABpar.ind
+        ind[-1]+=1
+        self.FlagSettingPar=True
         self.setFocus()
+        self.FlagSettingPar=False
+        self.setTABpar_at(ind,FlagAdjustPar=ind[-1]==0,FlagBridge=True) #True=with bridge
+        return False
 
     def bfContextMenu(self,bf,event):
-        ind=self.TABpar.ind
-        TABpar_prev=self.TABpar_prev[self.TABpar.indTree][self.TABpar.indItem]
+        i=self.TABpar.ind[-1]
+        TABpar_prev=self.TABpar_prev_at(self.TABpar.ind)
 
         if bf==-1:
             b=self.ui.button_back
-            f=self.button_back_callback
-            kin=max([0,ind-Num_Prevs_back_forw])
-            krange=[k for k in range(ind-1,kin,-1)]+[0]
+            f=self.button_back_action
+            kin=max([0,i-Num_Prevs_back_forw])
+            krange=[k for k in range(i-1,kin,-1)]+[0]
             icon=self.undo_icon
             d=1
         elif bf==1:
             b=self.ui.button_forward
-            f=self.button_forward_callback
-            kfin=min([len(TABpar_prev)-1,ind+Num_Prevs_back_forw])
-            krange=[k for k in range(ind+1,kfin)]+[len(TABpar_prev)-1]
+            f=self.button_forward_action
+            kfin=min([len(TABpar_prev)-1,i+Num_Prevs_back_forw])
+            krange=[k for k in range(i+1,kfin)]+[len(TABpar_prev)-1]
             icon=self.redo_icon
             d=0
 
@@ -540,7 +969,7 @@ class gPaIRS_Tab(QWidget):
                     s=' (...)'
                 else:
                     s=''
-            n=f"{k-ind:+d}: "
+            n=f"{k-i:+d}: "
             name=n+TABpar_prev[k+d].tip+s
             act.append(QAction(icon,name,b))
             menu.addAction(act[-1])  
@@ -548,71 +977,21 @@ class gPaIRS_Tab(QWidget):
         action = menu.exec_(b.mapToGlobal(event.pos()))
         for k,a in zip(krange,act):
             if a==action: 
-                self.TABpar.ind=k-bf
+                self.TABpar.ind[-1]=k-bf
                 f()
 
-    def cleanPrevs(self,indTree,indItem):
-        TABpar_prev=self.TABpar_prev[indTree][indItem]
-        for _ in range(len(TABpar_prev)-1):
+    def cleanPrevs(self,ind,FlagAllPrev=False):
+        TABpar_prev=self.TABpar_prev_at(ind)
+        for _ in range(len(TABpar_prev)-1*int(not FlagAllPrev)):
             TABpar_prev.pop(0)
-        TABpar_prev[0].ind=0
-        if self.TABpar.indTree==indTree and self.TABpar.indItem==indItem:
-            self.TABpar.ind=0
-
-#*************************************************** Spin boxes
-    def spinFocusIn(self,sp):
-        sp.valIn=sp.value()
-        sp.FlagIn=True
-
-    def spinWrapper(self,sp,fcallback):
-        def newfcallback():
-            fcallback()
-            if sp.FlagIn:
-                if sp.value()!=sp.valIn:
-                    sp.FlagIn=False
-                    flagAddPar=+1
-                else:
-                    flagAddPar=0
-            else: flagAddPar=-1
-            return [flagAddPar,None]
-        return newfcallback
-    
-    def setSpinCallbacks(self,SpinNames,*args):
-        if len(args): Tips=args[0]
-        else: Tips=SpinNames
-        def spinCallback(sname,tip):
-            sp=getattr(self.ui,"spin_"+sname)
-            sp.FlagIn=False
-            sp.valIn=sp.value()
-            fcallback=getattr(self,"spin_"+sname+"_callback")
-            #sp.valueChanged.connect(self.addParWrapper(self.spinWrapper(sp,fcallback),sname))
-            sp.valueChanged.connect(fcallback)
-            sp.addfuncin['initCallback']=lambda spin=sp: self.spinFocusIn(spin)
-            def fout():
-                if sp.value()!=sp.valIn:
-                    return [1,None]
-                else:
-                    return [-1,None] 
-            sp.addfuncout['callback']=self.addParWrapper(fout,tip)
-            sp.addfuncreturn['callback']=self.addParWrapper(None,tip)
-        for sname,tip in zip(SpinNames,Tips):
-            spinCallback(sname,tip)
-            
+        if not FlagAllPrev:
+            TABpar_prev[0].ind[-1]=0
+            if self.TABpar.ind[:-1]==ind[:-1]:
+                self.TABpar.ind[-1]=0
 
-#*************************************************** Special spin boxes (x,y,w,h)
-    def setSpinxywhCallbacks(self):
-        self.spin_x_callback=lambda: spin_x_callback(self)
-        self.spin_y_callback=lambda: spin_y_callback(self)
-        self.spin_w_callback=lambda: spin_w_callback(self)
-        self.spin_h_callback=lambda: spin_h_callback(self)
-        self.button_resize_callback=lambda: button_resize_callback(self)
-        self.setSpinCallbacks(['x','y','w','h'],
-            ['First column of image area to process','First row of image','Width of image area to process','Height of image area to process'])
-        self.ui.button_resize.clicked.connect(self.addParWrapper(self.button_resize_callback,'resize button'))
 
+#*************************************************** Special spin boxes (x,y,w,h)
     def setMinMaxSpinxywh(self):
-        h=self.TABpar.h
-        w=self.TABpar.w
         self.ui.spin_x.setMinimum(0)
         self.ui.spin_x.setMaximum(self.TABpar.W-1)
         self.ui.spin_y.setMinimum(0)
@@ -621,11 +1000,49 @@ class gPaIRS_Tab(QWidget):
         self.ui.spin_w.setMaximum(self.TABpar.W)
         self.ui.spin_h.setMinimum(1)
         self.ui.spin_h.setMaximum(self.TABpar.H)
-        self.TABpar.h=h
-        self.TABpar.w=w
-        for sname in ('spin_x','spin_y','spin_w','spin_h'):
-            self.newTip(sname)
+        for field in ('spin_x','spin_y','spin_w','spin_h'):
+            s:MyQSpin=getattr(self.ui,field)
+            tip=getattr(self,"tip_"+field)
+            stringa=". Image size: "+str(self.TABpar.W)+"x"+str(self.TABpar.H)
+            newtip=tip+stringa
+            s.setToolTip(newtip)
+            s.setStatusTip(newtip)
+        self.check_resize()
+
+    def check_resize(self):
+        if self.TABpar.W!=self.TABpar.w or \
+            self.TABpar.H!=self.TABpar.h:
+            self.ui.button_resize.show()
+        else:
+            self.ui.button_resize.hide()     
+
+    def button_resize_action(self):
+        self.TABpar.x=self.TABpar.y=0
+        self.TABpar.w=self.TABpar.W
+        self.TABpar.h=self.TABpar.H
+        self.ui.spin_w.setMaximum(self.TABpar.W)
+        self.ui.spin_h.setMaximum(self.TABpar.H)
+        return
+
+    def spin_x_changing(self):
+        wmax=self.TABpar.W-self.ui.spin_x.value()
+        self.ui.spin_w.setMaximum(wmax)
+        w=min([self.TABpar.w,wmax])
+        self.ui.spin_w.setValue(w)
 
+    def spin_x_action(self):
+        self.TABpar.w=self.ui.spin_w.value()
+
+    def spin_y_changing(self):
+        hmax=self.TABpar.H-self.ui.spin_y.value()
+        self.ui.spin_h.setMaximum(hmax)
+        h=min([self.TABpar.h,hmax])
+        self.ui.spin_h.setValue(h)
+
+    def spin_y_action(self):
+       self.TABpar.h=self.ui.spin_h.value()
+
+#*************************************************** Widget setup
     def newTip(self,field):
         s: MyQSpin
         if field=='spin_range_from':  #INPpar
@@ -636,70 +1053,17 @@ class gPaIRS_Tab(QWidget):
             s=self.ui.spin_range_to
             stringa=". Max.: "+str(s.maximum())
             newtip=self.tip_spin_range_to+stringa
-        elif field in ('spin_x','spin_y','spin_w','spin_h'):  #INPpar and #OUTpar
-            s=getattr(self.ui,field)
-            tip=getattr(self,"tip_"+field)
-            stringa=". Image size: "+str(self.TABpar.W)+"x"+str(self.TABpar.H)
-            newtip=tip+stringa
         s.setToolTip(newtip)
         s.setStatusTip(newtip)  
 
-    def setValueSpinxywh(self):
-        self.ui.spin_x.setValue(self.TABpar.x)
-        self.ui.spin_y.setValue(self.TABpar.y)
-        self.ui.spin_w.setValue(self.TABpar.w)
-        self.ui.spin_h.setValue(self.TABpar.h)
-        self.check_resize()
-
-    def check_resize(self):
-        if self.TABpar.W!=self.ui.spin_w.value() or \
-            self.TABpar.H!=self.ui.spin_h.value():
-            self.ui.button_resize.show()
-        else:
-            self.ui.button_resize.hide()   
-
-#*************************************************** Image sizes
-def spin_x_callback(self):
-    self.TABpar.x=self.ui.spin_x.value()
-    if self.ui.spin_x.hasFocus():
-        dx=self.TABpar.W-self.TABpar.x
-        self.ui.spin_w.setMaximum(dx)
-        if self.ui.spin_x.Win<dx:
-            dx=self.ui.spin_x.Win
-        self.TABpar.w=dx
-        self.ui.spin_w.setValue(dx)
-        
-def spin_y_callback(self):
-    self.TABpar.y=self.ui.spin_y.value()
-    if self.ui.spin_y.hasFocus():
-        dy=self.ui.spin_y.Win-self.TABpar.y
-        self.ui.spin_h.setMaximum(dy)
-        if self.ui.spin_y.Win<dy:
-            dy=self.ui.spin_y.Win
-        self.TABpar.h=dy    
-        self.ui.spin_h.setValue(dy)
-        
-def spin_w_callback(self):
-    self.TABpar.w=self.ui.spin_w.value()
-
-def spin_h_callback(self):
-    self.TABpar.h=self.ui.spin_h.value()
-
-def button_resize_callback(self):
-        self.ui.spin_x.setValue(0)
-        self.ui.spin_y.setValue(0)
-        self.ui.spin_w.setMaximum(self.TABpar.W)
-        self.ui.spin_w.setValue(self.TABpar.W)
-        self.ui.spin_h.setMaximum(self.TABpar.H)
-        self.ui.spin_h.setValue(self.TABpar.H)
-        self.check_resize()
-        return [1, None]
-
-def setupWid(self:QWidget):
-    setFontPixelSize(self,fontPixelSize)
+#*************************************************** Widget setup
+def setupWid(self:gPaIRS_Tab,FlagFontSize=True):
+    if FlagFontSize: setFontPixelSize(self,fontPixelSize)
     
-    c=self.findChildren(QObject)
-    for w in c:
+    if hasattr(self,'widgets'): widgets=self.widgets
+    else: widgets=self.findChildren(QWidget)
+    widgets+=self.findChildren(CollapsibleBox)
+    for w in widgets:
         w:QToolButton
         if hasattr(w,'toolTip'):
             tooltip=toPlainText(w.toolTip())
@@ -710,28 +1074,17 @@ def setupWid(self:QWidget):
                     if scut not in tooltip:
                         tooltip+=' '+scut
                         w.setToolTip(tooltip)
-            if hasattr(w,'statusTip'):
-                w.setStatusTip(tooltip)
+            #if hasattr(w,'statusTip'):
+            w.setStatusTip(tooltip)
                     
-    self.ui.labels=self.findChildren(QLabel)
-    #for child in self.ui.labels:
-    #    child:QLabel
-    #    child.setToolTip(child.text())
-    #    child.setStatusTip(child.text())
-    self.ui.edits=self.findChildren(MyQLineEdit)+self.findChildren(MyQLineEditNumber)
-    for child in self.ui.edits:
-        child.setup()
-    for child in self.ui.edits:
-        child.setup2()
-    self.ui.spins=self.findChildren(MyQSpin)
-    for child in self.ui.spins:
-        child.setup()
-    self.ui.dspins=self.findChildren(MyQDoubleSpin)
-    for child in self.ui.dspins:
-        child.setup()
-    self.ui.CollapBoxes=self.findChildren(CollapsibleBox)
-    for child in self.ui.CollapBoxes:
-        child.setup()
+        if hasattr(w,'setup'):
+            w.setup()
+        if hasattr(w,'setup2'):
+            w.setup2()
+
+        if isinstance(w,QToolButton) or isinstance(w,QPushButton):
+            if w.cursor().shape()==Qt.CursorShape.ArrowCursor:
+                w.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
 
     for sname in ('range_from','range_to','x','y','w','h'):
         if hasattr(self.ui,"spin_"+sname):
@@ -743,10 +1096,20 @@ def setFontPixelSize(self,fPixSize):
     font.setFamily(fontName)
     font.setPixelSize(fPixSize)
     self.setFont(font)
-    c=self.findChildren(QObject)
+    c=self.findChildren(QWidget)
     for w in c:
         w:QWidget
-        if hasattr(w,'setFont'):
+        if w.objectName()=='title_project' and hasattr(self,'projectTree'):
+            self.projectTree.titleFont(w,fPixSize)
+        elif  w.objectName()=='subtitle_project' and hasattr(self,'projectTree'):
+            self.projectTree.subTitleFont(w,fPixSize)
+        elif w.objectName()=='title_process' and hasattr(self,'processTree'):
+            self.processTree.titleFont(w,fPixSize)
+        elif  w.objectName()=='subtitle_process' and hasattr(self,'processTree'):
+            self.processTree.subTitleFont(w,fPixSize)
+        elif  w.objectName()=='title_step':
+            w.parent().stepTitleFont(w,fPixSize)
+        elif hasattr(w,'setFont'):
             font=w.font()
             font.setFamily(fontName)
             t=type(w)
@@ -760,14 +1123,20 @@ def setFontPixelSize(self,fPixSize):
                 font.setPixelSize(fPixSize)
                 w.setFont(font)
                 adjustFont(w)
-
+    c=self.findChildren(RichTextPushButton)
+    for w in c:
+        font=w.font()
+        font.setFamily(fontName)
+        font.setPixelSize(fPixSize+3)
+        w.lbl.setFont(font)
+        
 def setFontSizeText(lab:QLabel,fPixSizes):
     text=lab.text()
-    text=re.sub("font-size:\d+pt",f"font-size:{fPixSizes[0]}px",text)   
-    text=re.sub("font-size:\d+px",f"font-size:{fPixSizes[0]}px",text)  
+    text=re.sub(r"font-size:\d+pt",f"font-size:{fPixSizes[0]}px",text)   
+    text=re.sub(r"font-size:\d+px",f"font-size:{fPixSizes[0]}px",text)  
     if len(fPixSizes)>1:
         for k in range(len(fPixSizes)-1,0,-1):
-            text=re.sub("font-size:\d+px",f"font-size:{fPixSizes[k]}px",text,k)
+            text=re.sub(r"font-size:\d+px",f"font-size:{fPixSizes[k]}px",text,k)
     lab.setText(text)
     font=lab.font()
     font.setPixelSize(fPixSizes[0])
@@ -844,55 +1213,6 @@ def iterateList(l,value):
                     for k in range(len(l)):
                         l[k]=value
 
-#*************************************************** TREE icons
-class TREico:
-    def __init__(self):
-        self.none = QIcon()
-
-        self.completed = QIcon()  
-        self.completed.addFile(""+ icons_path +"completed.png", QSize(), QIcon.Normal, QIcon.Off)
-
-        self.done = QIcon()       
-        self.done.addFile(""+ icons_path +"done.png", QSize(), QIcon.Normal, QIcon.Off)
-    
-        self.cancelled = QIcon()  
-        self.cancelled.addFile(""+ icons_path +"cancelled.png", QSize(), QIcon.Normal, QIcon.Off)
-
-        self.trash = QIcon()      
-        self.trash.addFile(""+ icons_path +"trash.png", QSize(), QIcon.Normal, QIcon.Off)
-
-        self.running = QIcon()
-        self.running.addFile(""+ icons_path +"processing.png", QSize(), QIcon.Normal, QIcon.Off)
-
-        self.waiting = QIcon()
-        self.waiting.addFile(""+ icons_path +"waiting_circle.png", QSize(), QIcon.Normal, QIcon.Off)
-
-        self.issue = QIcon()
-        self.issue.addFile(""+ icons_path +"issue.png", QSize(), QIcon.Normal, QIcon.Off)
-    
-        self.missing = QIcon()
-        self.missing.addFile(""+ icons_path +"missing.png", QSize(), QIcon.Normal, QIcon.Off)
-
-        self.editing = QIcon()
-        self.editing.addFile(""+ icons_path +"editing.png", QSize(), QIcon.Normal, QIcon.Off)
-
-        self.paused = QIcon()
-        self.paused.addFile(""+ icons_path +"paused.png", QSize(), QIcon.Normal, QIcon.Off)
-
-        self.icon_names=[f for f,_ in self.__dict__.items()]
-
-    def icontype(self,type_name):
-        type=self.icon_names.index(type_name)
-        return type
-    
-    def icon(self,icon_type):
-        if type(icon_type)==int:
-            type_name=self.icon_names[icon_type]
-        else:
-            type_name=icon_type
-        icon=getattr(self,type_name)
-        return icon
-
 def funexample():
     def fun2(i):
         if FlagSimulateError:
@@ -911,15 +1231,15 @@ if __name__ == "__main__":
     a.copyfrom(b)
     a.printPar('a: ','   copied from b')
     c.printPar('c: ')
-    c.copyfromdiz(b,['surname'])
+    c.copyfromfields(b,['surname'])
     c.printPar('c: ', '   surname copied from b')
 
-    print(f'Is a different from b? {a.isDifferentFrom(b,())}')
-    print(f'Is a equal to b? {a.isEqualTo(b,())}')
-    print(f'Is c different from b? {c.isDifferentFrom(b,())}')
-    print(f'Is c equal to b? {c.isEqualTo(b,())}')
-    print(f'Is c different from b except surname? {c.isDifferentFrom(b,("surname"))}')
-    print(f'Is c equal to b except name? {c.isEqualTo(b,("name"))}')
+    print(f'Is a different from b? {a.isDifferentFrom(b)}')
+    print(f'Is a equal to b? {a.isEqualTo(b)}')
+    print(f'Is c different from b? {c.isDifferentFrom(b)}')
+    print(f'Is c equal to b? {c.isEqualTo(b)}')
+    print(f'Is c different from b except surname? {c.isDifferentFrom(b,["surname"])}')
+    print(f'Is c equal to b except name? {c.isEqualTo(b,["name"])}')
 
     """
     app=QApplication.instance()