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            selection_loops_to_parent=True,
181        )
182        bui.widget(edit=self._text_field, down_widget=self._scrollwidget)
183        self._col = bui.columnwidget(
184            parent=scrollwidget,
185            claims_left_right=True,
186            selection_loops_to_parent=True,
187        )
188
189        self._song_type_buttons: dict[str, bui.Widget] = {}
190        self._refresh()
191        bui.buttonwidget(edit=cancel_button, on_activate_call=self._cancel)
192        bui.containerwidget(edit=self._root_widget, cancel_button=cancel_button)
193        bui.buttonwidget(edit=save_button, on_activate_call=self._do_it)
194        bui.containerwidget(edit=self._root_widget, start_button=save_button)
195        bui.widget(edit=self._text_field, up_widget=cancel_button)
196        bui.widget(edit=cancel_button, down_widget=self._text_field)
197
198    @override
199    def get_main_window_state(self) -> bui.MainWindowState:
200        # Support recreating our window for back/refresh purposes.
201        cls = type(self)
202
203        # Pull this out of self here; if we do it in the lambda we'll
204        # keep our window alive due to the 'self' reference.
205        existing_soundtrack = {
206            'name': self._soundtrack_name,
207            'existing_name': self._existing_soundtrack_name,
208            'soundtrack': self._soundtrack,
209            'last_edited_song_type': self._last_edited_song_type,
210        }
211
212        return bui.BasicMainWindowState(
213            create_call=lambda transition, origin_widget: cls(
214                transition=transition,
215                origin_widget=origin_widget,
216                existing_soundtrack=existing_soundtrack,
217            )
218        )
219
220    def _refresh(self) -> None:
221        for widget in self._col.get_children():
222            widget.delete()
223
224        types = [
225            'Menu',
226            'CharSelect',
227            'ToTheDeath',
228            'Onslaught',
229            'Keep Away',
230            'Race',
231            'Epic Race',
232            'ForwardMarch',
233            'FlagCatcher',
234            'Survival',
235            'Epic',
236            'Hockey',
237            'Football',
238            'Flying',
239            'Scary',
240            'Marching',
241            'GrandRomp',
242            'Chosen One',
243            'Scores',
244            'Victory',
245        ]
246
247        # FIXME: We should probably convert this to use translations.
248        type_names_translated = bui.app.lang.get_resource('soundtrackTypeNames')
249        prev_type_button: bui.Widget | None = None
250        prev_test_button: bui.Widget | None = None
251
252        for index, song_type in enumerate(types):
253            row = bui.rowwidget(
254                parent=self._col,
255                size=(self._width - 40, 40),
256                claims_left_right=True,
257                selection_loops_to_parent=True,
258            )
259            type_name = type_names_translated.get(song_type, song_type)
260            bui.textwidget(
261                parent=row,
262                size=(230, 25),
263                always_highlight=True,
264                text=type_name,
265                scale=0.7,
266                h_align='left',
267                v_align='center',
268                maxwidth=190,
269            )
270
271            if song_type in self._soundtrack:
272                entry = self._soundtrack[song_type]
273            else:
274                entry = None
275
276            if entry is not None:
277                # Make sure they don't muck with this after it gets to us.
278                entry = copy.deepcopy(entry)
279
280            icon_type = self._get_entry_button_display_icon_type(entry)
281            self._song_type_buttons[song_type] = btn = bui.buttonwidget(
282                parent=row,
283                size=(230, 32),
284                label=self._get_entry_button_display_name(entry),
285                text_scale=0.6,
286                on_activate_call=bui.Call(
287                    self._get_entry, song_type, entry, type_name
288                ),
289                icon=(
290                    self._file_tex
291                    if icon_type == 'file'
292                    else self._folder_tex if icon_type == 'folder' else None
293                ),
294                icon_color=(
295                    (1.1, 0.8, 0.2) if icon_type == 'folder' else (1, 1, 1)
296                ),
297                left_widget=self._text_field,
298                iconscale=0.7,
299                autoselect=True,
300                up_widget=prev_type_button,
301            )
302            if index == 0:
303                bui.widget(edit=btn, up_widget=self._text_field)
304            bui.widget(edit=btn, down_widget=btn)
305
306            if (
307                self._last_edited_song_type is not None
308                and song_type == self._last_edited_song_type
309            ):
310                bui.containerwidget(
311                    edit=row, selected_child=btn, visible_child=btn
312                )
313                bui.containerwidget(
314                    edit=self._col, selected_child=row, visible_child=row
315                )
316                bui.containerwidget(
317                    edit=self._scrollwidget,
318                    selected_child=self._col,
319                    visible_child=self._col,
320                )
321                bui.containerwidget(
322                    edit=self._root_widget,
323                    selected_child=self._scrollwidget,
324                    visible_child=self._scrollwidget,
325                )
326
327            if prev_type_button is not None:
328                bui.widget(edit=prev_type_button, down_widget=btn)
329            prev_type_button = btn
330            bui.textwidget(parent=row, size=(10, 32), text='')  # spacing
331            assert bui.app.classic is not None
332            btn = bui.buttonwidget(
333                parent=row,
334                size=(50, 32),
335                label=bui.Lstr(resource=f'{self._r}.testText'),
336                text_scale=0.6,
337                on_activate_call=bui.Call(self._test, bs.MusicType(song_type)),
338                up_widget=(
339                    prev_test_button
340                    if prev_test_button is not None
341                    else self._text_field
342                ),
343            )
344            if prev_test_button is not None:
345                bui.widget(edit=prev_test_button, down_widget=btn)
346            bui.widget(edit=btn, down_widget=btn, right_widget=btn)
347            prev_test_button = btn
348
349    @classmethod
350    def _restore_editor(
351        cls, state: dict[str, Any], musictype: str, entry: Any
352    ) -> None:
353        assert bui.app.classic is not None
354        music = bui.app.classic.music
355
356        # Apply the change and recreate the window.
357        soundtrack = state['soundtrack']
358        existing_entry = (
359            None if musictype not in soundtrack else soundtrack[musictype]
360        )
361        if existing_entry != entry:
362            bui.getsound('gunCocking').play()
363
364        # Make sure this doesn't get mucked with after we get it.
365        if entry is not None:
366            entry = copy.deepcopy(entry)
367
368        entry_type = music.get_soundtrack_entry_type(entry)
369        if entry_type == 'default':
370            # For 'default' entries simply exclude them from the list.
371            if musictype in soundtrack:
372                del soundtrack[musictype]
373        else:
374            soundtrack[musictype] = entry
375
376        mainwindow = bui.app.ui_v1.get_main_window()
377        assert mainwindow is not None
378
379        mainwindow.main_window_back_state = state['back_state']
380        mainwindow.main_window_back()
381
382    def _get_entry(
383        self, song_type: str, entry: Any, selection_target_name: str
384    ) -> None:
385        assert bui.app.classic is not None
386        music = bui.app.classic.music
387
388        # no-op if we're not in control.
389        if not self.main_window_has_control():
390            return
391
392        if selection_target_name != '':
393            selection_target_name = "'" + selection_target_name + "'"
394        state = {
395            'name': self._soundtrack_name,
396            'existing_name': self._existing_soundtrack_name,
397            'soundtrack': self._soundtrack,
398            'last_edited_song_type': song_type,
399        }
400        new_win = music.get_music_player().select_entry(
401            bui.Call(self._restore_editor, state, song_type),
402            entry,
403            selection_target_name,
404        )
405        self.main_window_replace(new_win)
406
407        # Once we've set the new window, grab the back-state; we'll use
408        # that to jump back here after selection completes.
409        assert new_win.main_window_back_state is not None
410        state['back_state'] = new_win.main_window_back_state
411
412    def _test(self, song_type: bs.MusicType) -> None:
413        assert bui.app.classic is not None
414        music = bui.app.classic.music
415
416        # Warn if volume is zero.
417        if bui.app.config.resolve('Music Volume') < 0.01:
418            bui.getsound('error').play()
419            bui.screenmessage(
420                bui.Lstr(resource=f'{self._r}.musicVolumeZeroWarning'),
421                color=(1, 0.5, 0),
422            )
423        music.set_music_play_mode(bui.app.classic.MusicPlayMode.TEST)
424        music.do_play_music(
425            song_type,
426            mode=bui.app.classic.MusicPlayMode.TEST,
427            testsoundtrack=self._soundtrack,
428        )
429
430    def _get_entry_button_display_name(self, entry: Any) -> str | bui.Lstr:
431        assert bui.app.classic is not None
432        music = bui.app.classic.music
433        etype = music.get_soundtrack_entry_type(entry)
434        ename: str | bui.Lstr
435        if etype == 'default':
436            ename = bui.Lstr(resource=f'{self._r}.defaultGameMusicText')
437        elif etype in ('musicFile', 'musicFolder'):
438            ename = os.path.basename(music.get_soundtrack_entry_name(entry))
439        else:
440            ename = music.get_soundtrack_entry_name(entry)
441        return ename
442
443    def _get_entry_button_display_icon_type(self, entry: Any) -> str | None:
444        assert bui.app.classic is not None
445        music = bui.app.classic.music
446        etype = music.get_soundtrack_entry_type(entry)
447        if etype == 'musicFile':
448            return 'file'
449        if etype == 'musicFolder':
450            return 'folder'
451        return None
452
453    def _cancel(self) -> None:
454        # from bauiv1lib.soundtrack.browser import SoundtrackBrowserWindow
455
456        # no-op if our underlying widget is dead or on its way out.
457        if not self._root_widget or self._root_widget.transitioning_out:
458            return
459
460        assert bui.app.classic is not None
461        music = bui.app.classic.music
462
463        # Resets music back to normal.
464        music.set_music_play_mode(bui.app.classic.MusicPlayMode.REGULAR)
465
466        self.main_window_back()
467
468    def _do_it(self) -> None:
469
470        # no-op if our underlying widget is dead or on its way out.
471        if not self._root_widget or self._root_widget.transitioning_out:
472            return
473
474        assert bui.app.classic is not None
475        music = bui.app.classic.music
476        cfg = bui.app.config
477        new_name = cast(str, bui.textwidget(query=self._text_field))
478        if new_name != self._soundtrack_name and new_name in cfg['Soundtracks']:
479            bui.screenmessage(
480                bui.Lstr(resource=f'{self._r}.cantSaveAlreadyExistsText')
481            )
482            bui.getsound('error').play()
483            return
484        if not new_name:
485            bui.getsound('error').play()
486            return
487        if (
488            new_name
489            == bui.Lstr(
490                resource=f'{self._r}.defaultSoundtrackNameText'
491            ).evaluate()
492        ):
493            bui.screenmessage(
494                bui.Lstr(resource=f'{self._r}.cantOverwriteDefaultText')
495            )
496            bui.getsound('error').play()
497            return
498
499        # Make sure config exists.
500        if 'Soundtracks' not in cfg:
501            cfg['Soundtracks'] = {}
502
503        # If we had an old one, delete it.
504        if (
505            self._existing_soundtrack_name is not None
506            and self._existing_soundtrack_name in cfg['Soundtracks']
507        ):
508            del cfg['Soundtracks'][self._existing_soundtrack_name]
509        cfg['Soundtracks'][new_name] = self._soundtrack
510        cfg['Soundtrack'] = new_name
511
512        cfg.commit()
513        bui.getsound('gunCocking').play()
514
515        # Resets music back to normal.
516        music.set_music_play_mode(
517            bui.app.classic.MusicPlayMode.REGULAR, force_restart=True
518        )
519
520        self.main_window_back()
521
522    def _do_it_with_sound(self) -> None:
523        bui.getsound('swish').play()
524        self._do_it()