xnano.geometry

A cell position, counted in columns (x) and rows (y) from the top-left.

Maps to ratatui::layout::Position.

Parameters:

• x (int, default: 0 ) –

  The column.

• y (int, default: 0 ) –

  The row.

Attributes:

• x (int) –

  The column.

• y (int) –

  The row.

Examples:

point = Point(2, 3) + Point(1, 1)
assert (point.x, point.y) == (3, 4)
assert point - Point(3, 4) == Point(0, 0)

Create a Point.

Parameters:

• x (int, default: 0 ) –

  int. Defaults to 0.

• y (int, default: 0 ) –

  int. Defaults to 0.

Methods:

• __add__ –

  Add two positions component by component.

• __sub__ –

  Subtract two positions component by component.

194
195
196
197
198
199
200
201

def __init__(self, x: int = 0, y: int = 0) -> None:
    """
    Create a Point.

    Args:
        x: ``int``. Defaults to ``0``.
        y: ``int``. Defaults to ``0``.
    """

x: int

y: int

__add__(other: Point | Offset) -> Point

assert Point(1, 2) + Point(3, 4) == Point(4, 6)

210
211
212
213
214
215
216
217
218

def __add__(self, other: Point | Offset) -> Point:
    """
    Add two positions component by component.

    Examples:
        ```python
        assert Point(1, 2) + Point(3, 4) == Point(4, 6)
        ```
    """

__sub__(other: Point | Offset) -> Point

assert Point(4, 6) - Point(3, 4) == Point(1, 2)

220
221
222
223
224
225
226
227
228

def __sub__(self, other: Point | Offset) -> Point:
    """
    Subtract two positions component by component.

    Examples:
        ```python
        assert Point(4, 6) - Point(3, 4) == Point(1, 2)
        ```
    """

A rectangle of cells with half-open bounds.

The left and top edges are inclusive, and the right and bottom edges are exclusive.

Maps to ratatui::layout::Rect.

Parameters:

• x (int, default: 0 ) –

  The left column.

• y (int, default: 0 ) –

  The top row.

• width (int, default: 0 ) –

  The number of columns.

• height (int, default: 0 ) –

  The number of rows.

Attributes:

• x (int) –

  The left column.

• y (int) –

  The top row.

• width (int) –

  The number of columns.

• height (int) –

  The number of rows.

• position (Point) –

  The top-left corner.

• size (Size) –

  The width and height.

• area (int) –

  The number of cells, width * height.

• is_empty (bool) –

  Whether the rectangle holds no cells.

Examples:

area = Rectangle(2, 1, 10, 4)
assert area.area == 40
assert area.contains(Point(2, 1))
assert not area.contains(Point(12, 1))

Create a Rectangle.

Parameters:

• x (int, default: 0 ) –

  int. Defaults to 0.

• y (int, default: 0 ) –

  int. Defaults to 0.

• width (int, default: 0 ) –

  int. Defaults to 0.

• height (int, default: 0 ) –

  int. Defaults to 0.

Methods:

• contains –

  Whether point lies inside the rectangle.

• intersects –

  Whether the two rectangles share at least one cell.

• intersection –

  The cells both rectangles share. The result is empty when they do not overlap.

• union –

  The smallest rectangle that holds both rectangles.

• translate –

  Move the rectangle by a number of columns and rows.

• inset –

  Shrink the rectangle by a margin on every side.

309
310
311
312
313
314
315
316
317
318

def __init__(self, x: int = 0, y: int = 0, width: int = 0, height: int = 0) -> None:
    """
    Create a Rectangle.

    Args:
        x: ``int``. Defaults to ``0``.
        y: ``int``. Defaults to ``0``.
        width: ``int``. Defaults to ``0``.
        height: ``int``. Defaults to ``0``.
    """

x: int

y: int

width: int

height: int

position: Point

size: Size

area: int

is_empty: bool

contains(point: Point) -> bool

area = Rectangle(0, 0, 4, 2)
assert area.contains(Point(3, 1))
assert not area.contains(Point(4, 1))

351
352
353
354
355
356
357
358
359
360
361

def contains(self, point: Point) -> bool:
    """
    Whether ``point`` lies inside the rectangle.

    Examples:
        ```python
        area = Rectangle(0, 0, 4, 2)
        assert area.contains(Point(3, 1))
        assert not area.contains(Point(4, 1))
        ```
    """

intersects(other: Rectangle) -> bool

assert Rectangle(0, 0, 4, 4).intersects(Rectangle(3, 3, 4, 4))
assert not Rectangle(0, 0, 4, 4).intersects(Rectangle(4, 0, 4, 4))

363
364
365
366
367
368
369
370
371
372

def intersects(self, other: Rectangle) -> bool:
    """
    Whether the two rectangles share at least one cell.

    Examples:
        ```python
        assert Rectangle(0, 0, 4, 4).intersects(Rectangle(3, 3, 4, 4))
        assert not Rectangle(0, 0, 4, 4).intersects(Rectangle(4, 0, 4, 4))
        ```
    """

intersection(other: Rectangle) -> Rectangle

shared = Rectangle(0, 0, 10, 5).intersection(Rectangle(5, 2, 10, 10))
assert shared == Rectangle(5, 2, 5, 3)

374
375
376
377
378
379
380
381
382
383

def intersection(self, other: Rectangle) -> Rectangle:
    """
    The cells both rectangles share. The result is empty when they do not overlap.

    Examples:
        ```python
        shared = Rectangle(0, 0, 10, 5).intersection(Rectangle(5, 2, 10, 10))
        assert shared == Rectangle(5, 2, 5, 3)
        ```
    """

union(other: Rectangle) -> Rectangle

joined = Rectangle(0, 0, 10, 5).union(Rectangle(8, 8, 4, 4))
assert joined == Rectangle(0, 0, 12, 12)

385
386
387
388
389
390
391
392
393
394

def union(self, other: Rectangle) -> Rectangle:
    """
    The smallest rectangle that holds both rectangles.

    Examples:
        ```python
        joined = Rectangle(0, 0, 10, 5).union(Rectangle(8, 8, 4, 4))
        assert joined == Rectangle(0, 0, 12, 12)
        ```
    """

translate(x: int = 0, y: int = 0) -> Rectangle

assert Rectangle(0, 0, 4, 2).translate(2, 1) == Rectangle(2, 1, 4, 2)
assert Rectangle(5, 5, 4, 2).translate(x=-1, y=-2) == Rectangle(4, 3, 4, 2)

396
397
398
399
400
401
402
403
404
405
406
407
408
409

def translate(self, x: int = 0, y: int = 0) -> Rectangle:
    """
    Move the rectangle by a number of columns and rows.

    Args:
        x: Columns to move right; negative values move left.
        y: Rows to move down; negative values move up.

    Examples:
        ```python
        assert Rectangle(0, 0, 4, 2).translate(2, 1) == Rectangle(2, 1, 4, 2)
        assert Rectangle(5, 5, 4, 2).translate(x=-1, y=-2) == Rectangle(4, 3, 4, 2)
        ```
    """

inset(horizontal: int = 0, vertical: int = 0) -> Rectangle

assert Rectangle(0, 0, 10, 5).inset(1, 1) == Rectangle(1, 1, 8, 3)

411
412
413
414
415
416
417
418
419

def inset(self, horizontal: int = 0, vertical: int = 0) -> Rectangle:
    """
    Shrink the rectangle by a margin on every side.

    Examples:
        ```python
        assert Rectangle(0, 0, 10, 5).inset(1, 1) == Rectangle(1, 1, 8, 3)
        ```
    """

A width and a height, counted in cells.

Maps to ratatui::layout::Size.

Parameters:

• width (int, default: 0 ) –

  The number of columns.

• height (int, default: 0 ) –

  The number of rows.

Attributes:

• width (int) –

  The number of columns.

• height (int) –

  The number of rows.

Examples:

size = Size(80, 24)
assert (size.width, size.height) == (80, 24)

Create a Size.

Parameters:

• width (int, default: 0 ) –

  int. Defaults to 0.

• height (int, default: 0 ) –

  int. Defaults to 0.

255
256
257
258
259
260
261
262

def __init__(self, width: int = 0, height: int = 0) -> None:
    """
    Create a Size.

    Args:
        width: ``int``. Defaults to ``0``.
        height: ``int``. Defaults to ``0``.
    """

width: int

height: int

How much space one child takes along a layout's main axis.

Maps to ratatui::layout::Constraint.

Examples:

rules = [SizeRule.cells(4), SizeRule.fill()]
parent = Buffer(width=12, height=3)
first, second = Buffer(), Buffer()
parent.attach(first, geometry='inherit')
parent.attach(second, geometry='inherit')
parent.update(Layout('row', sizes=rules))
assert (first.width, second.width) == (4, 8)

Methods:

• cells –

  Take exactly count cells.

• percent –

  Take percentage percent of the available space.

• fill –

  Share the remaining space with other fill rules in proportion to weight.

• fit –

  Take the size of the child's own content.

• minimum –

  Take at least count cells.

• maximum –

  Take at most count cells.

cells(count: int) -> SizeRule

assert repr(SizeRule.cells(4)) == 'SizeRule.cells(4)'

5129
5130
5131
5132
5133
5134
5135
5136
5137
5138

@classmethod
def cells(cls, count: int) -> SizeRule:
    """
    Take exactly ``count`` cells.

    Examples:
        ```python
        assert repr(SizeRule.cells(4)) == 'SizeRule.cells(4)'
        ```
    """

percent(percentage: int) -> SizeRule

assert repr(SizeRule.percent(50)) == 'SizeRule.percent(50)'

5140
5141
5142
5143
5144
5145
5146
5147
5148
5149

@classmethod
def percent(cls, percentage: int) -> SizeRule:
    """
    Take ``percentage`` percent of the available space.

    Examples:
        ```python
        assert repr(SizeRule.percent(50)) == 'SizeRule.percent(50)'
        ```
    """

fill(weight: int = 1) -> SizeRule

assert repr(SizeRule.fill(2)) == 'SizeRule.fill(2)'

5151
5152
5153
5154
5155
5156
5157
5158
5159
5160

@classmethod
def fill(cls, weight: int = 1) -> SizeRule:
    """
    Share the remaining space with other fill rules in proportion to ``weight``.

    Examples:
        ```python
        assert repr(SizeRule.fill(2)) == 'SizeRule.fill(2)'
        ```
    """

fit() -> SizeRule

assert repr(SizeRule.fit()) == 'SizeRule.fit()'

5162
5163
5164
5165
5166
5167
5168
5169
5170
5171

@classmethod
def fit(cls) -> SizeRule:
    """
    Take the size of the child's own content.

    Examples:
        ```python
        assert repr(SizeRule.fit()) == 'SizeRule.fit()'
        ```
    """

minimum(count: int) -> SizeRule

assert repr(SizeRule.minimum(2)) == 'SizeRule.minimum(2)'

5173
5174
5175
5176
5177
5178
5179
5180
5181
5182

@classmethod
def minimum(cls, count: int) -> SizeRule:
    """
    Take at least ``count`` cells.

    Examples:
        ```python
        assert repr(SizeRule.minimum(2)) == 'SizeRule.minimum(2)'
        ```
    """

maximum(count: int) -> SizeRule

assert repr(SizeRule.maximum(3)) == 'SizeRule.maximum(3)'

5184
5185
5186
5187
5188
5189
5190
5191
5192
5193

@classmethod
def maximum(cls, count: int) -> SizeRule:
    """
    Take at most ``count`` cells.

    Examples:
        ```python
        assert repr(SizeRule.maximum(3)) == 'SizeRule.maximum(3)'
        ```
    """