833 lines
25 KiB
Python
833 lines
25 KiB
Python
"""
|
|
Components/TimePicker
|
|
=====================
|
|
|
|
.. seealso::
|
|
|
|
`Material Design spec, Time picker <https://material.io/components/time-pickers>`_
|
|
|
|
.. rubric:: Includes time picker.
|
|
|
|
.. image:: https://github.com/HeaTTheatR/KivyMD-data/raw/master/gallery/kivymddoc/picker-previous.png
|
|
:align: center
|
|
|
|
.. warning:: The widget is under testing. Therefore, we would be grateful if
|
|
you would let us know about the bugs found.
|
|
|
|
.. rubric:: Usage
|
|
|
|
.. tabs::
|
|
|
|
.. tab:: Declarative KV style
|
|
|
|
.. code-block:: python
|
|
|
|
from kivy.lang import Builder
|
|
|
|
from kivymd.app import MDApp
|
|
from kivymd.uix.pickers import MDTimePicker
|
|
|
|
KV = '''
|
|
MDFloatLayout:
|
|
|
|
MDRaisedButton:
|
|
text: "Open time picker"
|
|
pos_hint: {'center_x': .5, 'center_y': .5}
|
|
on_release: app.show_time_picker()
|
|
'''
|
|
|
|
|
|
class Test(MDApp):
|
|
def build(self):
|
|
self.theme_cls.theme_style = "Dark"
|
|
self.theme_cls.primary_palette = "Orange"
|
|
return Builder.load_string(KV)
|
|
|
|
def show_time_picker(self):
|
|
'''Open time picker dialog.'''
|
|
|
|
time_dialog = MDTimePicker()
|
|
time_dialog.open()
|
|
|
|
|
|
Test().run()
|
|
|
|
.. tab:: Declarative python style
|
|
|
|
.. code-block:: python
|
|
|
|
from kivymd.app import MDApp
|
|
from kivymd.uix.button import MDRaisedButton
|
|
from kivymd.uix.pickers import MDTimePicker
|
|
from kivymd.uix.screen import MDScreen
|
|
|
|
|
|
class Test(MDApp):
|
|
def build(self):
|
|
self.theme_cls.theme_style = "Dark"
|
|
self.theme_cls.primary_palette = "Orange"
|
|
return (
|
|
MDScreen(
|
|
MDRaisedButton(
|
|
text="Open time picker",
|
|
pos_hint={'center_x': .5, 'center_y': .5},
|
|
on_release=self.show_time_picker,
|
|
)
|
|
)
|
|
)
|
|
|
|
def show_time_picker(self, *args):
|
|
'''Open time picker dialog.'''
|
|
|
|
MDTimePicker().open()
|
|
|
|
|
|
Test().run()
|
|
|
|
.. image:: https://github.com/HeaTTheatR/KivyMD-data/raw/master/gallery/kivymddoc/MDTimePicker.png
|
|
:align: center
|
|
|
|
Binding method returning set time
|
|
---------------------------------
|
|
|
|
.. code-block:: python
|
|
|
|
def show_time_picker(self):
|
|
time_dialog = MDTimePicker()
|
|
time_dialog.bind(time=self.get_time)
|
|
time_dialog.open()
|
|
|
|
def get_time(self, instance, time):
|
|
'''
|
|
The method returns the set time.
|
|
|
|
:type instance: <kivymd.uix.picker.MDTimePicker object>
|
|
:type time: <class 'datetime.time'>
|
|
'''
|
|
|
|
return time
|
|
|
|
Open time dialog with the specified time
|
|
----------------------------------------
|
|
|
|
Use the :attr:`~MDTimePicker.set_time` method of the
|
|
:class:`~MDTimePicker.` class.
|
|
|
|
.. code-block:: python
|
|
|
|
def show_time_picker(self):
|
|
from datetime import datetime
|
|
|
|
# Must be a datetime object
|
|
previous_time = datetime.strptime("03:20:00", '%H:%M:%S').time()
|
|
time_dialog = MDTimePicker()
|
|
time_dialog.set_time(previous_time)
|
|
time_dialog.open()
|
|
|
|
.. note:: For customization of the :class:`~MDTimePicker` class, see the
|
|
documentation in the :class:`~kivymd.uix.pickers.datepicker.datepicker.BaseDialogPicker` class.
|
|
|
|
.. code-block:: python
|
|
|
|
MDTimePicker(
|
|
primary_color="brown",
|
|
accent_color="red",
|
|
text_button_color="white",
|
|
).open()
|
|
|
|
.. image:: https://github.com/HeaTTheatR/KivyMD-data/raw/master/gallery/kivymddoc/time-picker-customization.png
|
|
:align: center
|
|
"""
|
|
|
|
__all__ = ("MDTimePicker",)
|
|
|
|
import datetime
|
|
import os
|
|
import re
|
|
import time
|
|
from typing import List, Union
|
|
|
|
from kivy.animation import Animation
|
|
from kivy.clock import Clock
|
|
from kivy.event import EventDispatcher
|
|
from kivy.lang import Builder
|
|
from kivy.metrics import dp
|
|
from kivy.properties import (
|
|
BooleanProperty,
|
|
ColorProperty,
|
|
ListProperty,
|
|
NumericProperty,
|
|
ObjectProperty,
|
|
OptionProperty,
|
|
StringProperty,
|
|
VariableListProperty,
|
|
)
|
|
from kivy.uix.behaviors import ButtonBehavior
|
|
from kivy.vector import Vector
|
|
|
|
from kivymd import uix_path
|
|
from kivymd.uix.boxlayout import MDBoxLayout
|
|
from kivymd.uix.circularlayout import MDCircularLayout
|
|
from kivymd.uix.label import MDLabel
|
|
from kivymd.uix.pickers.datepicker import BaseDialogPicker
|
|
from kivymd.uix.relativelayout import MDRelativeLayout
|
|
from kivymd.uix.textfield import MDTextField
|
|
|
|
with open(
|
|
os.path.join(uix_path, "pickers", "timepicker", "timepicker.kv"),
|
|
encoding="utf-8",
|
|
) as kv_file:
|
|
Builder.load_string(kv_file.read())
|
|
|
|
|
|
class AmPmSelectorLabel(ButtonBehavior, MDLabel):
|
|
pass
|
|
|
|
|
|
class AmPmSelector(MDBoxLayout):
|
|
border_radius = NumericProperty()
|
|
border_color = ColorProperty()
|
|
bg_color = ColorProperty()
|
|
bg_color_active = ColorProperty()
|
|
border_width = NumericProperty()
|
|
am = ObjectProperty()
|
|
am = ObjectProperty()
|
|
owner = ObjectProperty()
|
|
text_color = ColorProperty()
|
|
selected = StringProperty()
|
|
|
|
_am_bg_color = ColorProperty()
|
|
_pm_bg_color = ColorProperty()
|
|
|
|
def __init__(self, **kwargs):
|
|
super().__init__(**kwargs)
|
|
self.bind(selected=self._upadte_color)
|
|
Clock.schedule_once(self._upadte_color)
|
|
|
|
def _upadte_color(self, *args):
|
|
bg_color = (
|
|
self.owner.accent_color
|
|
if self.owner.accent_color
|
|
else self.bg_color_active
|
|
)
|
|
if self.selected == "am":
|
|
self._am_bg_color = bg_color
|
|
self._pm_bg_color = (
|
|
self.owner.primary_color
|
|
if self.owner.accent_color
|
|
else self.bg_color
|
|
)
|
|
elif self.selected == "pm":
|
|
self._am_bg_color = (
|
|
self.owner.primary_color
|
|
if self.owner.accent_color
|
|
else self.bg_color
|
|
)
|
|
self._pm_bg_color = bg_color
|
|
|
|
|
|
class TimeInputTextField(MDTextField):
|
|
num_type = OptionProperty("hour", options=["hour", "minute"])
|
|
hour_regx = "^[0-9]$|^0[1-9]$|^1[0-2]$"
|
|
minute_regx = "^[0-9]$|^0[0-9]$|^[1-5][0-9]$"
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
Clock.schedule_once(self.set_text)
|
|
self.register_event_type("on_select")
|
|
self.bind(text_color_focus=self.setter("hint_text_color_normal"))
|
|
|
|
def validate_time(self, text) -> Union[None, re.Match]:
|
|
reg = self.hour_regx if self.num_type == "hour" else self.minute_regx
|
|
return re.match(reg, text)
|
|
|
|
def insert_text(self, text, from_undo=False):
|
|
strip_text = self.text.strip()
|
|
current_string = "".join([strip_text, text])
|
|
if not self.validate_time(current_string):
|
|
text = ""
|
|
return super().insert_text(text, from_undo=from_undo)
|
|
|
|
def set_text(self, *args) -> None:
|
|
"""
|
|
Texts should be center aligned. Now we are setting the padding of text
|
|
to somehow make them aligned.
|
|
"""
|
|
|
|
def set_text(*args):
|
|
if not self.text:
|
|
self.text = " "
|
|
|
|
self._refresh_text(self.text)
|
|
max_size = max(self._lines_rects, key=lambda r: r.size[0]).size
|
|
dx = (self.width - max_size[0]) / 2.0
|
|
dy = (self.height - max_size[1]) / 2.0
|
|
self.padding = [dx, dy, dx, dy]
|
|
|
|
if len(self.text) > 1:
|
|
self.text = self.text.replace(" ", "")
|
|
|
|
Clock.schedule_once(set_text)
|
|
|
|
def on_focus(self, *args) -> None:
|
|
super().on_focus(*args)
|
|
if self.text.strip():
|
|
if (
|
|
not self.focus
|
|
and int(self.text) == 0
|
|
and self.num_type == "hour"
|
|
):
|
|
self.text = "12"
|
|
else:
|
|
self.text = " 12" if self.num_type == "hour" else " 00"
|
|
|
|
def on_select(self, *args) -> None:
|
|
pass
|
|
|
|
def on_touch_down(self, touch):
|
|
if self.collide_point(*touch.pos):
|
|
self.dispatch("on_select")
|
|
super().on_touch_down(touch)
|
|
|
|
|
|
class TimeInput(MDRelativeLayout):
|
|
"""Implements two text fields for displaying and entering a time value."""
|
|
|
|
bg_color = ColorProperty()
|
|
bg_color_active = ColorProperty()
|
|
text_color = ColorProperty()
|
|
disabled = BooleanProperty(True)
|
|
minute_radius = ListProperty([0, 0, 0, 0])
|
|
hour_radius = ListProperty([0, 0, 0, 0])
|
|
state = StringProperty("hour")
|
|
|
|
_hour = ObjectProperty()
|
|
_minute = ObjectProperty()
|
|
|
|
def __init__(self, **kwargs):
|
|
super().__init__(**kwargs)
|
|
self.register_event_type("on_time_input")
|
|
self.register_event_type("on_hour_select")
|
|
self.register_event_type("on_minute_select")
|
|
|
|
def set_time(self, time_list) -> None:
|
|
hour, minute = time_list
|
|
self._hour.text = hour
|
|
self._minute.text = minute
|
|
|
|
def get_time(self) -> List[str]:
|
|
hour = self._hour.text.strip()
|
|
minute = self._minute.text.strip()
|
|
return [hour, minute]
|
|
|
|
def on_time_input(self, *args) -> None:
|
|
pass
|
|
|
|
def on_minute_select(self, *args) -> None:
|
|
pass
|
|
|
|
def on_hour_select(self, *args) -> None:
|
|
pass
|
|
|
|
def _update_padding(self, *args):
|
|
self._hour.set_text()
|
|
self._minute.set_text()
|
|
|
|
|
|
class SelectorLabel(MDLabel):
|
|
pass
|
|
|
|
|
|
class CircularSelector(MDCircularLayout, EventDispatcher):
|
|
"""Implements clock face display."""
|
|
|
|
mode = OptionProperty("hour", options=["hour", "minute"]) # and military
|
|
text_color = ColorProperty()
|
|
selected_hour = StringProperty("12")
|
|
selected_minute = StringProperty("0")
|
|
selector_size = NumericProperty("48dp")
|
|
selector_pos = ListProperty([0, 0])
|
|
selector_color = ColorProperty()
|
|
bg_color = ColorProperty()
|
|
font_name = StringProperty()
|
|
scale = NumericProperty(1)
|
|
content_scale = NumericProperty(1)
|
|
t = StringProperty("out_quad")
|
|
d = NumericProperty(0.2)
|
|
scale_origin = ListProperty([100, 100])
|
|
|
|
_centers_pos = ListProperty()
|
|
|
|
def __init__(self, **kwargs):
|
|
super().__init__(**kwargs)
|
|
self.bind(
|
|
mode=self._update_labels,
|
|
selected_hour=self.update_time,
|
|
selected_minute=self.update_time,
|
|
)
|
|
Clock.schedule_once(lambda x: self._update_labels(animate=False))
|
|
self.register_event_type("on_selector_change")
|
|
|
|
def do_layout(self, *largs, **kwargs):
|
|
self.update_time()
|
|
return super().do_layout(*largs, **kwargs)
|
|
|
|
def set_selector(self, selected) -> bool:
|
|
"""Sets the selector's position towards the given text."""
|
|
|
|
widget = None
|
|
for wid in self.children:
|
|
wid.text_color = self.text_color
|
|
if wid.text == selected:
|
|
widget = wid
|
|
if not widget:
|
|
return False
|
|
self.selector_pos = widget.center
|
|
widget.text_color = [1, 1, 1, 1]
|
|
self.dispatch("on_selector_change")
|
|
return True
|
|
|
|
def set_time(self, selected) -> None:
|
|
if self.mode == "hour":
|
|
self.selected_hour = selected
|
|
elif self.mode == "minute":
|
|
self.selected_minute = selected
|
|
|
|
def update_time(self, *args) -> None:
|
|
if self.mode == "hour":
|
|
self.set_selector(self.selected_hour)
|
|
elif self.mode == "minute":
|
|
self.set_selector(self.selected_minute)
|
|
|
|
def get_selected(self) -> str:
|
|
return self.selected
|
|
|
|
def switch_mode(self, mode) -> None:
|
|
if mode != self.mode:
|
|
self.mode = mode
|
|
|
|
def on_touch_down(self, touch):
|
|
if self.collide_point(*touch.pos):
|
|
touch.grab(self)
|
|
closest_wid = self._get_closest_widget(touch.pos)
|
|
self.set_time(closest_wid.text)
|
|
return True
|
|
|
|
def on_touch_move(self, touch):
|
|
if touch.grab_current == self:
|
|
closest_wid = self._get_closest_widget(touch.pos)
|
|
self.set_time(closest_wid.text)
|
|
|
|
def on_touch_up(self, touch):
|
|
if touch.grab_current is self:
|
|
touch.ungrab(self)
|
|
return True
|
|
|
|
def on_selector_change(self, *args):
|
|
pass
|
|
|
|
def _update_labels(self, animate=True, *args):
|
|
"""
|
|
This method builds the selector based on current mode which currently
|
|
can be hour or minute.
|
|
"""
|
|
|
|
if self.mode == "hour":
|
|
param = (1, 12)
|
|
self.degree_spacing = 30
|
|
self.start_from = 60
|
|
elif self.mode == "minute":
|
|
param = (0, 59, 5)
|
|
self.degree_spacing = 6
|
|
self.start_from = 90
|
|
elif self.mode == "military":
|
|
param = (1, 24)
|
|
self.degree_spacing = 30
|
|
self.start_from = 90
|
|
if animate:
|
|
anim = Animation(content_scale=0, t=self.t, d=self.d)
|
|
anim.bind(on_complete=lambda *args: self._add_items(*param))
|
|
anim.start(self)
|
|
else:
|
|
self._add_items(*param)
|
|
|
|
def _add_items(self, start, end, step=1):
|
|
"""
|
|
Adds all number in range `[start, end + 1]` to the circular layout with
|
|
the specified step. Step means that all widgets will be added to layout
|
|
but sets the opacity for skipped widgets to `0` because we are using
|
|
the label's text as a reference to the selected number so we have to
|
|
add these to layout.
|
|
"""
|
|
|
|
self.clear_widgets()
|
|
i = 0
|
|
for x in range(start, end + 1):
|
|
label = SelectorLabel(
|
|
text=f"{x}",
|
|
)
|
|
if i % step != 0:
|
|
label.opacity = 0
|
|
self.bind(
|
|
text_color=label.setter("text_color"),
|
|
font_name=label.setter("font_name"),
|
|
)
|
|
self.add_widget(label)
|
|
i += 1
|
|
Clock.schedule_once(self.update_time)
|
|
Clock.schedule_once(self._get_centers, 0.1)
|
|
anim = Animation(content_scale=1, t=self.t, d=self.d)
|
|
anim.start(self)
|
|
|
|
def _get_centers(self, *args):
|
|
"""
|
|
Returns a list of all center. we use this for positioning the selector
|
|
indicator.
|
|
"""
|
|
|
|
self._centers_pos = []
|
|
for child in self.children:
|
|
self._centers_pos.append(child.center)
|
|
|
|
def _get_closest_widget(self, pos):
|
|
"""
|
|
Returns the nearest widget to the given position. we use this to create
|
|
the magnetic effect.
|
|
"""
|
|
|
|
distance = [Vector(pos).distance(point) for point in self._centers_pos]
|
|
if not distance:
|
|
return False
|
|
index = distance.index(min(distance))
|
|
return self.children[index]
|
|
|
|
|
|
class MDTimePicker(BaseDialogPicker):
|
|
hour = StringProperty("12")
|
|
"""
|
|
Current hour.
|
|
|
|
:attr:`hour` is an :class:`~kivy.properties.StringProperty`
|
|
and defaults to `'12'`.
|
|
"""
|
|
|
|
minute = StringProperty("0")
|
|
"""
|
|
Current minute.
|
|
|
|
:attr:`minute` is an :class:`~kivy.properties.StringProperty`
|
|
and defaults to `0`.
|
|
"""
|
|
|
|
minute_radius = VariableListProperty(dp(5), length=4)
|
|
"""
|
|
Radius of the minute input field.
|
|
|
|
.. image:: https://github.com/HeaTTheatR/KivyMD-data/raw/master/gallery/kivymddoc/time-picker-minute-radius.png
|
|
:align: center
|
|
|
|
:attr:`minute_radius` is an :class:`~kivy.properties.ListProperty`
|
|
and defaults to `[dp(5), dp(5), dp(5), dp(5)]`.
|
|
"""
|
|
|
|
hour_radius = VariableListProperty(dp(5), length=4)
|
|
"""
|
|
Radius of the hour input field.
|
|
|
|
.. image:: https://github.com/HeaTTheatR/KivyMD-data/raw/master/gallery/kivymddoc/time-picker-hour-radius.png
|
|
:align: center
|
|
|
|
:attr:`hour_radius` is an :class:`~kivy.properties.ListProperty`
|
|
and defaults to `[dp(5), dp(5), dp(5), dp(5)]`.
|
|
"""
|
|
|
|
am_pm_radius = NumericProperty("5dp")
|
|
"""
|
|
Radius of the AM/PM selector.
|
|
|
|
.. image:: https://github.com/HeaTTheatR/KivyMD-data/raw/master/gallery/kivymddoc/time-picker-am-pm-radius.png
|
|
:align: center
|
|
|
|
:attr:`am_pm_radius` is an :class:`~kivy.properties.NumericProperty`
|
|
and defaults to `dp(5)`.
|
|
"""
|
|
|
|
am_pm_border_width = NumericProperty("1dp")
|
|
"""
|
|
Width of the AM/PM selector's borders.
|
|
|
|
.. image:: https://github.com/HeaTTheatR/KivyMD-data/raw/master/gallery/kivymddoc/time-picker-am-pm-border-width.png
|
|
:align: center
|
|
|
|
:attr:`am_pm_border_width` is an :class:`~kivy.properties.NumericProperty`
|
|
and defaults to `dp(1)`.
|
|
"""
|
|
|
|
am_pm = OptionProperty("am", options=["am", "pm"])
|
|
"""
|
|
Current AM/PM mode.
|
|
|
|
:attr:`am_pm` is an :class:`~kivy.properties.OptionProperty`
|
|
and defaults to `'am'`.
|
|
"""
|
|
|
|
animation_duration = NumericProperty(0.3)
|
|
"""
|
|
Duration of the animations.
|
|
|
|
:attr:`animation_duration` is an :class:`~kivy.properties.NumericProperty`
|
|
and defaults to `0.2`.
|
|
"""
|
|
|
|
animation_transition = StringProperty("out_quad")
|
|
"""
|
|
Transition type of the animations.
|
|
|
|
:attr:`animation_transition` is an :class:`~kivy.properties.StringProperty`
|
|
and defaults to `'out_quad'`.
|
|
"""
|
|
|
|
time = ObjectProperty(allownone=True)
|
|
"""
|
|
Returns the current time object.
|
|
|
|
:attr:`time` is an :class:`~kivy.properties.ObjectProperty`
|
|
and defaults to `None`.
|
|
"""
|
|
|
|
_state = StringProperty()
|
|
_selector = ObjectProperty()
|
|
_time_input = ObjectProperty()
|
|
_am_pm_selector = ObjectProperty()
|
|
_hour_label = ObjectProperty()
|
|
_minute_label = ObjectProperty()
|
|
_anim_playing = BooleanProperty(False)
|
|
|
|
def __init__(self, **kwargs):
|
|
super().__init__(**kwargs)
|
|
self.bind(
|
|
hour=self._set_current_time,
|
|
minute=self._set_current_time,
|
|
am_pm=self._set_current_time,
|
|
)
|
|
self.theme_cls.bind(device_orientation=self._check_orienation)
|
|
if self.title == "SELECT DATE":
|
|
self.title = "SELECT TIME"
|
|
self.set_time(datetime.time(hour=12, minute=0)) # default time
|
|
self._check_orienation()
|
|
|
|
def set_time(self, time_obj) -> None:
|
|
"""Manually set time dialog with the specified time."""
|
|
|
|
hour = time_obj.hour
|
|
minute = time_obj.minute
|
|
if hour > 12:
|
|
hour -= 12
|
|
mode = "pm"
|
|
else:
|
|
mode = "am"
|
|
hour = str(hour)
|
|
minute = str(minute)
|
|
self._set_time_input(hour, minute)
|
|
self._set_dial_time(hour, minute)
|
|
self._set_am_pm(mode)
|
|
|
|
def get_state(self) -> str:
|
|
"""
|
|
Returns the current state of TimePicker.
|
|
Can be one of `portrait`, `landscape` or `input`.
|
|
"""
|
|
|
|
return self._state
|
|
|
|
def _get_dial_time(self, instance):
|
|
mode = instance.mode
|
|
if mode == "hour":
|
|
self.hour = instance.selected_hour
|
|
elif mode == "minute":
|
|
self.minute = instance.selected_minute
|
|
else:
|
|
raise Exception("invalid mode for MDTimePicker: " % mode)
|
|
self._set_time_input(self.hour, self.minute)
|
|
|
|
def _set_dial_time(self, hour, minute):
|
|
self._selector.selected_minute = minute
|
|
self._selector.selected_hour = hour
|
|
|
|
def _get_time_input(self, hour, minute):
|
|
if hour:
|
|
self.hour = f"{int(hour):01d}"
|
|
if minute:
|
|
self.minute = f"{int(minute):01d}"
|
|
self._set_dial_time(self.hour, self.minute)
|
|
|
|
def _set_time_input(self, hour, minute):
|
|
hour = f"{int(hour):02d}"
|
|
minute = f"{int(minute):02d}"
|
|
if self._state != "input":
|
|
self._time_input.set_time([hour, minute])
|
|
|
|
def _get_am_pm(self, selected):
|
|
self.am_pm = selected
|
|
|
|
def _set_am_pm(self, selected: str) -> None:
|
|
"""Used by set_time() to manually set the mode to "am" or "pm"."""
|
|
self.am_pm = selected
|
|
self._am_pm_selector.mode = self.am_pm
|
|
self._am_pm_selector.selected = self.am_pm
|
|
|
|
def _get_data(self):
|
|
try:
|
|
if time.strftime("%p"):
|
|
result = datetime.datetime.strptime(
|
|
f"{int(self.hour):02d}:{int(self.minute):02d} {self.am_pm}",
|
|
"%I:%M %p",
|
|
).time()
|
|
else:
|
|
result = datetime.datetime.strptime(
|
|
f"{int(self.hour):02d}:{int(self.minute):02d}",
|
|
"%I:%M",
|
|
).time()
|
|
return result
|
|
except ValueError:
|
|
return None # hour is zero
|
|
|
|
def _check_orienation(self, *args, do_anim=False):
|
|
orientation = self.theme_cls.device_orientation
|
|
if self._state != "input" and orientation != self._state:
|
|
self._update_pos_size(orientation, anim=do_anim)
|
|
|
|
def _update_pos_size(self, orientation, anim=False):
|
|
d = self.animation_duration
|
|
# time input
|
|
time_input_pos = (
|
|
[dp(24), dp(368)]
|
|
if orientation == "portrait"
|
|
else (
|
|
[dp(24), dp(178)]
|
|
if orientation == "landscape"
|
|
else [dp(24), dp(96)]
|
|
)
|
|
)
|
|
if anim:
|
|
_time_input = Animation(
|
|
pos=time_input_pos,
|
|
d=d,
|
|
t=self.animation_transition, # 80 - 8,
|
|
)
|
|
_time_input.start(self._time_input)
|
|
else:
|
|
self._time_input.pos = time_input_pos
|
|
|
|
self._time_input.disabled = False if orientation == "input" else True
|
|
self._time_input.size = (
|
|
[dp(216), dp(62)] if orientation == "input" else [dp(216), dp(72)]
|
|
)
|
|
Clock.schedule_once(self._time_input._update_padding)
|
|
|
|
# Circular selector.
|
|
if orientation == "input":
|
|
if self.theme_cls.device_orientation == "portrait":
|
|
selector_pos = [dp(34), dp(-256)]
|
|
self._selector.scale_origin = [dp(162), dp(200)]
|
|
else:
|
|
selector_pos = [dp(324), dp(-19)]
|
|
self._selector.scale_origin = [dp(292), dp(109)]
|
|
elif orientation == "portrait":
|
|
self._selector.pos = selector_pos = [dp(36), dp(76)]
|
|
else:
|
|
self._selector.pos = selector_pos = [dp(304), dp(76)]
|
|
|
|
Animation(
|
|
pos=selector_pos,
|
|
scale=0 if orientation == "input" else 1,
|
|
opacity=0 if orientation == "input" else 1,
|
|
d=d,
|
|
t=self.animation_transition,
|
|
).start(self._selector)
|
|
|
|
# AM/PM selector.
|
|
am_pm_pos = (
|
|
[dp(252), dp(368)]
|
|
if orientation == "portrait"
|
|
else (
|
|
[dp(24), dp(126)]
|
|
if orientation == "landscape"
|
|
else [dp(252), dp(96)]
|
|
)
|
|
)
|
|
am_pm_size = (
|
|
[dp(52), dp(80)]
|
|
if orientation == "portrait"
|
|
else (
|
|
[dp(216), dp(40)]
|
|
if orientation == "landscape"
|
|
else [dp(48), dp(70)]
|
|
)
|
|
)
|
|
if anim:
|
|
Animation(
|
|
pos=am_pm_pos,
|
|
size=am_pm_size,
|
|
d=d,
|
|
t=self.animation_transition,
|
|
).start(self._am_pm_selector)
|
|
else:
|
|
self._am_pm_selector.pos = am_pm_pos
|
|
self._am_pm_selector.size = am_pm_size
|
|
|
|
self._am_pm_selector.orientation = (
|
|
"horizontal" if orientation == "landscape" else "vertical"
|
|
)
|
|
|
|
# MDTimePicker.
|
|
time_picker_size = (
|
|
[dp(328), dp(500)]
|
|
if orientation == "portrait"
|
|
else (
|
|
[dp(584), dp(368)]
|
|
if orientation == "landscape"
|
|
else [dp(324), dp(218)]
|
|
)
|
|
)
|
|
if anim:
|
|
Animation(
|
|
size=time_picker_size,
|
|
d=d,
|
|
t=self.animation_transition,
|
|
).start(self)
|
|
else:
|
|
self.size = time_picker_size
|
|
|
|
# Minute label.
|
|
Animation(
|
|
pos=[dp(144), dp(76)],
|
|
opacity=1 if orientation == "input" else 0,
|
|
d=d,
|
|
t=self.animation_transition,
|
|
).start(self._minute_label)
|
|
|
|
# Hour label.
|
|
Animation(
|
|
pos=[dp(24), dp(76)],
|
|
opacity=1 if orientation == "input" else 0,
|
|
d=d,
|
|
t=self.animation_transition,
|
|
).start(self._hour_label)
|
|
|
|
self._state = orientation
|
|
self.ids.input_clock_switch.icon = (
|
|
"clock-time-four-outline" if orientation == "input" else "keyboard"
|
|
)
|
|
|
|
def _set_current_time(self, *args):
|
|
self.time = self._get_data()
|
|
|
|
def _switch_input(self):
|
|
self._update_pos_size(
|
|
self.theme_cls.device_orientation
|
|
if self._state == "input"
|
|
else "input",
|
|
anim=True,
|
|
)
|