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