constrain both axis

Author: willmcgugan

src/textual/_compositor.py

@@ -535,23 +535,32 @@ def _constrain(
         Returns:
             New region.
         """
-        constrain = styles.constrain
-        if constrain == "inflect":
-            inflect_margin = styles.margin
-            margin_region = region.grow(inflect_margin)
-            region = region.inflect(
-                (-1 if margin_region.right > constrain_region.right else 0),
-                (-1 if margin_region.bottom > constrain_region.bottom else 0),
-                inflect_margin,
-            )
-            region = region.translate_inside(constrain_region, True, True)
-        elif constrain != "none":
-            # Constrain to avoid clipping
-            region = region.translate_inside(
-                constrain_region,
-                constrain in ("x", "both"),
-                constrain in ("y", "both"),
-            )
+        constrain_x = styles.constrain_x
+        constrain_y = styles.constrain_y
+
+        inflect_margin = styles.margin
+        margin_region = region.grow(inflect_margin)
+
+        region = region.inflect(
+            (
+                (-1 if margin_region.right > constrain_region.right else 0)
+                if constrain_x == "inflect"
+                else 0
+            ),
+            (
+                (-1 if margin_region.bottom > constrain_region.bottom else 0)
+                if constrain_y == "inflect"
+                else 0
+            ),
+            inflect_margin,
+        )
+
+        region = region.translate_inside(
+            constrain_region.shrink(styles.margin),
+            constrain_x == "limit",
+            constrain_y == "limit",
+        )
+
         return region
 
     def _arrange_root(
@@ -688,7 +697,10 @@ def add_widget(
 
                         widget_order = order + ((layer_index, z, layer_order),)
 
-                        if overlay and sub_widget.styles.constrain != "none":
+                        if overlay and (
+                            sub_widget.styles.constrain_x != "none"
+                            or sub_widget.styles.constrain_y != "none"
+                        ):
                             widget_region = self._constrain(
                                 sub_widget.styles, widget_region, no_clip
                             )
@@ -740,11 +752,15 @@ def add_widget(
                 widget_region = region + layout_offset
 
                 if widget._absolute_offset is not None:
+                    margin = styles.margin
                     widget_region = widget_region.reset_offset.translate(
-                        widget._absolute_offset + widget.styles.margin.top_left
+                        widget._absolute_offset + margin.top_left
+                    )
+                    widget_region = widget_region.translate(
+                        styles.offset.resolve(widget_region.grow(margin).size, size)
                     )
 
-                if styles.constrain != "none":
+                if styles.constrain_x != "none" or styles.constrain_y != "none":
                     widget_region = self._constrain(styles, widget_region, no_clip)
 
                 map[widget._render_widget] = _MapGeometry(

src/textual/css/_styles_builder.py

@@ -1047,6 +1047,40 @@ def process_overlay(self, name: str, tokens: list[Token]) -> None:
             self.styles._rules[name] = value  # type: ignore
 
     def process_constrain(self, name: str, tokens: list[Token]) -> None:
+        if len(tokens) == 1:
+            try:
+                value = self._process_enum(name, tokens, VALID_CONSTRAIN)
+            except StyleValueError:
+                self.error(
+                    name,
+                    tokens[0],
+                    string_enum_help_text(name, VALID_CONSTRAIN, context="css"),
+                )
+            else:
+                self.styles._rules["constrain_x"] = value  # type: ignore
+                self.styles._rules["constrain_y"] = value  # type: ignore
+        elif len(tokens) == 2:
+            constrain_x, constrain_y = self._process_enum_multiple(
+                name, tokens, VALID_CONSTRAIN, 2
+            )
+            self.styles._rules["constrain_x"] = constrain_x  # type: ignore
+            self.styles._rules["constrain_y"] = constrain_y  # type: ignore
+        else:
+            self.error(name, tokens[0], "one or two values here")
+
+    def process_constrain_x(self, name: str, tokens: list[Token]) -> None:
+        try:
+            value = self._process_enum(name, tokens, VALID_CONSTRAIN)
+        except StyleValueError:
+            self.error(
+                name,
+                tokens[0],
+                string_enum_help_text(name, VALID_CONSTRAIN, context="css"),
+            )
+        else:
+            self.styles._rules[name] = value  # type: ignore
+
+    def process_constrain_y(self, name: str, tokens: list[Token]) -> None:
         try:
             value = self._process_enum(name, tokens, VALID_CONSTRAIN)
         except StyleValueError:

src/textual/css/constants.py

@@ -74,7 +74,7 @@
     "nocolor",
 }
 VALID_OVERLAY: Final = {"none", "screen"}
-VALID_CONSTRAIN: Final = {"x", "y", "both", "inflect", "none"}
+VALID_CONSTRAIN: Final = {"inflect", "limit", "none"}
 VALID_KEYLINE: Final = {"none", "thin", "heavy", "double"}
 VALID_HATCH: Final = {"left", "right", "cross", "vertical", "horizontal"}
 HATCHES: Final = {

src/textual/css/styles.py

@@ -190,7 +190,8 @@ class RulesMap(TypedDict, total=False):
     hatch: tuple[str, Color] | Literal["none"]
 
     overlay: Overlay
-    constrain: Constrain
+    constrain_x: Constrain
+    constrain_y: Constrain
 
 
 RULE_NAMES = list(RulesMap.__annotations__.keys())
@@ -450,7 +451,8 @@ class StylesBase:
     overlay = StringEnumProperty(
         VALID_OVERLAY, "none", layout=True, refresh_parent=True
     )
-    constrain = StringEnumProperty(VALID_CONSTRAIN, "none")
+    constrain_x = StringEnumProperty(VALID_CONSTRAIN, "none")
+    constrain_y = StringEnumProperty(VALID_CONSTRAIN, "none")
 
     def __textual_animation__(
         self,
@@ -1172,8 +1174,18 @@ def append_declaration(name: str, value: str) -> None:
             append_declaration("subtitle-text-style", str(self.border_subtitle_style))
         if "overlay" in rules:
             append_declaration("overlay", str(self.overlay))
-        if "constrain" in rules:
-            append_declaration("constrain", str(self.constrain))
+        if "constrain_x" in rules and "constrain_y" in rules:
+            if self.constrain_x == self.constrain_y:
+                append_declaration("constrain", self.constrain_x)
+            else:
+                append_declaration(
+                    "constrain", f"{self.constrain_x} {self.constrain_y}"
+                )
+        elif "constrain_x" in rules:
+            append_declaration("constrain-x", self.constrain_x)
+        elif "constrain_y" in rules:
+            append_declaration("constrain-y", self.constrain_y)
+
         if "keyline" in rules:
             keyline_type, keyline_color = self.keyline
             if keyline_type != "none":

src/textual/css/types.py

@@ -36,7 +36,7 @@
 Overflow = Literal["scroll", "hidden", "auto"]
 EdgeStyle = Tuple[EdgeType, Color]
 TextAlign = Literal["left", "start", "center", "right", "end", "justify"]
-Constrain = Literal["none", "x", "y", "both"]
+Constrain = Literal["none", "inflect", "limit"]
 Overlay = Literal["none", "screen"]
 
 Specificity3 = Tuple[int, int, int]

src/textual/widgets/_tooltip.py

@@ -8,13 +8,15 @@ class Tooltip(Static, inherit_css=False):
     Tooltip {
         layer: _tooltips;
         margin: 1 2;
+
         padding: 1 2;
         background: $background;
         width: auto;
         height: auto;
-        constrain: inflect;
+        constrain: limit inflect;
         max-width: 40;
         display: none;
+        offset-x: -50%;
     }
     """
     DEFAULT_CLASSES = "-textual-system"