bauiv1lib.gather

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Provides UI for inviting/joining friends."""
  4
  5from __future__ import annotations
  6
  7import weakref
  8import logging
  9from enum import Enum
 10from typing import override, TYPE_CHECKING
 11
 12from bauiv1lib.tabs import TabRow
 13import bauiv1 as bui
 14
 15if TYPE_CHECKING:
 16    from bauiv1lib.play import PlaylistSelectContext
 17
 18
 19class GatherTab:
 20    """Defines a tab for use in the gather UI."""
 21
 22    def __init__(self, window: GatherWindow) -> None:
 23        self._window = weakref.ref(window)
 24
 25    @property
 26    def window(self) -> GatherWindow:
 27        """The GatherWindow that this tab belongs to."""
 28        window = self._window()
 29        if window is None:
 30            raise bui.NotFoundError("GatherTab's window no longer exists.")
 31        return window
 32
 33    def on_activate(
 34        self,
 35        parent_widget: bui.Widget,
 36        tab_button: bui.Widget,
 37        region_width: float,
 38        region_height: float,
 39        region_left: float,
 40        region_bottom: float,
 41    ) -> bui.Widget:
 42        """Called when the tab becomes the active one.
 43
 44        The tab should create and return a container widget covering the
 45        specified region.
 46        """
 47        # pylint: disable=too-many-positional-arguments
 48        raise RuntimeError('Should not get here.')
 49
 50    def on_deactivate(self) -> None:
 51        """Called when the tab will no longer be the active one."""
 52
 53    def save_state(self) -> None:
 54        """Called when the parent window is saving state."""
 55
 56    def restore_state(self) -> None:
 57        """Called when the parent window is restoring state."""
 58
 59
 60class GatherWindow(bui.MainWindow):
 61    """Window for joining/inviting friends."""
 62
 63    class TabID(Enum):
 64        """Our available tab types."""
 65
 66        ABOUT = 'about'
 67        INTERNET = 'internet'
 68        PRIVATE = 'private'
 69        NEARBY = 'nearby'
 70        MANUAL = 'manual'
 71
 72    def __init__(
 73        self,
 74        transition: str | None = 'in_right',
 75        origin_widget: bui.Widget | None = None,
 76    ):
 77        # pylint: disable=too-many-locals
 78        # pylint: disable=cyclic-import
 79        from bauiv1lib.gather.abouttab import AboutGatherTab
 80        from bauiv1lib.gather.manualtab import ManualGatherTab
 81        from bauiv1lib.gather.privatetab import PrivateGatherTab
 82        from bauiv1lib.gather.publictab import PublicGatherTab
 83        from bauiv1lib.gather.nearbytab import NearbyGatherTab
 84
 85        plus = bui.app.plus
 86        assert plus is not None
 87
 88        bui.set_analytics_screen('Gather Window')
 89        uiscale = bui.app.ui_v1.uiscale
 90        self._width = (
 91            1640
 92            if uiscale is bui.UIScale.SMALL
 93            else 1100 if uiscale is bui.UIScale.MEDIUM else 1200
 94        )
 95        self._height = (
 96            1000
 97            if uiscale is bui.UIScale.SMALL
 98            else 730 if uiscale is bui.UIScale.MEDIUM else 900
 99        )
100        self._current_tab: GatherWindow.TabID | None = None
101        self._r = 'gatherWindow'
102
103        # Do some fancy math to fill all available screen area up to the
104        # size of our backing container. This lets us fit to the exact
105        # screen shape at small ui scale.
106        screensize = bui.get_virtual_screen_size()
107        scale = (
108            1.4
109            if uiscale is bui.UIScale.SMALL
110            else 0.88 if uiscale is bui.UIScale.MEDIUM else 0.66
111        )
112        # Calc screen size in our local container space and clamp to a
113        # bit smaller than our container size.
114        target_width = min(self._width - 130, screensize[0] / scale)
115        target_height = min(self._height - 130, screensize[1] / scale)
116
117        # To get top/left coords, go to the center of our window and
118        # offset by half the width/height of our target area.
119        yoffs = 0.5 * self._height + 0.5 * target_height + 30.0
120
121        self._scroll_width = target_width
122        self._scroll_height = target_height - 65
123        self._scroll_bottom = yoffs - 93 - self._scroll_height
124        self._scroll_left = (self._width - self._scroll_width) * 0.5
125
126        super().__init__(
127            root_widget=bui.containerwidget(
128                size=(self._width, self._height),
129                toolbar_visibility=(
130                    'menu_tokens'
131                    if uiscale is bui.UIScale.SMALL
132                    else 'menu_full'
133                ),
134                scale=scale,
135            ),
136            transition=transition,
137            origin_widget=origin_widget,
138            # We're affected by screen size only at small ui-scale.
139            refresh_on_screen_size_changes=uiscale is bui.UIScale.SMALL,
140        )
141
142        if uiscale is bui.UIScale.SMALL:
143            bui.containerwidget(
144                edit=self._root_widget, on_cancel_call=self.main_window_back
145            )
146            self._back_button = None
147        else:
148            self._back_button = btn = bui.buttonwidget(
149                parent=self._root_widget,
150                position=(70, yoffs - 43),
151                size=(60, 60),
152                scale=1.1,
153                autoselect=True,
154                label=bui.charstr(bui.SpecialChar.BACK),
155                button_type='backSmall',
156                on_activate_call=self.main_window_back,
157            )
158            bui.containerwidget(edit=self._root_widget, cancel_button=btn)
159
160        bui.textwidget(
161            parent=self._root_widget,
162            position=(
163                (
164                    self._width * 0.5
165                    + (
166                        (self._scroll_width * -0.5 + 170.0 - 70.0)
167                        if uiscale is bui.UIScale.SMALL
168                        else 0.0
169                    )
170                ),
171                yoffs - (64 if uiscale is bui.UIScale.SMALL else 4),
172            ),
173            size=(0, 0),
174            color=bui.app.ui_v1.title_color,
175            scale=1.3 if uiscale is bui.UIScale.SMALL else 1.0,
176            h_align='left' if uiscale is bui.UIScale.SMALL else 'center',
177            v_align='center',
178            text=(bui.Lstr(resource=f'{self._r}.titleText')),
179            maxwidth=135 if uiscale is bui.UIScale.SMALL else 320,
180        )
181
182        # Build up the set of tabs we want.
183        tabdefs: list[tuple[GatherWindow.TabID, bui.Lstr]] = [
184            (self.TabID.ABOUT, bui.Lstr(resource=f'{self._r}.aboutText'))
185        ]
186        if plus.get_v1_account_misc_read_val('enablePublicParties', True):
187            tabdefs.append(
188                (
189                    self.TabID.INTERNET,
190                    bui.Lstr(resource=f'{self._r}.publicText'),
191                )
192            )
193        tabdefs.append(
194            (self.TabID.PRIVATE, bui.Lstr(resource=f'{self._r}.privateText'))
195        )
196        tabdefs.append(
197            (self.TabID.NEARBY, bui.Lstr(resource=f'{self._r}.nearbyText'))
198        )
199        tabdefs.append(
200            (self.TabID.MANUAL, bui.Lstr(resource=f'{self._r}.manualText'))
201        )
202
203        tab_inset = 250.0 if uiscale is bui.UIScale.SMALL else 100.0
204
205        self._tab_row = TabRow(
206            self._root_widget,
207            tabdefs,
208            size=(self._scroll_width - 2.0 * tab_inset, 50),
209            pos=(
210                self._scroll_left + tab_inset,
211                self._scroll_bottom + self._scroll_height - 4.0,
212            ),
213            on_select_call=bui.WeakCall(self._set_tab),
214        )
215
216        # Now instantiate handlers for these tabs.
217        tabtypes: dict[GatherWindow.TabID, type[GatherTab]] = {
218            self.TabID.ABOUT: AboutGatherTab,
219            self.TabID.MANUAL: ManualGatherTab,
220            self.TabID.PRIVATE: PrivateGatherTab,
221            self.TabID.INTERNET: PublicGatherTab,
222            self.TabID.NEARBY: NearbyGatherTab,
223        }
224        self._tabs: dict[GatherWindow.TabID, GatherTab] = {}
225        for tab_id in self._tab_row.tabs:
226            tabtype = tabtypes.get(tab_id)
227            if tabtype is not None:
228                self._tabs[tab_id] = tabtype(self)
229
230        # Eww; tokens meter may or may not be here; should be smarter
231        # about this.
232        bui.widget(
233            edit=self._tab_row.tabs[tabdefs[-1][0]].button,
234            right_widget=bui.get_special_widget('tokens_meter'),
235        )
236        if uiscale is bui.UIScale.SMALL:
237            bui.widget(
238                edit=self._tab_row.tabs[tabdefs[0][0]].button,
239                left_widget=bui.get_special_widget('back_button'),
240                up_widget=bui.get_special_widget('back_button'),
241            )
242
243        # Not actually using a scroll widget anymore; just an image.
244        bui.imagewidget(
245            parent=self._root_widget,
246            size=(self._scroll_width, self._scroll_height),
247            position=(
248                self._width * 0.5 - self._scroll_width * 0.5,
249                self._scroll_bottom,
250            ),
251            texture=bui.gettexture('scrollWidget'),
252            mesh_transparent=bui.getmesh('softEdgeOutside'),
253            opacity=0.4,
254        )
255        self._tab_container: bui.Widget | None = None
256
257        self._restore_state()
258
259    @override
260    def get_main_window_state(self) -> bui.MainWindowState:
261        # Support recreating our window for back/refresh purposes.
262        cls = type(self)
263        return bui.BasicMainWindowState(
264            create_call=lambda transition, origin_widget: cls(
265                transition=transition, origin_widget=origin_widget
266            )
267        )
268
269    @override
270    def on_main_window_close(self) -> None:
271        self._save_state()
272
273    def playlist_select(
274        self,
275        origin_widget: bui.Widget,
276        context: PlaylistSelectContext,
277    ) -> None:
278        """Called by the private-hosting tab to select a playlist."""
279        from bauiv1lib.play import PlayWindow
280
281        # Avoid redundant window spawns.
282        if not self.main_window_has_control():
283            return
284
285        playwindow = PlayWindow(
286            origin_widget=origin_widget, playlist_select_context=context
287        )
288        self.main_window_replace(playwindow)
289
290        # Grab the newly-set main-window's back-state; that will lead us
291        # back here once we're done going down our main-window
292        # rabbit-hole for playlist selection.
293        context.back_state = playwindow.main_window_back_state
294
295    def _set_tab(self, tab_id: TabID) -> None:
296        if self._current_tab is tab_id:
297            return
298        prev_tab_id = self._current_tab
299        self._current_tab = tab_id
300
301        # We wanna preserve our current tab between runs.
302        cfg = bui.app.config
303        cfg['Gather Tab'] = tab_id.value
304        cfg.commit()
305
306        # Update tab colors based on which is selected.
307        self._tab_row.update_appearance(tab_id)
308
309        if prev_tab_id is not None:
310            prev_tab = self._tabs.get(prev_tab_id)
311            if prev_tab is not None:
312                prev_tab.on_deactivate()
313
314        # Clear up prev container if it hasn't been done.
315        if self._tab_container:
316            self._tab_container.delete()
317
318        tab = self._tabs.get(tab_id)
319        if tab is not None:
320            self._tab_container = tab.on_activate(
321                self._root_widget,
322                self._tab_row.tabs[tab_id].button,
323                self._scroll_width,
324                self._scroll_height,
325                self._scroll_left,
326                self._scroll_bottom,
327            )
328            return
329
330    def _save_state(self) -> None:
331        try:
332            for tab in self._tabs.values():
333                tab.save_state()
334
335            sel = self._root_widget.get_selected_child()
336            selected_tab_ids = [
337                tab_id
338                for tab_id, tab in self._tab_row.tabs.items()
339                if sel == tab.button
340            ]
341            if sel == self._back_button:
342                sel_name = 'Back'
343            elif selected_tab_ids:
344                assert len(selected_tab_ids) == 1
345                sel_name = f'Tab:{selected_tab_ids[0].value}'
346            elif sel == self._tab_container:
347                sel_name = 'TabContainer'
348            else:
349                raise ValueError(f'unrecognized selection: \'{sel}\'')
350            assert bui.app.classic is not None
351            bui.app.ui_v1.window_states[type(self)] = {
352                'sel_name': sel_name,
353            }
354        except Exception:
355            logging.exception('Error saving state for %s.', self)
356
357    def _restore_state(self) -> None:
358        try:
359            for tab in self._tabs.values():
360                tab.restore_state()
361
362            sel: bui.Widget | None
363            assert bui.app.classic is not None
364            winstate = bui.app.ui_v1.window_states.get(type(self), {})
365            sel_name = winstate.get('sel_name', None)
366            assert isinstance(sel_name, (str, type(None)))
367            current_tab = self.TabID.ABOUT
368            gather_tab_val = bui.app.config.get('Gather Tab')
369            try:
370                stored_tab = self.TabID(gather_tab_val)
371                if stored_tab in self._tab_row.tabs:
372                    current_tab = stored_tab
373            except ValueError:
374                pass
375            self._set_tab(current_tab)
376            if sel_name == 'Back':
377                sel = self._back_button
378            elif sel_name == 'TabContainer':
379                sel = self._tab_container
380            elif isinstance(sel_name, str) and sel_name.startswith('Tab:'):
381                try:
382                    sel_tab_id = self.TabID(sel_name.split(':')[-1])
383                except ValueError:
384                    sel_tab_id = self.TabID.ABOUT
385                sel = self._tab_row.tabs[sel_tab_id].button
386            else:
387                sel = self._tab_row.tabs[current_tab].button
388            bui.containerwidget(edit=self._root_widget, selected_child=sel)
389
390        except Exception:
391            logging.exception('Error restoring state for %s.', self)