bauiv1lib.soundtrack.edit

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Provides UI for editing a soundtrack."""
  4
  5from __future__ import annotations
  6
  7import copy
  8import os
  9from typing import TYPE_CHECKING, cast, override
 10
 11import bascenev1 as bs
 12import bauiv1 as bui
 13
 14if TYPE_CHECKING:
 15    from typing import Any
 16
 17
 18class SoundtrackEditWindow(bui.MainWindow):
 19    """Window for editing a soundtrack."""
 20
 21    def __init__(
 22        self,
 23        existing_soundtrack: str | dict[str, Any] | None,
 24        transition: str | None = 'in_right',
 25        origin_widget: bui.Widget | None = None,
 26    ):
 27        # pylint: disable=too-many-statements
 28
 29        appconfig = bui.app.config
 30        self._r = 'editSoundtrackWindow'
 31        self._folder_tex = bui.gettexture('folder')
 32        self._file_tex = bui.gettexture('file')
 33        assert bui.app.classic is not None
 34        uiscale = bui.app.ui_v1.uiscale
 35        self._width = 900 if uiscale is bui.UIScale.SMALL else 648
 36        x_inset = 100 if uiscale is bui.UIScale.SMALL else 0
 37        self._height = (
 38            450
 39            if uiscale is bui.UIScale.SMALL
 40            else 450 if uiscale is bui.UIScale.MEDIUM else 560
 41        )
 42        yoffs = -48 if uiscale is bui.UIScale.SMALL else 0
 43
 44        super().__init__(
 45            root_widget=bui.containerwidget(
 46                size=(self._width, self._height),
 47                scale=(
 48                    1.8
 49                    if uiscale is bui.UIScale.SMALL
 50                    else 1.5 if uiscale is bui.UIScale.MEDIUM else 1.0
 51                ),
 52                stack_offset=(
 53                    (0, 0)
 54                    if uiscale is bui.UIScale.SMALL
 55                    else (0, 15) if uiscale is bui.UIScale.MEDIUM else (0, 0)
 56                ),
 57            ),
 58            transition=transition,
 59            origin_widget=origin_widget,
 60        )
 61        cancel_button = bui.buttonwidget(
 62            parent=self._root_widget,
 63            position=(38 + x_inset, self._height - 60 + yoffs),
 64            size=(160, 60),
 65            autoselect=True,
 66            label=bui.Lstr(resource='cancelText'),
 67            scale=0.8,
 68        )
 69        save_button = bui.buttonwidget(
 70            parent=self._root_widget,
 71            position=(self._width - (168 + x_inset), self._height - 60 + yoffs),
 72            autoselect=True,
 73            size=(160, 60),
 74            label=bui.Lstr(resource='saveText'),
 75            scale=0.8,
 76        )
 77        bui.widget(edit=save_button, left_widget=cancel_button)
 78        bui.widget(edit=cancel_button, right_widget=save_button)
 79        bui.textwidget(
 80            parent=self._root_widget,
 81            position=(0, self._height - 50 + yoffs),
 82            size=(self._width, 25),
 83            text=bui.Lstr(
 84                resource=self._r
 85                + (
 86                    '.editSoundtrackText'
 87                    if existing_soundtrack is not None
 88                    else '.newSoundtrackText'
 89                )
 90            ),
 91            color=bui.app.ui_v1.title_color,
 92            h_align='center',
 93            v_align='center',
 94            maxwidth=280,
 95        )
 96        v = self._height - 110 + yoffs
 97        if 'Soundtracks' not in appconfig:
 98            appconfig['Soundtracks'] = {}
 99
100        self._soundtrack_name: str | None
101        self._existing_soundtrack = existing_soundtrack
102        self._existing_soundtrack_name: str | None
103        if existing_soundtrack is not None:
104            # if they passed just a name, pull info from that soundtrack
105            if isinstance(existing_soundtrack, str):
106                self._soundtrack = copy.deepcopy(
107                    appconfig['Soundtracks'][existing_soundtrack]
108                )
109                self._soundtrack_name = existing_soundtrack
110                self._existing_soundtrack_name = existing_soundtrack
111                self._last_edited_song_type = None
112            else:
113                # Otherwise they can pass info on an in-progress edit.
114                self._soundtrack = existing_soundtrack['soundtrack']
115                self._soundtrack_name = existing_soundtrack['name']
116                self._existing_soundtrack_name = existing_soundtrack[
117                    'existing_name'
118                ]
119                self._last_edited_song_type = existing_soundtrack[
120                    'last_edited_song_type'
121                ]
122        else:
123            self._soundtrack_name = None
124            self._existing_soundtrack_name = None
125            self._soundtrack = {}
126            self._last_edited_song_type = None
127
128        bui.textwidget(
129            parent=self._root_widget,
130            text=bui.Lstr(resource=f'{self._r}.nameText'),
131            maxwidth=80,
132            scale=0.8,
133            position=(105 + x_inset, v + 19),
134            color=(0.8, 0.8, 0.8, 0.5),
135            size=(0, 0),
136            h_align='right',
137            v_align='center',
138        )
139
140        # if there's no initial value, find a good initial unused name
141        if existing_soundtrack is None:
142            i = 1
143            st_name_text = bui.Lstr(
144                resource=f'{self._r}.newSoundtrackNameText'
145            ).evaluate()
146            if '${COUNT}' not in st_name_text:
147                # make sure we insert number *somewhere*
148                st_name_text = st_name_text + ' ${COUNT}'
149            while True:
150                self._soundtrack_name = st_name_text.replace('${COUNT}', str(i))
151                if self._soundtrack_name not in appconfig['Soundtracks']:
152                    break
153                i += 1
154
155        self._text_field = bui.textwidget(
156            parent=self._root_widget,
157            position=(120 + x_inset, v - 5),
158            size=(self._width - (160 + 2 * x_inset), 43),
159            text=self._soundtrack_name,
160            h_align='left',
161            v_align='center',
162            max_chars=32,
163            autoselect=True,
164            description=bui.Lstr(resource=f'{self._r}.nameText'),
165            editable=True,
166            padding=4,
167            on_return_press_call=self._do_it_with_sound,
168        )
169
170        scroll_height = self._height - (
171            230 if uiscale is bui.UIScale.SMALL else 180
172        )
173        self._scrollwidget = scrollwidget = bui.scrollwidget(
174            parent=self._root_widget,
175            highlight=False,
176            position=(40 + x_inset, v - (scroll_height + 10)),
177            size=(self._width - (80 + 2 * x_inset), scroll_height),
178            simple_culling_v=10,
179            claims_left_right=True,
180            claims_tab=True,
181            selection_loops_to_parent=True,
182        )
183        bui.widget(edit=self._text_field, down_widget=self._scrollwidget)
184        self._col = bui.columnwidget(
185            parent=scrollwidget,
186            claims_left_right=True,
187            claims_tab=True,
188            selection_loops_to_parent=True,
189        )
190
191        self._song_type_buttons: dict[str, bui.Widget] = {}
192        self._refresh()
193        bui.buttonwidget(edit=cancel_button, on_activate_call=self._cancel)
194        bui.containerwidget(edit=self._root_widget, cancel_button=cancel_button)
195        bui.buttonwidget(edit=save_button, on_activate_call=self._do_it)
196        bui.containerwidget(edit=self._root_widget, start_button=save_button)
197        bui.widget(edit=self._text_field, up_widget=cancel_button)
198        bui.widget(edit=cancel_button, down_widget=self._text_field)
199
200    @override
201    def get_main_window_state(self) -> bui.MainWindowState:
202        # Support recreating our window for back/refresh purposes.
203        cls = type(self)
204
205        # Pull this out of self here; if we do it in the lambda we'll
206        # keep our window alive due to the 'self' reference.
207        existing_soundtrack = {
208            'name': self._soundtrack_name,
209            'existing_name': self._existing_soundtrack_name,
210            'soundtrack': self._soundtrack,
211            'last_edited_song_type': self._last_edited_song_type,
212        }
213
214        return bui.BasicMainWindowState(
215            create_call=lambda transition, origin_widget: cls(
216                transition=transition,
217                origin_widget=origin_widget,
218                existing_soundtrack=existing_soundtrack,
219            )
220        )
221
222    def _refresh(self) -> None:
223        for widget in self._col.get_children():
224            widget.delete()
225
226        types = [
227            'Menu',
228            'CharSelect',
229            'ToTheDeath',
230            'Onslaught',
231            'Keep Away',
232            'Race',
233            'Epic Race',
234            'ForwardMarch',
235            'FlagCatcher',
236            'Survival',
237            'Epic',
238            'Hockey',
239            'Football',
240            'Flying',
241            'Scary',
242            'Marching',
243            'GrandRomp',
244            'Chosen One',
245            'Scores',
246            'Victory',
247        ]
248
249        # FIXME: We should probably convert this to use translations.
250        type_names_translated = bui.app.lang.get_resource('soundtrackTypeNames')
251        prev_type_button: bui.Widget | None = None
252        prev_test_button: bui.Widget | None = None
253
254        for index, song_type in enumerate(types):
255            row = bui.rowwidget(
256                parent=self._col,
257                size=(self._width - 40, 40),
258                claims_left_right=True,
259                claims_tab=True,
260                selection_loops_to_parent=True,
261            )
262            type_name = type_names_translated.get(song_type, song_type)
263            bui.textwidget(
264                parent=row,
265                size=(230, 25),
266                always_highlight=True,
267                text=type_name,
268                scale=0.7,
269                h_align='left',
270                v_align='center',
271                maxwidth=190,
272            )
273
274            if song_type in self._soundtrack:
275                entry = self._soundtrack[song_type]
276            else:
277                entry = None
278
279            if entry is not None:
280                # Make sure they don't muck with this after it gets to us.
281                entry = copy.deepcopy(entry)
282
283            icon_type = self._get_entry_button_display_icon_type(entry)
284            self._song_type_buttons[song_type] = btn = bui.buttonwidget(
285                parent=row,
286                size=(230, 32),
287                label=self._get_entry_button_display_name(entry),
288                text_scale=0.6,
289                on_activate_call=bui.Call(
290                    self._get_entry, song_type, entry, type_name
291                ),
292                icon=(
293                    self._file_tex
294                    if icon_type == 'file'
295                    else self._folder_tex if icon_type == 'folder' else None
296                ),
297                icon_color=(
298                    (1.1, 0.8, 0.2) if icon_type == 'folder' else (1, 1, 1)
299                ),
300                left_widget=self._text_field,
301                iconscale=0.7,
302                autoselect=True,
303                up_widget=prev_type_button,
304            )
305            if index == 0:
306                bui.widget(edit=btn, up_widget=self._text_field)
307            bui.widget(edit=btn, down_widget=btn)
308
309            if (
310                self._last_edited_song_type is not None
311                and song_type == self._last_edited_song_type
312            ):
313                bui.containerwidget(
314                    edit=row, selected_child=btn, visible_child=btn
315                )
316                bui.containerwidget(
317                    edit=self._col, selected_child=row, visible_child=row
318                )
319                bui.containerwidget(
320                    edit=self._scrollwidget,
321                    selected_child=self._col,
322                    visible_child=self._col,
323                )
324                bui.containerwidget(
325                    edit=self._root_widget,
326                    selected_child=self._scrollwidget,
327                    visible_child=self._scrollwidget,
328                )
329
330            if prev_type_button is not None:
331                bui.widget(edit=prev_type_button, down_widget=btn)
332            prev_type_button = btn
333            bui.textwidget(parent=row, size=(10, 32), text='')  # spacing
334            assert bui.app.classic is not None
335            btn = bui.buttonwidget(
336                parent=row,
337                size=(50, 32),
338                label=bui.Lstr(resource=f'{self._r}.testText'),
339                text_scale=0.6,
340                on_activate_call=bui.Call(self._test, bs.MusicType(song_type)),
341                up_widget=(
342                    prev_test_button
343                    if prev_test_button is not None
344                    else self._text_field
345                ),
346            )
347            if prev_test_button is not None:
348                bui.widget(edit=prev_test_button, down_widget=btn)
349            bui.widget(edit=btn, down_widget=btn, right_widget=btn)
350            prev_test_button = btn
351
352    @classmethod
353    def _restore_editor(
354        cls, state: dict[str, Any], musictype: str, entry: Any
355    ) -> None:
356        assert bui.app.classic is not None
357        music = bui.app.classic.music
358
359        # Apply the change and recreate the window.
360        soundtrack = state['soundtrack']
361        existing_entry = (
362            None if musictype not in soundtrack else soundtrack[musictype]
363        )
364        if existing_entry != entry:
365            bui.getsound('gunCocking').play()
366
367        # Make sure this doesn't get mucked with after we get it.
368        if entry is not None:
369            entry = copy.deepcopy(entry)
370
371        entry_type = music.get_soundtrack_entry_type(entry)
372        if entry_type == 'default':
373            # For 'default' entries simply exclude them from the list.
374            if musictype in soundtrack:
375                del soundtrack[musictype]
376        else:
377            soundtrack[musictype] = entry
378
379        mainwindow = bui.app.ui_v1.get_main_window()
380        assert mainwindow is not None
381
382        mainwindow.main_window_back_state = state['back_state']
383        mainwindow.main_window_back()
384
385    def _get_entry(
386        self, song_type: str, entry: Any, selection_target_name: str
387    ) -> None:
388        assert bui.app.classic is not None
389        music = bui.app.classic.music
390
391        # no-op if we're not in control.
392        if not self.main_window_has_control():
393            return
394
395        if selection_target_name != '':
396            selection_target_name = "'" + selection_target_name + "'"
397        state = {
398            'name': self._soundtrack_name,
399            'existing_name': self._existing_soundtrack_name,
400            'soundtrack': self._soundtrack,
401            'last_edited_song_type': song_type,
402        }
403        new_win = music.get_music_player().select_entry(
404            bui.Call(self._restore_editor, state, song_type),
405            entry,
406            selection_target_name,
407        )
408        self.main_window_replace(new_win)
409
410        # Once we've set the new window, grab the back-state; we'll use
411        # that to jump back here after selection completes.
412        assert new_win.main_window_back_state is not None
413        state['back_state'] = new_win.main_window_back_state
414
415    def _test(self, song_type: bs.MusicType) -> None:
416        assert bui.app.classic is not None
417        music = bui.app.classic.music
418
419        # Warn if volume is zero.
420        if bui.app.config.resolve('Music Volume') < 0.01:
421            bui.getsound('error').play()
422            bui.screenmessage(
423                bui.Lstr(resource=f'{self._r}.musicVolumeZeroWarning'),
424                color=(1, 0.5, 0),
425            )
426        music.set_music_play_mode(bui.app.classic.MusicPlayMode.TEST)
427        music.do_play_music(
428            song_type,
429            mode=bui.app.classic.MusicPlayMode.TEST,
430            testsoundtrack=self._soundtrack,
431        )
432
433    def _get_entry_button_display_name(self, entry: Any) -> str | bui.Lstr:
434        assert bui.app.classic is not None
435        music = bui.app.classic.music
436        etype = music.get_soundtrack_entry_type(entry)
437        ename: str | bui.Lstr
438        if etype == 'default':
439            ename = bui.Lstr(resource=f'{self._r}.defaultGameMusicText')
440        elif etype in ('musicFile', 'musicFolder'):
441            ename = os.path.basename(music.get_soundtrack_entry_name(entry))
442        else:
443            ename = music.get_soundtrack_entry_name(entry)
444        return ename
445
446    def _get_entry_button_display_icon_type(self, entry: Any) -> str | None:
447        assert bui.app.classic is not None
448        music = bui.app.classic.music
449        etype = music.get_soundtrack_entry_type(entry)
450        if etype == 'musicFile':
451            return 'file'
452        if etype == 'musicFolder':
453            return 'folder'
454        return None
455
456    def _cancel(self) -> None:
457        # from bauiv1lib.soundtrack.browser import SoundtrackBrowserWindow
458
459        # no-op if our underlying widget is dead or on its way out.
460        if not self._root_widget or self._root_widget.transitioning_out:
461            return
462
463        assert bui.app.classic is not None
464        music = bui.app.classic.music
465
466        # Resets music back to normal.
467        music.set_music_play_mode(bui.app.classic.MusicPlayMode.REGULAR)
468
469        self.main_window_back()
470
471    def _do_it(self) -> None:
472
473        # no-op if our underlying widget is dead or on its way out.
474        if not self._root_widget or self._root_widget.transitioning_out:
475            return
476
477        assert bui.app.classic is not None
478        music = bui.app.classic.music
479        cfg = bui.app.config
480        new_name = cast(str, bui.textwidget(query=self._text_field))
481        if new_name != self._soundtrack_name and new_name in cfg['Soundtracks']:
482            bui.screenmessage(
483                bui.Lstr(resource=f'{self._r}.cantSaveAlreadyExistsText')
484            )
485            bui.getsound('error').play()
486            return
487        if not new_name:
488            bui.getsound('error').play()
489            return
490        if (
491            new_name
492            == bui.Lstr(
493                resource=f'{self._r}.defaultSoundtrackNameText'
494            ).evaluate()
495        ):
496            bui.screenmessage(
497                bui.Lstr(resource=f'{self._r}.cantOverwriteDefaultText')
498            )
499            bui.getsound('error').play()
500            return
501
502        # Make sure config exists.
503        if 'Soundtracks' not in cfg:
504            cfg['Soundtracks'] = {}
505
506        # If we had an old one, delete it.
507        if (
508            self._existing_soundtrack_name is not None
509            and self._existing_soundtrack_name in cfg['Soundtracks']
510        ):
511            del cfg['Soundtracks'][self._existing_soundtrack_name]
512        cfg['Soundtracks'][new_name] = self._soundtrack
513        cfg['Soundtrack'] = new_name
514
515        cfg.commit()
516        bui.getsound('gunCocking').play()
517
518        # Resets music back to normal.
519        music.set_music_play_mode(
520            bui.app.classic.MusicPlayMode.REGULAR, force_restart=True
521        )
522
523        self.main_window_back()
524
525    def _do_it_with_sound(self) -> None:
526        bui.getsound('swish').play()
527        self._do_it()