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