Fix ImageProcessing

tranga-website/src/Components/Settings/AprilFoolsMode.tsx

@@ -23,7 +23,6 @@ export default function ImageProcessing({backendSettings}: {backendSettings?: IB
     const valueChanged = (e : React.ChangeEvent<HTMLInputElement>) => {
         setColor("warning");
         clearTimeout(timerRef.current);
-        console.log(e);
         timerRef.current = setTimeout(() => {
             UpdateAprilFoolsMode(e.target.checked);
         }, 1000);
@@ -33,14 +32,14 @@ export default function ImageProcessing({backendSettings}: {backendSettings?: IB
         setValue(backendSettings?.aprilFoolsMode??false);
     }, [backendSettings]);
 
-    const UpdateAprilFoolsMode = useCallback((value: boolean) => {
+    const UpdateAprilFoolsMode = useCallback((val: boolean) => {
-        UpdateAprilFoolsToggle(apiUri, value)
+        UpdateAprilFoolsToggle(apiUri, val)
             .then(() => GetAprilFoolsToggle(apiUri))
             .then((val) => setValue(val))
             .then(() => setColor("success"))
             .catch(() => setColor("danger"))
             .finally(() => setLoading(false));
-    }, [apiUri, value]);
+    }, [apiUri]);
 
     return (
         <Accordion>

tranga-website/src/Components/Settings/ImageProcessing.tsx

@@ -1,113 +1,101 @@
 import IBackendSettings from "../../api/types/IBackendSettings.ts";
-import {useCallback, useContext, useState} from "react";
+import {ChangeEvent, useCallback, useContext, useEffect, useRef, useState} from "react";
 import {ApiUriContext} from "../../api/fetchApi.tsx";
 import {
     Accordion,
     AccordionDetails,
-    AccordionSummary,
+    AccordionSummary, ColorPaletteProp, Input, Stack, Switch, Typography,
-    ColorPaletteProp,
-    Input,
-    Switch,
-    Typography
 } from "@mui/joy";
-import * as React from "react";
+import {
-import {UpdateBWImageToggle, UpdateImageCompressionValue} from "../../api/BackendSettings.tsx";
+    GetBWImageToggle,
+    GetImageCompressionValue,
+    UpdateBWImageToggle,
+    UpdateImageCompressionValue
+} from "../../api/BackendSettings.tsx";
 
 export default function ImageProcessing ({backendSettings}: { backendSettings?: IBackendSettings }) {
     const apiUri = useContext(ApiUriContext);
 
-    const [loadingBw, setLoadingBw] = useState<boolean>(false);
+    useEffect(() => {
-    const [bwInputColor, setBwInputcolor] = useState<ColorPaletteProp>("neutral");
+        setBwImages(backendSettings?.bwImages??false);
+        setCompression(backendSettings?.compression??100);
+    }, [backendSettings]);
 
-    const timerRefBw = React.useRef<ReturnType<typeof setTimeout>>(undefined);
+    const [bwImages, setBwImages] = useState<boolean>(backendSettings?.bwImages??false);
-    const bwChanged = (e : React.ChangeEvent<HTMLInputElement>) => {
+    const [bwImagesLoading, setBwImagesLoading] = useState(false);
-        setBwInputcolor("warning");
+    const [bwImagesColor, setBwImagesColor] = useState<ColorPaletteProp>("neutral");
-        clearTimeout(timerRefBw.current);
+    const bwTimerRef = useRef<ReturnType<typeof setTimeout>>(undefined);
-        console.log(e);
+    const bwValueChanged = (e : ChangeEvent<HTMLInputElement>) => {
-        timerRefBw.current = setTimeout(() => {
+        setBwImages(e.target.checked);
-            UpdateBw(e.target.checked);
+        setBwImagesColor("warning");
+        clearTimeout(bwTimerRef.current);
+        bwTimerRef.current = setTimeout(() => {
+            UpdateBwImages(e.target.checked);
         }, 1000);
     }
-
+    const UpdateBwImages = useCallback((val : boolean) => {
-    const UpdateBw = useCallback((value: boolean) => {
+        setBwImagesLoading(true);
-        UpdateBWImageToggle(apiUri, value)
+        UpdateBWImageToggle(apiUri, val)
-            .then(() => setBwInputcolor("success"))
+            .then(() => GetBWImageToggle(apiUri))
-            .catch(() => setBwInputcolor("danger"))
+            .then(setBwImages)
-            .finally(() => setLoadingBw(false));
+            .then(() => setBwImagesColor("success"))
+            .catch(() => setBwImagesColor("danger"))
+            .finally(() => setBwImagesLoading(false));
     },[apiUri]);
 
-    const [loadingCompression, setLoadingCompression] = useState<boolean>(false);
+    const [compression, setCompression] = useState<number>(backendSettings?.compression??100);
-    const [compressionInputColor, setCompressionInputColor] = useState<ColorPaletteProp>("neutral");
+    const [compressionLoading, setCompressionLoading] = useState(false);
-    const [compressionEnabled, setCompressionEnabled] = useState<boolean>((backendSettings?.compression??100) < 100);
+    const [compressionColor, setCompressionColor] = useState<ColorPaletteProp>("neutral");
-    const [compressionValue, setCompressionValue] = useState<number|undefined>(backendSettings?.compression);
+    const compressionTimerRef = useRef<ReturnType<typeof setTimeout>>(undefined);
-
+    const compressionCheckedChanged = (e : ChangeEvent<HTMLInputElement>) => {
-    const timerRefCompression = React.useRef<ReturnType<typeof setTimeout>>(undefined);
+        setCompressionColor("warning");
-    const compressionLevelChanged = (e : React.ChangeEvent<HTMLInputElement>) => {
+        if(!e.target.checked)
-        setCompressionInputColor("warning");
+            setCompression(100);
-        setCompressionValue(Number.parseInt(e.target.value));
+        else
-        clearTimeout(timerRefCompression.current);
+            setCompression(50);
-
+        clearTimeout(compressionTimerRef.current);
-        console.log(e);
+        bwTimerRef.current = setTimeout(() => {
-        timerRefCompression.current = setTimeout(() => {
+            UpdateImageCompression(e.target.checked ? 50 : 100);
-            UpdateCompressionLevel(Number.parseInt(e.target.value));
         }, 1000);
     }
-
+    const compressionValueChanged = (e : ChangeEvent<HTMLInputElement>) => {
-    const compressionEnableChanged = (e : React.ChangeEvent<HTMLInputElement>) => {
+        setCompressionColor("warning");
-        setCompressionInputColor("warning");
+        setCompression(parseInt(e.target.value));
-        setCompressionEnabled(e.target.checked);
+        clearTimeout(compressionTimerRef.current);
-        clearTimeout(timerRefCompression.current);
+        bwTimerRef.current = setTimeout(() => {
-        timerRefCompression.current = setTimeout(() => {
+            UpdateImageCompression(parseInt(e.target.value));
-            UpdateCompressionLevel(e.target.checked ? compressionValue! : 100);
         }, 1000);
     }
-
+    const UpdateImageCompression = useCallback((val : number) => {
-    const UpdateCompressionLevel = useCallback((value: number)=> {
+        setCompressionLoading(true);
-        setLoadingCompression(true);
+        UpdateImageCompressionValue(apiUri, val)
-        UpdateImageCompressionValue(apiUri, value)
+            .then(() => GetImageCompressionValue(apiUri))
-            .then(() => {
+            .then(setCompression)
-                setCompressionInputColor("success");
+            .then(() => setCompressionColor("success"))
-                setCompressionValue(value);
+            .catch(() => setCompressionColor("danger"))
-            })
+            .finally(() => setCompressionLoading(false));
-            .catch(() => setCompressionInputColor("danger"))
-            .finally(() => setLoadingCompression(false));
     },[apiUri]);
 
     return (
         <Accordion>
             <AccordionSummary>Image Processing</AccordionSummary>
             <AccordionDetails>
+                <Stack>
                     <Typography endDecorator={
-                    <Switch disabled={backendSettings === undefined || loadingBw}
+                        <Switch disabled={backendSettings === undefined || bwImagesLoading}
-                            onChange={bwChanged}
+                                onChange={bwValueChanged}
-                            color={bwInputColor}
+                                color={bwImagesColor}
-                            defaultChecked={backendSettings?.bwImages} />
+                                checked={bwImages} />
-                }>
+                    }>B/W Images</Typography>
-                    Black and White Images
-                </Typography>
                     <Typography endDecorator={
-                    <Switch disabled={backendSettings === undefined || loadingCompression}
+                        <Input type={"number"} value={compression} onChange={compressionValueChanged} startDecorator={
-                            onChange={compressionEnableChanged}
+                            <Switch disabled={backendSettings === undefined || compressionLoading}
-                            color={compressionInputColor}
+                                    onChange={compressionCheckedChanged}
-                            defaultChecked={compressionEnabled} endDecorator={
+                                    color={compressionColor}
-                        <Input
+                                    checked={compression < 100} />
-                            defaultValue={backendSettings?.compression}
-                            disabled={!compressionEnabled || loadingCompression}
-                            onChange={compressionLevelChanged}
-                            color={compressionInputColor}
-                            onKeyDown={(e) => {
-                                if(e.key === "Enter") {
-                                    clearTimeout(timerRefCompression.current);
-                                    // @ts-ignore
-                                    UpdateCompressionLevel(Number.parseInt(e.target.value));
-                                }
-                            }}
-                            sx={{width:"70px"}}
-                        />
                         } />
-                }>
+                    }>Compression</Typography>
-                    Image Compression
+                </Stack>
-                </Typography>
             </AccordionDetails>
         </Accordion>
     );

tranga-website/src/Settings.tsx

@@ -84,7 +84,7 @@ export default function Settings({open, setOpen, setApiUri, setConnected}:{open:
     }, [checking]);
 
     return (
-        <Drawer size={"md"} open={open} onClose={() => setOpen(false)}>
+        <Drawer size={"lg"} open={open} onClose={() => setOpen(false)}>
             <ModalClose />
             <DialogTitle>Settings</DialogTitle>
             <DialogContent>