bastd.ui.onscreenkeyboard

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Provides the built-in on screen keyboard UI."""
  4
  5from __future__ import annotations
  6
  7from typing import TYPE_CHECKING, cast
  8
  9import ba
 10import ba.internal
 11
 12if TYPE_CHECKING:
 13    pass
 14
 15
 16class OnScreenKeyboardWindow(ba.Window):
 17    """Simple built-in on-screen keyboard."""
 18
 19    def __init__(self, textwidget: ba.Widget, label: str, max_chars: int):
 20        self._target_text = textwidget
 21        self._width = 700
 22        self._height = 400
 23        uiscale = ba.app.ui.uiscale
 24        top_extra = 20 if uiscale is ba.UIScale.SMALL else 0
 25        super().__init__(
 26            root_widget=ba.containerwidget(
 27                parent=ba.internal.get_special_widget('overlay_stack'),
 28                size=(self._width, self._height + top_extra),
 29                transition='in_scale',
 30                scale_origin_stack_offset=(
 31                    self._target_text.get_screen_space_center()
 32                ),
 33                scale=(
 34                    2.0
 35                    if uiscale is ba.UIScale.SMALL
 36                    else 1.5
 37                    if uiscale is ba.UIScale.MEDIUM
 38                    else 1.0
 39                ),
 40                stack_offset=(0, 0)
 41                if uiscale is ba.UIScale.SMALL
 42                else (0, 0)
 43                if uiscale is ba.UIScale.MEDIUM
 44                else (0, 0),
 45            )
 46        )
 47        self._done_button = ba.buttonwidget(
 48            parent=self._root_widget,
 49            position=(self._width - 200, 44),
 50            size=(140, 60),
 51            autoselect=True,
 52            label=ba.Lstr(resource='doneText'),
 53            on_activate_call=self._done,
 54        )
 55        ba.containerwidget(
 56            edit=self._root_widget,
 57            on_cancel_call=self._cancel,
 58            start_button=self._done_button,
 59        )
 60
 61        ba.textwidget(
 62            parent=self._root_widget,
 63            position=(self._width * 0.5, self._height - 41),
 64            size=(0, 0),
 65            scale=0.95,
 66            text=label,
 67            maxwidth=self._width - 140,
 68            color=ba.app.ui.title_color,
 69            h_align='center',
 70            v_align='center',
 71        )
 72
 73        self._text_field = ba.textwidget(
 74            parent=self._root_widget,
 75            position=(70, self._height - 116),
 76            max_chars=max_chars,
 77            text=cast(str, ba.textwidget(query=self._target_text)),
 78            on_return_press_call=self._done,
 79            autoselect=True,
 80            size=(self._width - 140, 55),
 81            v_align='center',
 82            editable=True,
 83            maxwidth=self._width - 175,
 84            force_internal_editing=True,
 85            always_show_carat=True,
 86        )
 87
 88        self._key_color_lit = (1.4, 1.2, 1.4)
 89        self._key_color = (0.69, 0.6, 0.74)
 90        self._key_color_dark = (0.55, 0.55, 0.71)
 91
 92        self._shift_button: ba.Widget | None = None
 93        self._backspace_button: ba.Widget | None = None
 94        self._space_button: ba.Widget | None = None
 95        self._double_press_shift = False
 96        self._num_mode_button: ba.Widget | None = None
 97        self._emoji_button: ba.Widget | None = None
 98        self._char_keys: list[ba.Widget] = []
 99        self._keyboard_index = 0
100        self._last_space_press = 0.0
101        self._double_space_interval = 0.3
102
103        self._keyboard: ba.Keyboard
104        self._chars: list[str]
105        self._modes: list[str]
106        self._mode: str
107        self._mode_index: int
108        self._load_keyboard()
109
110    def _load_keyboard(self) -> None:
111        # pylint: disable=too-many-locals
112        self._keyboard = self._get_keyboard()
113        # We want to get just chars without column data, etc.
114        self._chars = [j for i in self._keyboard.chars for j in i]
115        self._modes = ['normal'] + list(self._keyboard.pages)
116        self._mode_index = 0
117        self._mode = self._modes[self._mode_index]
118
119        v = self._height - 180.0
120        key_width = 46 * 10 / len(self._keyboard.chars[0])
121        key_height = 46 * 3 / len(self._keyboard.chars)
122        key_textcolor = (1, 1, 1)
123        row_starts = (69.0, 95.0, 151.0)
124        key_color = self._key_color
125        key_color_dark = self._key_color_dark
126
127        self._click_sound = ba.getsound('click01')
128
129        # kill prev char keys
130        for key in self._char_keys:
131            key.delete()
132        self._char_keys = []
133
134        # dummy data just used for row/column lengths... we don't actually
135        # set things until refresh
136        chars: list[tuple[str, ...]] = self._keyboard.chars
137
138        for row_num, row in enumerate(chars):
139            h = row_starts[row_num]
140            # shift key before row 3
141            if row_num == 2 and self._shift_button is None:
142                self._shift_button = ba.buttonwidget(
143                    parent=self._root_widget,
144                    position=(h - key_width * 2.0, v),
145                    size=(key_width * 1.7, key_height),
146                    autoselect=True,
147                    textcolor=key_textcolor,
148                    color=key_color_dark,
149                    label=ba.charstr(ba.SpecialChar.SHIFT),
150                    enable_sound=False,
151                    extra_touch_border_scale=0.3,
152                    button_type='square',
153                )
154
155            for _ in row:
156                btn = ba.buttonwidget(
157                    parent=self._root_widget,
158                    position=(h, v),
159                    size=(key_width, key_height),
160                    autoselect=True,
161                    enable_sound=False,
162                    textcolor=key_textcolor,
163                    color=key_color,
164                    label='',
165                    button_type='square',
166                    extra_touch_border_scale=0.1,
167                )
168                self._char_keys.append(btn)
169                h += key_width + 10
170
171            # Add delete key at end of third row.
172            if row_num == 2:
173                if self._backspace_button is not None:
174                    self._backspace_button.delete()
175
176                self._backspace_button = ba.buttonwidget(
177                    parent=self._root_widget,
178                    position=(h + 4, v),
179                    size=(key_width * 1.8, key_height),
180                    autoselect=True,
181                    enable_sound=False,
182                    repeat=True,
183                    textcolor=key_textcolor,
184                    color=key_color_dark,
185                    label=ba.charstr(ba.SpecialChar.DELETE),
186                    button_type='square',
187                    on_activate_call=self._del,
188                )
189            v -= key_height + 9
190            # Do space bar and stuff.
191            if row_num == 2:
192                if self._num_mode_button is None:
193                    self._num_mode_button = ba.buttonwidget(
194                        parent=self._root_widget,
195                        position=(112, v - 8),
196                        size=(key_width * 2, key_height + 5),
197                        enable_sound=False,
198                        button_type='square',
199                        extra_touch_border_scale=0.3,
200                        autoselect=True,
201                        textcolor=key_textcolor,
202                        color=key_color_dark,
203                        label='',
204                    )
205                if self._emoji_button is None:
206                    self._emoji_button = ba.buttonwidget(
207                        parent=self._root_widget,
208                        position=(56, v - 8),
209                        size=(key_width, key_height + 5),
210                        autoselect=True,
211                        enable_sound=False,
212                        textcolor=key_textcolor,
213                        color=key_color_dark,
214                        label=ba.charstr(ba.SpecialChar.LOGO_FLAT),
215                        extra_touch_border_scale=0.3,
216                        button_type='square',
217                    )
218                btn1 = self._num_mode_button
219                if self._space_button is None:
220                    self._space_button = ba.buttonwidget(
221                        parent=self._root_widget,
222                        position=(210, v - 12),
223                        size=(key_width * 6.1, key_height + 15),
224                        extra_touch_border_scale=0.3,
225                        enable_sound=False,
226                        autoselect=True,
227                        textcolor=key_textcolor,
228                        color=key_color_dark,
229                        label=ba.Lstr(resource='spaceKeyText'),
230                        on_activate_call=ba.Call(self._type_char, ' '),
231                    )
232
233                    # Show change instructions only if we have more than one
234                    # keyboard option.
235                    keyboards = (
236                        ba.app.meta.scanresults.exports_of_class(ba.Keyboard)
237                        if ba.app.meta.scanresults is not None
238                        else []
239                    )
240                    if len(keyboards) > 1:
241                        ba.textwidget(
242                            parent=self._root_widget,
243                            h_align='center',
244                            position=(210, v - 70),
245                            size=(key_width * 6.1, key_height + 15),
246                            text=ba.Lstr(
247                                resource='keyboardChangeInstructionsText'
248                            ),
249                            scale=0.75,
250                        )
251                btn2 = self._space_button
252                btn3 = self._emoji_button
253                ba.widget(edit=btn1, right_widget=btn2, left_widget=btn3)
254                ba.widget(
255                    edit=btn2, left_widget=btn1, right_widget=self._done_button
256                )
257                ba.widget(edit=btn3, left_widget=btn1)
258                ba.widget(edit=self._done_button, left_widget=btn2)
259
260        ba.containerwidget(
261            edit=self._root_widget, selected_child=self._char_keys[14]
262        )
263
264        self._refresh()
265
266    def _get_keyboard(self) -> ba.Keyboard:
267        assert ba.app.meta.scanresults is not None
268        classname = ba.app.meta.scanresults.exports_of_class(ba.Keyboard)[
269            self._keyboard_index
270        ]
271        kbclass = ba.getclass(classname, ba.Keyboard)
272        return kbclass()
273
274    def _refresh(self) -> None:
275        chars: list[str] | None = None
276        if self._mode in ['normal', 'caps']:
277            chars = list(self._chars)
278            if self._mode == 'caps':
279                chars = [c.upper() for c in chars]
280            ba.buttonwidget(
281                edit=self._shift_button,
282                color=self._key_color_lit
283                if self._mode == 'caps'
284                else self._key_color_dark,
285                label=ba.charstr(ba.SpecialChar.SHIFT),
286                on_activate_call=self._shift,
287            )
288            ba.buttonwidget(
289                edit=self._num_mode_button,
290                label='123#&*',
291                on_activate_call=self._num_mode,
292            )
293            ba.buttonwidget(
294                edit=self._emoji_button,
295                color=self._key_color_dark,
296                label=ba.charstr(ba.SpecialChar.LOGO_FLAT),
297                on_activate_call=self._next_mode,
298            )
299        else:
300            if self._mode == 'num':
301                chars = list(self._keyboard.nums)
302            else:
303                chars = list(self._keyboard.pages[self._mode])
304            ba.buttonwidget(
305                edit=self._shift_button,
306                color=self._key_color_dark,
307                label='',
308                on_activate_call=self._null_press,
309            )
310            ba.buttonwidget(
311                edit=self._num_mode_button,
312                label='abc',
313                on_activate_call=self._abc_mode,
314            )
315            ba.buttonwidget(
316                edit=self._emoji_button,
317                color=self._key_color_dark,
318                label=ba.charstr(ba.SpecialChar.LOGO_FLAT),
319                on_activate_call=self._next_mode,
320            )
321
322        for i, btn in enumerate(self._char_keys):
323            assert chars is not None
324            have_char = True
325            if i >= len(chars):
326                # No such char.
327                have_char = False
328                pagename = self._mode
329                ba.print_error(
330                    f'Size of page "{pagename}" of keyboard'
331                    f' "{self._keyboard.name}" is incorrect:'
332                    f' {len(chars)} != {len(self._chars)}'
333                    f' (size of default "normal" page)',
334                    once=True,
335                )
336            ba.buttonwidget(
337                edit=btn,
338                label=chars[i] if have_char else ' ',
339                on_activate_call=ba.Call(
340                    self._type_char, chars[i] if have_char else ' '
341                ),
342            )
343
344    def _null_press(self) -> None:
345        ba.playsound(self._click_sound)
346
347    def _abc_mode(self) -> None:
348        ba.playsound(self._click_sound)
349        self._mode = 'normal'
350        self._refresh()
351
352    def _num_mode(self) -> None:
353        ba.playsound(self._click_sound)
354        self._mode = 'num'
355        self._refresh()
356
357    def _next_mode(self) -> None:
358        ba.playsound(self._click_sound)
359        self._mode_index = (self._mode_index + 1) % len(self._modes)
360        self._mode = self._modes[self._mode_index]
361        self._refresh()
362
363    def _next_keyboard(self) -> None:
364        assert ba.app.meta.scanresults is not None
365        kbexports = ba.app.meta.scanresults.exports_of_class(ba.Keyboard)
366        self._keyboard_index = (self._keyboard_index + 1) % len(kbexports)
367
368        self._load_keyboard()
369        if len(kbexports) < 2:
370            ba.playsound(ba.getsound('error'))
371            ba.screenmessage(
372                ba.Lstr(resource='keyboardNoOthersAvailableText'),
373                color=(1, 0, 0),
374            )
375        else:
376            ba.screenmessage(
377                ba.Lstr(
378                    resource='keyboardSwitchText',
379                    subs=[('${NAME}', self._keyboard.name)],
380                ),
381                color=(0, 1, 0),
382            )
383
384    def _shift(self) -> None:
385        ba.playsound(self._click_sound)
386        if self._mode == 'normal':
387            self._mode = 'caps'
388            self._double_press_shift = False
389        elif self._mode == 'caps':
390            if not self._double_press_shift:
391                self._double_press_shift = True
392            else:
393                self._mode = 'normal'
394        self._refresh()
395
396    def _del(self) -> None:
397        ba.playsound(self._click_sound)
398        txt = cast(str, ba.textwidget(query=self._text_field))
399        # pylint: disable=unsubscriptable-object
400        txt = txt[:-1]
401        ba.textwidget(edit=self._text_field, text=txt)
402
403    def _type_char(self, char: str) -> None:
404        ba.playsound(self._click_sound)
405        if char.isspace():
406            if (
407                ba.time(ba.TimeType.REAL) - self._last_space_press
408                < self._double_space_interval
409            ):
410                self._last_space_press = 0
411                self._next_keyboard()
412                self._del()  # We typed unneeded space around 1s ago.
413                return
414            self._last_space_press = ba.time(ba.TimeType.REAL)
415
416        # Operate in unicode so we don't do anything funky like chop utf-8
417        # chars in half.
418        txt = cast(str, ba.textwidget(query=self._text_field))
419        txt += char
420        ba.textwidget(edit=self._text_field, text=txt)
421
422        # If we were caps, go back only if not Shift is pressed twice.
423        if self._mode == 'caps' and not self._double_press_shift:
424            self._mode = 'normal'
425        self._refresh()
426
427    def _cancel(self) -> None:
428        ba.playsound(ba.getsound('swish'))
429        ba.containerwidget(edit=self._root_widget, transition='out_scale')
430
431    def _done(self) -> None:
432        ba.containerwidget(edit=self._root_widget, transition='out_scale')
433        if self._target_text:
434            ba.textwidget(
435                edit=self._target_text,
436                text=cast(str, ba.textwidget(query=self._text_field)),
437            )