# lv_obj_pos.h (/api/core/lv_obj_pos_h)
Functions [#functions]
lv_obj_set_pos [#lv_obj_set_pos]
Set the position of an object relative to the set alignment.
```c title=" " lineNumbers=1
void lv_obj_set_pos(lv_obj_t *obj, int32_t x, int32_t y)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
| `x` | | new x coordinate |
| `y` | | new y coordinate |
With default alignment it's the distance from the top left corner
E.g. LV\_ALIGN\_CENTER alignment it's the offset from the center of the parent
The position is interpreted on the content area of the parent
The values can be set in pixel or in percentage of parent size with `lv_pct(v)`
lv_obj_set_x [#lv_obj_set_x]
Set the x coordinate of an object
```c title=" " lineNumbers=1
void lv_obj_set_x(lv_obj_t *obj, int32_t x)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
| `x` | | new x coordinate |
With default alignment it's the distance from the top left corner
E.g. LV\_ALIGN\_CENTER alignment it's the offset from the center of the parent
The position is interpreted on the content area of the parent
The values can be set in pixel or in percentage of parent size with `lv_pct(v)`
lv_obj_set_y [#lv_obj_set_y]
Set the y coordinate of an object
```c title=" " lineNumbers=1
void lv_obj_set_y(lv_obj_t *obj, int32_t y)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
| `y` | | new y coordinate |
With default alignment it's the distance from the top left corner
E.g. LV\_ALIGN\_CENTER alignment it's the offset from the center of the parent
The position is interpreted on the content area of the parent
The values can be set in pixel or in percentage of parent size with `lv_pct(v)`
lv_obj_set_size [#lv_obj_set_size]
Set the size of an object.
```c title=" " lineNumbers=1
void lv_obj_set_size(lv_obj_t *obj, int32_t w, int32_t h)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
| `w` | | the new width |
| `h` | | the new height |
possible values are: pixel simple set the size accordingly LV\_SIZE\_CONTENT set the size to involve all children in the given direction lv\_pct(x) to set size in percentage of the parent's content area size (the size without paddings). x should be in \[0..1000]% range
lv_obj_set_width [#lv_obj_set_width]
Set the width of an object
```c title=" " lineNumbers=1
void lv_obj_set_width(lv_obj_t *obj, int32_t w)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
| `w` | | the new width |
possible values are: pixel simple set the size accordingly LV\_SIZE\_CONTENT set the size to involve all children in the given direction lv\_pct(x) to set size in percentage of the parent's content area size (the size without paddings). x should be in \[0..1000]% range
lv_obj_set_height [#lv_obj_set_height]
Set the height of an object
```c title=" " lineNumbers=1
void lv_obj_set_height(lv_obj_t *obj, int32_t h)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
| `h` | | the new height |
possible values are: pixel simple set the size accordingly LV\_SIZE\_CONTENT set the size to involve all children in the given direction lv\_pct(x) to set size in percentage of the parent's content area size (the size without paddings). x should be in \[0..1000]% range
lv_obj_set_content_width [#lv_obj_set_content_width]
Set the width reduced by the left and right padding and the border width.
```c title=" " lineNumbers=1
void lv_obj_set_content_width(lv_obj_t *obj, int32_t w)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | ------------------------------------ |
| `obj` | | pointer to an object |
| `w` | | the width without paddings in pixels |
lv_obj_set_content_height [#lv_obj_set_content_height]
Set the height reduced by the top and bottom padding and the border width.
```c title=" " lineNumbers=1
void lv_obj_set_content_height(lv_obj_t *obj, int32_t h)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | ------------------------------------- |
| `obj` | | pointer to an object |
| `h` | | the height without paddings in pixels |
lv_obj_set_layout [#lv_obj_set_layout]
Set a layout for an object
```c title=" " lineNumbers=1
void lv_obj_set_layout(lv_obj_t *obj, uint32_t layout)
```
Parameters
| Name | Type | Description |
| -------- | ------------------------------------------------ | ------------------------------------- |
| `obj` | | pointer to an object |
| `layout` | | pointer to a layout descriptor to set |
lv_obj_set_align [#lv_obj_set_align]
Change the alignment of an object.
```c title=" " lineNumbers=1
void lv_obj_set_align(lv_obj_t *obj, lv_align_t align)
```
Parameters
| Name | Type | Description |
| ------- | ------------------------------------------------ | ----------------------------------------------------------------------------- |
| `obj` | | pointer to an object to align |
| `align` | | type of alignment (see 'lv\_align\_t' enum) `LV_ALIGN_OUT_...` can't be used. |
lv_obj_set_transform [#lv_obj_set_transform]
Set the transform matrix of an object
```c title=" " lineNumbers=1
void lv_obj_set_transform(lv_obj_t *obj, const lv_matrix_t *matrix)
```
Parameters
| Name | Type | Description |
| -------- | ------------------------------------------------------------ | -------------------------- |
| `obj` | | pointer to an object |
| `matrix` | | pointer to a matrix to set |
`LV_DRAW_TRANSFORM_USE_MATRIX` needs to be enabled.
lv_obj_set_ext_click_area [#lv_obj_set_ext_click_area]
Set the size of an extended clickable area
```c title=" " lineNumbers=1
void lv_obj_set_ext_click_area(lv_obj_t *obj, int32_t size)
```
Parameters
| Name | Type | Description |
| ------ | ------------------------------------------------ | ------------------------------------------------- |
| `obj` | | pointer to an object |
| `size` | | extended clickable area in all 4 directions \[px] |
lv_obj_get_coords [#lv_obj_get_coords]
Copy the coordinates of an object to an area
```c title=" " lineNumbers=1
void lv_obj_get_coords(const lv_obj_t *obj, lv_area_t *coords)
```
Parameters
| Name | Type | Description |
| -------- | ------------------------------------------------------ | ------------------------------------------- |
| `obj` | | pointer to an object |
| `coords` | | pointer to an area to store the coordinates |
lv_obj_get_x [#lv_obj_get_x]
Get the x coordinate of object.
```c title=" " lineNumbers=1
int32_t lv_obj_get_x(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — distance of `obj` from the left side of its parent plus the parent's left padding
The position of the object is recalculated only on the next redraw. To force coordinate recalculation call `lv_obj_update_layout(obj)`.
Zero return value means the object is on the left padding of the parent, and not on the left edge.
Scrolling of the parent doesn't change the returned value.
The returned value is always the distance from the parent even if `obj` is positioned by a layout.
lv_obj_get_x2 [#lv_obj_get_x2]
Get the x2 coordinate of object.
```c title=" " lineNumbers=1
int32_t lv_obj_get_x2(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — distance of `obj` from the right side of its parent plus the parent's right padding
The position of the object is recalculated only on the next redraw. To force coordinate recalculation call `lv_obj_update_layout(obj)`.
Zero return value means the object is on the right padding of the parent, and not on the right edge.
Scrolling of the parent doesn't change the returned value.
The returned value is always the distance from the parent even if `obj` is positioned by a layout.
lv_obj_get_y [#lv_obj_get_y]
Get the y coordinate of object.
```c title=" " lineNumbers=1
int32_t lv_obj_get_y(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — distance of `obj` from the top side of its parent plus the parent's top padding
The position of the object is recalculated only on the next redraw. To force coordinate recalculation call `lv_obj_update_layout(obj)`.
Zero return value means the object is on the top padding of the parent, and not on the top edge.
Scrolling of the parent doesn't change the returned value.
The returned value is always the distance from the parent even if `obj` is positioned by a layout.
lv_obj_get_y2 [#lv_obj_get_y2]
Get the y2 coordinate of object.
```c title=" " lineNumbers=1
int32_t lv_obj_get_y2(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — distance of `obj` from the bottom side of its parent plus the parent's bottom padding
The position of the object is recalculated only on the next redraw. To force coordinate recalculation call `lv_obj_update_layout(obj)`.
Zero return value means the object is on the bottom padding of the parent, and not on the bottom edge.
Scrolling of the parent doesn't change the returned value.
The returned value is always the distance from the parent even if `obj` is positioned by a layout.
lv_obj_get_x_aligned [#lv_obj_get_x_aligned]
Get the actually set x coordinate of object, i.e. the offset from the set alignment
```c title=" " lineNumbers=1
int32_t lv_obj_get_x_aligned(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — the set x coordinate
lv_obj_get_y_aligned [#lv_obj_get_y_aligned]
Get the actually set y coordinate of object, i.e. the offset from the set alignment
```c title=" " lineNumbers=1
int32_t lv_obj_get_y_aligned(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — the set y coordinate
lv_obj_get_width [#lv_obj_get_width]
Get the width of an object
```c title=" " lineNumbers=1
int32_t lv_obj_get_width(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — the width in pixels
The position of the object is recalculated only on the next redraw. To force coordinate recalculation call `lv_obj_update_layout(obj)`.
lv_obj_get_height [#lv_obj_get_height]
Get the height of an object
```c title=" " lineNumbers=1
int32_t lv_obj_get_height(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — the height in pixels
The position of the object is recalculated only on the next redraw. To force coordinate recalculation call `lv_obj_update_layout(obj)`.
lv_obj_get_content_width [#lv_obj_get_content_width]
Get the width reduced by the left and right padding and the border width.
```c title=" " lineNumbers=1
int32_t lv_obj_get_content_width(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — the width which still fits into its parent without causing overflow (making the parent scrollable)
The position of the object is recalculated only on the next redraw. To force coordinate recalculation call `lv_obj_update_layout(obj)`.
lv_obj_get_content_height [#lv_obj_get_content_height]
Get the height reduced by the top and bottom padding and the border width.
```c title=" " lineNumbers=1
int32_t lv_obj_get_content_height(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — the height which still fits into the parent without causing overflow (making the parent scrollable)
The position of the object is recalculated only on the next redraw. To force coordinate recalculation call `lv_obj_update_layout(obj)`.
lv_obj_get_content_coords [#lv_obj_get_content_coords]
Get the area reduced by the paddings and the border width.
```c title=" " lineNumbers=1
void lv_obj_get_content_coords(const lv_obj_t *obj, lv_area_t *area)
```
Parameters
| Name | Type | Description |
| ------ | ------------------------------------------------------ | ------------------------------------------------------------------------------------------------- |
| `obj` | | pointer to an object |
| `area` | | the area which still fits into the parent without causing overflow (making the parent scrollable) |
The position of the object is recalculated only on the next redraw. To force coordinate recalculation call `lv_obj_update_layout(obj)`.
lv_obj_get_self_width [#lv_obj_get_self_width]
Get the width occupied by the "parts" of the widget. E.g. the width of all columns of a table.
```c title=" " lineNumbers=1
int32_t lv_obj_get_self_width(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — the width of the virtually drawn content
This size independent from the real size of the widget. It just tells how large the internal ("virtual") content is.
lv_obj_get_self_height [#lv_obj_get_self_height]
Get the height occupied by the "parts" of the widget. E.g. the height of all rows of a table.
```c title=" " lineNumbers=1
int32_t lv_obj_get_self_height(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — the width of the virtually drawn content
This size independent from the real size of the widget. It just tells how large the internal ("virtual") content is.
lv_obj_get_style_clamped_width [#lv_obj_get_style_clamped_width]
Get the style width actually used by the object after clamping the width within the min max range.
```c title=" " lineNumbers=1
int32_t lv_obj_get_style_clamped_width(lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — the min/max/normal width set by `lv_obj_set_style__width()`
This is not the calculated size, so if the size was set as `LV_SIZE_CONTENT` or then that value will be returned.
lv_obj_get_style_clamped_height [#lv_obj_get_style_clamped_height]
Get the style height actually used by the object after clamping the height within the min max range.
```c title=" " lineNumbers=1
int32_t lv_obj_get_style_clamped_height(lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — the min/max/normal height set by `lv_obj_set_style__height()`
This is not the calculated size, so if the size was set as `LV_SIZE_CONTENT` or then that value will be returned.
lv_obj_get_transform [#lv_obj_get_transform]
Get the transform matrix of an object
```c title=" " lineNumbers=1
const lv_matrix_t * lv_obj_get_transform(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — pointer to the transform matrix or NULL if not set
lv_obj_get_transformed_area [#lv_obj_get_transformed_area]
Transform an area using the angle and zoom style properties of an object
```c title=" " lineNumbers=1
void lv_obj_get_transformed_area(const lv_obj_t *obj, lv_area_t *area, lv_obj_point_transform_flag_t flags)
```
Parameters
| Name | Type | Description |
| ------- | ------------------------------------------------------ | -------------------------------------------------------------- |
| `obj` | | pointer to an object whose style properties should be used |
| `area` | | an area to transform, the result will be written back here too |
| `flags` | | OR-ed valued of :cpp:enum:`lv_obj_point_transform_flag_t` |
lv_obj_get_click_area [#lv_obj_get_click_area]
Get the an area where to object can be clicked. It's the object's normal area plus the extended click area.
```c title=" " lineNumbers=1
void lv_obj_get_click_area(const lv_obj_t *obj, lv_area_t *area)
```
Parameters
| Name | Type | Description |
| ------ | ------------------------------------------------------ | -------------------------- |
| `obj` | | pointer to an object |
| `area` | | store the result area here |
lv_obj_refr_size [#lv_obj_refr_size]
Recalculate the size of the object
```c title=" " lineNumbers=1
bool lv_obj_refr_size(lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — true: the size has been changed
lv_obj_is_layout_positioned [#lv_obj_is_layout_positioned]
Test whether the and object is positioned by a layout or not
```c title=" " lineNumbers=1
bool lv_obj_is_layout_positioned(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | ---------------------------- |
| `obj` | | pointer to an object to test |
**Returns:** — true: positioned by a layout; false: not positioned by a layout
lv_obj_mark_layout_as_dirty [#lv_obj_mark_layout_as_dirty]
Mark the object for layout update.
```c title=" " lineNumbers=1
void lv_obj_mark_layout_as_dirty(lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | ------------------------------------------------------ |
| `obj` | | pointer to an object whose children need to be updated |
lv_obj_update_layout [#lv_obj_update_layout]
Update the layout of an object.
```c title=" " lineNumbers=1
void lv_obj_update_layout(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | ---------------------------------------------------------------- |
| `obj` | | pointer to an object whose position and size needs to be updated |
lv_obj_align [#lv_obj_align]
Change the alignment of an object and set new coordinates. Equivalent to: lv\_obj\_set\_align(obj, align); lv\_obj\_set\_pos(obj, x\_ofs, y\_ofs);
```c title=" " lineNumbers=1
void lv_obj_align(lv_obj_t *obj, lv_align_t align, int32_t x_ofs, int32_t y_ofs)
```
Parameters
| Name | Type | Description |
| ------- | ------------------------------------------------ | ----------------------------------------------------------------------------- |
| `obj` | | pointer to an object to align |
| `align` | | type of alignment (see 'lv\_align\_t' enum) `LV_ALIGN_OUT_...` can't be used. |
| `x_ofs` | | x coordinate offset after alignment |
| `y_ofs` | | y coordinate offset after alignment |
lv_obj_align_to [#lv_obj_align_to]
Align an object to another object.
```c title=" " lineNumbers=1
void lv_obj_align_to(lv_obj_t *obj, const lv_obj_t *base, lv_align_t align, int32_t x_ofs, int32_t y_ofs)
```
Parameters
| Name | Type | Description |
| ------- | ------------------------------------------------------ | --------------------------------------------------------------------------------------- |
| `obj` | | pointer to an object to align |
| `base` | | pointer to another object (if NULL `obj`s parent is used). 'obj' will be aligned to it. |
| `align` | | type of alignment (see 'lv\_align\_t' enum) |
| `x_ofs` | | x coordinate offset after alignment |
| `y_ofs` | | y coordinate offset after alignment |
if the position or size of `base` changes `obj` needs to be aligned manually again
lv_obj_center [#lv_obj_center]
Align an object to the center on its parent.
```c title=" " lineNumbers=1
void lv_obj_center(lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | ----------------------------- |
| `obj` | | pointer to an object to align |
if the parent size changes `obj` needs to be aligned manually again
lv_obj_reset_transform [#lv_obj_reset_transform]
Reset the transform matrix of an object to identity matrix
```c title=" " lineNumbers=1
void lv_obj_reset_transform(lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
`LV_DRAW_TRANSFORM_USE_MATRIX` needs to be enabled.
lv_obj_is_style_any_width_content [#lv_obj_is_style_any_width_content]
Determine if any of the object's width style properties are set to `LV_SIZE_CONTENT`.
```c title=" " lineNumbers=1
bool lv_obj_is_style_any_width_content(lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------------- |
| `obj` | | Pointer to a valid object. |
**Returns:** — `false` No width style properties are `LV_SIZE_CONTENT`.
lv_obj_is_style_any_height_content [#lv_obj_is_style_any_height_content]
Determine if any of the object's height style properties are set to `LV_SIZE_CONTENT`.
```c title=" " lineNumbers=1
bool lv_obj_is_style_any_height_content(lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------------- |
| `obj` | | Pointer to a valid object. |
**Returns:** — `false` No height style properties are `LV_SIZE_CONTENT`.
lv_obj_is_width_min [#lv_obj_is_width_min]
Determine if the object's resolved width was limited by its minimum width constraint.
This function reports whether, in the most recent layout / size calculation, the object's final (used) width had to be raised to satisfy a minimum width requirement.
```c title=" " lineNumbers=1
bool lv_obj_is_width_min(lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------------- |
| `obj` | | Pointer to a valid object. |
**Returns:** — false The width is larger than the minimum (not min‑clamped).
lv_obj_is_height_min [#lv_obj_is_height_min]
Determine if the object's resolved height was limited by its minimum height constraint.
This function reports whether, in the most recent layout / size calculation, the object's final (used) height had to be raised to satisfy a minimum height requirement.
```c title=" " lineNumbers=1
bool lv_obj_is_height_min(lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------------- |
| `obj` | | Pointer to a valid object. |
**Returns:** — false The height is larger than the minimum (not min‑clamped).
lv_obj_is_width_max [#lv_obj_is_width_max]
Determine if the object's resolved width was limited by its maximum width constraint.
This function reports whether, in the most recent layout / size calculation, the object's final (used) width had to be raised to satisfy a maximum width requirement.
```c title=" " lineNumbers=1
bool lv_obj_is_width_max(lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------------- |
| `obj` | | Pointer to a valid object. |
**Returns:** — false The width is smaller than the maximum (not min‑clamped).
lv_obj_is_height_max [#lv_obj_is_height_max]
Determine if the object's resolved height was limited by its maximum height constraint.
This function reports whether, in the most recent layout / size calculation, the object's final (used) height had to be raised to satisfy a maximum height requirement.
```c title=" " lineNumbers=1
bool lv_obj_is_height_max(lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------------- |
| `obj` | | Pointer to a valid object. |
**Returns:** — false The height is smaller than the maximum (not min‑clamped).
lv_obj_refresh_self_size [#lv_obj_refresh_self_size]
Handle if the size of the internal ("virtual") content of an object has changed.
```c title=" " lineNumbers=1
bool lv_obj_refresh_self_size(lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — false: nothing happened; true: refresh happened
lv_obj_refr_pos [#lv_obj_refr_pos]
```c title=" " lineNumbers=1
void lv_obj_refr_pos(lv_obj_t *obj)
```
Parameters
| Name | Type |
| ----- | ------------------------------------------------ |
| `obj` | |
lv_obj_move_to [#lv_obj_move_to]
```c title=" " lineNumbers=1
void lv_obj_move_to(lv_obj_t *obj, int32_t x, int32_t y)
```
Parameters
| Name | Type |
| ----- | ------------------------------------------------ |
| `obj` | |
| `x` | |
| `y` | |
lv_obj_move_children_by [#lv_obj_move_children_by]
```c title=" " lineNumbers=1
void lv_obj_move_children_by(lv_obj_t *obj, int32_t x_diff, int32_t y_diff, bool ignore_floating)
```
Parameters
| Name | Type |
| ----------------- | ------------------------------------------------ |
| `obj` | |
| `x_diff` | |
| `y_diff` | |
| `ignore_floating` | |
lv_obj_transform_point [#lv_obj_transform_point]
Transform a point using the angle and zoom style properties of an object
```c title=" " lineNumbers=1
void lv_obj_transform_point(const lv_obj_t *obj, lv_point_t *p, lv_obj_point_transform_flag_t flags)
```
Parameters
| Name | Type | Description |
| ------- | ------------------------------------------------------ | -------------------------------------------------------------- |
| `obj` | | pointer to an object whose style properties should be used |
| `p` | | a point to transform, the result will be written back here too |
| `flags` | | OR-ed valued of :cpp:enum:`lv_obj_point_transform_flag_t` |
lv_obj_transform_point_array [#lv_obj_transform_point_array]
Transform an array of points using the angle and zoom style properties of an object
```c title=" " lineNumbers=1
void lv_obj_transform_point_array(const lv_obj_t *obj, lv_point_t points[], size_t count, lv_obj_point_transform_flag_t flags)
```
Parameters
| Name | Type | Description |
| -------- | ------------------------------------------------------ | -------------------------------------------------------------------------- |
| `obj` | | pointer to an object whose style properties should be used |
| `points` | | the array of points to transform, the result will be written back here too |
| `count` | | number of points in the array |
| `flags` | | OR-ed valued of :cpp:enum:`lv_obj_point_transform_flag_t` |
lv_obj_invalidate_area [#lv_obj_invalidate_area]
Mark an area of an object as invalid. The area will be truncated to the object's area and marked for redraw.
```c title=" " lineNumbers=1
lv_result_t lv_obj_invalidate_area(const lv_obj_t *obj, const lv_area_t *area)
```
Parameters
| Name | Type | Description |
| ------ | -------------------------------------------------------- | -------------------- |
| `obj` | | pointer to an object |
| `area` | | the area to redraw |
**Returns:** — LV\_RESULT\_OK: the area is invalidated; LV\_RESULT\_INVALID: the area wasn't invalidated. (maybe it was off-screen or fully clipped)
lv_obj_invalidate [#lv_obj_invalidate]
Mark the object as invalid to redrawn its area
```c title=" " lineNumbers=1
lv_result_t lv_obj_invalidate(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — LV\_RESULT\_OK: the area is invalidated; LV\_RESULT\_INVALID: the area wasn't invalidated. (maybe it was off-screen or fully clipped)
lv_obj_area_is_visible [#lv_obj_area_is_visible]
Tell whether an area of an object is visible (even partially) now or not
```c title=" " lineNumbers=1
bool lv_obj_area_is_visible(const lv_obj_t *obj, lv_area_t *area)
```
Parameters
| Name | Type | Description |
| ------ | ------------------------------------------------------ | ------------------------------------------------------------------------- |
| `obj` | | pointer to an object |
| `area` | | the are to check. The visible part of the area will be written back here. |
**Returns:** — true visible; false not visible (hidden, out of parent, on other screen, etc)
lv_obj_is_visible [#lv_obj_is_visible]
Tell whether an object is visible (even partially) now or not
```c title=" " lineNumbers=1
bool lv_obj_is_visible(const lv_obj_t *obj)
```
Parameters
| Name | Type | Description |
| ----- | ------------------------------------------------------ | -------------------- |
| `obj` | | pointer to an object |
**Returns:** — true: visible; false not visible (hidden, out of parent, on other screen, etc)
lv_obj_hit_test [#lv_obj_hit_test]
Hit-test an object given a particular point in screen space.
```c title=" " lineNumbers=1
bool lv_obj_hit_test(lv_obj_t *obj, const lv_point_t *point)
```
Parameters
| Name | Type | Description |
| ------- | ---------------------------------------------------------- | ---------------------------------------- |
| `obj` | | object to hit-test |
| `point` | | screen-space point (absolute coordinate) |
**Returns:** — true: if the object is considered under the point
lv_clamp_width [#lv_clamp_width]
Clamp a width between min and max width. If the min/max width is in percentage value use the ref\_width
```c title=" " lineNumbers=1
int32_t lv_clamp_width(int32_t width, int32_t min_width, int32_t max_width, int32_t ref_width)
```
Parameters
| Name | Type | Description |
| ----------- | -------------------------- | ------------------------------------------------------------ |
| `width` | | width to clamp |
| `min_width` | | the minimal width |
| `max_width` | | the maximal width |
| `ref_width` | | the reference width used when min/max width is in percentage |
**Returns:** — the clamped width
lv_clamp_height [#lv_clamp_height]
Clamp a height between min and max height. If the min/max height is in percentage value use the ref\_height
```c title=" " lineNumbers=1
int32_t lv_clamp_height(int32_t height, int32_t min_height, int32_t max_height, int32_t ref_height)
```
Parameters
| Name | Type | Description |
| ------------ | -------------------------- | -------------------------------------------------------------- |
| `height` | | height to clamp |
| `min_height` | | the minimal height |
| `max_height` | | the maximal height |
| `ref_height` | | the reference height used when min/max height is in percentage |
**Returns:** — the clamped height
lv_obj_calc_dynamic_width [#lv_obj_calc_dynamic_width]
Calculates the width in pixels of an LVGL object based on its style and parent for a given width `prop`.
```c title=" " lineNumbers=1
int32_t lv_obj_calc_dynamic_width(lv_obj_t *obj, lv_style_prop_t prop)
```
Parameters
| Name | Type | Description |
| ------ | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
| `obj` | | Pointer to the LVGL object whose width is being calculated. |
| `prop` | | Which style width to calculate for. Valid values are: LV\_STYLE\_WIDTH, LV\_STYLE\_MIN\_WIDTH, or LV\_STYLE\_MAX\_WIDTH. |
**Returns:** — The computed width for the object:
If the style width is a fixed value, that value is returned.
If the style width is `LV_SIZE_CONTENT`, the content width is calculated and returned.
If the style width is a , the percentage is applied to the parent's width.
lv_obj_calc_dynamic_height [#lv_obj_calc_dynamic_height]
Calculates the height in pixels of an LVGL object based on its style and parent for a given height `prop`.
```c title=" " lineNumbers=1
int32_t lv_obj_calc_dynamic_height(lv_obj_t *obj, lv_style_prop_t prop)
```
Parameters
| Name | Type | Description |
| ------ | ------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------- |
| `obj` | | Pointer to the LVGL object whose height is being calculated. |
| `prop` | | Which style height to calculate for. Valid values are: LV\_STYLE\_HEIGHT, LV\_STYLE\_MIN\_HEIGHT, or LV\_STYLE\_MAX\_HEIGHT. |
**Returns:** — The computed height for the object:
If the style height is a fixed value, that value is returned.
If the style height is `LV_SIZE_CONTENT`, the content height is calculated and returned.
If the style height is a , the percentage is applied to the parent's height.
Enums [#enums]
lv_obj_point_transform_flag_t [#lv_obj_point_transform_flag_t]
| Name | Value | Description |
| ----------------------------------------------- | ------ | ------------------------------------------------------------- |
| `LV_OBJ_POINT_TRANSFORM_FLAG_NONE` | `0x00` | No flags |
| `LV_OBJ_POINT_TRANSFORM_FLAG_RECURSIVE` | `0x01` | Consider the transformation properties of the parents too |
| `LV_OBJ_POINT_TRANSFORM_FLAG_INVERSE` | `0x02` | Execute the inverse of the transformation (-angle and 1/zoom) |
| `LV_OBJ_POINT_TRANSFORM_FLAG_INVERSE_RECURSIVE` | `0x03` | Both inverse and recursive |
* `lv_obj_transform_point` — param `flags`
* `lv_obj_transform_point_array` — param `flags`
* `lv_obj_get_transformed_area` — param `flags`
Dependencies [#dependencies]