@@ -15,15 +15,13 @@ def __init__(self, parent: QtWidgets.QWidget = None, *args, **kwargs):
         self._marquee: bool = True
         self.timer = QtCore.QTimer()
         self.timer.timeout.connect(self._scroll_text)
-        self.delay_timer = QtCore.QTimer()
-        self.delay_timer.setSingleShot(True)
-        self.delay_timer.timeout.connect(self._start_marquee)
-
         self.scroll_pos = 0.0
-        self.marquee_spacing = 20
+        self.marquee_spacing = 40
+        self.scroll_speed = 40
+        self.scroll_animation_speed = 30
+        self.max_loops = 2
+        self.loop_count = 0
         self.paused = False
-        self.scroll_speed = 20
-        self.scroll_animation_speed = 50
         self.setMouseTracking(True)
         self.setTabletTracking(True)
         self.setSizePolicy(
@@ -41,8 +39,8 @@ def __init__(self, parent: QtWidgets.QWidget = None, *args, **kwargs):
         self.glow_animation.finished.connect(self.repaint)
 
         self.total_scroll_width: float = 0.0
-        self.marquee_delay = 5000
-        self.loop_count = 0
+        self.text_width: float = 0.0
+        self.label_width: float = 0.0
         self.first_run = True
 
     def resizeEvent(self, a0: QtGui.QResizeEvent) -> None:
@@ -67,6 +65,7 @@ def setPixmap(self, a0: QtGui.QPixmap) -> None:
     def setText(self, text: str) -> None:
         """Set widget text"""
         self._text = text
+        self.scroll_pos = 0.0
         self.update_text_metrics()
 
     @property
@@ -102,7 +101,7 @@ def marquee(self) -> bool:
         return self._marquee
 
     @marquee.setter
-    def marquee(self, activate) -> None:
+    def marquee(self, activate: bool) -> None:
         self._marquee = activate
         self.update_text_metrics()
 
@@ -130,10 +129,9 @@ def start_glow_animation(self) -> None:
         """Start glow animation"""
         self.glow_animation.setDuration(self.animation_speed)
         start_color = QtGui.QColor("#00000000")
+        end_color = QtGui.QColor("#E95757")
         self.glow_animation.setStartValue(start_color)
-        base_end_color = QtGui.QColor("#E95757")
-        self.glow_animation.setEndValue(base_end_color)
-
+        self.glow_animation.setEndValue(end_color)
         self.glow_animation.setDirection(QtCore.QPropertyAnimation.Direction.Forward)
         self.glow_animation.setLoopCount(-1)
         self.glow_animation.start()
@@ -155,145 +153,98 @@ def update_text_metrics(self) -> None:
         self.total_scroll_width = float(self.text_width + self.marquee_spacing)
 
         if self._marquee and self.text_width > self.label_width:
-            self.start_scroll()
+            self.scroll_pos = 0.0
+            QtCore.QTimer.singleShot(2000, self.start_scroll)
         else:
             self.stop_scroll()
             self.scroll_pos = 0.0
         self.update()
 
     def start_scroll(self) -> None:
-        """Start marquee text scroll effect"""
-        if not self.delay_timer.isActive() and not self.timer.isActive():
+        """Start or restart the scrolling."""
+        if not self.timer.isActive():
             self.scroll_pos = 0
             self.loop_count = 0
-            if self.first_run:
-                self.delay_timer.start(self.marquee_delay)
-                self.first_run = False
-            else:
-                self._start_marquee()
-
-    def _start_marquee(self) -> None:
-        """Starts the actual marquee animation after the delay or immediately."""
-        if not self.timer.isActive():
             self.timer.start(self.scroll_animation_speed)
 
     def stop_scroll(self) -> None:
         """Stop marquee text scroll effect"""
         self.timer.stop()
-        self.delay_timer.stop()
+        self.repaint()
 
     def _scroll_text(self) -> None:
-        if self.paused:
+        """Smoothly scroll the text leftwards."""
+        if not self._marquee or self.paused:
             return
-
         p_to_m = self.scroll_speed * (self.scroll_animation_speed / 1000.0)
         self.scroll_pos -= p_to_m
-
         if self.scroll_pos <= -self.total_scroll_width:
             self.loop_count += 1
-            if self.loop_count >= 2:
+            if self.loop_count >= self.max_loops:
                 self.stop_scroll()
-            else:
-                self.scroll_pos = 0
-
-        self.repaint()
+            self.scroll_pos = 0.0
+        self.update()
 
     def paintEvent(self, a0: QtGui.QPaintEvent) -> None:
         """Re-implemented method, paint widget"""
-        qp = QtWidgets.QStylePainter(self)
-        opt = QtWidgets.QStyleOption()
-        opt.initFrom(self)
-
+        qp = QtGui.QPainter(self)
         qp.setRenderHint(qp.RenderHint.Antialiasing, True)
         qp.setRenderHint(qp.RenderHint.SmoothPixmapTransform, True)
         qp.setRenderHint(qp.RenderHint.LosslessImageRendering, True)
-        _rect = self.rect()
-        _style = self.style()
-
-        icon_margin = _style.pixelMetric(_style.PixelMetric.PM_HeaderMargin, opt, self)
-        if not _style or _rect.isNull():
-            return
+        rect = self.contentsRect()
+        if self._background_color:
+            qp.setBrush(self._background_color)
+            qp.setPen(QtCore.Qt.PenStyle.NoPen)
+            if self._rounded:
+                path = QtGui.QPainterPath()
+                path.addRoundedRect(QtCore.QRectF(rect), 10, 10)
+                qp.fillPath(path, self._background_color)
+            else:
+                qp.fillRect(rect, self._background_color)
 
         if self.icon_pixmap:
-            qp.setCompositionMode(qp.CompositionMode.CompositionMode_SourceOver)
-            _icon_rect = QtCore.QRectF(
-                0.0 + icon_margin,
-                0.0 + icon_margin,
-                self.width() - icon_margin,
-                self.height() - icon_margin,
-            )
-            _icon_scaled = self.icon_pixmap.scaled(
-                _icon_rect.size().toSize(),
+            icon_rect = QtCore.QRectF(0, 0, self.height(), self.height())
+            scaled = self.icon_pixmap.scaled(
+                icon_rect.size().toSize(),
                 QtCore.Qt.AspectRatioMode.KeepAspectRatio,
                 QtCore.Qt.TransformationMode.SmoothTransformation,
             )
-            scaled_width = _icon_scaled.width()
-            scaled_height = _icon_scaled.height()
-            adjusted_x = (_icon_rect.width() - scaled_width) / 2.0
-            adjusted_y = (_icon_rect.height() - scaled_height) / 2.0
-            adjusted_icon_rect = QtCore.QRectF(
-                _icon_rect.x() + adjusted_x,
-                _icon_rect.y() + adjusted_y,
-                scaled_width,
-                scaled_height,
-            )
-            qp.drawPixmap(
-                adjusted_icon_rect, _icon_scaled, _icon_scaled.rect().toRectF()
-            )
-
-        big_rect = QtGui.QPainterPath()
-        rect = self.contentsRect().toRectF()
-        big_rect.addRoundedRect(rect, 10.0, 10.0, QtCore.Qt.SizeMode.AbsoluteSize)
-        mini_rect = QtCore.QRectF(
-            (rect.width() - rect.width() * 0.99) / 2,
-            (rect.height() - rect.height() * 0.85) / 2,
-            rect.width() * 0.99,
-            rect.height() * 0.85,
-        )
-        mini_path = QtGui.QPainterPath()
-        mini_path.addRoundedRect(mini_rect, 10.0, 10.0, QtCore.Qt.SizeMode.AbsoluteSize)
-        subtracted = big_rect.subtracted(mini_path)
-
+            qp.drawPixmap(icon_rect.toRect(), scaled)
         if self.glow_animation.state() == self.glow_animation.State.Running:
-            qp.setCompositionMode(qp.CompositionMode.CompositionMode_SourceAtop)
-            subtracted.setFillRule(QtCore.Qt.FillRule.OddEvenFill)
-            qp.fillPath(subtracted, self.glow_color)
+            path = QtGui.QPainterPath()
+            path.addRoundedRect(QtCore.QRectF(rect), 10, 10)
+            qp.fillPath(path, self.glow_color)
         if self._text:
-            qp.setCompositionMode(qp.CompositionMode.CompositionMode_SourceOver)
-
-            text_rect = self.contentsRect()
-            text_rect.translate(int(self.scroll_pos), 0)
-            text_path = QtGui.QPainterPath()
-            text_path.addRect(self.contentsRect().toRectF())
-            qp.setClipPath(text_path)
-
             text_option = QtGui.QTextOption(self.alignment())
             text_option.setWrapMode(QtGui.QTextOption.WrapMode.NoWrap)
-            qp.drawText(
-                QtCore.QRectF(text_rect),
-                self._text,
-                text_option,
+            qp.save()
+            qp.setClipRect(rect)
+            baseline_y = (
+                rect.y()
+                + (
+                    rect.height()
+                    + self.fontMetrics().ascent()
+                    - self.fontMetrics().descent()
+                )
+                / 2
             )
-            if self._marquee and self.text_width > self.label_width:
-                second_text_rect = self.rect()
-                second_text_rect.translate(
-                    int(self.scroll_pos + self.text_width + self.label_width / 2),
-                    0,
+
+            if self.text_width > self.label_width:
+                qp.drawText(
+                    QtCore.QPointF(rect.x() + self.scroll_pos, baseline_y), self._text
                 )
-                qp.drawText(QtCore.QRectF(second_text_rect), self._text, text_option)
-                draw_rect = QtCore.QRectF(
-                    self.contentsRect().x()
-                    + self.scroll_pos
-                    + self.text_width
-                    + self.marquee_spacing,
-                    self.contentsRect().y(),
-                    self.text_width,
-                    self.contentsRect().height(),
+                # Draw scrolling repeater text
+                qp.drawText(
+                    QtCore.QPointF(
+                        rect.x() + self.scroll_pos + self.total_scroll_width, baseline_y
+                    ),
+                    self._text,
                 )
-                qp.drawText(draw_rect, self._text, text_option)
             else:
-                text_rect = self.contentsRect().toRectF()
-                qp.drawText(text_rect, self._text, text_option)
+                center_x = rect.x() + (rect.width() - self.text_width) / 2
+
+                qp.drawText(QtCore.QPointF(center_x, baseline_y), self._text)
+            qp.restore()
 
         qp.end()