ZToolTip 2.0.0__py3-none-any.whl

ztooltip/__init__.py

@@ -0,0 +1 @@
+from .tooltip import Tooltip, TooltipPlacement

ztooltip/constants.py

@@ -0,0 +1,3 @@
+
+QWIDGETSIZE_MAX = 16777215
+DROP_SHADOW_SIZE = 10

ztooltip/drop_shadow.py

@@ -0,0 +1,59 @@
+from qtpy.QtWidgets import QWidget
+from qtpy.QtCore import QSize
+from .tooltip_interface import TooltipInterface
+from .constants import *
+
+
+class DropShadow(QWidget):
+
+    def __init__(self, tooltip: TooltipInterface):
+        """Create a new DropShadow instance
+
+        :param tooltip: tooltip the drop shadow belongs to
+        """
+
+        super(DropShadow, self).__init__(tooltip)
+
+        self.tooltip = tooltip
+
+        # Drop shadow drawn manually since only one graphics effect can be applied
+        self.layers = []
+
+        for i in range(DROP_SHADOW_SIZE):
+            layer = QWidget(self)
+            self.__apply_layer_stylesheet(layer, i)
+            self.layers.append(layer)
+
+    def update(self):
+        """Update the stylesheets of the layers"""
+
+        for i, layer in enumerate(self.layers):
+            self.__apply_layer_stylesheet(layer, i)
+
+    def resize(self, size: QSize):
+        """Resize the drop shadow widget
+
+        :param size: new size
+        """
+
+        super().resize(size)
+        width = size.width()
+        height = size.height()
+
+        # Resize and move drop shadow layers
+        for i, layer in enumerate(self.layers):
+            layer.resize(width - i * 2, height - i * 2)
+            layer.move(i, i)
+
+    def __apply_layer_stylesheet(self, layer: QWidget, index: int):
+        """Apply stylesheet to a layer widget
+
+        :param layer: layer to apply the stylesheet to
+        :param index: index of the layer
+        """
+
+        layer.setStyleSheet(
+            'background: rgba(0, 0, 0, {}); '
+            'border-radius: 8px;'
+            .format((index + 1) * 0.001 * self.tooltip.getDropShadowStrength())
+        )

ztooltip/enums.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class TooltipPlacement(Enum):
+    AUTO = 0
+    LEFT = 1
+    RIGHT = 2
+    TOP = 3
+    BOTTOM = 4

ztooltip/placement_utils.py

@@ -0,0 +1,58 @@
+from qtpy.QtWidgets import QWidget
+from qtpy.QtCore import QPoint
+from .enums import TooltipPlacement
+from .utils import Utils
+
+
+class PlacementUtils:
+
+    @staticmethod
+    def get_optimal_placement(widget: QWidget, triangle_size: int, border_radius: int) -> TooltipPlacement:
+        """Calculate the optimal placement of a tooltip based on the widget,
+        triangle size, and border radius.
+
+        :param widget: widget of the tooltip
+        :param triangle_size: size of the tooltip triangle
+        :param border_radius: border radius of the tooltip
+        :return: optimal placement
+        """
+        top_level_parent = Utils.get_top_level_parent(widget)
+        top_level_parent_geometry = top_level_parent.geometry()
+        widget_pos = widget.mapToGlobal(QPoint(0, 0))
+        widget_center_x = widget_pos.x() + widget.width() // 2
+
+        min_space_required = 2 * triangle_size + border_radius
+
+        # Available space left and right from widget center
+        left_space_from_center = widget_center_x - top_level_parent.pos().x()
+        right_space_from_center = top_level_parent_geometry.right() - widget_center_x
+
+        # Available space top and bottom
+        top_space = widget_pos.y() - top_level_parent.pos().y()
+        bottom_space = top_level_parent_geometry.bottom() - widget_pos.y() - widget.height()
+
+        # Available space left and right
+        left_space = widget_pos.x() - top_level_parent.pos().x()
+        right_space = top_level_parent_geometry.right() - widget_pos.x() - widget.width()
+
+        # Check if top/bottom placement is possible
+        can_place_top_bottom = (left_space_from_center > min_space_required and 
+                               right_space_from_center > min_space_required)
+
+        # Check if left/right placement is possible
+        can_place_left_right = (top_space > min_space_required and 
+                               bottom_space > min_space_required)
+
+        if can_place_top_bottom:
+            return TooltipPlacement.TOP if top_space >= bottom_space else TooltipPlacement.BOTTOM
+        elif can_place_left_right:
+            return TooltipPlacement.RIGHT if right_space >= left_space else TooltipPlacement.LEFT
+        else:
+            # Fallback: choose placement with most available space
+            spaces = [
+                (TooltipPlacement.LEFT, left_space),
+                (TooltipPlacement.RIGHT, right_space),
+                (TooltipPlacement.TOP, top_space),
+                (TooltipPlacement.BOTTOM, bottom_space)
+            ]
+            return max(spaces, key=lambda x: x[1])[0]