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