bauiv1lib.playlist.editcontroller

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Defines a controller for wrangling playlist edit UIs."""
  4
  5from __future__ import annotations
  6
  7import copy
  8from typing import TYPE_CHECKING
  9
 10import bascenev1 as bs
 11import bauiv1 as bui
 12
 13if TYPE_CHECKING:
 14    from typing import Any
 15
 16
 17class PlaylistEditController:
 18    """Coordinates various UIs involved in playlist editing."""
 19
 20    def __init__(
 21        self,
 22        sessiontype: type[bs.Session],
 23        existing_playlist_name: str | None = None,
 24        transition: str = 'in_right',
 25        playlist: list[dict[str, Any]] | None = None,
 26        playlist_name: str | None = None,
 27    ):
 28        from bascenev1 import filter_playlist
 29        from bauiv1lib.playlist import PlaylistTypeVars
 30        from bauiv1lib.playlist.edit import PlaylistEditWindow
 31
 32        appconfig = bui.app.config
 33
 34        # Since we may be showing our map list momentarily,
 35        # lets go ahead and preload all map preview textures.
 36        if bui.app.classic is not None:
 37            bui.app.classic.preload_map_preview_media()
 38
 39        self._sessiontype = sessiontype
 40
 41        self._editing_game = False
 42        self._editing_game_type: type[bs.GameActivity] | None = None
 43        self._pvars = PlaylistTypeVars(sessiontype)
 44        self._existing_playlist_name = existing_playlist_name
 45        self._config_name_full = self._pvars.config_name + ' Playlists'
 46
 47        # Make sure config exists.
 48        if self._config_name_full not in appconfig:
 49            appconfig[self._config_name_full] = {}
 50
 51        self._selected_index = 0
 52        if existing_playlist_name:
 53            self._name = existing_playlist_name
 54
 55            # Filter out invalid games.
 56            self._playlist = filter_playlist(
 57                appconfig[self._pvars.config_name + ' Playlists'][
 58                    existing_playlist_name
 59                ],
 60                sessiontype=sessiontype,
 61                remove_unowned=False,
 62                name=existing_playlist_name,
 63            )
 64            self._edit_ui_selection = None
 65        else:
 66            if playlist is not None:
 67                self._playlist = playlist
 68            else:
 69                self._playlist = []
 70            if playlist_name is not None:
 71                self._name = playlist_name
 72            else:
 73                # Find a good unused name.
 74                i = 1
 75                while True:
 76                    self._name = (
 77                        self._pvars.default_new_list_name.evaluate()
 78                        + ((' ' + str(i)) if i > 1 else '')
 79                    )
 80                    if (
 81                        self._name
 82                        not in appconfig[self._pvars.config_name + ' Playlists']
 83                    ):
 84                        break
 85                    i += 1
 86
 87            # Also we want it to start with 'add' highlighted since its empty
 88            # and that's all they can do.
 89            self._edit_ui_selection = 'add_button'
 90
 91        assert bui.app.classic is not None
 92        bui.app.ui_v1.set_main_menu_window(
 93            PlaylistEditWindow(
 94                editcontroller=self, transition=transition
 95            ).get_root_widget()
 96        )
 97
 98    def get_config_name(self) -> str:
 99        """(internal)"""
100        return self._pvars.config_name
101
102    def get_existing_playlist_name(self) -> str | None:
103        """(internal)"""
104        return self._existing_playlist_name
105
106    def get_edit_ui_selection(self) -> str | None:
107        """(internal)"""
108        return self._edit_ui_selection
109
110    def set_edit_ui_selection(self, selection: str) -> None:
111        """(internal)"""
112        self._edit_ui_selection = selection
113
114    def getname(self) -> str:
115        """(internal)"""
116        return self._name
117
118    def setname(self, name: str) -> None:
119        """(internal)"""
120        self._name = name
121
122    def get_playlist(self) -> list[dict[str, Any]]:
123        """Return the current state of the edited playlist."""
124        return copy.deepcopy(self._playlist)
125
126    def set_playlist(self, playlist: list[dict[str, Any]]) -> None:
127        """Set the playlist contents."""
128        self._playlist = copy.deepcopy(playlist)
129
130    def get_session_type(self) -> type[bs.Session]:
131        """Return the bascenev1.Session type for this edit-session."""
132        return self._sessiontype
133
134    def get_selected_index(self) -> int:
135        """Return the index of the selected playlist."""
136        return self._selected_index
137
138    def get_default_list_name(self) -> bui.Lstr:
139        """(internal)"""
140        return self._pvars.default_list_name
141
142    def set_selected_index(self, index: int) -> None:
143        """Sets the selected playlist index."""
144        self._selected_index = index
145
146    def add_game_pressed(self) -> None:
147        """(internal)"""
148        from bauiv1lib.playlist.addgame import PlaylistAddGameWindow
149
150        assert bui.app.classic is not None
151        bui.app.ui_v1.clear_main_menu_window(transition='out_left')
152        bui.app.ui_v1.set_main_menu_window(
153            PlaylistAddGameWindow(editcontroller=self).get_root_widget()
154        )
155
156    def edit_game_pressed(self) -> None:
157        """Should be called by supplemental UIs when a game is to be edited."""
158
159        if not self._playlist:
160            return
161        self._show_edit_ui(
162            gametype=bui.getclass(
163                self._playlist[self._selected_index]['type'],
164                subclassof=bs.GameActivity,
165            ),
166            settings=self._playlist[self._selected_index],
167        )
168
169    def add_game_cancelled(self) -> None:
170        """(internal)"""
171        from bauiv1lib.playlist.edit import PlaylistEditWindow
172
173        assert bui.app.classic is not None
174        bui.app.ui_v1.clear_main_menu_window(transition='out_right')
175        bui.app.ui_v1.set_main_menu_window(
176            PlaylistEditWindow(
177                editcontroller=self, transition='in_left'
178            ).get_root_widget()
179        )
180
181    def _show_edit_ui(
182        self, gametype: type[bs.GameActivity], settings: dict[str, Any] | None
183    ) -> None:
184        self._editing_game = settings is not None
185        self._editing_game_type = gametype
186        assert self._sessiontype is not None
187        gametype.create_settings_ui(
188            self._sessiontype, copy.deepcopy(settings), self._edit_game_done
189        )
190
191    def add_game_type_selected(self, gametype: type[bs.GameActivity]) -> None:
192        """(internal)"""
193        self._show_edit_ui(gametype=gametype, settings=None)
194
195    def _edit_game_done(self, config: dict[str, Any] | None) -> None:
196        from bauiv1lib.playlist.edit import PlaylistEditWindow
197        from bauiv1lib.playlist.addgame import PlaylistAddGameWindow
198
199        assert bui.app.classic is not None
200        if config is None:
201            # If we were editing, go back to our list.
202            if self._editing_game:
203                bui.getsound('powerdown01').play()
204                bui.app.ui_v1.clear_main_menu_window(transition='out_right')
205                bui.app.ui_v1.set_main_menu_window(
206                    PlaylistEditWindow(
207                        editcontroller=self, transition='in_left'
208                    ).get_root_widget()
209                )
210
211            # Otherwise we were adding; go back to the add type choice list.
212            else:
213                bui.app.ui_v1.clear_main_menu_window(transition='out_right')
214                bui.app.ui_v1.set_main_menu_window(
215                    PlaylistAddGameWindow(
216                        editcontroller=self, transition='in_left'
217                    ).get_root_widget()
218                )
219        else:
220            # Make sure type is in there.
221            assert self._editing_game_type is not None
222            config['type'] = bui.get_type_name(self._editing_game_type)
223
224            if self._editing_game:
225                self._playlist[self._selected_index] = copy.deepcopy(config)
226            else:
227                # Add a new entry to the playlist.
228                insert_index = min(
229                    len(self._playlist), self._selected_index + 1
230                )
231                self._playlist.insert(insert_index, copy.deepcopy(config))
232                self._selected_index = insert_index
233
234            bui.getsound('gunCocking').play()
235            bui.app.ui_v1.clear_main_menu_window(transition='out_right')
236            bui.app.ui_v1.set_main_menu_window(
237                PlaylistEditWindow(
238                    editcontroller=self, transition='in_left'
239                ).get_root_widget()
240            )