# Observers (/main-modules/data_binding/observers)
An **Observer** watches one [Subject](/main-modules/data_binding/subjects) and runs a
callback whenever that Subject's value changes. When you subscribe, the callback is
also called once immediately, so the Observer can pick up the current value right
away.
A callback always has the same signature:
```c title=" " lineNumbers=1
static void temperature_cb(lv_observer_t * observer, lv_subject_t * subject)
{
int32_t t = lv_subject_get_int(subject);
LV_LOG_USER("Temperature is now %d", t);
}
```
Subscribing [#subscribing]
The simplest way to subscribe is .
The third argument is free-form user data passed to the callback:
```c title=" " lineNumbers=1
lv_subject_add_observer(temperature, temperature_cb, NULL);
```
Often the Observer needs to update a specific object. Pass a Widget with
,
then read it back in the callback with .
```c title=" " lineNumbers=1
lv_subject_add_observer_obj(temperature, label_cb, my_label, NULL);
static void label_cb(lv_observer_t * observer, lv_subject_t * subject)
{
lv_obj_t * label = lv_observer_get_target_obj(observer);
lv_label_set_text_fmt(label, "%d °C", lv_subject_get_int(subject));
}
```
In a generic case any other pointer can be passed as target with
and the
target can be read back with .
Unsubscribing [#unsubscribing]
An Observer bound to a Widget using is removed automatically when that Widget is deleted, so in this case you don't need to do anything. Otherwise:
* removes a
single Observer (use the pointer returned when subscribing).
*
removes a Widget's Observers (`subject` may be `NULL` to detach from all).
* disconnects a
Subject from all of its Observers and frees it.
Binding a Widget to a Subject [#binding-a-widget-to-a-subject]
Besides subscribing by hand, a Widget's property can be bound to a Subject directly.
Each binding is just an Observer, so it too is removed automatically when the Widget
is deleted.
Flags [#flags]
To drive a flag from a `0`/non-zero Subject, use
. Because the callback
takes a `bool`, a dedicated per-flag setter can be passed straight in:
```c title=" " lineNumbers=1
lv_obj_bind_bool(widget, subject, lv_obj_set_hidden); /* hidden while non-zero */
```
States [#states]
There's no dedicated setter for a state, and states often depend on a comparison, so
bind them with a small Observer of your own:
```c title=" " lineNumbers=1
static void disabled_cb(lv_observer_t * observer, lv_subject_t * subject)
{
lv_obj_t * obj = lv_observer_get_target_obj(observer);
lv_obj_set_state(obj, LV_STATE_DISABLED, lv_subject_get_int(subject) > 80);
}
lv_subject_add_observer_obj(subject, disabled_cb, widget, NULL);
```
The older `lv_obj_bind_flag_if_*` and `lv_obj_bind_state_if_*` functions are
**deprecated** in favor of the two approaches above.
Checked state [#checked-state]
creates a
**two-way** binding: the Widget's checked state follows the Subject (checked while
non-zero), and clicking the Widget writes `1` or `0` back to the Subject. The Widget
should have
to make it checkable.
```c title=" " lineNumbers=1
lv_obj_bind_checked(checkbox, subject);
```
Widget values [#widget-values]
A Widget's main value or text is bound with the widget's own `lv__bind_...()`
function, described under "Data binding" on each widget's page. A few examples:
Label text [#label-text]
keeps a Label's
text in sync with a Subject, optionally through a `printf`-style format string.
Slider value [#slider-value]
ties a Slider's
position to a Subject; dragging the Slider updates the Subject and vice versa.
Arc value [#arc-value]
keeps an Arc's value
in sync with a Subject.
Drop-down value [#drop-down-value]
binds the
selected option's index to a Subject.
Roller value [#roller-value]
binds the
selected option's index to a Subject.