mousefox.app.connectpanel

  1"""Home of `ConnectPanel`."""
  2
  3from typing import Callable
  4from dataclasses import dataclass
  5from loguru import logger
  6import json
  7import kvex as kx
  8import pgnet
  9from .. import util
 10
 11
 12LINE_HEIGHT = 40
 13CONFIG_FILE = util.get_appdata_dir() / "connection_config.json"
 14
 15
 16@dataclass
 17class _ConnectionConfig:
 18    online: bool = False
 19    username: str = pgnet.util.ADMIN_USERNAME
 20    address: str = "localhost"
 21    port: int = pgnet.util.DEFAULT_PORT
 22    pubkey: str = ""
 23
 24    @classmethod
 25    def load_from_disk(cls) -> "_ConnectionConfig":
 26        if not CONFIG_FILE.is_file():
 27            return cls()
 28        with open(CONFIG_FILE) as f:
 29            try:
 30                config = json.load(f)
 31            except json.decoder.JSONDecodeError as e:
 32                logger.warning(f"Failed to load connection config: {e}")
 33                return cls()
 34        return cls(**config)
 35
 36    def save_to_disk(self):
 37        data = {k: getattr(self, k) for k in self.__dataclass_fields__.keys()}
 38        with open(CONFIG_FILE, "w") as f:
 39            json.dump(data, f, indent=4)
 40
 41
 42class ConnectPanel(kx.XAnchor):
 43    """Widget enabling creation of clients."""
 44
 45    _conpath = "client.connect"
 46
 47    def __init__(
 48        self,
 49        app_config: "mousefox.AppConfig",  # noqa: F821
 50        on_client: Callable,
 51    ):
 52        """Initialize the class."""
 53        super().__init__()
 54        if app_config.disable_local and app_config.disable_remote:
 55            raise ValueError("Cannot disable both local and remote clients.")
 56        self._client_class = app_config.client_class
 57        self._game_class = app_config.game_class
 58        self._server_factory = app_config.server_factory
 59        self._enable_local = not app_config.disable_local
 60        self._enable_remote = not app_config.disable_remote
 61        self._on_client = on_client
 62        self._make_widgets(app_config.info_text, app_config.online_info_text)
 63        self.app.controller.set_active_callback(self._conpath, self.set_focus)
 64        self.app.controller.bind(f"{self._conpath}.focus", self.set_focus)
 65
 66    def _make_widgets(self, info_text, online_info_text):
 67        self.clear_widgets()
 68        config = _ConnectionConfig.load_from_disk()
 69        if not self._enable_remote and config.online:
 70            config.online = False
 71        elif not self._enable_local and not config.online:
 72            config.online = True
 73        # Side panel
 74        info_label = kx.XLabel(
 75            text=info_text,
 76            valign="top",
 77            halign="left",
 78            padding=(10, 10),
 79            fixed_width=True,
 80        )
 81        online_info_label = kx.XLabel(
 82            text=online_info_text,
 83            valign="top",
 84            halign="left",
 85            padding=(10, 10),
 86            fixed_width=True,
 87        )
 88        self._online_info_label = kx.XCurtain(
 89            content=online_info_label,
 90            showing=config.online,
 91        )
 92        left_labels = kx.XDBox()
 93        left_labels.add_widgets(info_label, self._online_info_label)
 94        left_frame = kx.XBox(orientation="vertical")
 95        left_frame.add_widgets(left_labels, kx.XAnchor())
 96        # Connection details
 97        pwidgets = dict(
 98            online=kx.XInputPanelWidget(
 99                "Online",
100                "bool",
101                default=config.online,
102                bold=True,
103                italic=False,
104                showing=self._enable_local and self._enable_remote,
105            ),
106            username=kx.XInputPanelWidget("Username", default=config.username),
107            password=kx.XInputPanelWidget(
108                "Password",
109                "password",
110                showing=config.online,
111            ),
112            address=kx.XInputPanelWidget(
113                "IP Address",
114                default=config.address,
115                showing=config.online,
116            ),
117            invite_code=kx.XInputPanelWidget(
118                "Invite code",
119                showing=config.online,
120            ),
121            advanced=kx.XInputPanelWidget(
122                "Advanced",
123                "bool",
124                default=False,
125                bold=True,
126                italic=False,
127                showing=config.online,
128            ),
129            port=kx.XInputPanelWidget(
130                "Port number",
131                "int",
132                default=config.port,
133                showing=False,
134            ),
135            pubkey=kx.XInputPanelWidget(
136                "Server verification",
137                default=config.pubkey,
138                showing=False,
139            ),
140        )
141        with self.app.subtheme_context("secondary"):
142            self.connection_panel = kx.XInputPanel(pwidgets, invoke_text="Connect")
143            connection_panel = kx.fwrap(self.connection_panel)
144        self.connection_panel.bind(
145            on_invoke=self._connect,
146            on_values=self._on_connection_values,
147        )
148        # Assemble
149        main_frame = kx.XBox()
150        main_frame.add_widgets(kx.pwrap(left_frame), kx.pwrap(connection_panel))
151        self.add_widget(kx.pwrap(kx.fwrap(main_frame)))
152
153    def _connect(self, *args):
154        self.connection_panel.set_focus("username")
155        get_value = self.connection_panel.get_value
156        online = get_value("online")
157        advanced = online and get_value("advanced")
158        online = get_value("online")
159        username = get_value("username")
160        password = get_value("password")
161        invite_code = get_value("invite_code")
162        address = get_value("address") if online else _ConnectionConfig.address
163        port = get_value("port") if advanced else _ConnectionConfig.port
164        pubkey = get_value("pubkey") if advanced else _ConnectionConfig.pubkey
165        if online:
166            client = self._client_class.remote(
167                address=address,
168                port=port,
169                username=username,
170                password=password,
171                invite_code=invite_code,
172                verify_server_pubkey=pubkey or None,
173            )
174        else:
175            client = self._client_class.local(
176                username=username,
177                password=pgnet.util.DEFAULT_ADMIN_PASSWORD,
178                game=self._game_class,
179                server_factory=self._server_factory,
180            )
181        config = _ConnectionConfig(online, username, address, port, pubkey)
182        config.save_to_disk()
183        self._on_client(client)
184
185    def _on_connection_values(self, w, values: dict):
186        online = values["online"]
187        advanced = online and values["advanced"]
188        self._online_info_label.showing = online
189        for iname in ("password", "address", "invite_code", "advanced"):
190            self.connection_panel.set_showing(iname, online)
191        for iname in ("port", "pubkey"):
192            self.connection_panel.set_showing(iname, advanced)
193
194    def set_focus(self, *args):
195        """Focus the input widgets."""
196        self.connection_panel.set_focus("username")