bauiv1lib.soundtrack.browser

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Provides UI for browsing soundtracks."""
  4
  5from __future__ import annotations
  6
  7import copy
  8import logging
  9from typing import TYPE_CHECKING
 10
 11import bauiv1 as bui
 12
 13if TYPE_CHECKING:
 14    from typing import Any
 15
 16
 17class SoundtrackBrowserWindow(bui.Window):
 18    """Window for browsing soundtracks."""
 19
 20    def __init__(
 21        self,
 22        transition: str = 'in_right',
 23        origin_widget: bui.Widget | None = None,
 24    ):
 25        # pylint: disable=too-many-locals
 26        # pylint: disable=too-many-statements
 27
 28        # If they provided an origin-widget, scale up from that.
 29        scale_origin: tuple[float, float] | None
 30        if origin_widget is not None:
 31            self._transition_out = 'out_scale'
 32            scale_origin = origin_widget.get_screen_space_center()
 33            transition = 'in_scale'
 34        else:
 35            self._transition_out = 'out_right'
 36            scale_origin = None
 37
 38        self._r = 'editSoundtrackWindow'
 39        assert bui.app.classic is not None
 40        uiscale = bui.app.ui_v1.uiscale
 41        self._width = 800 if uiscale is bui.UIScale.SMALL else 600
 42        x_inset = 100 if uiscale is bui.UIScale.SMALL else 0
 43        self._height = (
 44            340
 45            if uiscale is bui.UIScale.SMALL
 46            else 370 if uiscale is bui.UIScale.MEDIUM else 440
 47        )
 48        spacing = 40.0
 49        v = self._height - 40.0
 50        v -= spacing * 1.0
 51
 52        super().__init__(
 53            root_widget=bui.containerwidget(
 54                size=(self._width, self._height),
 55                transition=transition,
 56                toolbar_visibility='menu_minimal',
 57                scale_origin_stack_offset=scale_origin,
 58                scale=(
 59                    2.3
 60                    if uiscale is bui.UIScale.SMALL
 61                    else 1.6 if uiscale is bui.UIScale.MEDIUM else 1.0
 62                ),
 63                stack_offset=(
 64                    (0, -18) if uiscale is bui.UIScale.SMALL else (0, 0)
 65                ),
 66            )
 67        )
 68
 69        assert bui.app.classic is not None
 70        if bui.app.ui_v1.use_toolbars and uiscale is bui.UIScale.SMALL:
 71            self._back_button = None
 72        else:
 73            self._back_button = bui.buttonwidget(
 74                parent=self._root_widget,
 75                position=(45 + x_inset, self._height - 60),
 76                size=(120, 60),
 77                scale=0.8,
 78                label=bui.Lstr(resource='backText'),
 79                button_type='back',
 80                autoselect=True,
 81            )
 82            bui.buttonwidget(
 83                edit=self._back_button,
 84                button_type='backSmall',
 85                size=(60, 60),
 86                label=bui.charstr(bui.SpecialChar.BACK),
 87            )
 88        bui.textwidget(
 89            parent=self._root_widget,
 90            position=(self._width * 0.5, self._height - 35),
 91            size=(0, 0),
 92            maxwidth=300,
 93            text=bui.Lstr(resource=self._r + '.titleText'),
 94            color=bui.app.ui_v1.title_color,
 95            h_align='center',
 96            v_align='center',
 97        )
 98
 99        h = 43 + x_inset
100        v = self._height - 60
101        b_color = (0.6, 0.53, 0.63)
102        b_textcolor = (0.75, 0.7, 0.8)
103        lock_tex = bui.gettexture('lock')
104        self._lock_images: list[bui.Widget] = []
105
106        scl = (
107            1.0
108            if uiscale is bui.UIScale.SMALL
109            else 1.13 if uiscale is bui.UIScale.MEDIUM else 1.4
110        )
111        v -= 60.0 * scl
112        self._new_button = btn = bui.buttonwidget(
113            parent=self._root_widget,
114            position=(h, v),
115            size=(100, 55.0 * scl),
116            on_activate_call=self._new_soundtrack,
117            color=b_color,
118            button_type='square',
119            autoselect=True,
120            textcolor=b_textcolor,
121            text_scale=0.7,
122            label=bui.Lstr(resource=self._r + '.newText'),
123        )
124        self._lock_images.append(
125            bui.imagewidget(
126                parent=self._root_widget,
127                size=(30, 30),
128                draw_controller=btn,
129                position=(h - 10, v + 55.0 * scl - 28),
130                texture=lock_tex,
131            )
132        )
133
134        if self._back_button is None:
135            bui.widget(
136                edit=btn,
137                left_widget=bui.get_special_widget('back_button'),
138            )
139        v -= 60.0 * scl
140
141        self._edit_button = btn = bui.buttonwidget(
142            parent=self._root_widget,
143            position=(h, v),
144            size=(100, 55.0 * scl),
145            on_activate_call=self._edit_soundtrack,
146            color=b_color,
147            button_type='square',
148            autoselect=True,
149            textcolor=b_textcolor,
150            text_scale=0.7,
151            label=bui.Lstr(resource=self._r + '.editText'),
152        )
153        self._lock_images.append(
154            bui.imagewidget(
155                parent=self._root_widget,
156                size=(30, 30),
157                draw_controller=btn,
158                position=(h - 10, v + 55.0 * scl - 28),
159                texture=lock_tex,
160            )
161        )
162        if self._back_button is None:
163            bui.widget(
164                edit=btn,
165                left_widget=bui.get_special_widget('back_button'),
166            )
167        v -= 60.0 * scl
168
169        self._duplicate_button = btn = bui.buttonwidget(
170            parent=self._root_widget,
171            position=(h, v),
172            size=(100, 55.0 * scl),
173            on_activate_call=self._duplicate_soundtrack,
174            button_type='square',
175            autoselect=True,
176            color=b_color,
177            textcolor=b_textcolor,
178            text_scale=0.7,
179            label=bui.Lstr(resource=self._r + '.duplicateText'),
180        )
181        self._lock_images.append(
182            bui.imagewidget(
183                parent=self._root_widget,
184                size=(30, 30),
185                draw_controller=btn,
186                position=(h - 10, v + 55.0 * scl - 28),
187                texture=lock_tex,
188            )
189        )
190        if self._back_button is None:
191            bui.widget(
192                edit=btn,
193                left_widget=bui.get_special_widget('back_button'),
194            )
195        v -= 60.0 * scl
196
197        self._delete_button = btn = bui.buttonwidget(
198            parent=self._root_widget,
199            position=(h, v),
200            size=(100, 55.0 * scl),
201            on_activate_call=self._delete_soundtrack,
202            color=b_color,
203            button_type='square',
204            autoselect=True,
205            textcolor=b_textcolor,
206            text_scale=0.7,
207            label=bui.Lstr(resource=self._r + '.deleteText'),
208        )
209        self._lock_images.append(
210            bui.imagewidget(
211                parent=self._root_widget,
212                size=(30, 30),
213                draw_controller=btn,
214                position=(h - 10, v + 55.0 * scl - 28),
215                texture=lock_tex,
216            )
217        )
218        if self._back_button is None:
219            bui.widget(
220                edit=btn,
221                left_widget=bui.get_special_widget('back_button'),
222            )
223
224        # Keep our lock images up to date/etc.
225        self._update_timer = bui.AppTimer(
226            1.0, bui.WeakCall(self._update), repeat=True
227        )
228        self._update()
229
230        v = self._height - 65
231        scroll_height = self._height - 105
232        v -= scroll_height
233        self._scrollwidget = scrollwidget = bui.scrollwidget(
234            parent=self._root_widget,
235            position=(152 + x_inset, v),
236            highlight=False,
237            size=(self._width - (205 + 2 * x_inset), scroll_height),
238        )
239        bui.widget(
240            edit=self._scrollwidget,
241            left_widget=self._new_button,
242            right_widget=(
243                bui.get_special_widget('party_button')
244                if bui.app.ui_v1.use_toolbars
245                else self._scrollwidget
246            ),
247        )
248        self._col = bui.columnwidget(parent=scrollwidget, border=2, margin=0)
249
250        self._soundtracks: dict[str, Any] | None = None
251        self._selected_soundtrack: str | None = None
252        self._selected_soundtrack_index: int | None = None
253        self._soundtrack_widgets: list[bui.Widget] = []
254        self._allow_changing_soundtracks = False
255        self._refresh()
256        if self._back_button is not None:
257            bui.buttonwidget(
258                edit=self._back_button, on_activate_call=self._back
259            )
260            bui.containerwidget(
261                edit=self._root_widget, cancel_button=self._back_button
262            )
263        else:
264            bui.containerwidget(
265                edit=self._root_widget, on_cancel_call=self._back
266            )
267
268    def _update(self) -> None:
269        have = (
270            bui.app.classic is None
271            or bui.app.classic.accounts.have_pro_options()
272        )
273        for lock in self._lock_images:
274            bui.imagewidget(edit=lock, opacity=0.0 if have else 1.0)
275
276    def _do_delete_soundtrack(self) -> None:
277        cfg = bui.app.config
278        soundtracks = cfg.setdefault('Soundtracks', {})
279        if self._selected_soundtrack in soundtracks:
280            del soundtracks[self._selected_soundtrack]
281        cfg.commit()
282        bui.getsound('shieldDown').play()
283        assert self._selected_soundtrack_index is not None
284        assert self._soundtracks is not None
285        self._selected_soundtrack_index = min(
286            self._selected_soundtrack_index, len(self._soundtracks)
287        )
288        self._refresh()
289
290    def _delete_soundtrack(self) -> None:
291        # pylint: disable=cyclic-import
292        from bauiv1lib.purchase import PurchaseWindow
293        from bauiv1lib.confirm import ConfirmWindow
294
295        if (
296            bui.app.classic is not None
297            and not bui.app.classic.accounts.have_pro_options()
298        ):
299            PurchaseWindow(items=['pro'])
300            return
301        if self._selected_soundtrack is None:
302            return
303        if self._selected_soundtrack == '__default__':
304            bui.getsound('error').play()
305            bui.screenmessage(
306                bui.Lstr(resource=self._r + '.cantDeleteDefaultText'),
307                color=(1, 0, 0),
308            )
309        else:
310            ConfirmWindow(
311                bui.Lstr(
312                    resource=self._r + '.deleteConfirmText',
313                    subs=[('${NAME}', self._selected_soundtrack)],
314                ),
315                self._do_delete_soundtrack,
316                450,
317                150,
318            )
319
320    def _duplicate_soundtrack(self) -> None:
321        # pylint: disable=cyclic-import
322        from bauiv1lib.purchase import PurchaseWindow
323
324        if (
325            bui.app.classic is not None
326            and not bui.app.classic.accounts.have_pro_options()
327        ):
328            PurchaseWindow(items=['pro'])
329            return
330        cfg = bui.app.config
331        cfg.setdefault('Soundtracks', {})
332
333        if self._selected_soundtrack is None:
334            return
335        sdtk: dict[str, Any]
336        if self._selected_soundtrack == '__default__':
337            sdtk = {}
338        else:
339            sdtk = cfg['Soundtracks'][self._selected_soundtrack]
340
341        # Find a valid dup name that doesn't exist.
342        test_index = 1
343        copy_text = bui.Lstr(resource='copyOfText').evaluate()
344        # Get just 'Copy' or whatnot.
345        copy_word = copy_text.replace('${NAME}', '').strip()
346        base_name = self._get_soundtrack_display_name(
347            self._selected_soundtrack
348        ).evaluate()
349        assert isinstance(base_name, str)
350
351        # If it looks like a copy, strip digits and spaces off the end.
352        if copy_word in base_name:
353            while base_name[-1].isdigit() or base_name[-1] == ' ':
354                base_name = base_name[:-1]
355        while True:
356            if copy_word in base_name:
357                test_name = base_name
358            else:
359                test_name = copy_text.replace('${NAME}', base_name)
360            if test_index > 1:
361                test_name += ' ' + str(test_index)
362            if test_name not in cfg['Soundtracks']:
363                break
364            test_index += 1
365
366        cfg['Soundtracks'][test_name] = copy.deepcopy(sdtk)
367        cfg.commit()
368        self._refresh(select_soundtrack=test_name)
369
370    def _select(self, name: str, index: int) -> None:
371        assert bui.app.classic is not None
372        music = bui.app.classic.music
373        self._selected_soundtrack_index = index
374        self._selected_soundtrack = name
375        cfg = bui.app.config
376        current_soundtrack = cfg.setdefault('Soundtrack', '__default__')
377
378        # If it varies from current, commit and play.
379        if current_soundtrack != name and self._allow_changing_soundtracks:
380            bui.getsound('gunCocking').play()
381            cfg['Soundtrack'] = self._selected_soundtrack
382            cfg.commit()
383
384            # Just play whats already playing.. this'll grab it from the
385            # new soundtrack.
386            music.do_play_music(
387                music.music_types[bui.app.classic.MusicPlayMode.REGULAR]
388            )
389
390    def _back(self) -> None:
391        # pylint: disable=cyclic-import
392        from bauiv1lib.settings import audio
393
394        # no-op if our underlying widget is dead or on its way out.
395        if not self._root_widget or self._root_widget.transitioning_out:
396            return
397
398        self._save_state()
399        bui.containerwidget(
400            edit=self._root_widget, transition=self._transition_out
401        )
402        assert bui.app.classic is not None
403        bui.app.ui_v1.set_main_menu_window(
404            audio.AudioSettingsWindow(transition='in_left').get_root_widget(),
405            from_window=self._root_widget,
406        )
407
408    def _edit_soundtrack_with_sound(self) -> None:
409        # pylint: disable=cyclic-import
410        from bauiv1lib.purchase import PurchaseWindow
411
412        if (
413            bui.app.classic is not None
414            and not bui.app.classic.accounts.have_pro_options()
415        ):
416            PurchaseWindow(items=['pro'])
417            return
418        bui.getsound('swish').play()
419        self._edit_soundtrack()
420
421    def _edit_soundtrack(self) -> None:
422        # pylint: disable=cyclic-import
423        from bauiv1lib.purchase import PurchaseWindow
424        from bauiv1lib.soundtrack.edit import SoundtrackEditWindow
425
426        # no-op if our underlying widget is dead or on its way out.
427        if not self._root_widget or self._root_widget.transitioning_out:
428            return
429
430        if (
431            bui.app.classic is not None
432            and not bui.app.classic.accounts.have_pro_options()
433        ):
434            PurchaseWindow(items=['pro'])
435            return
436        if self._selected_soundtrack is None:
437            return
438        if self._selected_soundtrack == '__default__':
439            bui.getsound('error').play()
440            bui.screenmessage(
441                bui.Lstr(resource=self._r + '.cantEditDefaultText'),
442                color=(1, 0, 0),
443            )
444            return
445
446        self._save_state()
447        bui.containerwidget(edit=self._root_widget, transition='out_left')
448        assert bui.app.classic is not None
449        bui.app.ui_v1.set_main_menu_window(
450            SoundtrackEditWindow(
451                existing_soundtrack=self._selected_soundtrack
452            ).get_root_widget(),
453            from_window=self._root_widget,
454        )
455
456    def _get_soundtrack_display_name(self, soundtrack: str) -> bui.Lstr:
457        if soundtrack == '__default__':
458            return bui.Lstr(resource=self._r + '.defaultSoundtrackNameText')
459        return bui.Lstr(value=soundtrack)
460
461    def _refresh(self, select_soundtrack: str | None = None) -> None:
462        from efro.util import asserttype
463
464        self._allow_changing_soundtracks = False
465        old_selection = self._selected_soundtrack
466
467        # If there was no prev selection, look in prefs.
468        if old_selection is None:
469            old_selection = bui.app.config.get('Soundtrack')
470        old_selection_index = self._selected_soundtrack_index
471
472        # Delete old.
473        while self._soundtrack_widgets:
474            self._soundtrack_widgets.pop().delete()
475
476        self._soundtracks = bui.app.config.get('Soundtracks', {})
477        assert self._soundtracks is not None
478        items = list(self._soundtracks.items())
479        items.sort(key=lambda x: asserttype(x[0], str).lower())
480        items = [('__default__', None)] + items  # default is always first
481        index = 0
482        for pname, _pval in items:
483            assert pname is not None
484            txtw = bui.textwidget(
485                parent=self._col,
486                size=(self._width - 40, 24),
487                text=self._get_soundtrack_display_name(pname),
488                h_align='left',
489                v_align='center',
490                maxwidth=self._width - 110,
491                always_highlight=True,
492                on_select_call=bui.WeakCall(self._select, pname, index),
493                on_activate_call=self._edit_soundtrack_with_sound,
494                selectable=True,
495            )
496            if index == 0:
497                bui.widget(edit=txtw, up_widget=self._back_button)
498            self._soundtrack_widgets.append(txtw)
499
500            # Select this one if the user requested it
501            if select_soundtrack is not None:
502                if pname == select_soundtrack:
503                    bui.columnwidget(
504                        edit=self._col, selected_child=txtw, visible_child=txtw
505                    )
506            else:
507                # Select this one if it was previously selected.
508                # Go by index if there's one.
509                if old_selection_index is not None:
510                    if index == old_selection_index:
511                        bui.columnwidget(
512                            edit=self._col,
513                            selected_child=txtw,
514                            visible_child=txtw,
515                        )
516                else:  # Otherwise look by name.
517                    if pname == old_selection:
518                        bui.columnwidget(
519                            edit=self._col,
520                            selected_child=txtw,
521                            visible_child=txtw,
522                        )
523            index += 1
524
525        # Explicitly run select callback on current one and re-enable
526        # callbacks.
527
528        # Eww need to run this in a timer so it happens after our select
529        # callbacks. With a small-enough time sometimes it happens before
530        # anyway. Ew. need a way to just schedule a callable i guess.
531        bui.apptimer(0.1, bui.WeakCall(self._set_allow_changing))
532
533    def _set_allow_changing(self) -> None:
534        self._allow_changing_soundtracks = True
535        assert self._selected_soundtrack is not None
536        assert self._selected_soundtrack_index is not None
537        self._select(self._selected_soundtrack, self._selected_soundtrack_index)
538
539    def _new_soundtrack(self) -> None:
540        # pylint: disable=cyclic-import
541        from bauiv1lib.purchase import PurchaseWindow
542        from bauiv1lib.soundtrack.edit import SoundtrackEditWindow
543
544        if (
545            bui.app.classic is not None
546            and not bui.app.classic.accounts.have_pro_options()
547        ):
548            PurchaseWindow(items=['pro'])
549            return
550        self._save_state()
551        bui.containerwidget(edit=self._root_widget, transition='out_left')
552        SoundtrackEditWindow(existing_soundtrack=None)
553
554    def _create_done(self, new_soundtrack: str) -> None:
555        if new_soundtrack is not None:
556            bui.getsound('gunCocking').play()
557            self._refresh(select_soundtrack=new_soundtrack)
558
559    def _save_state(self) -> None:
560        try:
561            sel = self._root_widget.get_selected_child()
562            if sel == self._scrollwidget:
563                sel_name = 'Scroll'
564            elif sel == self._new_button:
565                sel_name = 'New'
566            elif sel == self._edit_button:
567                sel_name = 'Edit'
568            elif sel == self._duplicate_button:
569                sel_name = 'Duplicate'
570            elif sel == self._delete_button:
571                sel_name = 'Delete'
572            elif sel == self._back_button:
573                sel_name = 'Back'
574            else:
575                raise ValueError(f'unrecognized selection \'{sel}\'')
576            assert bui.app.classic is not None
577            bui.app.ui_v1.window_states[type(self)] = sel_name
578        except Exception:
579            logging.exception('Error saving state for %s.', self)
580
581    def _restore_state(self) -> None:
582        try:
583            assert bui.app.classic is not None
584            sel_name = bui.app.ui_v1.window_states.get(type(self))
585            if sel_name == 'Scroll':
586                sel = self._scrollwidget
587            elif sel_name == 'New':
588                sel = self._new_button
589            elif sel_name == 'Edit':
590                sel = self._edit_button
591            elif sel_name == 'Duplicate':
592                sel = self._duplicate_button
593            elif sel_name == 'Delete':
594                sel = self._delete_button
595            else:
596                sel = self._scrollwidget
597            bui.containerwidget(edit=self._root_widget, selected_child=sel)
598        except Exception:
599            logging.exception('Error restoring state for %s.', self)