fork/replay-manager-for-slippi

git clone https://git.julia.blue/fork/replay-manager-for-slippi

Nicoletofflinemode connect formbb31521

2.5.1
7.9 KiB259 linesraw
1import { Cable, ContentCopy } from '@mui/icons-material';
2import {
3  Alert,
4  Button,
5  CircularProgress,
6  Dialog,
7  DialogContent,
8  DialogTitle,
9  IconButton,
10  InputBase,
11  List,
12  ListItemButton,
13  ListItemText,
14  Stack,
15  TextField,
16  Tooltip,
17} from '@mui/material';
18import { useEffect, useState } from 'react';
19import {
20  OfflineModeStatus,
21  RendererOfflineModeTournament,
22} from '../common/types';
23
24function toLabel(offlineModeStatus: OfflineModeStatus) {
25  return offlineModeStatus.addressOrHost
26    ? 'Offline Mode connected'
27    : 'Connect to Offline Mode';
28}
29
30export function OfflineModeConnectionDialogContent({
31  offlineModeStatus,
32}: {
33  offlineModeStatus: OfflineModeStatus;
34}) {
35  const [offlineModePassword, setOfflineModePassword] = useState('');
36  const [offlineModeHosts, setOfflineModeHosts] = useState<string[]>([]);
37  useEffect(() => {
38    window.electron.onOfflineModeHosts((event, newOfflineModeHosts) => {
39      setOfflineModeHosts(newOfflineModeHosts);
40    });
41    (async () => {
42      const offlineModePasswordPromise =
43        window.electron.getOfflineModePassword();
44      const offlineModeHostsPromise = window.electron.getOfflineModeHosts();
45      setOfflineModePassword(await offlineModePasswordPromise);
46      setOfflineModeHosts(await offlineModeHostsPromise);
47    })();
48  }, []);
49
50  const [addressOrHost, setAddressOrHost] = useState('127.0.0.1');
51  const [passwordCopied, setPasswordCopied] = useState(false);
52  const [addressCopied, setAddressCopied] = useState(false);
53
54  return (
55    <>
56      <DialogTitle>{toLabel(offlineModeStatus)}</DialogTitle>
57      <DialogContent>
58        {offlineModeStatus.addressOrHost ? (
59          <>
60            <Stack
61              alignItems="center"
62              direction="row"
63              gap="8px"
64              marginBottom="8px"
65            >
66              <TextField
67                fullWidth
68                disabled
69                label="Offline Mode password"
70                size="small"
71                type="password"
72                value={offlineModePassword}
73                variant="standard"
74              />
75              <Button
76                disabled={passwordCopied}
77                endIcon={passwordCopied ? undefined : <ContentCopy />}
78                onClick={async () => {
79                  await window.electron.copyToClipboard(offlineModePassword);
80                  setPasswordCopied(true);
81                  setTimeout(() => setPasswordCopied(false), 5000);
82                }}
83                variant="contained"
84              >
85                {passwordCopied ? 'Copied!' : 'Copy'}
86              </Button>
87            </Stack>
88            <Stack direction="row" alignItems="center" spacing="8px">
89              <TextField
90                fullWidth
91                label="Host"
92                size="small"
93                value={offlineModeStatus.addressOrHost}
94                variant="standard"
95              />
96              <Button
97                disabled={addressCopied}
98                endIcon={addressCopied ? undefined : <ContentCopy />}
99                onClick={async () => {
100                  await window.electron.copyToClipboard(
101                    offlineModeStatus.addressOrHost,
102                  );
103                  setAddressCopied(true);
104                  setTimeout(() => setAddressCopied(false), 5000);
105                }}
106                variant="contained"
107              >
108                {addressCopied ? 'Copied!' : 'Copy'}
109              </Button>
110            </Stack>
111          </>
112        ) : (
113          <>
114            <form
115              style={{
116                display: 'flex',
117                flexDirection: 'column',
118                gap: '8px',
119              }}
120              onSubmit={async (event) => {
121                event.preventDefault();
122                event.stopPropagation();
123                await window.electron.setOfflineModePassword(
124                  offlineModePassword,
125                );
126                window.electron.connectToOfflineMode(addressOrHost);
127              }}
128            >
129              <Stack alignItems="center" direction="row" gap="8px">
130                <TextField
131                  fullWidth
132                  label="Offline Mode password"
133                  onChange={(event) => {
134                    setOfflineModePassword(event.target.value);
135                  }}
136                  size="small"
137                  type="password"
138                  value={offlineModePassword}
139                  variant="standard"
140                />
141                <Button
142                  disabled={passwordCopied}
143                  endIcon={passwordCopied ? undefined : <ContentCopy />}
144                  onClick={async () => {
145                    await window.electron.copyToClipboard(offlineModePassword);
146                    setPasswordCopied(true);
147                    setTimeout(() => setPasswordCopied(false), 5000);
148                  }}
149                  variant="contained"
150                >
151                  {passwordCopied ? 'Copied!' : 'Copy'}
152                </Button>
153              </Stack>
154              <Stack alignItems="center" direction="row" gap="8px">
155                <TextField
156                  autoFocus
157                  fullWidth
158                  label="Host"
159                  onChange={(event) => {
160                    setAddressOrHost(event.target.value);
161                  }}
162                  size="small"
163                  style={{ flexGrow: 1 }}
164                  value={addressOrHost}
165                  variant="standard"
166                />
167                <Button
168                  disabled={!addressOrHost}
169                  type="submit"
170                  variant="contained"
171                >
172                  Connect
173                </Button>
174              </Stack>
175            </form>
176            {offlineModeHosts.length === 0 ? (
177              <Stack direction="row" justifyContent="center" margin="8px 0">
178                <CircularProgress />
179              </Stack>
180            ) : (
181              <List>
182                {offlineModeHosts.map((offlineModeHost) => (
183                  <ListItemButton
184                    key={offlineModeHost}
185                    onClick={async () => {
186                      await window.electron.setOfflineModePassword(
187                        offlineModePassword,
188                      );
189                      window.electron.connectToOfflineMode(offlineModeHost);
190                    }}
191                  >
192                    <ListItemText>{offlineModeHost}</ListItemText>
193                  </ListItemButton>
194                ))}
195              </List>
196            )}
197            {offlineModeStatus.error && (
198              <Alert severity="error">{offlineModeStatus.error}</Alert>
199            )}
200          </>
201        )}
202      </DialogContent>
203    </>
204  );
205}
206
207export default function OfflineModeConnection({
208  offlineModeStatus,
209  offlineModeTournament,
210}: {
211  offlineModeStatus: OfflineModeStatus;
212  offlineModeTournament: RendererOfflineModeTournament;
213}) {
214  const [open, setOpen] = useState(false);
215
216  useEffect(() => {
217    if (offlineModeStatus.addressOrHost) {
218      setOpen(false);
219    }
220  }, [offlineModeStatus]);
221
222  return (
223    <Stack direction="row">
224      <InputBase
225        disabled
226        size="small"
227        value={
228          offlineModeTournament.slug ||
229          offlineModeStatus.addressOrHost ||
230          (offlineModeStatus.error ? 'Error!' : 'Connect to Offline Mode...')
231        }
232        style={{ flexGrow: 1 }}
233      />
234      <Tooltip arrow title={toLabel(offlineModeStatus)}>
235        <IconButton
236          onClick={() => {
237            setOpen(true);
238            if (!offlineModeStatus.addressOrHost) {
239              window.electron.listenForOfflineMode();
240            }
241          }}
242        >
243          <Cable />
244        </IconButton>
245      </Tooltip>
246      <Dialog
247        fullWidth
248        open={open}
249        onClose={() => {
250          setOpen(false);
251        }}
252      >
253        <OfflineModeConnectionDialogContent
254          offlineModeStatus={offlineModeStatus}
255        />
256      </Dialog>
257    </Stack>
258  );
259}