bauiv1lib.playlist.browser

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Provides a window for browsing and launching game playlists."""
  4
  5from __future__ import annotations
  6
  7import copy
  8import math
  9import logging
 10from typing import override, TYPE_CHECKING
 11
 12import bascenev1 as bs
 13import bauiv1 as bui
 14
 15if TYPE_CHECKING:
 16    from bauiv1lib.play import PlaylistSelectContext
 17
 18
 19class PlaylistBrowserWindow(bui.MainWindow):
 20    """Window for starting teams games."""
 21
 22    def __init__(
 23        self,
 24        sessiontype: type[bs.Session],
 25        transition: str | None = 'in_right',
 26        origin_widget: bui.Widget | None = None,
 27        playlist_select_context: PlaylistSelectContext | None = None,
 28    ):
 29        # pylint: disable=cyclic-import
 30        from bauiv1lib.playlist import PlaylistTypeVars
 31
 32        # Store state for when we exit the next game.
 33        if issubclass(sessiontype, bs.DualTeamSession):
 34            bui.set_analytics_screen('Teams Window')
 35        elif issubclass(sessiontype, bs.FreeForAllSession):
 36            bui.set_analytics_screen('FreeForAll Window')
 37        else:
 38            raise TypeError(f'Invalid sessiontype: {sessiontype}.')
 39        self._pvars = PlaylistTypeVars(sessiontype)
 40
 41        self._sessiontype = sessiontype
 42
 43        self._customize_button: bui.Widget | None = None
 44        self._sub_width: float | None = None
 45        self._sub_height: float | None = None
 46        self._playlist_select_context = playlist_select_context
 47
 48        self._ensure_standard_playlists_exist()
 49
 50        # Get the current selection (if any).
 51        self._selected_playlist = bui.app.config.get(
 52            self._pvars.config_name + ' Playlist Selection'
 53        )
 54
 55        uiscale = bui.app.ui_v1.uiscale
 56        self._width = (
 57            1100.0
 58            if uiscale is bui.UIScale.SMALL
 59            else 800.0 if uiscale is bui.UIScale.MEDIUM else 1040
 60        )
 61        self._height = (
 62            600
 63            if uiscale is bui.UIScale.SMALL
 64            else 550 if uiscale is bui.UIScale.MEDIUM else 700
 65        )
 66
 67        # Do some fancy math to fill all available screen area up to the
 68        # size of our backing container. This lets us fit to the exact
 69        # screen shape at small ui scale.
 70        screensize = bui.get_virtual_screen_size()
 71        scale = (
 72            1.85
 73            if uiscale is bui.UIScale.SMALL
 74            else 1.0 if uiscale is bui.UIScale.MEDIUM else 0.8
 75        )
 76        # Calc screen size in our local container space and clamp to a
 77        # bit smaller than our container size.
 78        target_width = min(self._width - 100, screensize[0] / scale)
 79        target_height = min(self._height - 100, screensize[1] / scale)
 80
 81        # To get top/left coords, go to the center of our window and
 82        # offset by half the width/height of our target area.
 83        yoffs = 0.5 * self._height + 0.5 * target_height + 30.0
 84
 85        self._scroll_width = target_width
 86        self._scroll_height = target_height - 31
 87        scroll_bottom = yoffs - 60 - self._scroll_height
 88
 89        super().__init__(
 90            root_widget=bui.containerwidget(
 91                size=(self._width, self._height),
 92                toolbar_visibility=(
 93                    'menu_minimal'
 94                    if (
 95                        uiscale is bui.UIScale.SMALL
 96                        or playlist_select_context is not None
 97                    )
 98                    else 'menu_full'
 99                ),
100                scale=scale,
101            ),
102            transition=transition,
103            origin_widget=origin_widget,
104            # We're affected by screen size only at small ui-scale.
105            refresh_on_screen_size_changes=uiscale is bui.UIScale.SMALL,
106        )
107
108        self._back_button: bui.Widget | None
109        if uiscale is bui.UIScale.SMALL:
110            self._back_button = None
111            bui.containerwidget(
112                edit=self._root_widget, on_cancel_call=self._on_back_press
113            )
114        else:
115            self._back_button = bui.buttonwidget(
116                parent=self._root_widget,
117                position=(59, yoffs - 45),
118                size=(60, 54),
119                scale=1.0,
120                on_activate_call=self._on_back_press,
121                autoselect=True,
122                label=bui.charstr(bui.SpecialChar.BACK),
123                button_type='backSmall',
124            )
125            bui.containerwidget(
126                edit=self._root_widget, cancel_button=self._back_button
127            )
128
129        self._title_text = bui.textwidget(
130            parent=self._root_widget,
131            position=(
132                self._width * 0.5,
133                yoffs - (45 if uiscale is bui.UIScale.SMALL else 20),
134            ),
135            size=(0, 0),
136            text=self._pvars.window_title_name,
137            scale=(0.8 if uiscale is bui.UIScale.SMALL else 1.3),
138            res_scale=1.5,
139            color=bui.app.ui_v1.heading_color,
140            h_align='center',
141            v_align='center',
142        )
143
144        self._scrollwidget = bui.scrollwidget(
145            parent=self._root_widget,
146            highlight=False,
147            size=(self._scroll_width, self._scroll_height),
148            position=(
149                self._width * 0.5 - self._scroll_width * 0.5,
150                scroll_bottom,
151            ),
152            border_opacity=0.4,
153            center_small_content_horizontally=True,
154        )
155        bui.containerwidget(edit=self._scrollwidget, claims_left_right=True)
156        self._subcontainer: bui.Widget | None = None
157        self._config_name_full = self._pvars.config_name + ' Playlists'
158        self._last_config = None
159
160        # Update now and once per second (this should do our initial
161        # refresh).
162        self._update()
163        self._update_timer = bui.AppTimer(
164            1.0, bui.WeakCall(self._update), repeat=True
165        )
166
167    @override
168    def get_main_window_state(self) -> bui.MainWindowState:
169        # Support recreating our window for back/refresh purposes.
170        cls = type(self)
171
172        # Pull things out of self here; if we do it below in the lambda
173        # then we keep self alive.
174        sessiontype = self._sessiontype
175
176        # Pull anything out of self here; if we do it in the lambda
177        # we'll inadvertanly keep self alive.
178        playlist_select_context = self._playlist_select_context
179
180        return bui.BasicMainWindowState(
181            create_call=lambda transition, origin_widget: cls(
182                transition=transition,
183                origin_widget=origin_widget,
184                sessiontype=sessiontype,
185                playlist_select_context=playlist_select_context,
186            )
187        )
188
189    @override
190    def on_main_window_close(self) -> None:
191        self._save_state()
192
193    def _ensure_standard_playlists_exist(self) -> None:
194        plus = bui.app.plus
195        assert plus is not None
196
197        # On new installations, go ahead and create a few playlists
198        # besides the hard-coded default one:
199        if not plus.get_v1_account_misc_val('madeStandardPlaylists', False):
200            plus.add_v1_account_transaction(
201                {
202                    'type': 'ADD_PLAYLIST',
203                    'playlistType': 'Free-for-All',
204                    'playlistName': bui.Lstr(
205                        resource='singleGamePlaylistNameText'
206                    )
207                    .evaluate()
208                    .replace(
209                        '${GAME}',
210                        bui.Lstr(
211                            translate=('gameNames', 'Death Match')
212                        ).evaluate(),
213                    ),
214                    'playlist': [
215                        {
216                            'type': 'bs_death_match.DeathMatchGame',
217                            'settings': {
218                                'Epic Mode': False,
219                                'Kills to Win Per Player': 10,
220                                'Respawn Times': 1.0,
221                                'Time Limit': 300,
222                                'map': 'Doom Shroom',
223                            },
224                        },
225                        {
226                            'type': 'bs_death_match.DeathMatchGame',
227                            'settings': {
228                                'Epic Mode': False,
229                                'Kills to Win Per Player': 10,
230                                'Respawn Times': 1.0,
231                                'Time Limit': 300,
232                                'map': 'Crag Castle',
233                            },
234                        },
235                    ],
236                }
237            )
238            plus.add_v1_account_transaction(
239                {
240                    'type': 'ADD_PLAYLIST',
241                    'playlistType': 'Team Tournament',
242                    'playlistName': bui.Lstr(
243                        resource='singleGamePlaylistNameText'
244                    )
245                    .evaluate()
246                    .replace(
247                        '${GAME}',
248                        bui.Lstr(
249                            translate=('gameNames', 'Capture the Flag')
250                        ).evaluate(),
251                    ),
252                    'playlist': [
253                        {
254                            'type': 'bs_capture_the_flag.CTFGame',
255                            'settings': {
256                                'map': 'Bridgit',
257                                'Score to Win': 3,
258                                'Flag Idle Return Time': 30,
259                                'Flag Touch Return Time': 0,
260                                'Respawn Times': 1.0,
261                                'Time Limit': 600,
262                                'Epic Mode': False,
263                            },
264                        },
265                        {
266                            'type': 'bs_capture_the_flag.CTFGame',
267                            'settings': {
268                                'map': 'Roundabout',
269                                'Score to Win': 2,
270                                'Flag Idle Return Time': 30,
271                                'Flag Touch Return Time': 0,
272                                'Respawn Times': 1.0,
273                                'Time Limit': 600,
274                                'Epic Mode': False,
275                            },
276                        },
277                        {
278                            'type': 'bs_capture_the_flag.CTFGame',
279                            'settings': {
280                                'map': 'Tip Top',
281                                'Score to Win': 2,
282                                'Flag Idle Return Time': 30,
283                                'Flag Touch Return Time': 3,
284                                'Respawn Times': 1.0,
285                                'Time Limit': 300,
286                                'Epic Mode': False,
287                            },
288                        },
289                    ],
290                }
291            )
292            plus.add_v1_account_transaction(
293                {
294                    'type': 'ADD_PLAYLIST',
295                    'playlistType': 'Team Tournament',
296                    'playlistName': bui.Lstr(
297                        translate=('playlistNames', 'Just Sports')
298                    ).evaluate(),
299                    'playlist': [
300                        {
301                            'type': 'bs_hockey.HockeyGame',
302                            'settings': {
303                                'Time Limit': 0,
304                                'map': 'Hockey Stadium',
305                                'Score to Win': 1,
306                                'Respawn Times': 1.0,
307                            },
308                        },
309                        {
310                            'type': 'bs_football.FootballTeamGame',
311                            'settings': {
312                                'Time Limit': 0,
313                                'map': 'Football Stadium',
314                                'Score to Win': 21,
315                                'Respawn Times': 1.0,
316                            },
317                        },
318                    ],
319                }
320            )
321            plus.add_v1_account_transaction(
322                {
323                    'type': 'ADD_PLAYLIST',
324                    'playlistType': 'Free-for-All',
325                    'playlistName': bui.Lstr(
326                        translate=('playlistNames', 'Just Epic')
327                    ).evaluate(),
328                    'playlist': [
329                        {
330                            'type': 'bs_elimination.EliminationGame',
331                            'settings': {
332                                'Time Limit': 120,
333                                'map': 'Tip Top',
334                                'Respawn Times': 1.0,
335                                'Lives Per Player': 1,
336                                'Epic Mode': 1,
337                            },
338                        }
339                    ],
340                }
341            )
342            plus.add_v1_account_transaction(
343                {
344                    'type': 'SET_MISC_VAL',
345                    'name': 'madeStandardPlaylists',
346                    'value': True,
347                }
348            )
349            plus.run_v1_account_transactions()
350
351    def _refresh(self) -> None:
352        # FIXME: Should tidy this up.
353        # pylint: disable=too-many-statements
354        # pylint: disable=too-many-branches
355        # pylint: disable=too-many-locals
356        # pylint: disable=too-many-nested-blocks
357        from efro.util import asserttype
358        from bascenev1 import get_map_class, filter_playlist
359
360        if not self._root_widget:
361            return
362        if self._subcontainer is not None:
363            self._save_state()
364            self._subcontainer.delete()
365
366        # Make sure config exists.
367        if self._config_name_full not in bui.app.config:
368            bui.app.config[self._config_name_full] = {}
369
370        items = list(bui.app.config[self._config_name_full].items())
371
372        # Make sure everything is unicode.
373        items = [
374            (i[0].decode(), i[1]) if not isinstance(i[0], str) else i
375            for i in items
376        ]
377
378        items.sort(key=lambda x2: asserttype(x2[0], str).lower())
379        items = [['__default__', None]] + items  # default is always first
380
381        button_width = 230
382        button_height = 230
383        button_buffer_h = -3
384        button_buffer_v = 0
385
386        count = len(items)
387        columns = max(
388            1,
389            math.floor(
390                self._scroll_width / (button_width + 2 * button_buffer_h)
391            ),
392        )
393        rows = int(math.ceil(float(count) / columns))
394
395        self._sub_width = columns * button_width + 2 * button_buffer_h
396
397        self._sub_height = (
398            40.0 + rows * (button_height + 2 * button_buffer_v) + 90
399        )
400        assert self._sub_width is not None
401        assert self._sub_height is not None
402        self._subcontainer = bui.containerwidget(
403            parent=self._scrollwidget,
404            size=(self._sub_width, self._sub_height),
405            background=False,
406        )
407
408        children = self._subcontainer.get_children()
409        for child in children:
410            child.delete()
411
412        # On small ui-scale, nudge 'Playlists' text to the right when
413        # we're small enough so that the back button doesn't partly
414        # obscure it.
415        uiscale = bui.app.ui_v1.uiscale
416        screensize = bui.get_virtual_screen_size()
417        xoffs = (
418            40 if uiscale is bui.UIScale.SMALL and screensize[0] < 1400 else 0
419        )
420
421        assert bui.app.classic is not None
422        bui.textwidget(
423            parent=self._subcontainer,
424            text=bui.Lstr(resource='playlistsText'),
425            position=(40 + xoffs, self._sub_height - 26),
426            size=(0, 0),
427            scale=1.0,
428            maxwidth=400,
429            color=bui.app.ui_v1.title_color,
430            h_align='left',
431            v_align='center',
432        )
433
434        index = 0
435        appconfig = bui.app.config
436
437        mesh_opaque = bui.getmesh('level_select_button_opaque')
438        mesh_transparent = bui.getmesh('level_select_button_transparent')
439        mask_tex = bui.gettexture('mapPreviewMask')
440
441        # h_offs = 225 if count == 1 else 115 if count == 2 else 0
442        h_offs = 2
443        h_offs_bottom = 0
444
445        uiscale = bui.app.ui_v1.uiscale
446        for y in range(rows):
447            for x in range(columns):
448                name = items[index][0]
449                assert name is not None
450                pos = (
451                    x * (button_width + 2 * button_buffer_h)
452                    + button_buffer_h
453                    + 8
454                    + h_offs,
455                    self._sub_height
456                    - 47
457                    - (y + 1) * (button_height + 2 * button_buffer_v),
458                )
459                btn = bui.buttonwidget(
460                    parent=self._subcontainer,
461                    button_type='square',
462                    size=(button_width, button_height),
463                    autoselect=True,
464                    label='',
465                    position=pos,
466                )
467
468                if x == 0 and uiscale is bui.UIScale.SMALL:
469                    bui.widget(
470                        edit=btn,
471                        left_widget=bui.get_special_widget('back_button'),
472                    )
473                if x == columns - 1 and uiscale is bui.UIScale.SMALL:
474                    bui.widget(
475                        edit=btn,
476                        right_widget=bui.get_special_widget('squad_button'),
477                    )
478                bui.buttonwidget(
479                    edit=btn,
480                    on_activate_call=bui.Call(
481                        self._on_playlist_press, btn, name
482                    ),
483                    on_select_call=bui.Call(self._on_playlist_select, name),
484                )
485
486                # Top row biases things up more to show header above it.
487                if y == 0:
488                    bui.widget(
489                        edit=btn, show_buffer_top=60, show_buffer_bottom=5
490                    )
491                else:
492                    bui.widget(
493                        edit=btn, show_buffer_top=30, show_buffer_bottom=30
494                    )
495
496                if self._selected_playlist == name:
497                    bui.containerwidget(
498                        edit=self._subcontainer,
499                        selected_child=btn,
500                        visible_child=btn,
501                    )
502
503                if self._back_button is not None:
504                    if y == 0:
505                        bui.widget(edit=btn, up_widget=self._back_button)
506                    if x == 0:
507                        bui.widget(edit=btn, left_widget=self._back_button)
508
509                print_name: str | bui.Lstr | None
510                if name == '__default__':
511                    print_name = self._pvars.default_list_name
512                else:
513                    print_name = name
514                bui.textwidget(
515                    parent=self._subcontainer,
516                    text=print_name,
517                    position=(
518                        pos[0] + button_width * 0.5,
519                        pos[1] + button_height * 0.79,
520                    ),
521                    size=(0, 0),
522                    scale=button_width * 0.003,
523                    maxwidth=button_width * 0.7,
524                    draw_controller=btn,
525                    h_align='center',
526                    v_align='center',
527                )
528
529                # Poke into this playlist and see if we can display some of
530                # its maps.
531                map_images = []
532                try:
533                    map_textures = []
534                    map_texture_entries = []
535                    if name == '__default__':
536                        playlist = self._pvars.get_default_list_call()
537                    else:
538                        if (
539                            name
540                            not in appconfig[
541                                self._pvars.config_name + ' Playlists'
542                            ]
543                        ):
544                            print(
545                                'NOT FOUND ERR',
546                                appconfig[
547                                    self._pvars.config_name + ' Playlists'
548                                ],
549                            )
550                        playlist = appconfig[
551                            self._pvars.config_name + ' Playlists'
552                        ][name]
553                    playlist = filter_playlist(
554                        playlist,
555                        self._sessiontype,
556                        remove_unowned=False,
557                        mark_unowned=True,
558                        name=name,
559                    )
560                    for entry in playlist:
561                        mapname = entry['settings']['map']
562                        maptype: type[bs.Map] | None
563                        try:
564                            maptype = get_map_class(mapname)
565                        except bui.NotFoundError:
566                            maptype = None
567                        if maptype is not None:
568                            tex_name = maptype.get_preview_texture_name()
569                            if tex_name is not None:
570                                map_textures.append(tex_name)
571                                map_texture_entries.append(entry)
572                        if len(map_textures) >= 6:
573                            break
574
575                    if len(map_textures) > 4:
576                        img_rows = 3
577                        img_columns = 2
578                        scl = 0.33
579                        h_offs_img = 30
580                        v_offs_img = 126
581                    elif len(map_textures) > 2:
582                        img_rows = 2
583                        img_columns = 2
584                        scl = 0.35
585                        h_offs_img = 24
586                        v_offs_img = 110
587                    elif len(map_textures) > 1:
588                        img_rows = 2
589                        img_columns = 1
590                        scl = 0.5
591                        h_offs_img = 47
592                        v_offs_img = 105
593                    else:
594                        img_rows = 1
595                        img_columns = 1
596                        scl = 0.75
597                        h_offs_img = 20
598                        v_offs_img = 65
599
600                    v = None
601                    for row in range(img_rows):
602                        for col in range(img_columns):
603                            tex_index = row * img_columns + col
604                            if tex_index < len(map_textures):
605                                entry = map_texture_entries[tex_index]
606
607                                owned = not (
608                                    (
609                                        'is_unowned_map' in entry
610                                        and entry['is_unowned_map']
611                                    )
612                                    or (
613                                        'is_unowned_game' in entry
614                                        and entry['is_unowned_game']
615                                    )
616                                )
617
618                                tex_name = map_textures[tex_index]
619                                h = pos[0] + h_offs_img + scl * 250 * col
620                                v = pos[1] + v_offs_img - scl * 130 * row
621                                map_images.append(
622                                    bui.imagewidget(
623                                        parent=self._subcontainer,
624                                        size=(scl * 250.0, scl * 125.0),
625                                        position=(h, v),
626                                        texture=bui.gettexture(tex_name),
627                                        opacity=1.0 if owned else 0.25,
628                                        draw_controller=btn,
629                                        mesh_opaque=mesh_opaque,
630                                        mesh_transparent=mesh_transparent,
631                                        mask_texture=mask_tex,
632                                    )
633                                )
634                                if not owned:
635                                    bui.imagewidget(
636                                        parent=self._subcontainer,
637                                        size=(scl * 100.0, scl * 100.0),
638                                        position=(h + scl * 75, v + scl * 10),
639                                        texture=bui.gettexture('lock'),
640                                        draw_controller=btn,
641                                    )
642                        if v is not None:
643                            v -= scl * 130.0
644
645                except Exception:
646                    logging.exception('Error listing playlist maps.')
647
648                if not map_images:
649                    bui.textwidget(
650                        parent=self._subcontainer,
651                        text='???',
652                        scale=1.5,
653                        size=(0, 0),
654                        color=(1, 1, 1, 0.5),
655                        h_align='center',
656                        v_align='center',
657                        draw_controller=btn,
658                        position=(
659                            pos[0] + button_width * 0.5,
660                            pos[1] + button_height * 0.5,
661                        ),
662                    )
663
664                index += 1
665
666                if index >= count:
667                    break
668            if index >= count:
669                break
670        self._customize_button = btn = bui.buttonwidget(
671            parent=self._subcontainer,
672            size=(100, 30),
673            position=(34 + h_offs_bottom, 50),
674            text_scale=0.6,
675            label=bui.Lstr(resource='customizeText'),
676            on_activate_call=self._on_customize_press,
677            color=(0.54, 0.52, 0.67),
678            textcolor=(0.7, 0.65, 0.7),
679            autoselect=True,
680        )
681        bui.widget(edit=btn, show_buffer_top=22, show_buffer_bottom=28)
682        self._restore_state()
683
684    def on_play_options_window_run_game(self) -> None:
685        """(internal)"""
686
687        # No-op if we're not in control.
688        if not self.main_window_has_control():
689            # if not self._root_widget:
690            return
691
692        if self._playlist_select_context is not None:
693            # Done doing a playlist selection; now back all the way out
694            # of our selection windows to our stored starting point.
695            if self._playlist_select_context.back_state is None:
696                logging.error(
697                    'No back state found'
698                    ' after playlist select context completion.'
699                )
700            else:
701                self.main_window_back_state = (
702                    self._playlist_select_context.back_state
703                )
704            self.main_window_back()
705        else:
706            # Launching a regular game session; simply get our window
707            # transitioning out.
708            self.main_window_close(transition='out_left')
709
710    def _on_playlist_select(self, playlist_name: str) -> None:
711        self._selected_playlist = playlist_name
712
713    def _update(self) -> None:
714        # Make sure config exists.
715        if self._config_name_full not in bui.app.config:
716            bui.app.config[self._config_name_full] = {}
717
718        cfg = bui.app.config[self._config_name_full]
719        if cfg != self._last_config:
720            self._last_config = copy.deepcopy(cfg)
721            self._refresh()
722
723    def _on_playlist_press(
724        self, button: bui.Widget, playlist_name: str
725    ) -> None:
726        # pylint: disable=cyclic-import
727        from bauiv1lib.playoptions import PlayOptionsWindow
728
729        # Make sure the target playlist still exists.
730        exists = (
731            playlist_name == '__default__'
732            or playlist_name in bui.app.config.get(self._config_name_full, {})
733        )
734        if not exists:
735            return
736
737        self._save_state()
738        PlayOptionsWindow(
739            sessiontype=self._sessiontype,
740            scale_origin=button.get_screen_space_center(),
741            playlist=playlist_name,
742            delegate=self,
743            playlist_select_context=self._playlist_select_context,
744        )
745
746    def _on_customize_press(self) -> None:
747        # pylint: disable=cyclic-import
748        from bauiv1lib.playlist.customizebrowser import (
749            PlaylistCustomizeBrowserWindow,
750        )
751
752        # no-op if we're not in control.
753        if not self.main_window_has_control():
754            return
755
756        self.main_window_replace(
757            PlaylistCustomizeBrowserWindow(
758                origin_widget=self._customize_button,
759                sessiontype=self._sessiontype,
760            )
761        )
762
763    def _on_back_press(self) -> None:
764        # pylint: disable=cyclic-import
765        # from bauiv1lib.play import PlayWindow
766
767        # no-op if we're not in control.
768        if not self.main_window_has_control():
769            return
770
771        # Store our selected playlist if that's changed.
772        if self._selected_playlist is not None:
773            prev_sel = bui.app.config.get(
774                self._pvars.config_name + ' Playlist Selection'
775            )
776            if self._selected_playlist != prev_sel:
777                cfg = bui.app.config
778                cfg[self._pvars.config_name + ' Playlist Selection'] = (
779                    self._selected_playlist
780                )
781                cfg.commit()
782
783        self.main_window_back()
784
785    def _save_state(self) -> None:
786        try:
787            sel = self._root_widget.get_selected_child()
788            if sel == self._back_button:
789                sel_name = 'Back'
790            elif sel == self._scrollwidget:
791                assert self._subcontainer is not None
792                subsel = self._subcontainer.get_selected_child()
793                if subsel == self._customize_button:
794                    sel_name = 'Customize'
795                else:
796                    sel_name = 'Scroll'
797            else:
798                raise RuntimeError('Unrecognized selected widget.')
799            assert bui.app.classic is not None
800            bui.app.ui_v1.window_states[type(self)] = sel_name
801        except Exception:
802            logging.exception('Error saving state for %s.', self)
803
804    def _restore_state(self) -> None:
805        try:
806            assert bui.app.classic is not None
807            sel_name = bui.app.ui_v1.window_states.get(type(self))
808            if sel_name == 'Back':
809                sel = self._back_button
810            elif sel_name == 'Scroll':
811                sel = self._scrollwidget
812            elif sel_name == 'Customize':
813                sel = self._scrollwidget
814                bui.containerwidget(
815                    edit=self._subcontainer,
816                    selected_child=self._customize_button,
817                    visible_child=self._customize_button,
818                )
819            else:
820                sel = self._scrollwidget
821            bui.containerwidget(edit=self._root_widget, selected_child=sel)
822        except Exception:
823            logging.exception('Error restoring state for %s.', self)