PaIRS-UniNa 0.2.7__cp311-cp311-win_amd64.whl → 0.2.11__cp311-cp311-win_amd64.whl

PaIRS_UniNa/addwidgets_ps.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+import types
 from .PaIRS_pypacks import *
 #from ui_Tree_Tab import Ui_TreeTab
 
@@ -9,9 +11,10 @@ InitCheck=True   #False=Collap closed, True=opened
 font_italic=True
 font_weight=QFont.DemiBold
 backgroundcolor_none=" background-color: none;"
-backgroundcolor_changing=" background-color: rgb(255,230,230);"
-color_changing="color: rgb(33,33,255); "+backgroundcolor_changing
-color_changing_black="color: rgb(0,0,0); "+backgroundcolor_changing
+backgroundcolor_changing=f" background-color: {PaIRS_pink};"
+backgroundcolor_hover=f" background-color: {PaIRS_ghostblue};"
+border_hover = " "  #"border: 1px solid gray; "
+color_changing=f"color: {PaIRS_darkblue}; "+backgroundcolor_changing
 
 #********************************************* Operating Widgets
 def setSS(b,style):
@@ -53,6 +56,9 @@ class MyQLineEdit(QtWidgets.QLineEdit):
     def setup(self):
         if not self.initFlag:
             self.initFlag=True
+            self.FlagFocusIn=False
+            self.oldFont=None
+            self.oldStyle=None
             font_changing = QtGui.QFont(self.font())
             font_changing.setItalic(font_italic)
             font_changing.setWeight(font_weight)
@@ -63,21 +69,17 @@ class MyQLineEdit(QtWidgets.QLineEdit):
                 if hasattr(b,'setStyleSheet'):
                     if hasStyleFlag:
                         if b.styleFlag: continue
-                    b.flagS=True
                     b.initialStyle=b.styleSheet()+" "+backgroundcolor_none
                     b.setEnabled(False)
                     b.disabledStyle=b.styleSheet()
                     b.setEnabled(True)
-                    b.setStyleSheet(setSS(b,b.initialStyle))
-                else:
-                    b.flagS=False
+                    b.setStyleSheet(setSS(b,b.initialStyle)+"\n"+gPaIRS_QMenu_style)
                 if hasattr(b,'setFont'):
-                    b.flagF=True
                     b.initialFont=b.font()
                     b.font_changing=font_changing
-                else:
-                    b.flagF=False
                 if hasStyleFlag: b.styleFlag=True
+            self.CElabs=[w for w in self.bros if isinstance(w, ClickableEditLabel)]
+            self.CElabs_styles=[w.styleSheet() for w in self.CElabs]
 
     def setup2(self):
         if not self.initFlag2:
@@ -99,57 +101,106 @@ class MyQLineEdit(QtWidgets.QLineEdit):
         self.setCompleterList()
 
     def enterEvent(self, event):
-        super().enterEvent(event)
-        if not self.font()==self.font_changing and not self.hasFocus():
+        if not self.hasFocus() and self.isEnabled():
+            self.oldFont=self.font()
+            self.oldStyle=self.styleSheet()
             self.setFont(self.font_changing)
-
+            self.setStyleSheet(setSS(self,self.initialStyle+" "+backgroundcolor_hover)+"\n"+gPaIRS_QMenu_style)
+            for k,w in enumerate(self.CElabs): 
+                self.CElabs_styles[k]=w.styleSheet()
+                w.setStyleSheet(w.styleSheet()+" "+f"""
+                ClickableEditLabel {{
+                    {backgroundcolor_hover};
+                }}
+                """)
+                w.repaint()
+        super().enterEvent(event)
+            
     def leaveEvent(self, event):
+        if not self.hasFocus() and self.oldFont is not None:
+            self.setFont(self.oldFont)
+            self.setStyleSheet(self.oldStyle)
+            for k,w in enumerate(self.CElabs): 
+                w.setStyleSheet(self.CElabs_styles[k])
+                w.repaint()
+            self.oldFont=None
+            self.oldStyle=None
         super().leaveEvent(event)
-        if self.font()==self.font_changing and not self.hasFocus():
-            self.setFont(self.initialFont)
 
     def focusInEvent(self, event):
         super().focusInEvent(event)
         for f in self.addfuncin:
             self.addfuncin[f]()
         self.focusInFun()
-            
+               
     def setFocus(self):
         super().setFocus()
         self.focusInFun()
 
     def focusInFun(self):
-        self.setStyleSheet(setSS(self,self.initialStyle+" "+color_changing))
-        self.setFont(self.font_changing)
+        self.setStyleFont(color_changing,self.font_changing)
+
+    def setStyleFont(self,color_changing,font):
         for b in self.bros:
-            if (not b==self) and b.flagS:
-                    b.setStyleSheet(b.initialStyle+" "+color_changing_black)
-                 
+            if hasattr(b,'setInitalStyle') and hasattr(b,'FlagFocusIn') and b.FlagFocusIn: 
+                b.setInitalStyle()
+                break
+        if not self.FlagFocusIn:
+            self.FlagFocusIn=True
+            self.setFont(font)
+            for b in self.bros:
+                if hasattr(b,'initialStyle'): 
+                    b.setStyleSheet(setSS(b,b.initialStyle+" "+color_changing)+"\n"+gPaIRS_QMenu_style)
+
     def focusOutEvent(self, event):
         super().focusOutEvent(event) #to preserve classical behaviour before adding the below
         for f in self.addfuncout:
             self.addfuncout[f]()
-        self.focusOutFun()
+        self.setInitalStyle()
 
     def clearFocus(self):
         super().clearFocus()
-        self.focusOutFun()
+        self.setInitalStyle()
 
-    def focusOutFun(self):
-        for b in self.bros:
-            if b.flagS:
+    def setInitalStyle(self):
+        if self.FlagFocusIn:
+            self.FlagFocusIn=False
+            for b in self.bros:
                 if hasattr(b,'default_stylesheet'):
                     b.setStyleSheet(b.default_stylesheet)
-                else:
-                    b.setStyleSheet(setSS(b,b.initialStyle))
-            if b.flagF:
-                b.setFont(b.initialFont)
-        #self.addlab.clear()
+                elif hasattr(b,'initialStyle'):
+                    b.setStyleSheet(b.initialStyle)
+                if  hasattr(b,'initialFont'):
+                    b.setFont(b.initialFont)
+            for k,w in enumerate(self.CElabs): 
+                self.CElabs_styles[k]=w.default_stylesheet
+                w.setStyleSheet(self.CElabs_styles[k])
+                w.repaint()
+            self.oldFont=None
+            self.oldStyle=None
+            #self.addlab.clear()
             
     def showCompleter(self):
-        if self.completer():
-            self.completer().complete()
-
+        comp=self.completer()
+        if comp:
+            view=comp.popup()
+            # ---- focus item matching line edit text ----
+            text = (self.text() or "").strip()
+            if text:
+                model = comp.completionModel() or comp.model()
+                col = comp.completionColumn()
+                for r in range(model.rowCount()):
+                    idx = model.index(r, col)
+                    if not idx.isValid():
+                        continue
+                    if (idx.data() or "") == text:
+                        comp.setCurrentRow(r)
+                        view.setCurrentIndex(idx)
+                        view.scrollTo(idx, QAbstractItemView.PositionAtCenter)
+                        break
+            view.setStyleSheet(gPaIRS_Completer_style)
+            comp.complete()
+            
 class MyQLineEditNumber(MyQLineEdit):
     def __init__(self,parent):
         super().__init__(parent)       
@@ -185,11 +236,14 @@ class MyQSpin(QtWidgets.QSpinBox):
         self.addfuncreturn={}
         
         self.setAccelerated(True)
-        self.setGroupSeparatorShown(True)
+        self.setGroupSeparatorShown(True)       
 
     def setup(self): 
         if not self.initFlag:
             self.initFlag=True
+            self.FlagFocusIn=False
+            self.oldFont=None
+            self.oldStyle=None
             font_changing = QtGui.QFont(self.font())
             font_changing.setItalic(font_italic)
             font_changing.setWeight(font_weight)
@@ -200,15 +254,14 @@ class MyQSpin(QtWidgets.QSpinBox):
                 b.initialFont=b.font()
                 b.font_changing=font_changing
                 b.styleFlag=True
-            self.spinFontObj=[]
-            for c in self.findChildren(QObject):
-                if hasattr(c,'setFont'):
-                    self.spinFontObj+=[c]
-
+            #self.spinFontObj = self.findChildren(QtWidgets.QLineEdit)[0]
+            #self.spinFontObj.initialStyle=self.spinFontObj.styleSheet()+" "+backgroundcolor_none
+            #self.spinFontObj.font_changing=font_changing
+                
     def setFocus(self):
         super().setFocus()
         self.focusInFun()
-
+    
     def focusInEvent(self, event):
         super().focusInEvent(event) #to preserve classical behaviour before adding the below
         for f in self.addfuncin:
@@ -216,23 +269,51 @@ class MyQSpin(QtWidgets.QSpinBox):
         self.focusInFun()
 
     def focusInFun(self):
-        if not self.font()==self.font_changing:
+        if not self.FlagFocusIn:
+            self.FlagFocusIn=True
+            #self.spinFontObj.setStyleSheet(self.spinFontObj.initialStyle+" "+color_changing)
             for b in self.bros:
-                b.setStyleSheet(b.initialStyle+" "+color_changing)
-                b.setFont(b.font_changing)
-            for b in self.spinFontObj:
+                b.setStyleSheet(setSS(b,b.initialStyle+" "+color_changing)+"\n"+gPaIRS_QMenu_style)
                 b.setFont(self.font_changing)
 
+    def clearFocus(self):
+        super().clearFocus()
+        self.setInitalStyle()
+
     def focusOutEvent(self, event):
         super().focusOutEvent(event) #to preserve classical behaviour before adding the below
         for f in self.addfuncout:
             self.addfuncout[f]()
-        if self.font()==self.font_changing:
+        self.setInitalStyle()
+    
+    def setInitalStyle(self):
+        if self.FlagFocusIn:
+            self.FlagFocusIn=False
+            #self.spinFontObj.setStyleSheet(self.spinFontObj.initialStyle)
             for b in self.bros:
-                b.setStyleSheet(b.initialStyle)
-                b.setFont(b.initialFont)
-            for b in self.spinFontObj:
-               b.setFont(self.initialFont)
+                b.setStyleSheet(setSS(b,b.initialStyle)+"\n"+gPaIRS_QMenu_style)
+                b.setFont(self.initialFont)
+            self.findChildren(QtWidgets.QLineEdit)[0].setFont(self.initialFont)
+            self.oldFont=None
+            self.oldStyle=None
+
+    def enterEvent(self, event):
+        super().enterEvent(event)
+        if not self.hasFocus() and self.isEnabled():
+            self.oldFont=self.font()
+            self.setFont(self.font_changing)
+            b=self #b=self.spinFontObj
+            self.oldStyle=b.styleSheet()
+            b.setStyleSheet(setSS(b,b.initialStyle+" "+backgroundcolor_hover+" "+border_hover)+"\n"+gPaIRS_QMenu_style)
+            
+    def leaveEvent(self, event):
+        super().leaveEvent(event)
+        if not self.hasFocus() and self.oldFont is not None:
+            self.setFont(self.oldFont)
+            b=self #b=self.spinFontObj
+            b.setStyleSheet(self.oldStyle)
+            self.oldFont=None
+            self.oldStyle=None
 
     def keyPressEvent(self, event):
         super().keyPressEvent(event)
@@ -284,6 +365,9 @@ class MyQDoubleSpin(QtWidgets.QDoubleSpinBox):
     def setup(self): 
         if not self.initFlag:
             self.initFlag=True
+            self.FlagFocusIn=False
+            self.oldFont=None
+            self.oldStyle=None
             font_changing = QtGui.QFont(self.font())
             font_changing.setItalic(font_italic)
             font_changing.setWeight(font_weight)
@@ -294,33 +378,67 @@ class MyQDoubleSpin(QtWidgets.QDoubleSpinBox):
                 b.initialFont=b.font()
                 b.font_changing=font_changing
                 b.styleFlag=True
-            self.spinFontObj=[]
-            for c in self.findChildren(QObject):
-                if hasattr(c,'setFont'):
-                    self.spinFontObj+=[c]
+            #self.spinFontObj = self.findChildren(QtWidgets.QLineEdit)[0]
+            #self.spinFontObj.initialStyle=self.spinFontObj.styleSheet()+" "+backgroundcolor_none
+            #self.spinFontObj.font_changing=font_changing
+
+    def setFocus(self):
+        super().setFocus()
+        self.focusInFun()
 
     def focusInEvent(self, event):
         super().focusInEvent(event) #to preserve classical behaviour before adding the below
         for f in self.addfuncin:
             self.addfuncin[f]()
-        if not self.font()==self.font_changing:
+        self.focusInFun()
+
+    def focusInFun(self):
+        if not self.FlagFocusIn:
+            self.FlagFocusIn=True
+            #self.spinFontObj.setStyleSheet(self.spinFontObj.initialStyle+" "+color_changing)
             for b in self.bros:
-                b.setStyleSheet(b.initialStyle+" "+color_changing)
-                b.setFont(self.font_changing)
-            for b in self.spinFontObj:
+                b.setStyleSheet(setSS(b,b.initialStyle+" "+color_changing)+"\n"+gPaIRS_QMenu_style)
                 b.setFont(self.font_changing)
 
+    def clearFocus(self):
+        super().clearFocus()
+        self.setInitalStyle()
+
     def focusOutEvent(self, event):
         super().focusOutEvent(event) #to preserve classical behaviour before adding the below
         for f in self.addfuncout:
             self.addfuncout[f]()
-        if self.font()==self.font_changing:
+        self.setInitalStyle()
+    
+    def setInitalStyle(self):
+        if self.FlagFocusIn:
+            self.FlagFocusIn=False
+            #self.spinFontObj.setStyleSheet(self.spinFontObj.initialStyle)
             for b in self.bros:
-                b.setStyleSheet(b.initialStyle)
-                b.setFont(b.initialFont)
-            for b in self.spinFontObj:
+                b.setStyleSheet(setSS(b,b.initialStyle)+"\n"+gPaIRS_QMenu_style)
                 b.setFont(self.initialFont)
-                
+            self.findChildren(QtWidgets.QLineEdit)[0].setFont(self.initialFont)
+            self.oldFont=None
+            self.oldStyle=None
+      
+    def enterEvent(self, event):
+        super().enterEvent(event)
+        if not self.hasFocus() and self.isEnabled():
+            self.oldFont=self.font()
+            self.setFont(self.font_changing)
+            b=self #b=self.spinFontObj
+            self.oldStyle=b.styleSheet()
+            b.setStyleSheet(setSS(b,b.initialStyle+" "+backgroundcolor_hover+" "+border_hover)+"\n"+gPaIRS_QMenu_style)
+            
+    def leaveEvent(self, event):
+        super().leaveEvent(event)
+        if not self.hasFocus() and self.oldFont is not None:
+            self.setFont(self.oldFont)
+            b=self #b=self.spinFontObj
+            b.setStyleSheet(self.oldStyle)
+            self.oldFont=None
+            self.oldStyle=None
+
     def keyPressEvent(self, event):
         super().keyPressEvent(event)
         if event.key() in (Qt.Key.Key_Return,Qt.Key.Key_Enter) and self.hasFocus():
@@ -350,6 +468,20 @@ class CollapsibleBox(QtWidgets.QWidget):
         self.toggle_button:QPushButton=None
         self.push_button:MyToolButton=None
         
+    def initialize_widgets(self):
+        if self.content_area is None:
+            self.content_area=self.findChild(QtWidgets.QGroupBox)
+        if self.toggle_button is None:
+            self.toggle_button=self.findChild(QtWidgets.QToolButton)
+            if self.toggle_button:
+                self.toggle_button.setObjectName("CollapsibleBox_toggle")
+                self.toggle_button.setChecked(InitCheck)
+                self.toggle_button.clicked.connect(self.on_click)
+                if hasattr(self.toggle_button,'_orig_paintEvent'): 
+                    self.toggle_button.paintEvent = self.toggle_button._orig_paintEvent
+        if self.push_button is None:
+            self.push_button=self.findChild(MyToolButton)
+
     def setup(self,*args):
         if not self.initFlag:
             if len(args):
@@ -360,29 +492,17 @@ class CollapsibleBox(QtWidgets.QWidget):
                 self.stretch=0
             self.initFlag=True
 
-            if self.content_area is None:
-                self.content_area=self.findChild(QtWidgets.QGroupBox)
+            self.initialize_widgets()
             self.content_area.setStyleSheet("QGroupBox{border: 1px solid gray; border-radius: 6px;}")
-
-            if self.toggle_button is None:
-                self.toggle_button=self.findChild(QtWidgets.QToolButton)
-                self.toggle_button.setChecked(InitCheck)
-                self.toggle_button.clicked.connect(self.on_click)    
             self.toggle_button.setCursor(QtCore.Qt.CursorShape.PointingHandCursor)
             self.toggle_button.setMinimumWidth(self.toolMinimumWidth)
-
-            if self.push_button is None:
-                self.push_button=self.findChild(MyToolButton)
-
             self.OpenStyle=\
             "QToolButton { border: none; }\n"+\
-            "QToolButton::hover{color: rgba(0,0,255,200);}"+\
-            "QToolButton::focus{color: rgba(0,0,255,200);}"
+            "QToolButton::hover{color: rgba(0,116,255,200);}"
             #"QToolButton::hover{border: none; border-radius: 6px; background-color: rgba(0, 0,128,32); }"
             self.ClosedStyle=\
             "QToolButton { border: 1px solid lightgray; border-radius: 6px }\n"+\
-            "QToolButton::hover{ border: 1px solid rgba(0,0,255,200); border-radius: 6px; color: rgba(0,0,255,200);}"+\
-            "QToolButton::focus{ border: 1px solid rgba(0,0,255,200); border-radius: 6px; color: rgba(0,0,255,200);}" #background-color: rgba(0, 0,128,32); }" 
+            "QToolButton::hover{ border: 1px solid rgba(0,116,255,200); border-radius: 6px; color: rgba(0,116,255,200);}"
 
             self.heightToogle=self.toggle_button.minimumHeight()
             self.heightOpened=self.minimumHeight()
@@ -579,6 +699,7 @@ class RichTextPushButton(QPushButton):
 
         self.lyt=self.__lyt
         self.lbl=self.__lbl
+        self.icnWidget=self.__icon
         self.icn=None
         return
 
@@ -682,8 +803,8 @@ class ClickableLabel(QLabel):
     def __init__(self, *args):
         super().__init__(*args)
         
-        self.default_stylesheet = self.styleSheet()
-        self.highlight_stylesheet = "background-color: #dcdcdc; border-radius: 3px;"
+        self.default_stylesheet = self.styleSheet() 
+        self.highlight_stylesheet = f"background-color: {PaIRS_ghostblue}; border-radius: 3px;"
         
         self.timer = QTimer(self)
         self.timer.timeout.connect(self.resetHighlight)
@@ -703,6 +824,7 @@ class ClickableLabel(QLabel):
         warningDialog(self.window(),Message=self.toolTip(),pixmap=pixmap,title='Info')
 
     def highlight(self):
+        self.default_stylesheet = self.styleSheet()  # <-- capture current style
         self.setStyleSheet(self.highlight_stylesheet)
         self.repaint()
 
@@ -719,12 +841,17 @@ class ClickableLabel(QLabel):
 
 class ClickableEditLabel(ClickableLabel):
     def setup(self):
-        line_edit=QLineEdit(self)
-        line_edit.setPalette(self.palette())
-        line_edit_bg_color_str = line_edit.palette().color(QPalette.ColorRole.Base).name()
-        self.default_stylesheet=self.styleSheet()+f"ClickableEditLabel{{background-color: {line_edit_bg_color_str}}};"
+        le = QLineEdit()
+        bg = le.palette().color(QPalette.Base)
+        bg_rgba = f"rgba({bg.red()}, {bg.green()}, {bg.blue()}, {bg.alpha()})"
+
+        self.default_stylesheet = self.styleSheet() + f"""
+        ClickableEditLabel {{
+            background-color: {bg_rgba};
+        }}
+        """
         self.setStyleSheet(self.default_stylesheet)
-        line_edit.setParent(None)
+        le.setParent(None)
 
 class CustomLineEdit(QLineEdit):
     cancelEditing = Signal()
@@ -837,6 +964,372 @@ class EditableLabel(QWidget):
         self.label.show()
         self.updateLabel()
 
+class HoverZoomToolButton(QToolButton):
+    def __init__(self, parent=None, base_icon=24, zoom=1.25):
+        super().__init__(parent)
+
+        self.zoom_factor = zoom
+        self.base_size = QSize(base_icon, base_icon)
+        self.zoom_size = QSize(
+            int(base_icon * zoom),
+            int(base_icon * zoom)
+        )
+
+        self.setIconSize(self.base_size)
+
+        self.anim = QPropertyAnimation(self, b"iconSize", self)
+        self.anim.setDuration(120)
+        self.anim.setEasingCurve(QEasingCurve.OutCubic)
+
+    # --- OVERRIDE ---
+    def setIconSize(self, size: QSize):
+        """
+        Override setIconSize to automatically update base and zoom sizes.
+        """
+        super().setIconSize(size)
+        self.updateFromCurrentIconSize()
+
+    def updateFromCurrentIconSize(self, zoom: float | None = None):
+        """
+        Recompute base_size and zoom_size starting from the current iconSize().
+        Optionally updates the zoom factor.
+        """
+        if zoom is not None:
+            self.zoom_factor = zoom
+
+        current = self.iconSize()
+        self.base_size = QSize(current.width(), current.height())
+        self.zoom_size = QSize(
+            int(current.width() * self.zoom_factor),
+            int(current.height() * self.zoom_factor)
+        )
+
+    def enterEvent(self, event):
+        if self.isEnabled():
+            self.anim.stop()
+            self.anim.setStartValue(self.iconSize())
+            self.anim.setEndValue(self.zoom_size)
+            self.anim.start()
+        super().enterEvent(event)
+
+    def leaveEvent(self, event):
+        if self.isEnabled():
+            self.anim.stop()
+            self.anim.setStartValue(self.iconSize())
+            self.anim.setEndValue(self.base_size)
+            self.anim.start()
+        super().leaveEvent(event)
+
+def apply_native_hover_border(w, *, borderRadius=3, borderWidth=1, borderColor=str2QColor(PaIRS_gray)):
+    """
+    Adds a hover border overlay while preserving native button rendering.
+    No stylesheet is used. No subclassing (wraps paintEvent + installs eventFilter).
+    """
+
+    # ensure hover events
+    w.setAttribute(Qt.WA_Hover, True)
+
+    # keep original paintEvent once
+    if not hasattr(w, "_orig_paintEvent"):
+        w._orig_paintEvent = w.paintEvent
+
+    def paintEvent_with_border(self, event):
+        # native painting first
+        self._orig_paintEvent(event)
+
+        # overlay border only on hover
+        if self.underMouse() and self.isEnabled():
+            p = QPainter(self)
+            p.setRenderHint(QPainter.Antialiasing, True)
+
+            pen = QPen(borderColor)
+            pen.setWidth(borderWidth)
+            p.setPen(pen)
+            p.setBrush(Qt.NoBrush)
+
+            # keep border inside widget rect
+            d = borderWidth #/ 2.0
+            r = self.rect().adjusted(int(d), int(d), -int(d), -int(d))
+            p.drawRoundedRect(r, borderRadius, borderRadius)
+
+            p.end()
+
+    w.paintEvent = types.MethodType(paintEvent_with_border, w)
+
+    # eventFilter to trigger updates on hover transitions
+    class _HoverUpdateFilter(type(w)):
+        pass
+
+    # simpler: store filter object on widget
+    if not hasattr(w, "_hoverBorderFilter"):
+        from PySide6.QtCore import QObject
+        class HoverBorderFilter(QObject):
+            def eventFilter(self, obj, ev):
+                if ev.type() in (QEvent.Enter, QEvent.Leave, QEvent.HoverEnter, QEvent.HoverLeave, QEvent.HoverMove):
+                    obj.update()
+                return False
+
+        w._hoverBorderFilter = HoverBorderFilter(w)
+        w.installEventFilter(w._hoverBorderFilter)
+
+def apply_native_hover_glow(
+    w:QWidget, *,
+    borderRadius=3,
+    glowSize=4,                 # spessore della sfumatura
+    baseColor=str2QColor(PaIRS_gray)
+    ):
+    """
+    Adds a soft glow around the widget border on hover,
+    preserving native rendering (no stylesheet).
+    """
+    if w.objectName()=='CollapsibleBox_toggle':
+        pass
+    w.setAttribute(Qt.WA_Hover, True)
+
+    if not hasattr(w, "_orig_paintEvent"):
+        w._orig_paintEvent = w.paintEvent
+
+    def paintEvent_with_glow(self, event):
+        # 1) Native painting
+        self._orig_paintEvent(event)
+
+        if not (self.underMouse() and self.isEnabled()):
+            return
+
+        p = QPainter(self)
+        p.setRenderHint(QPainter.Antialiasing, True)
+        p.setBrush(Qt.NoBrush)
+
+        # 2) Draw soft glow (outer → inner)
+        for i in range(glowSize):
+            alpha = int(120 * (1 - i / glowSize))  # fade out
+            c = QColor(baseColor)
+            c.setAlpha(alpha)
+
+            pen = QPen(c)
+            pen.setWidth(1)
+            p.setPen(pen)
+
+            r = self.rect().adjusted(
+                i + 1, i + 1,
+                -(i + 1), -(i + 1)
+            )
+            p.drawRoundedRect(r, borderRadius, borderRadius)
+
+        p.end()
+
+    w.paintEvent = types.MethodType(paintEvent_with_glow, w)
+
+    # Force repaint on hover transitions
+    if not hasattr(w, "_hoverGlowFilter"):
+        from PySide6.QtCore import QObject
+        class HoverGlowFilter(QObject):
+            def eventFilter(self, obj, ev):
+                if ev.type() in (
+                    QEvent.Enter, QEvent.Leave,
+                    QEvent.HoverEnter, QEvent.HoverLeave, QEvent.HoverMove
+                ):
+                    obj.update()
+                return False
+
+        w._hoverGlowFilter = HoverGlowFilter(w)
+        w.installEventFilter(w._hoverGlowFilter)
+
+def apply_hover_glow_label(
+    w: QLabel,
+    *,
+    color=str2QColor(PaIRS_blue), #"#0051FF",
+    blur=18,
+    max_alpha=170,
+    duration_ms=160,
+):
+    if getattr(w, "_hoverGlowInstalled", False):
+        w._hoverGlowColor = QColor(color)
+        w._hoverGlowBlur = float(blur)
+        w._hoverGlowMaxAlpha = int(max_alpha)
+        w._hoverGlowDuration = int(duration_ms)
+        w._hoverGlowEffect.setBlurRadius(w._hoverGlowBlur)
+        return
+
+    w._hoverGlowInstalled = True
+    w._hoverGlowColor = QColor(color)
+    w._hoverGlowBlur = float(blur)
+    w._hoverGlowMaxAlpha = int(max_alpha)
+    w._hoverGlowDuration = int(duration_ms)
+
+    eff = QGraphicsDropShadowEffect(w)
+    eff.setOffset(0, 0)
+    eff.setBlurRadius(w._hoverGlowBlur)
+
+    c = QColor(w._hoverGlowColor)
+    c.setAlpha(0)
+    eff.setColor(c)
+
+    w.setGraphicsEffect(eff)
+    w._hoverGlowEffect = eff
+
+    def _set_alpha(val):
+        col = QColor(w._hoverGlowColor)
+        col.setAlpha(int(val))
+        w._hoverGlowEffect.setColor(col)
+
+    # ✅ Animate a plain value (no Qt property needed)
+    w._hoverGlowAnimAlpha = QVariantAnimation(w)
+    w._hoverGlowAnimAlpha.setEasingCurve(QEasingCurve.OutCubic)
+    w._hoverGlowAnimAlpha.valueChanged.connect(_set_alpha)
+
+    class _GlowFilter(QObject):
+        def eventFilter(self, obj, ev):
+            if obj is not w:
+                return False
+
+            t = ev.type()
+            if t in (QEvent.Enter, QEvent.HoverEnter):
+                w._hoverGlowAnimAlpha.stop()
+                w._hoverGlowAnimAlpha.setDuration(w._hoverGlowDuration)
+                w._hoverGlowAnimAlpha.setStartValue(w._hoverGlowEffect.color().alpha())
+                w._hoverGlowAnimAlpha.setEndValue(w._hoverGlowMaxAlpha)
+                w._hoverGlowAnimAlpha.start()
+
+            elif t in (QEvent.Leave, QEvent.HoverLeave):
+                w._hoverGlowAnimAlpha.stop()
+                w._hoverGlowAnimAlpha.setDuration(w._hoverGlowDuration)
+                w._hoverGlowAnimAlpha.setStartValue(w._hoverGlowEffect.color().alpha())
+                w._hoverGlowAnimAlpha.setEndValue(0)
+                w._hoverGlowAnimAlpha.start()
+
+            return False
+
+    w._hoverGlowFilter = _GlowFilter(w)
+    w.installEventFilter(w._hoverGlowFilter)
+
+    w.setAttribute(Qt.WA_Hover, True)
+    w.setMouseTracking(True)
+
+def remove_hover_glow_label(w: QLabel):
+    """Removes the hover glow behavior and restores a clean state."""
+    if not getattr(w, "_hoverGlowInstalled", False):
+        return
+
+    # Stop animation cleanly
+    anim = getattr(w, "_hoverGlowAnimAlpha", None)
+    if anim is not None:
+        anim.stop()
+
+    # Remove event filter
+    filt = getattr(w, "_hoverGlowFilter", None)
+    if filt is not None:
+        try:
+            w.removeEventFilter(filt)
+        except RuntimeError:
+            pass
+
+    # Remove graphics effect
+    w.setGraphicsEffect(None)
+
+    # Restore hover-related flags (safe defaults)
+    w.setAttribute(Qt.WA_Hover, False)
+    w.setMouseTracking(False)
+
+    # Cleanup attributes
+    for attr in (
+        "_hoverGlowInstalled",
+        "_hoverGlowColor",
+        "_hoverGlowBlur",
+        "_hoverGlowMaxAlpha",
+        "_hoverGlowDuration",
+        "_hoverGlowEffect",
+        "_hoverGlowAnimAlpha",
+        "_hoverGlowFilter",
+    ):
+        if hasattr(w, attr):
+            delattr(w, attr)
+
+class SliderHandleCursorFilter(QObject):
+    def eventFilter(self, obj, event):
+        if isinstance(obj, QSlider) and event.type() == QEvent.MouseMove:
+
+            opt = QStyleOptionSlider()
+            obj.initStyleOption(opt)
+
+            handle_rect = obj.style().subControlRect(
+                QStyle.CC_Slider,
+                opt,
+                QStyle.SC_SliderHandle,
+                obj
+            )
+
+            if handle_rect.contains(event.position().toPoint()):
+                obj.setCursor(QCursor(Qt.OpenHandCursor))
+            else:
+                obj.unsetCursor()
+
+        return False
+
+def changes(self,TabType,filename,title=" Changes"):
+    FlagShow=False
+    if self.logChanges:
+        if self.logChanges.isVisible():
+            FlagShow=True
+    if FlagShow:
+        self.logChanges.hide()
+        self.logChanges.show()
+    else:
+        self.logChanges=TabType(self,True)
+        self.logChanges.resize(720,720)
+        self.logChanges.show()
+        self.logChanges.ui.progress_Proc.hide()
+        self.logChanges.ui.button_close_tab.hide()
+        icon=QPixmap(''+ icons_path +'news.png')
+        self.logChanges.ui.icon.setPixmap(icon)
+        apply_hover_glow_label(self.logChanges.ui.icon)
+        self.logChanges.setWindowIcon(self.windowIcon())
+        self.logChanges.setWindowTitle(title)
+        self.logChanges.ui.name_tab.setText(title)
+    
+        self.logChanges.ui.log.setLineWrapColumnOrWidth(self.logChanges.ui.log.width()-20)
+        base="""
+            QTextEdit {
+                border: 1px solid #2a2a2a;
+                border-radius: 6px;
+
+                padding: 2px;
+
+                selection-background-color: #0051FF;
+                selection-color: #FFFFFF;
+            }
+            """
+        self.logChanges.ui.log.setStyleSheet(base+"\n"+gPaIRS_QMenu_style)
+
+        def setFontPixelSize(logChanges:type(self.logChanges),fPixSize):
+            logfont=self.font()
+            logfont.setFamily(fontName)
+            logfont.setPixelSize(fPixSize+2)
+            logChanges.ui.log.setFont(logfont)
+            fPixSize_TabNames=min([fPixSize*2,30])
+            lab=logChanges.ui.name_tab
+            font=lab.font()
+            font.setPixelSize(fPixSize_TabNames)
+            lab.setFont(font)
+        self.logChanges.setFontPixelSize=lambda fS: setFontPixelSize(self.logChanges,fS)
+        self.logChanges.setFontPixelSize(self.TABpar.fontPixelSize)
+        def logResizeEvent(logChanges:type(self.logChanges),e):
+            super(type(logChanges),logChanges).resizeEvent(e) 
+            logChanges.ui.log.setLineWrapColumnOrWidth(logChanges.ui.log.width()-20)
+        self.logChanges.ui.log.resizeEvent=lambda e: logResizeEvent(self.logChanges,e)
+
+        self.logChanges.ui.icon.addfuncclick['whatsnew']=self.whatsNew
+        self.logChanges.ui.icon.setCustomCursor()
+
+        try:
+            file = open(filename, "rb")
+            content = file.read().decode("utf-8")
+            self.logChanges.ui.log.setText(content)
+            file.close()
+        except Exception as inst:
+            pri.Error.red(f'There was a problem while reading the file {filename}:\n{inst}')
+            self.logChanges.ui.log.setText(f'No information about PaIRS-UniNa updates available!\n\nSorry for this, try to reinstall PaIRS-UniNa or alternatively contact the authors at {__mail__}.')
+    return
 
 #********************************************* Matplotlib
 import io
@@ -905,7 +1398,7 @@ class MplCanvas(FigureCanvasQTAgg):
         lbl=QLabel(fig2)
         lbl.setAlignment(QtCore.Qt.AlignCenter)
         with io.BytesIO() as buffer:
-            self.fig.savefig(buffer)
+            self.fig.savefig(buffer, bbox_inches='tight', pad_inches=0)
             pixmap = QPixmap(QImage.fromData(buffer.getvalue()))
         lbl.setPixmap(pixmap)
         lbl.setScaledContents(False)
@@ -917,8 +1410,6 @@ class MplCanvas(FigureCanvasQTAgg):
         lay.addWidget(lbl)
         lay.addWidget(lbl2)
 
-        self.fig2.append(fig2) 
-
         def closeFig2(event):
             type(fig2).closeEvent(fig2,event)
             self.fig2.pop(self.fig2.index(fig2))
@@ -936,7 +1427,7 @@ class MplCanvas(FigureCanvasQTAgg):
             fig2.scaleFactor=fig2.scaleFactor*scale
             fig2.scaleFactor=min([fig2.scaleFactor,1.5])
             fig2.scaleFactor=max([fig2.scaleFactor,0.5])
-            fig2.setFixedSize(s0*fig2.scaleFactor)
+            fig2.setFixedSize(fig2.s0*fig2.scaleFactor)
             lbl.setPixmap(pixmap.scaled(pixmap.size()*fig2.scaleFactor,mode=Qt.TransformationMode.SmoothTransformation))
             return
         fig2.resizeFig2=resizeFig2
@@ -988,6 +1479,7 @@ class MplCanvas(FigureCanvasQTAgg):
         fig2.lbl:QLabel=lbl
         def contextMenuEventFig2(event):
             contextMenu = QMenu()
+            contextMenu.setStyleSheet(gPaIRS_QMenu_style)
             copy2clipboard = contextMenu.addAction("Copy to clipboard ("+QS_copy2clipboard.key().toString(QKeySequence.NativeText)+")")
             contextMenu.addSeparator()
             scaleDown = contextMenu.addAction("Scale down ("+QS_scaleDown.key().toString(QKeySequence.NativeText)+")")
@@ -1028,9 +1520,11 @@ class MplCanvas(FigureCanvasQTAgg):
 
         fig2.show()
         fig2.setFixedSize(fig2.width(), fig2.height())
-        s0=fig2.size()
+        fig2.s0=fig2.size()
 
+        self.fig2.append(fig2) 
         self.posWindow(len(self.fig2)-1)
+        
         """
         fgeo = fig2.frameGeometry()
         centerPoint = QGuiApplication.primaryScreen().availableGeometry().center()
@@ -1039,7 +1533,7 @@ class MplCanvas(FigureCanvasQTAgg):
         """
     
     def showTip(self,obj,message):
-        showTip(obj,message)
+        show_mouse_tooltip(obj,message)
 
     def posWindow(self,ind):
         w=h=0
@@ -1115,12 +1609,12 @@ def setAppGuiPalette(self:QWidget,palette:QPalette=None):
                         c.setPalette(palette)
                     if hasattr(c,'initialStyle') and hasattr(c, 'setStyleSheet'):
                         c.setStyleSheet(c.initialStyle)
-                for c in f.findChildren(QObject):
-                    c:MyQLineEdit
-                    if isinstance(c, MyQLineEdit) and hasattr(c, 'setup'):
-                        c.initFlag=False
-                        c.styleFlag=False
-                        c.setup()
+                for c in f.findChildren(MyQLineEdit):
+                    c.initFlag=False
+                    c.styleFlag=False
+                    c.setup()
+                for c in f.findChildren(ClickableEditLabel):
+                    c.setup()
                 for c in f.findChildren(QObject):
                     if hasattr(c,'setup2'):
                         c.initFlag2=False
@@ -1131,3 +1625,185 @@ def setAppGuiPalette(self:QWidget,palette:QPalette=None):
         if hasattr(self,'w_Vis'): self.w_Vis.addPlotToolBar()
     except:
         pri.Error.red("***** Error while setting the application palette! *****")
+
+class Toast(QFrame):
+    """
+    Tooltip-like custom toast that appears at the current mouse cursor position.
+    Non-native, does not steal focus. Auto-hides after timeout_ms.
+    """
+
+    def __init__(
+        self,
+        parent: QWidget,
+        msg: str,
+        *,
+        timeout_ms: int = 2500,
+        offset: QPoint = QPoint(10, 15),   # offset from cursor
+        min_width: int = 0,
+        max_width: int = 460,
+        fade_in_ms: int = 80,
+        fade_out_ms: int = 130,
+    ):
+        super().__init__(parent)
+
+        self.setObjectName("PaIRSToast")
+        self.setWindowFlags(Qt.FramelessWindowHint | Qt.ToolTip)
+        #self.setAttribute(Qt.WA_TranslucentBackground, True)
+        self.setAttribute(Qt.WA_ShowWithoutActivating, True)
+
+        self._label = QLabel(msg, self)
+        self._label.setObjectName("PaIRSToastLabel")
+        self._label.setWordWrap(True)
+
+        lay = QHBoxLayout(self)
+        lay.setContentsMargins(4,3,4,3)
+        lay.addWidget(self._label)
+
+        # Classic tooltip-like styling
+        self.setStyleSheet("""
+        QFrame#PaIRSToast {
+            background-color: #ffffdc;            /* classic tooltip-ish */
+            color: #000000;
+            border: 1px solid rgba(0, 0, 0, 0.45);
+            border-radius: 4px;
+        }
+        QLabel#PaIRSToastLabel {
+            color: #000000;
+        }
+        """)
+
+        # Width clamp + nice wrapping
+        # Reset any previous constraints (important if a previous tooltip was wider)
+        self.setMinimumSize(min_width, 0)
+        self.setMaximumSize(max_width, 16777215)
+
+        self._label.setMinimumSize(min_width, 0)
+        self._label.setMaximumSize(max_width, 16777215)
+
+        # Make sure the label doesn't "expand"
+        self._label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+        font=self.window().font()
+        self._label.setFont(font)
+        self._apply_size(msg)
+
+        # Position at cursor (global)
+        self._move_to_cursor(offset)
+
+        # Opacity animation
+        self.setWindowOpacity(0.0)
+        self._anim = QPropertyAnimation(self, b"windowOpacity", self)
+        self._anim.setEasingCurve(QEasingCurve.OutCubic)
+
+        # Auto hide
+        self._timer = QTimer(self)
+        self._timer.setSingleShot(True)
+        self._timer.timeout.connect(lambda: self.fade_out(duration_ms=fade_out_ms))
+
+        self.show()
+        self.raise_()
+        self.fade_in(duration_ms=fade_in_ms)
+        self._timer.start(timeout_ms)
+
+    def _apply_size(self, msg: str):
+        self._label.setText(msg)
+
+        # Let QLabel compute the correct wrapped size
+        self._label.adjustSize()
+        sh = self._label.sizeHint()
+
+        # Lock label to its real hint size
+        self._label.setFixedSize(sh)
+
+        # Now shrink the frame to content + margins
+        self.adjustSize()
+
+        # Lock the whole toaster too (prevents extra blank area)
+        self.setFixedSize(self.sizeHint())
+
+    def caret_global_pos(self, edit, offset):
+        """
+        Returns a stable global position near the text caret.
+        Works for QLineEdit, QTextEdit, QPlainTextEdit.
+        """
+        if hasattr(edit, "cursorRect"):
+            r = edit.cursorRect()  # widget coords
+
+            # Anchor to bottom-left of caret rect (more stable than bottomRight)
+            p = edit.mapToGlobal(r.bottomLeft())
+            p += offset
+
+            # Clamp to screen to avoid off-screen placement
+            screen = QApplication.screenAt(QCursor.pos()) or edit.screen()
+            if screen:
+                geo = screen.availableGeometry()
+                x = min(max(p.x(), geo.left()),  geo.right())
+                y = min(max(p.y(), geo.top()),   geo.bottom())
+                return QPoint(x, y)
+
+            return p
+
+        # Fallback: mouse cursor
+        return QCursor.pos() + offset
+    
+    def _move_to_cursor(self, offset: QPoint):
+        parent:QLineEdit = self.parent()
+        if parent and hasattr(parent, "cursorRect"):
+            p=self.caret_global_pos(parent,QPoint(0,6))
+        else:
+            p=self.caret_global_pos(parent,offset)
+                
+        # Keep inside the current screen geometry
+        screen = self.screen()
+        if screen is None:
+            self.move(p)
+            return
+
+        geo = screen.availableGeometry()
+        self.adjustSize()
+        w, h = self.width(), self.height()
+
+        x = p.x()
+        y = p.y()
+
+        if x + w > geo.right():
+            x = geo.right() - w
+        if y + h > geo.bottom():
+            y = geo.bottom() - h
+        if x < geo.left():
+            x = geo.left()
+        if y < geo.top():
+            y = geo.top()
+
+        self.move(QPoint(x, y))
+
+    def fade_in(self, *, duration_ms: int = 80):
+        self._anim.stop()
+        self._anim.setDuration(duration_ms)
+        self._anim.setStartValue(self.windowOpacity())
+        self._anim.setEndValue(1.0)
+        self._anim.start()
+
+    def fade_out(self, *, duration_ms: int = 130):
+        self._anim.stop()
+        self._anim.setDuration(duration_ms)
+        self._anim.setStartValue(self.windowOpacity())
+        self._anim.setEndValue(0.0)
+        self._anim.finished.connect(self.close)
+        self._anim.start()
+
+def show_mouse_tooltip(parent: QWidget, msg: str, *, timeout_ms: int = 2500):
+    """
+    Convenience function: show a tooltip-like toaster at the mouse cursor.
+    Keeps a reference on parent to avoid garbage collection.
+    """
+    old = getattr(parent, "_pairs_mouse_toaster", None)
+    if old is not None and old.isVisible():
+        old.close()
+
+    if msg:
+        t = Toast(parent, msg, timeout_ms=timeout_ms)
+    else: t=None
+    parent._pairs_mouse_toaster = t
+    return t
+