from typing import Any, Optional, Union from flet_core.constrained_control import ConstrainedControl from flet_core.control import OptionalNumber from flet_core.ref import Ref from flet_core.types import ( AnimationValue, OffsetValue, ResponsiveNumber, RotateValue, ScaleValue, ) class Slider(ConstrainedControl): """ A slider provides a visual indication of adjustable content, as well as the current setting in the total range of content. Use a slider when you want people to set defined values (such as volume or brightness), or when people would benefit from instant feedback on the effect of setting changes. Example: ``` import flet as ft def main(page): page.add( ft.Text("Slider with value:"), ft.Slider(value=0.3), ft.Text("Slider with a custom range and label:"), ft.Slider(min=0, max=100, divisions=10, label="{value}%")) ft.app(target=main) ``` ----- Online docs: https://flet.dev/docs/controls/slider """ def __init__( self, ref: Optional[Ref] = None, key: Optional[str] = None, width: OptionalNumber = None, height: OptionalNumber = None, left: OptionalNumber = None, top: OptionalNumber = None, right: OptionalNumber = None, bottom: OptionalNumber = None, expand: Union[None, bool, int] = None, col: Optional[ResponsiveNumber] = None, opacity: OptionalNumber = None, rotate: RotateValue = None, scale: ScaleValue = None, offset: OffsetValue = None, aspect_ratio: OptionalNumber = None, animate_opacity: AnimationValue = None, animate_size: AnimationValue = None, animate_position: AnimationValue = None, animate_rotation: AnimationValue = None, animate_scale: AnimationValue = None, animate_offset: AnimationValue = None, on_animation_end=None, tooltip: Optional[str] = None, visible: Optional[bool] = None, disabled: Optional[bool] = None, data: Any = None, # # Specific # value: OptionalNumber = None, adaptive: Optional[bool] = None, label: Optional[str] = None, min: OptionalNumber = None, max: OptionalNumber = None, divisions: Optional[int] = None, round: Optional[int] = None, autofocus: Optional[bool] = None, active_color: Optional[str] = None, inactive_color: Optional[str] = None, thumb_color: Optional[str] = None, on_change=None, on_change_start=None, on_change_end=None, on_focus=None, on_blur=None, ): ConstrainedControl.__init__( self, ref=ref, key=key, width=width, height=height, left=left, top=top, right=right, bottom=bottom, expand=expand, col=col, opacity=opacity, rotate=rotate, scale=scale, offset=offset, aspect_ratio=aspect_ratio, animate_opacity=animate_opacity, animate_size=animate_size, animate_position=animate_position, animate_rotation=animate_rotation, animate_scale=animate_scale, animate_offset=animate_offset, on_animation_end=on_animation_end, tooltip=tooltip, visible=visible, disabled=disabled, data=data, ) self.value = value self.adaptive = adaptive self.label = label self.min = min self.max = max self.divisions = divisions self.round = round self.autofocus = autofocus self.active_color = active_color self.inactive_color = inactive_color self.thumb_color = thumb_color self.on_change = on_change self.on_change_start = on_change_start self.on_change_end = on_change_end self.on_focus = on_focus self.on_blur = on_blur def _get_control_name(self): return "slider" # value @property def value(self) -> OptionalNumber: v = self._get_attr("value", data_type="float") # verify limits if self.min and v < self.min: v = self.min elif self.max and v > self.max: v = self.max return v @value.setter def value(self, value: OptionalNumber): self._set_attr("value", value) # label @property def label(self): return self._get_attr("label") @label.setter def label(self, value): self._set_attr("label", value) # min @property def min(self) -> OptionalNumber: return self._get_attr("min") @min.setter def min(self, value: OptionalNumber): self._set_attr("min", value) # max @property def max(self) -> OptionalNumber: return self._get_attr("max") @max.setter def max(self, value: OptionalNumber): self._set_attr("max", value) # divisions @property def divisions(self) -> Optional[int]: return self._get_attr("divisions") @divisions.setter def divisions(self, value: Optional[int]): self._set_attr("divisions", value) # round @property def round(self) -> Optional[int]: return self._get_attr("round") @round.setter def round(self, value: Optional[int]): self._set_attr("round", value) # autofocus @property def autofocus(self) -> Optional[bool]: return self._get_attr("autofocus", data_type="bool", def_value=False) @autofocus.setter def autofocus(self, value: Optional[bool]): self._set_attr("autofocus", value) # active_color @property def active_color(self): return self._get_attr("activeColor") @active_color.setter def active_color(self, value): self._set_attr("activeColor", value) # inactive_color @property def inactive_color(self): return self._get_attr("inactiveColor") @inactive_color.setter def inactive_color(self, value): self._set_attr("inactiveColor", value) # thumb_color @property def thumb_color(self): return self._get_attr("thumbColor") @thumb_color.setter def thumb_color(self, value): self._set_attr("thumbColor", value) # adaptive @property def adaptive(self) -> Optional[bool]: return self._get_attr("adaptive", data_type="bool", def_value=False) @adaptive.setter def adaptive(self, value: Optional[bool]): self._set_attr("adaptive", value) # on_change @property def on_change(self): return self._get_event_handler("change") @on_change.setter def on_change(self, handler): self._add_event_handler("change", handler) # on_change_start @property def on_change_start(self): return self._get_event_handler("change_start") @on_change_start.setter def on_change_start(self, handler): self._add_event_handler("change_start", handler) # on_change_end @property def on_change_end(self): return self._get_event_handler("change_end") @on_change_end.setter def on_change_end(self, handler): self._add_event_handler("change_end", handler) # on_focus @property def on_focus(self): return self._get_event_handler("focus") @on_focus.setter def on_focus(self, handler): self._add_event_handler("focus", handler) # on_blur @property def on_blur(self): return self._get_event_handler("blur") @on_blur.setter def on_blur(self, handler): self._add_event_handler("blur", handler)