Snapshot file model, Hotspot restart on config change.

react/src/ObservableEvent.tsx

@@ -0,0 +1,54 @@
+// Copyright (c) 2022 Robin Davies
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO `EVENT` SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+export type ObservableEventHandler<VALUE_TYPE> = (newValue: VALUE_TYPE) => void;
+
+
+export default class ObservableEvent<VALUE_TYPE> {
+
+    private _on_event_handlers: ObservableEventHandler<VALUE_TYPE>[] = [];
+
+
+    addEventHandler(handler: ObservableEventHandler<VALUE_TYPE> ) : void
+    {
+        this._on_event_handlers.push(handler);
+    }
+    removeEventHandler(handler: ObservableEventHandler<VALUE_TYPE> ) : void
+    {
+        let newArray: ObservableEventHandler<VALUE_TYPE>[] = [];
+
+        for (let myHandler of  this._on_event_handlers)
+        {
+            if (myHandler !== handler)
+            {
+                newArray.push(myHandler);
+            }
+        }
+        this._on_event_handlers = newArray;
+    }
+    fire(value: VALUE_TYPE)
+    {
+        for (let handler of this._on_event_handlers)
+        {
+            handler(value);
+        }
+    }
+};

react/src/ObservableProperty.tsx

@@ -12,7 +12,7 @@
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO `EVENT` SHALL THE AUTHORS OR
 // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 // IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

react/src/PerformanceView.tsx

@@ -19,6 +19,7 @@
 
 
 import { Theme } from '@mui/material/styles';
+import SaveIconOutline from '@mui/icons-material/Save';
 import { WithStyles } from '@mui/styles';
 import createStyles from '@mui/styles/createStyles';
 import withStyles from '@mui/styles/withStyles';
@@ -78,6 +79,7 @@ interface PerformanceViewState {
     banks: BankIndex;
     showSnapshotEditor: boolean;
     snapshotEditorIndex: number;
+    presetModified: boolean;
 }
 
 
@@ -97,11 +99,13 @@ export const PerformanceView =
                     banks: this.model.banks.get(),
                     wrapSelects: false,
                     showSnapshotEditor: false,
-                    snapshotEditorIndex: 0
+                    snapshotEditorIndex: 0,
+                    presetModified: this.model.presetChanged.get()
                 };
                 this.onPresetsChanged = this.onPresetsChanged.bind(this);
                 this.onBanksChanged = this.onBanksChanged.bind(this);
                 this.handlePopState = this.handlePopState.bind(this);
+                this.onPresetChangedChanged = this.onPresetChangedChanged.bind(this);
 
             }
 
@@ -181,6 +185,9 @@ export const PerformanceView =
             onBanksChanged(newValue: BankIndex) {
                 this.setState({ banks: this.model.banks.get() })
             }
+            onPresetChangedChanged(newValue: boolean) {
+                this.setState({ presetModified:newValue});
+            }
 
             private mounted: boolean = false;
             componentDidMount(): void {
@@ -188,9 +195,12 @@ export const PerformanceView =
                 this.mounted = true;
                 this.model.presets.addOnChangedHandler(this.onPresetsChanged);
                 this.model.banks.addOnChangedHandler(this.onBanksChanged);
+                this.model.presetChanged.addOnChangedHandler(this.onPresetChangedChanged)
                 this.setState({
                     presets: this.model.presets.get(),
-                    banks: this.model.banks.get()
+                    banks: this.model.banks.get(),
+                    presetModified: this.model.presetChanged.get()
+
                 });
 
                 this.updateHooks();
@@ -200,7 +210,7 @@ export const PerformanceView =
 
 
             componentWillUnmount(): void {
-
+                this.model.presetChanged.removeOnChangedHandler(this.onPresetChangedChanged)
                 this.model.presets.removeOnChangedHandler(this.onPresetsChanged);
                 this.model.banks.removeOnChangedHandler(this.onBanksChanged);
 
@@ -332,13 +342,27 @@ export const PerformanceView =
                                             <IconButton
                                                 aria-label="next-bank"
                                                 onClick={() => { this.handleNextBank(); }}
-                                                size="large"
                                                 color="inherit"
                                                 style={{ borderTopLeftRadius: "3px", borderBottomLeftRadius: "3px", marginLeft: 4 }}
                                             >
                                                 <ArrowForwardIosIcon style={{ opacity: 0.75 }} />
+                                                
                                             </IconButton>
 
+                                            {/** spacer */}
+                                            <IconButton
+                                                aria-label="next-bank"
+                                                onClick={() => { this.handleNextBank(); }}
+                                                size="medium"
+                                                color="inherit"
+                                                style={{visibility: "hidden"}}
+                                            >
+                                                <ArrowForwardIosIcon style={{ opacity: 0.75 }} />
+                                                
+                                            </IconButton>
+
+                                            
+
                                         </div>
                                         {/********* PRESETS *******************/}
                                         <div style={{ flex: "1 1 1px", display: "flex", flexFlow: "row nowrap", maxWidth: 500 }}>
@@ -367,9 +391,14 @@ export const PerformanceView =
                                             >
                                                 {
                                                     presets.presets.map((preset) => {
+                                                        let name = preset.name;
+                                                        if (this.state.presets.selectedInstanceId === preset.instanceId && this.state.presetModified)
+                                                        {
+                                                            name += "*";
+                                                        }
                                                         return (
                                                             <MenuItem key={preset.instanceId} value={preset.instanceId} >
-                                                                {preset.name}
+                                                                {name}
                                                             </MenuItem>
                                                         );
                                                     })
@@ -385,6 +414,16 @@ export const PerformanceView =
                                                 <ArrowForwardIosIcon style={{ opacity: 0.75 }} />
                                             </IconButton>
 
+                                            <IconButton
+                                                aria-label="save-preset"
+                                                onClick={() => { this.model.saveCurrentPreset(); }}
+                                                size="medium"
+                                                color="inherit"
+                                                style={{flexShrink: 0,visibility: this.state.presetModified? "visible": "hidden"}}
+                                            >
+                                                <SaveIconOutline style={{ opacity: 0.75 }} color="inherit" />                                                
+                                            </IconButton>
+
                                         </div>
                                     </div>
                                 </div>

react/src/PiPedalModel.tsx

@@ -21,6 +21,7 @@ import { UiPlugin, UiControl, PluginType, UiFileProperty } from './Lv2Plugin';
 
 import { PiPedalArgumentError, PiPedalStateError } from './PiPedalError';
 import { UpdateStatus, UpdatePolicyT } from './Updater';
+import ObservableEvent from './ObservableEvent';
 import { ObservableProperty } from './ObservableProperty';
 import { Pedalboard, PedalboardItem, ControlValue, Snapshot } from './Pedalboard'
 import PluginClass from './PluginClass';
@@ -362,6 +363,11 @@ export interface FavoritesList {
     [url: string]: boolean;
 };
 
+export interface SnapshotModifiedEvent {
+    snapshotIndex: number;
+    modified: boolean;
+};
+
 
 export class PiPedalModel //implements PiPedalModel 
 {
@@ -376,6 +382,9 @@ export class PiPedalModel //implements PiPedalModel
     webSocket?: PiPedalSocket;
 
 
+
+    onSnapshotModified: ObservableEvent<SnapshotModifiedEvent> = new ObservableEvent<SnapshotModifiedEvent>();
+
     ui_plugins: ObservableProperty<UiPlugin[]>
         = new ObservableProperty<UiPlugin[]>([]);
     state: ObservableProperty<State> = new ObservableProperty<State>(State.Loading);
@@ -503,6 +512,7 @@ export class PiPedalModel //implements PiPedalModel
     private setModelPedalboard(pedalboard: Pedalboard) {
         this.pedalboard.set(pedalboard);
         this.selectedSnapshot.set(pedalboard.selectedSnapshot);
+
     }
     onSocketMessage(header: PiPedalMessageHeader, body?: any) {
         if (this.visibilityState.get() === VisibilityState.Hidden) return;
@@ -564,6 +574,21 @@ export class PiPedalModel //implements PiPedalModel
             let channelSelectionBody = body as ChannelSelectionChangedBody;
             let channelSelection = new JackChannelSelection().deserialize(channelSelectionBody.jackChannelSelection);
             this.jackSettings.set(channelSelection);
+        } else if (message === "onSnapshotModified") {
+            let {snapshotIndex,modified} = (body as {snapshotIndex: number, modified: boolean});
+            let snapshots = this.pedalboard.get().snapshots;
+            if (snapshotIndex >= 0 && snapshotIndex < snapshots.length)
+            {
+                let snapshot = snapshots[snapshotIndex]
+                if (snapshot)
+                {
+                    if (snapshot.isModified !== modified)
+                    {
+                        snapshot.isModified = modified;
+                        this.onSnapshotModified.fire({snapshotIndex: snapshotIndex,modified: modified});
+                    }
+                }
+            }
         } else if (message === "onSelectedSnapshotChanged") {
             let selectedSnapshot = body as number;
             this.pedalboard.get().selectedSnapshot = selectedSnapshot;
@@ -581,6 +606,7 @@ export class PiPedalModel //implements PiPedalModel
             let presetsChangedBody = body as PresetsChangedBody;
             let presets = new PresetIndex().deserialize(presetsChangedBody.presets);
             this.presets.set(presets);
+            this.presetChanged.set(presets.presetChanged);
         } else if (message === "onPluginPresetsChanged") {
             let pluginUri = body as string;
             this.handlePluginPresetsChanged(pluginUri);
@@ -1286,7 +1312,6 @@ export class PiPedalModel //implements PiPedalModel
             changed = item.setControlValue(controlValue.key, controlValue.value) || changed;
         }
         if (changed) {
-            newPedalboard.selectedSnapshot = -1;
             this.setModelPedalboard(newPedalboard);
         }
     }
@@ -1428,7 +1453,6 @@ export class PiPedalModel //implements PiPedalModel
         if (pedalboard.input_volume_db !== volume_db) {
             let newPedalboard = pedalboard.clone();
             newPedalboard.input_volume_db = volume_db;
-            newPedalboard.selectedSnapshot = -1;
             this.setModelPedalboard(newPedalboard);
             changed = true;
         }
@@ -1457,7 +1481,6 @@ export class PiPedalModel //implements PiPedalModel
         if (pedalboard.output_volume_db !== volume_db) {
             let newPedalboard = pedalboard.clone();
             newPedalboard.output_volume_db = volume_db;
-            newPedalboard.selectedSnapshot = -1;
             this.setModelPedalboard(newPedalboard);
             changed = true;
         }
@@ -1494,7 +1517,6 @@ export class PiPedalModel //implements PiPedalModel
             if (notifyServer) {
                 this._setServerControl("setControl", instanceId, key, value);
             }
-            newPedalboard.selectedSnapshot = -1;
             this.setModelPedalboard(newPedalboard);
             for (let i = 0; i < this._controlValueChangeItems.length; ++i) {
                 let item = this._controlValueChangeItems[i];
@@ -1547,7 +1569,6 @@ export class PiPedalModel //implements PiPedalModel
         let changed = value !== item.isEnabled;
         if (changed) {
             item.isEnabled = value;
-            newPedalboard.selectedSnapshot = -1;
             this.setModelPedalboard(newPedalboard);
             if (notifyServer) {
                 let body: PedalboardItemEnableBody = {
@@ -1605,7 +1626,6 @@ export class PiPedalModel //implements PiPedalModel
                     //  null -> we've never seen a value.
                     item.pathProperties[fileProperty.patchProperty] = "null";
                 }
-                newPedalboard.selectedSnapshot = -1;
                 this.setModelPedalboard(newPedalboard);
                 this.updateServerPedalboard()
                 return item.instanceId;
@@ -1646,7 +1666,6 @@ export class PiPedalModel //implements PiPedalModel
 
         let result = newPedalboard.deleteItem(instanceId);
         if (result !== null) {
-            newPedalboard.selectedSnapshot = -1;
             this.setModelPedalboard(newPedalboard);
             this.updateServerPedalboard();
         }
@@ -1669,7 +1688,6 @@ export class PiPedalModel //implements PiPedalModel
         newPedalboard.deleteItem(fromInstanceId);
 
         newPedalboard.addBefore(fromItem, toInstanceId);
-        newPedalboard.selectedSnapshot = -1;
         this.setModelPedalboard(newPedalboard);
         this.updateServerPedalboard();
 
@@ -1690,7 +1708,6 @@ export class PiPedalModel //implements PiPedalModel
 
         newPedalboard.addAfter(fromItem, toInstanceId);
 
-        newPedalboard.selectedSnapshot = -1;
         this.setModelPedalboard(newPedalboard);
         this.updateServerPedalboard();
     }
@@ -1712,7 +1729,6 @@ export class PiPedalModel //implements PiPedalModel
 
         newPedalboard.addToStart(fromItem);
 
-        newPedalboard.selectedSnapshot = -1;
         this.setModelPedalboard(newPedalboard);
         this.updateServerPedalboard();
     }
@@ -1732,7 +1748,6 @@ export class PiPedalModel //implements PiPedalModel
 
         newPedalboard.addToEnd(fromItem);
 
-        newPedalboard.selectedSnapshot = -1;
         this.setModelPedalboard(newPedalboard);
 
         this.updateServerPedalboard();
@@ -1761,7 +1776,6 @@ export class PiPedalModel //implements PiPedalModel
         newPedalboard.replaceItem(fromInstanceId, emptyItem);
         newPedalboard.replaceItem(toInstanceId, fromItem);
 
-        newPedalboard.selectedSnapshot = -1;
         this.setModelPedalboard(newPedalboard);
         this.updateServerPedalboard();
 
@@ -1785,7 +1799,6 @@ export class PiPedalModel //implements PiPedalModel
         }
         let newItem = newPedalboard.createEmptyItem();
         newPedalboard.addItem(newItem, instanceId, append);
-        newPedalboard.selectedSnapshot = -1;
         this.setModelPedalboard(newPedalboard);
         this.updateServerPedalboard();
         return newItem.instanceId;
@@ -1811,7 +1824,6 @@ export class PiPedalModel //implements PiPedalModel
         }
         let newItem = newPedalboard.createEmptySplit();
         newPedalboard.addItem(newItem, instanceId, append);
-        newPedalboard.selectedSnapshot = -1;
         this.setModelPedalboard(newPedalboard);
         this.updateServerPedalboard();
         return newItem.instanceId;
@@ -1829,7 +1841,6 @@ export class PiPedalModel //implements PiPedalModel
         }
         newPedalboard.setItemEmpty(item);
 
-        newPedalboard.selectedSnapshot = -1;
         this.setModelPedalboard(newPedalboard);
         this.updateServerPedalboard();
         return item.instanceId;
@@ -2332,7 +2343,6 @@ export class PiPedalModel //implements PiPedalModel
         let newPedalboard = pedalboard.clone();
         this.updateVst3State(newPedalboard);
         if (newPedalboard.setMidiBinding(instanceId, midiBinding)) {
-            newPedalboard.selectedSnapshot = -1;
             this.setModelPedalboard(newPedalboard);
 
 

react/src/SnapshotButton.tsx

@@ -0,0 +1,212 @@
+/*
+* MIT License
+* 
+* Copyright (c) 2024 Robin E. R. Davies
+* 
+* Permission is hereby granted, free of charge, to any person obtaining a copy of
+* this software and associated documentation files (the "Software"), to deal in
+* the Software without restriction, including without limitation the rights to
+* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+* of the Software, and to permit persons to whom the Software is furnished to do
+* so, subject to the following conditions:
+* 
+* The above copyright notice and this permission notice shall be included in all
+* copies or substantial portions of the Software.
+* 
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*/
+
+import React from 'react';
+import Typography from '@mui/material/Typography';
+import IconButton from '@mui/material/IconButton';
+import ButtonBase from '@mui/material/ButtonBase';
+import ResizeResponsiveComponent from './ResizeResponsiveComponent';
+import SaveIconOutline from '@mui/icons-material/Save';
+import Button from "@mui/material/Button";
+import EditIconOutline from '@mui/icons-material/Edit';
+import { Snapshot } from './Pedalboard';
+
+import { colorKeys, getBackgroundColor, getBorderColor } from './MaterialColors';
+import { PiPedalModel, PiPedalModelFactory, SnapshotModifiedEvent } from './PiPedalModel';
+
+export interface SnapshotButtonProps {
+    snapshot: Snapshot | null;
+    snapshotIndex: number;
+    selected: boolean;
+    largeText: boolean;
+    collapseButtons: boolean;
+
+    onEditSnapshot: (index: number) => void;
+    onSaveSnapshot: (index: number) => void;
+    onSelectSnapshot: (index: number) => void;
+};
+
+export interface SnapshotButtonState {
+    modified: boolean;
+};
+
+export default class SnapshotButton extends ResizeResponsiveComponent<SnapshotButtonProps, SnapshotButtonState> {
+    private model: PiPedalModel;
+
+    constructor(props: SnapshotButtonProps) {
+        super(props);
+        this.state = {
+            modified: this.props.snapshot?.isModified ?? false,
+        };
+        this.model = PiPedalModelFactory.getInstance();
+        this.onSnapshotModified = this.onSnapshotModified.bind(this);
+
+    }
+
+    onWindowSizeChanged(width: number, height: number): void {
+
+    }
+
+    onSnapshotModified(event: SnapshotModifiedEvent) {
+        if (event.snapshotIndex === this.props.snapshotIndex) {
+            this.setState({ modified: event.modified });
+        }
+    }
+    componentDidMount(): void {
+        super.componentDidMount?.();
+        this.model.onSnapshotModified.addEventHandler(this.onSnapshotModified);
+    }
+    componentWillUnmount(): void {
+        this.model.onSnapshotModified.removeEventHandler(this.onSnapshotModified);
+        super.componentWillUnmount();
+    }
+    componentDidUpdate(
+        prevProps: Readonly<SnapshotButtonProps>,
+        prevState: Readonly<SnapshotButtonState>): void {
+        super.componentDidUpdate?.(prevProps, prevState);
+
+        if (this.props.snapshot !== prevProps.snapshot) {
+            this.setState({
+                modified: this.props.snapshot?.isModified ?? false
+            })
+        }
+    }
+
+    render() {
+        let { snapshot, snapshotIndex, selected } = this.props;
+        let { modified } = this.state;
+
+        // (snapshot: Snapshot | null, index: number) {
+        //let state = this.state;
+        let color: string;
+        let bordercolor: string;
+        if (snapshot) {
+            if (colorKeys.indexOf(snapshot.color) === -1) {
+                bordercolor = color = snapshot.color;
+            } else {
+                color = getBackgroundColor(snapshot.color);
+                bordercolor = getBorderColor(snapshot.color);
+            }
+        } else {
+            bordercolor = color = getBackgroundColor("grey");
+        }
+        let title = snapshot ? snapshot.name : "<unassigned>";
+        if (modified) {
+            title = title + "*";
+        }
+        let disabled = snapshot === null;
+        return (
+            <div style={{ display: "flex", position: "relative", flexGrow: 1, flexBasis: 1, flexFlow: "column nowrap", alignItems: "stretch", borderRadius: 16 }}>
+
+                <ButtonBase style={{
+                    display: "flex", flexGrow: 1, flexBasis: 1, flexFlow: "column nowrap", alignItems: "stretch", borderRadius: 16,
+                    background: color,
+                    boxShadow: "1px 3px 6px #00000090"
+                }}
+                    onMouseDown={(ev) => {
+                        if (!selected) ev.stopPropagation();
+                    }}
+
+                    onClick={() => { if (snapshot) this.props.onSelectSnapshot(snapshotIndex); }}
+                >
+                    <div
+                        style={{ flexGrow: 1, flexShrink: 1, display: "flex", flexFlow: "column nowrap", alignItems: "stretch" }}
+                        onMouseDown={(ev) => {
+                            if (disabled) ev.stopPropagation();
+                        }}
+                    >
+                        <div style={{
+                            flexGrow: 1, flexShrink: 1, display: "flex", flexFlow: "column nowrap", alignItems: "stretch", justifyContent: "center", margin: 6,
+                            borderColor: selected ? bordercolor : "transparent", borderStyle: "solid", borderWidth: 3, borderRadius: 10
+                        }}
+                        >
+                            <div style={{ flexGrow: 1, display: "flex", alignItems: "center", justifyContent: "center" }}>
+
+                                <Typography display="block" color="textPrimary" align="center" variant="body1"
+                                    style={{ fontSize: this.props.largeText ? "30px" : undefined }}
+                                >{title}</Typography>
+                            </div>
+                            <Typography variant="h3"
+                                style={{
+                                    position: "absolute",bottom: 0, left: 0, paddingBottom: 12, paddingLeft: 16, paddingRight: 12,
+                                    pointerEvents: "none", opacity: 0.15, fontSize: "44px", fontWeight: 900, fontFamily: "Arial Black", fontStyle: "italic"
+                                }}
+                            >
+                                {(snapshotIndex + 1).toString()}
+                            </Typography>
+                            <div style={{ height: 54, flexGrow: 0, flexShrink: 0 }}>
+                                {/* placeholder where we will float the buttons, which can't be witin another button (tons of DOM validation warning messages in chrome) */}
+                            </div>
+
+                        </div>
+                    </div>
+                </ButtonBase >
+
+                <div style={{ flexGrow: 0, position: "absolute", bottom: 0, right: 0, paddingBottom: 12, marginRight: 12 }} >
+                    {!this.props.collapseButtons ? (
+                        <div style={{ marginRight: 8, display: "flex", flexFlow: "row nowrap" }}>
+                            <Button variant="dialogSecondary" startIcon={<SaveIconOutline />} color="inherit" style={{ textTransform: "none" }}
+                                onMouseDown={(ev) => { ev.stopPropagation(); /*don't prop to card*/ }}
+                                onMouseUp={(ev) => { ev.stopPropagation(); /*don't prop to card*/ }}
+                                disabled={false}
+                                onClick={(ev) => { ev.stopPropagation(); this.props.onSaveSnapshot(snapshotIndex); }}
+
+                            >
+                                Save
+                            </Button>
+                            <Button variant="dialogSecondary" color="inherit" startIcon={<EditIconOutline />} style={{ textTransform: "none" }}
+                                onMouseDown={(ev) => { ev.stopPropagation();  /*don't prop to card*/ }}
+                                onMouseUp={(ev) => { ev.stopPropagation(); /*don't prop to card*/ }}
+                                disabled={disabled}
+                                onClick={(ev) => { ev.stopPropagation(); this.props.onEditSnapshot(snapshotIndex); }}
+
+                            >
+                                Edit
+                            </Button>
+                        </div>
+
+                    ) : (
+                        <div style={{ marginLeft: "auto", marginRight: 8, display: "flex", flexFlow: "row nowrap" }}>
+                            <div style={{ flexGrow: 1, flexBasis: 1 }} >&nbsp;</div>
+                            <IconButton color="inherit" style={{ opacity: 0.66 }} disabled={false}
+                                onMouseDown={(ev) => { ev.stopPropagation(); /*don't prop to card*/ }}
+                                onClick={() => { this.props.onSaveSnapshot(snapshotIndex); }}
+                            >
+                                <SaveIconOutline />
+                            </IconButton>
+                            <IconButton color="inherit" disabled={disabled} style={{ opacity: 0.66 }}
+                                onMouseDown={(ev) => { ev.stopPropagation();  /*don't prop to card*/ }}
+                                onClick={() => { this.props.onEditSnapshot(snapshotIndex); }}
+
+                            >
+                                <EditIconOutline />
+                            </IconButton>
+                        </div>
+                    )}
+                </div>
+            </div >
+        );
+    }
+}
+

react/src/SnapshotEditor.tsx

@@ -216,8 +216,23 @@ const SnapshotEditor = withStyles(appStyles)(class extends ResizeResponsiveCompo
     }
 
     handleOk() {
-        let selectedSnapshot = this.props.snapshotIndex;
         let currentPedalboard = this.model_.pedalboard.get();
+        let selectedSnapshot = this.props.snapshotIndex;
+        let currentSnapshot: Snapshot | null = currentPedalboard.snapshots[selectedSnapshot];
+        if (!currentSnapshot) 
+        {
+            this.props.onClose();
+            return;
+        }
+
+        let changed = this.state.name !== currentSnapshot.name 
+            || this.state.color !== currentSnapshot.color
+            || currentSnapshot.isModified;
+        if (!changed)
+        {
+            this.props.onClose();
+            return;
+        }
         let newSnapshots = Snapshot.cloneSnapshots(currentPedalboard.snapshots);
         let newSnapshot = this.model_.pedalboard.get().makeSnapshot();
         newSnapshot.name = this.state.name;

react/src/SnapshotPanel.tsx

@@ -22,18 +22,12 @@
 * SOFTWARE.
 */
 
-import Typography from '@mui/material/Typography';
+import SnapshotButton from './SnapshotButton';
-import IconButton from '@mui/material/IconButton';
-import ButtonBase from '@mui/material/ButtonBase';
 import { Pedalboard, Snapshot } from './Pedalboard';
 import { PiPedalModel, PiPedalModelFactory } from './PiPedalModel';
 import ResizeResponsiveComponent from './ResizeResponsiveComponent';
-import SaveIconOutline from '@mui/icons-material/Save';
-import Button from "@mui/material/Button";
-import EditIconOutline from '@mui/icons-material/Edit';
 
 import SnapshotPropertiesDialog from './SnapshotPropertiesDialog';
-import { colorKeys, getBackgroundColor, getBorderColor } from './MaterialColors';
 
 
 
@@ -100,7 +94,7 @@ export default class SnapshotPanel extends ResizeResponsiveComponent<SnapshotPan
     }
 
     onSelectedSnapshotChanged(value: number) {
-        this.setState({ selectedSnapshot: this.getSelectedSnapshot() })
+        this.setState({ selectedSnapshot: value })
     }
     onPedalboardChanged(value: Pedalboard) {
         // boofs our current edit, oh well. we can't track property across a structural change.
@@ -193,110 +187,17 @@ export default class SnapshotPanel extends ResizeResponsiveComponent<SnapshotPan
         this.model.selectSnapshot(index);
     }
     renderSnapshot(snapshot: Snapshot | null, index: number) {
-        //let state = this.state;
-        let color: string;
-        let bordercolor: string;
-        if (snapshot) {
-            if (colorKeys.indexOf(snapshot.color) === -1) {
-                bordercolor = color = snapshot.color;
-            } else {
-                color = getBackgroundColor(snapshot.color);
-                bordercolor = getBorderColor(snapshot.color);
-            }
-        } else {
-            bordercolor = color = getBackgroundColor("grey");
-        }
-        let title = snapshot ? snapshot.name : "<unassigned>";
-        let disabled = snapshot === null;
-        let selected = this.state.selectedSnapshot === index;
         return (
-            <div style={{ display: "flex", position: "relative",flexGrow: 1, flexBasis: 1, flexFlow: "column nowrap", alignItems: "stretch", borderRadius: 16 }}>
+            <SnapshotButton key={"s"+index}
-
+                snapshot={snapshot}
-                <ButtonBase style={{
+                snapshotIndex={index}
-                    display: "flex", flexGrow: 1, flexBasis: 1, flexFlow: "column nowrap", alignItems: "stretch", borderRadius: 16,
+                collapseButtons={this.state.collapseButtons}
-                    background: color,
+                selected={this.state.selectedSnapshot === index}
-                    boxShadow: "1px 3px 6px #00000090"
+                largeText={this.state.largeText}
-                }}
+                onEditSnapshot={(index)=>{this.onEditSnapshot(index)}}
-                    onMouseDown={(ev) => {
+                onSaveSnapshot={(index)=>{ this.onSaveSnapshot(index); }}
-                        if (!selected) ev.stopPropagation();
+                onSelectSnapshot={(index)=>{this.model.selectSnapshot(index);}}
-                    }}
+            />
-
-                    onClick={() => { if (snapshot) this.selectSnapshot(index); }}
-                >
-                    <div
-                        style={{ flexGrow: 1, flexShrink: 1, display: "flex", flexFlow: "column nowrap", alignItems: "stretch" }}
-                        onMouseDown={(ev) => {
-                            if (disabled) ev.stopPropagation();
-                        }}
-                    >
-                        <div style={{
-                            flexGrow: 1, flexShrink: 1, display: "flex", flexFlow: "column nowrap", alignItems: "stretch", justifyContent: "center", margin: 6,
-                            borderColor: selected ? bordercolor : "transparent", borderStyle: "solid", borderWidth: 3, borderRadius: 10
-                        }}
-                        >
-                            <div style={{ flexGrow: 1, display: "flex", alignItems: "center", justifyContent: "center" }}>
-
-                                <Typography display="block" color="textPrimary" align="center" variant="body1"
-                                    style={{ fontSize: this.state.largeText ? "30px" : undefined }}
-                                >{title}</Typography>
-                            </div>
-                            <div style={{ height: 54,flexGrow: 0,flexShrink: 0 }}>
-                                {/* placeholder where we will float the buttons, which can't be witin another button (tons of DOM validation warning messages in chrome) */}
-                            </div>
-
-                        </div>
-                    </div>
-                </ButtonBase >
-                <div style={{ flexGrow: 0, position: "absolute", bottom:0,left:0,right:0,paddingBottom:10,paddingLeft: 16, paddingRight:12 }} >
-                    <Typography variant="h3" style={{opacity: 0.15,fontSize: "44px",fontWeight:900,fontFamily: "Arial Black",fontStyle: "italic"}} >{(index+1).toString()}</Typography>
-                </div>
-
-                <div style={{ flexGrow: 0, position: "absolute", bottom:0,left:0,right:0,paddingBottom:12,paddingLeft: 12, paddingRight:12 }} >
-                        {!this.state.collapseButtons ? (
-                            <div style={{ marginRight: 8, display: "flex", flexFlow: "row nowrap" }}>
-                                <div style={{ flexGrow: 1, flexBasis: 1 }} >&nbsp;</div>
-                                <Button variant="dialogSecondary" startIcon={<SaveIconOutline />} color="inherit" style={{ textTransform: "none" }}
-                                    onMouseDown={(ev) => { ev.stopPropagation(); /*don't prop to card*/ }}
-                                    onMouseUp={(ev) => { ev.stopPropagation(); /*don't prop to card*/ }}
-                                    disabled={false}
-                                    onClick={(ev) => { ev.stopPropagation(); this.onSaveSnapshot(index); }}
-
-                                >
-                                    Save
-                                </Button>
-                                <Button variant="dialogSecondary" color="inherit" startIcon={<EditIconOutline />} style={{ textTransform: "none" }}
-                                    onMouseDown={(ev) => { ev.stopPropagation();  /*don't prop to card*/ }}
-                                    onMouseUp={(ev) => { ev.stopPropagation(); /*don't prop to card*/ }}
-                                    disabled={disabled}
-                                    onClick={(ev) => { ev.stopPropagation(); this.onEditSnapshot(index); }}
-
-                                >
-                                    Edit
-                                </Button>
-                            </div>
-
-                        ) : (
-                            <div style={{ marginLeft: "auto", marginRight: 8, display: "flex", flexFlow: "row nowrap" }}>
-                                <div style={{ flexGrow: 1, flexBasis: 1 }} >&nbsp;</div>
-                                <IconButton color="inherit" style={{ opacity: 0.66 }} disabled={false}
-                                    onMouseDown={(ev) => { ev.stopPropagation(); /*don't prop to card*/ }}
-                                    onClick={() => { this.onSaveSnapshot(index); }}
-                                >
-                                    <SaveIconOutline />
-                                </IconButton>
-                                <IconButton color="inherit" disabled={disabled} style={{ opacity: 0.66 }}
-                                    onMouseDown={(ev) => { ev.stopPropagation();  /*don't prop to card*/ }}
-                                    onClick={() => { this.onEditSnapshot(index); }}
-
-                                >
-                                    <EditIconOutline />
-                                </IconButton>
-                            </div>
-
-                        )}
-
-                    </div>
-            </div >
         );
     }
 

src/AudioHost.cpp

@@ -177,16 +177,24 @@ namespace pipedal
                             std::istringstream ss(pathProperty.second);
                             json_reader reader(ss);
                             reader.read(&vProperty);
-                            vProperty = pluginHost.MapPath(vProperty);
+                            if (!vProperty.is_null())
+                            {
+                                try {
+                                    vProperty = pluginHost.MapPath(vProperty);
 
-                            // now to atom format (what we want on the rt thread0)
+                                    // now to atom format (what we want on the rt thread0)
-                            AtomConverter atomConverter(pluginHost.GetMapFeature());
+                                    AtomConverter atomConverter(pluginHost.GetMapFeature());
-                            LV2_Atom *atomValue = atomConverter.ToAtom(vProperty);
+                                    LV2_Atom *atomValue = atomConverter.ToAtom(vProperty);
 
-                            size_t atomBufferSize = (atomValue->size + sizeof(LV2_Atom) + 3) / 4 * 4;
+                                    size_t atomBufferSize = (atomValue->size + sizeof(LV2_Atom) + 3) / 4 * 4;
-                            pathPatchProperty.atomBuffer.resize(atomValue->size + sizeof(LV2_Atom));
+                                    pathPatchProperty.atomBuffer.resize(atomValue->size + sizeof(LV2_Atom));
-                            memcpy(pathPatchProperty.atomBuffer.data(), atomValue, pathPatchProperty.atomBuffer.size());
+                                    memcpy(pathPatchProperty.atomBuffer.data(), atomValue, pathPatchProperty.atomBuffer.size());
-                            this->pathPatchProperties.push_back(std::move(pathPatchProperty));
+                                    this->pathPatchProperties.push_back(std::move(pathPatchProperty));
+                                } catch (const std::exception &e)
+                                {
+                                    Lv2Log::info(SS("IndexedSnapshotValue: Failed to map path property " << pathProperty.first << ". " << e.what()));
+                                }
+                            }
                         }
                     }
                 }

src/HotspotManager.cpp

@@ -37,7 +37,7 @@ using namespace dbus::networkmanager;
 namespace pipedal::impl
 {
 
-    #define PIPEDAL_HOTSPOT_NAME "PiPedal Hotspot"
+#define PIPEDAL_HOTSPOT_NAME "PiPedal Hotspot"
 
     class HotspotManagerImpl : public HotspotManager
     {
@@ -164,19 +164,20 @@ void HotspotManagerImpl::Open()
 
 void HotspotManagerImpl::onClose()
 {
-    this->closed  = true; // avoids a memory barrier probelm.
+    this->closed = true; // avoids a memory barrier probelm.
 
     CancelDeviceChangedTimer();
     CancelWaitForNetworkManagerTimer();
     CancelAccessPointsChangedTimer();
 
-
     if (networkManager && activeConnection)
     {
-        try {
+        try
+        {
             networkManager->DeactivateConnection(activeConnection->getObjectPath());
             activeConnection = nullptr;
-        } catch (const std::exception&e)
+        }
+        catch (const std::exception &e)
         {
             // nothrow.
         }
@@ -443,16 +444,31 @@ void HotspotManagerImpl::onReload()
     if (closed)
         return;
     WifiConfigSettings oldSettings = this->wifiConfigSettings;
-    ;
+    this->wifiConfigSettings.Load();
-    wifiConfigSettings.Load();
+    if (wifiConfigSettings == oldSettings)
+    {
+        return;
+    }
 
     switch (state)
     {
-    case State::Initial:
     case State::Error:
-        // ignore.
+        Lv2Log::error("NetworkManager is in an error state. Reboot and try again.");
         return;
+    case State::Initial:
+    case State::WaitingForNetworkManager:
+        // ignore. new config will be picked up once initialization completes.
+        return;
+
+    case State::Closed:
+        return;
+
+    case State::HotspotConnecting:
+    case State::HotspotConnected:
     default:
+        // force a reload.
+        StopHotspot(); 
+        SetState(State::Monitoring);
         MaybeStartHotspot();
         return;
     }
@@ -536,7 +552,8 @@ void HotspotManagerImpl::UpdateKnownNetworks(
     }
     for (auto &accessPoint : allAccessPoints)
     {
-        try {
+        try
+        {
             uint8_t strength = accessPoint->Strength();
             auto vSsid = accessPoint->Ssid();
             std::string ssid = ssidToString(vSsid);
@@ -547,7 +564,8 @@ void HotspotManagerImpl::UpdateKnownNetworks(
                 record.visibleNetwork = true;
                 record.strength = strength;
             }
-        } catch (const std::exception&ignored)
+        }
+        catch (const std::exception &ignored)
         {
             // race to get the info before it changes. np.
         }
@@ -819,8 +837,6 @@ void HotspotManagerImpl::StartHotspot()
             std::vector<uint8_t> vSsid{ssid.begin(), ssid.end()};
             wireless["ssid"] = vSsid;
             wireless["mode"] = "ap";
-            wireless["band"] = "a";
-            wireless["band"] = "bg";
 
             uint32_t iChannel = 0;
             auto channel = this->wifiConfigSettings.channel_;
@@ -829,9 +845,14 @@ void HotspotManagerImpl::StartHotspot()
                 std::stringstream ss{channel};
                 ss >> iChannel;
             }
-            if (iChannel != 0)
+            if (iChannel <= 1)
             {
                 wireless["channel"] = iChannel;
+                wireless["band"] = iChannel > 14 ? "a" : "bg";
+            }
+            else
+            {
+                wireless["band"] = iChannel == 0 ? "bg" : "a";
             }
 
             std::map<std::string, sdbus::Variant> &wirelessSecurity = settings["802-11-wireless-security"];
@@ -840,6 +861,26 @@ void HotspotManagerImpl::StartHotspot()
 
             settings["ipv4"]["method"] = "shared";
             settings["ipv6"]["method"] = "shared";
+
+            ////////////////////////////////////////////////////////////////
+
+            // Create connection
+            settings["ipv4"]["method"] = sdbus::Variant(std::string("shared"));
+            //settings["ipv6"]["method"] = sdbus::Variant(std::string("ignore"));
+
+            settings["ipv4"]["address-data"] = sdbus::Variant(std::vector<std::map<std::string, sdbus::Variant>>{{{"address", sdbus::Variant("192.168.60.1")},
+                                                                                                                  {"prefix", sdbus::Variant(uint32_t(24))}}});
+            settings["ipv4"]["dhcp-send-hostname"] = sdbus::Variant(true);
+            settings["ipv4"]["dhcp-hostname"] = sdbus::Variant("raspberrypi");
+            // settings["ipv4"]["dhcp-options"] = sdbus::Variant(std::vector<std::string>{
+            //     "option:classless-static-route,192.168.60.0/24,0.0.0.0,0.0.0.0/0,192.168.60.1"});
+
+            settings["ipv4"]["route-data"] = sdbus::Variant(std::vector<std::map<std::string, sdbus::Variant>>{{
+                    {"dest", sdbus::Variant("192.168.4.0")},
+                    {"prefix", sdbus::Variant(uint32_t(24))},
+                    {"metric", sdbus::Variant((uint32_t)99)}
+            }});
+            ////////////////////////////////////////////////////////////
             // settings["ipv6"]["addr-gen-mode"] = "stable-privacy";
 
             std::map<std::string, sdbus::Variant> options;

src/Ipv6Helpers.cpp

@@ -385,6 +385,34 @@ static std::string GetNonLinkLocalAddressForIp4Interface(const std::string &name
     return result;
 }
 
+bool pipedal::IsLinkLocalAddress(const std::string fromAddress)
+{
+    std::string address = fromAddress;
+    std::string result;
+    if (address[0] != '[')
+    {
+        return false;
+    }
+    else
+    {
+        // ipv6
+        if (address[0] != '[' || address[address.length() - 1] != ']')
+            throw std::invalid_argument("Bad address.");
+        address = address.substr(1, address.length() - 2);
+
+        struct in6_addr inetAddr6;
+        memset(&inetAddr6, 0, sizeof(inetAddr6));
+        if (inet_pton(AF_INET6, address.c_str(), &inetAddr6) == 1)
+        {
+            if (IN6_IS_ADDR_LINKLOCAL(&inetAddr6))
+            {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
 std::string pipedal::GetNonLinkLocalAddress(const std::string fromAddress)
 {
     std::string address = fromAddress;

src/Ipv6Helpers.hpp

@@ -27,6 +27,8 @@ namespace pipedal {
     std::string GetInterfaceIpv4Address(const std::string& interfaceName);
 
 
+    bool IsLinkLocalAddress(const std::string fromAddress);
+
     std::string GetNonLinkLocalAddress(const std::string fromAddress);
 
     bool IsOnLocalSubnet(const std::string&fromAddress);

src/Pedalboard.cpp

@@ -87,6 +87,18 @@ ControlValue* PedalboardItem::GetControlValue(const std::string&symbol)
     return nullptr;
 }
 
+const ControlValue* PedalboardItem::GetControlValue(const std::string&symbol) const
+{
+    for (size_t i = 0; i < this->controlValues().size(); ++i)
+    {
+        if (this->controlValues()[i].key() == symbol)
+        {
+            return &(this->controlValues()[i]);
+        }
+    }
+    return nullptr;
+}
+
 bool Pedalboard::SetItemEnabled(int64_t pedalItemId, bool enabled)
 {
     PedalboardItem*item = GetItem(pedalItemId);
@@ -266,6 +278,17 @@ bool PedalboardItem::IsStructurallyIdentical(const PedalboardItem&other) const
     }
     if (this->isSplit()) // so is the other by virtue of idential uris.
     {
+        auto myValue = this->GetControlValue("splitType");
+        auto otherValue = other.GetControlValue("splitType");
+        if (myValue == nullptr || otherValue == nullptr) // actually an error.
+        {
+            return false;
+        }
+        // split type changes potentially trigger buffer allocation changes, 
+        // so different split types are not structurally identical.
+        if (myValue->value() != otherValue->value()) {
+            return false; 
+        }
         if (topChain().size() != other.topChain().size())
         {
             return false;
@@ -356,6 +379,30 @@ void PedalboardItem::AddResetsForMissingProperties(Snapshot&snapshot, size_t*ind
 
 }
 
+Pedalboard Pedalboard::DeepCopy()
+{
+    Pedalboard result = *this;
+    for (size_t i= 0; i < snapshots_.size(); ++i)
+    {
+        if (snapshots_[i])
+        {
+            result.snapshots_[i] = std::make_shared<Snapshot>(*(snapshots_[i]));
+        }
+    }
+    return result;
+}
+void  Pedalboard::SetCurrentSnapshotModified(bool modified)
+{
+    if (selectedSnapshot() != -1)
+    {
+        auto& snapshot = snapshots_[selectedSnapshot_];
+        if (snapshot)
+        {
+            snapshot->isModified_ = modified;
+        }
+    }
+}
+
 Snapshot Pedalboard::MakeSnapshotFromCurrentSettings(const Pedalboard &previousPedalboard)
 {
     Snapshot snapshot;

src/Pedalboard.hpp

@@ -101,6 +101,7 @@ public:
     PropertyMap patchProperties;
 public:
     ControlValue*GetControlValue(const std::string&symbol);
+    const ControlValue*GetControlValue(const std::string&symbol) const;
 
     bool IsStructurallyIdentical(const PedalboardItem&other) const;
 
@@ -166,7 +167,7 @@ class Snapshot {
 public:
     std::string name_;
     std::string color_;
-    bool isModified_ = true;
+    bool isModified_ = false;
     std::vector<SnapshotValue> values_;
 
     DECLARE_JSON_MAP(Snapshot);
@@ -186,10 +187,13 @@ class Pedalboard {
     int64_t selectedSnapshot_ = -1;
 
 public:
+    // deep copy, breaking shared pointers.
+    Pedalboard DeepCopy(); 
     static constexpr int64_t INPUT_VOLUME_ID = -2; // synthetic PedalboardItem for input volume.
     static constexpr int64_t OUTPUT_VOLUME_ID = -3; // synthetic PedalboardItem for output volume.
     bool SetControlValue(int64_t pedalItemId, const std::string &symbol, float value);
     bool SetItemEnabled(int64_t pedalItemId, bool enabled);
+    void  SetCurrentSnapshotModified(bool modified);
 
     bool IsStructureIdentical(const Pedalboard &other) const; // caan we just send a snapshot-style uddate instead of reloading plugins? All settings are ignored.
     Snapshot MakeSnapshotFromCurrentSettings(const Pedalboard &previousPedalboard);

src/PiPedalModel.cpp

@@ -101,6 +101,26 @@ PiPedalModel::PiPedalModel()
     // don't actuall start the hotspotManager until after LV2 is initialized (in order to avoid logging oddities)
 }
 
+void PrepareSnapshostsForSave(Pedalboard&pedalboard) 
+{
+    if (pedalboard.selectedSnapshot() != -1) {
+        auto&currentSnapshot = pedalboard.snapshots()[pedalboard.selectedSnapshot()];
+        if (!currentSnapshot ||  currentSnapshot->isModified_)
+        {
+            pedalboard.selectedSnapshot(-1);
+
+        }
+    }
+    for (auto &snapshot: pedalboard.snapshots())
+    {
+        if (snapshot) {
+            snapshot->isModified_ = false;
+        }
+    }
+}
+
+
+
 void PiPedalModel::Close()
 {
     std::unique_ptr<AudioHost> oldAudioHost;
@@ -515,15 +535,19 @@ void PiPedalModel::SetPedalboard(int64_t clientId, Pedalboard &pedalboard)
 void PiPedalModel::SetSnapshot(int64_t selectedSnapshot)
 {
     std::lock_guard<std::recursive_mutex> lock(mutex);
-    if (this->pedalboard.selectedSnapshot() == selectedSnapshot)
-    {
-        return;
-    }
     if (this->pedalboard.ApplySnapshot(selectedSnapshot))
     {
+        this->pedalboard.SetCurrentSnapshotModified(false);
+        this->FireSnapshotModified(selectedSnapshot,false);
         if (this->audioHost)
         {
-            this->audioHost->LoadSnapshot(*(this->pedalboard.snapshots()[selectedSnapshot]), this->pluginHost); // no longer own it.
+            if (this->previousPedalboardLoaded &&  this->pedalboard.IsStructureIdentical(this->previousPedalboard))
+            {
+                this->audioHost->LoadSnapshot(*(this->pedalboard.snapshots()[selectedSnapshot]), this->pluginHost); // no longer own it.
+            } else {
+                LoadCurrentPedalboard();
+            }
+
         }
         SetPresetChanged(-1, true, false);
         this->pedalboard.selectedSnapshot(selectedSnapshot);
@@ -535,43 +559,21 @@ void PiPedalModel::SetSnapshots(std::vector<std::shared_ptr<Snapshot>> &snapshot
 {
     std::lock_guard<std::recursive_mutex> lock(mutex);
 
-    // notionally, snapshots are saved whenever they are modified, but pedalboards are not.
-    // so we must add the current snapshots BOTH to the current pedalbaoard, AND to the
-    // current saved instance of the pedalboard to create the illusion that the are stored separately.
-    // In practice, snapshots have to track structure changes (delete pedalboard items that have been deleted,
-    // and set default settings for pedalboard items that have ben added since the snapshots was last saved.
-    //
-    // This is acheived by:
-    // 1. updating BOTH the current pedalboard, and its saved instance.
-    // 2. discarding references to dangling instances as plugins are loaded (see UpdateDefaults).
-    // 3. Setting missing snapshot controls to default values (NOT the current pedalboard values)
-    // 4. (We currently don't do the right thing with patch properties if the patch property has never been set).
 
     UpdateVst3Settings(pedalboard);
 
-    {
-        // stealth update of the saved snapshots.
-        auto savedPedalboard = storage.GetCurrentPreset();
-        savedPedalboard.snapshots(snapshots); // makes a shallow copy
-
-        if (selectedSnapshot != -1)
-        {
-            // implies that this is a snapshot of the currently running pedalboard. so we can mark it as the selected pedalboard.
-            this->pedalboard.selectedSnapshot(selectedSnapshot);
-        }
-        // UpdateDefaults(&savedPedalboard); // The update is awfully fresh. wait until it gets loaded again before pruning.
-        storage.SaveCurrentPreset(savedPedalboard);
-    }
-
     this->pedalboard.snapshots(std::move(snapshots));
+
     if (selectedSnapshot != -1)
     {
         this->pedalboard.selectedSnapshot(selectedSnapshot);
     }
-
+    
     this->FirePedalboardChanged(-1, false); // notify clients (but don't change the running pedalboard, because it's still the same)
                                             // this means that all clients get an up-to-date copy of the snapshots AND the currently selected snapshot if that applies
                                             // (and a fresh copy of the pedalboard settings as well, which is harmless, since they have not changed)
+    this->SetPresetChanged(-1, true,false);
+
 }
 
 void PiPedalModel::UpdateCurrentPedalboard(int64_t clientId, Pedalboard &pedalboard)
@@ -634,8 +636,16 @@ void PiPedalModel::SetPresetChanged(int64_t clientId, bool value, bool changeSna
 {
     if (changeSnapshotSelect && value && this->pedalboard.selectedSnapshot() != -1)
     {
-        this->pedalboard.selectedSnapshot(-1);
+        auto & snapshot = this->pedalboard.snapshots()[pedalboard.selectedSnapshot()];
-        FireSelectedSnapshotChanged(-1);
+        if (snapshot) {
+            if (!snapshot->isModified_)
+            {
+                snapshot->isModified_  = true;
+                FireSnapshotModified(pedalboard.selectedSnapshot(),true);
+            }
+        }
+
+        this->pedalboard.SetCurrentSnapshotModified(true);
     }
     if (value != this->hasPresetChanged)
     {
@@ -644,6 +654,20 @@ void PiPedalModel::SetPresetChanged(int64_t clientId, bool value, bool changeSna
     }
 }
 
+void PiPedalModel::FireSnapshotModified(int64_t snapshotIndex, bool modified)
+{
+    std::lock_guard<std::recursive_mutex> guard{mutex};
+    {
+        // take a snapshot incase a client unsusbscribes in the notification handler (in which case the mutex won't protect us)
+        std::vector<IPiPedalModelSubscriber::ptr> t{subscribers.begin(), subscribers.end()};
+        for (auto &subscriber : t)
+        {
+            subscriber->OnSnapshotModified(snapshotIndex,modified);
+        }
+    }
+
+}
+
 void PiPedalModel::FireSelectedSnapshotChanged(int64_t selectedSnapshot)
 {
     std::lock_guard<std::recursive_mutex> guard{mutex};
@@ -762,6 +786,8 @@ void PiPedalModel::SaveCurrentPreset(int64_t clientId)
 
     UpdateVst3Settings(this->pedalboard);
     SyncLv2State();
+    PrepareSnapshostsForSave(pedalboard);
+
 
     storage.SaveCurrentPreset(this->pedalboard);
     this->SetPresetChanged(clientId, false);
@@ -791,12 +817,15 @@ int64_t PiPedalModel::SavePluginPresetAs(int64_t instanceId, const std::string &
     return presetId;
 }
 
+
 int64_t PiPedalModel::SaveCurrentPresetAs(int64_t clientId, const std::string &name, int64_t saveAfterInstanceId)
 {
     std::lock_guard<std::recursive_mutex> guard{mutex};
 
     SyncLv2State();
-    auto pedalboard = this->pedalboard;
+    auto pedalboard = this->pedalboard.DeepCopy();
+    PrepareSnapshostsForSave(pedalboard);    
+    
     UpdateVst3Settings(pedalboard);
     pedalboard.name(name);
     int64_t result = storage.SaveCurrentPresetAs(pedalboard, name, saveAfterInstanceId);
@@ -1280,6 +1309,7 @@ void PiPedalModel::RestartAudio(bool useDummyAudioDriver)
 
         this->audioHost->SetPedalboard(nullptr);
 
+        previousPedalboardLoaded = false;
         auto jackServerSettings = this->jackServerSettings;
         if (useDummyAudioDriver)
         {
@@ -2359,6 +2389,8 @@ bool PiPedalModel::LoadCurrentPedalboard()
     // return true if the error messages have changed
     CheckForResourceInitialization(this->pedalboard);
     audioHost->SetPedalboard(lv2Pedalboard);
+    previousPedalboard = this->pedalboard;
+    previousPedalboardLoaded = true;
     return true;
 }
 

src/PiPedalModel.hpp

@@ -68,6 +68,7 @@ namespace pipedal
         virtual void OnPedalboardChanged(int64_t clientId, const Pedalboard &pedalboard) = 0;
         virtual void OnPresetsChanged(int64_t clientId, const PresetIndex &presets) = 0;
         virtual void OnPresetChanged(bool changed) = 0;
+        virtual void OnSnapshotModified(int64_t selectedSnapshot, bool modified) = 0;
         virtual void OnSelectedSnapshotChanged(int64_t selectedSnapshot) = 0;
         virtual void OnPluginPresetsChanged(const std::string &pluginUri) = 0;
         virtual void OnChannelSelectionChanged(int64_t clientId, const JackChannelSelection &channelSelection) = 0;
@@ -180,6 +181,7 @@ namespace pipedal
 
         std::vector<std::shared_ptr<IPiPedalModelSubscriber>> subscribers;
         void SetPresetChanged(int64_t clientId, bool value, bool changeSnapshotSelect = true);
+        void FireSnapshotModified(int64_t snapshotIndex, bool modified);
         void FireSelectedSnapshotChanged(int64_t selectedSnapshot);
         void FirePresetsChanged(int64_t clientId);
         void FirePresetChanged(bool changed);

src/PiPedalSocket.cpp

@@ -396,6 +396,19 @@ JSON_MAP_REFERENCE(SetSnapshotsBody, snapshots)
 JSON_MAP_REFERENCE(SetSnapshotsBody, selectedSnapshot)
 JSON_MAP_END()
 
+class SnapshotModifiedBody {
+public:
+    int64_t snapshotIndex_;
+    bool modified_;
+
+    DECLARE_JSON_MAP(SnapshotModifiedBody);
+};
+
+JSON_MAP_BEGIN(SnapshotModifiedBody)
+JSON_MAP_REFERENCE(SnapshotModifiedBody, snapshotIndex)
+JSON_MAP_REFERENCE(SnapshotModifiedBody, modified)
+JSON_MAP_END()
+
 class ChannelSelectionChangedBody
 {
 public:
@@ -1762,6 +1775,15 @@ private:
         body.jackChannelSelection_ = const_cast<JackChannelSelection *>(&channelSelection);
         Send("onChannelSelectionChanged", body);
     }
+
+    virtual void OnSnapshotModified(int64_t snapshotIndex, bool modified) 
+    {
+        SnapshotModifiedBody body;
+        body.snapshotIndex_ = snapshotIndex;
+        body.modified_ = modified;
+        Send("onSnapshotModified", body);
+    }
+
     virtual void OnSelectedSnapshotChanged(int64_t selectedSnapshot) override
     {
         Send("onSelectedSnapshotChanged", selectedSnapshot);

src/WebServer.cpp

@@ -936,6 +936,20 @@ namespace pipedal
             return result.str();
         }
 
+        static void splitAddressAndPort(const std::string &address, std::string&addrOnly, std::string&port)
+        {
+            size_t portPos = address.length();
+            for (size_t i = address.length(); i > 0; --i)
+            {
+                if (address[i-1] == ':')
+                {
+                    portPos = i-1;
+                    break;
+                }
+            }
+            addrOnly = address.substr(0,portPos);
+            port = address.substr(portPos);
+        }
         void on_http(connection_hdl hdl)
         {
             // Upgrade our connection handle to a full connection_ptr
@@ -974,6 +988,31 @@ namespace pipedal
 
             std::string fromAddress = SS(con->get_remote_endpoint());
 
+            // redirect requests to IPV6 local connections to a better address.
+
+            std::string addrOnly,portStr;
+            splitAddressAndPort(fromAddress,addrOnly,portStr);
+
+            if (IsLinkLocalAddress(addrOnly))
+            {
+                try {
+                    uri_builder builder(requestUri);
+
+                    std::string redirectAddress = GetNonLinkLocalAddress(addrOnly);
+                    builder.set_authority(redirectAddress+portStr);
+                    std::string redirectUri = builder.str();
+
+                    res.set(HttpField::location,redirectUri.c_str());
+                    Lv2Log::info(SS("Redirecting from " << fromAddress << " to " << redirectUri));
+                    res.keepAlive(false);
+                    con->set_status(websocketpp::http::status_code::temporary_redirect);
+                    return;
+                } catch (const std::exception&e)
+                {
+                    ServerError(*con,"Invalid request on link-local address.");
+                    return;
+                }
+            }
             if (req.method() == HttpVerb::options)
             {
                 res.set(HttpField::access_control_allow_origin, origin);
@@ -984,6 +1023,7 @@ namespace pipedal
                 return;
             }
 
+
             for (auto requestHandler : this->request_handlers)
             {
 

src/WebServer.hpp

@@ -70,6 +70,7 @@ public:
     constexpr static const char* origin = "Origin";
     constexpr static const char* date = "Date";
     constexpr static const char* referer = "Referer";
+    constexpr static const char * location = "Location";
 };
 
 

src/WifiChannelSelectors.cpp

@@ -74,12 +74,12 @@ std::vector<WifiChannelSelector> pipedal::getWifiChannelSelectors(const char*cou
     if (forCommandline) {
         WifiChannelSelector autoSelect;
         autoSelect.channelId_ = "0";
-        autoSelect.channelName_ = "0 Select automatically";
+        autoSelect.channelName_ = "0 Automatic";
         result.push_back(autoSelect);
     } else {
         WifiChannelSelector autoSelect;
         autoSelect.channelId_ = "0";
-        autoSelect.channelName_ = "Select automatically";
+        autoSelect.channelName_ = "Automatic";
         result.push_back(autoSelect);
     }
     WifiInfo wifiInfo = getWifiInfo(countryIso3661);