vn_settings/
lib.rs

1mod color;
2mod layer;
3mod layout;
4mod object;
5mod timing;
6
7pub use color::ColorSettings;
8pub use layer::LayerSettings;
9pub use layout::{BoxLayoutSettings, LayoutSettings, ViewLayoutSettings};
10pub use object::ObjectSettings;
11pub use timing::TimingSettings;
12
13use color::{BoxColorParameter, ColorParameter, SelectableBoxColorParameter};
14use layer::{
15    LayerAnchorParameter, LayerImageParameter, LayerLayoutParameter, LayerObjectLayoutParameter,
16};
17use layout::{BoxLayoutParameter, LayoutParameter, ViewLayoutParameter};
18use object::{ObjectAnchorParameter, ObjectImageParameter, ObjectScaleParameter};
19use timing::TimingParameter;
20
21use dialogi::{DialogChange, DialogParameter};
22use indexmap::IndexMap;
23use simple_color::Color;
24
25use std::collections::HashMap;
26
27trait Settings<Parameter> {
28    type Value;
29
30    fn get_mut(&mut self, parameter: &Parameter) -> &mut Self::Value;
31}
32
33trait Resettable {
34    fn reset(&mut self) {}
35}
36
37#[derive(Default)]
38pub struct Override<T> {
39    default: T,
40    characters_default: HashMap<Box<str>, T>,
41    characters_scene: HashMap<Box<str>, T>,
42    scene: Option<T>,
43}
44
45impl<T> Override<T> {
46    fn set_default(&mut self, name: Option<Box<str>>, value: T) {
47        if let Some(name) = name {
48            self.characters_default.insert(name, value);
49        } else {
50            self.default = value;
51        }
52    }
53
54    fn set_scene(&mut self, name: Option<&str>, value: Option<T>) {
55        let Some(name) = name else {
56            self.scene = value;
57            return;
58        };
59
60        if let Some(value) = value {
61            self.characters_scene.insert(name.into(), value);
62        } else {
63            self.characters_scene.remove(name);
64        }
65    }
66}
67
68impl<T> Resettable for Override<T> {
69    fn reset(&mut self) {
70        self.scene = None;
71    }
72}
73
74impl<T> From<T> for Override<T> {
75    fn from(default: T) -> Self {
76        Self {
77            default,
78            characters_default: HashMap::new(),
79            characters_scene: HashMap::new(),
80            scene: None,
81        }
82    }
83}
84
85impl<T> Override<T> {
86    pub fn get(&self, name: &str) -> T
87    where
88        T: Copy,
89    {
90        *self.get_ref(name)
91    }
92
93    pub fn get_ref(&self, name: &str) -> &T {
94        if let Some(scene) = &self.scene {
95            scene
96        } else if name.is_empty() {
97            &self.default
98        } else if let Some(character_scene) = self.characters_scene.get(name) {
99            character_scene
100        } else if let Some(character_default) = self.characters_default.get(name) {
101            character_default
102        } else {
103            &self.default
104        }
105    }
106}
107
108#[derive(Default)]
109pub struct Names {
110    pub default: HashMap<Box<str>, Box<str>>,
111    pub scene: HashMap<Box<str>, Box<str>>,
112}
113
114impl Names {
115    pub fn new() -> Self {
116        Self::default()
117    }
118
119    pub fn reset(&mut self) {
120        self.scene.clear();
121    }
122
123    pub fn get<'a>(&'a self, name: &'a str) -> &'a str {
124        self.scene
125            .get(name)
126            .or_else(|| self.default.get(name))
127            .map_or(name, |v| v)
128    }
129}
130
131type OvrrideColorSettings = ColorSettings<Override<Color>>;
132type OverrideTimingSettings = TimingSettings<Override<f32>>;
133type OverrideObjectSettings =
134    ObjectSettings<Override<Option<Box<str>>>, Override<[f32; 2]>, Override<f32>>;
135type OverrideLayerSettings =
136    LayerSettings<Override<Option<usize>>, Override<f32>, Override<Option<usize>>>;
137type OverrideLayoutSettings = LayoutSettings<Override<f32>>;
138
139pub struct PlayerSettings {
140    pub colors: OvrrideColorSettings,
141    pub timing: OverrideTimingSettings,
142    pub objects: OverrideObjectSettings,
143    pub layers: OverrideLayerSettings,
144    pub layout: OverrideLayoutSettings,
145    pub names: Names,
146}
147
148impl PlayerSettings {
149    pub fn common() -> Self {
150        Self {
151            colors: ColorSettings::common(),
152            timing: TimingSettings::common(),
153            objects: ObjectSettings::common(),
154            layers: LayerSettings::common(),
155            layout: LayoutSettings::common(),
156            names: Names::new(),
157        }
158    }
159
160    pub fn apply_setting(&mut self, context: &mut SettingsContext, key: &str, value: &str) {
161        if let Some(parameter) = Parameter::create(key, context) {
162            let setter = parameter.value_setter(value, context);
163            self.set_character_default(setter);
164        }
165    }
166
167    pub fn extract_settings(
168        &mut self,
169        context: &mut SettingsContext,
170        config_map: &mut IndexMap<Box<str>, Box<str>>,
171    ) {
172        for (key, value) in config_map.drain(..) {
173            self.apply_setting(context, &key, &value);
174        }
175    }
176
177    pub fn reset(&mut self) {
178        self.colors.reset();
179        self.timing.reset();
180        self.layers.reset();
181        self.layout.reset();
182        self.names.reset();
183    }
184}
185
186#[derive(Clone, Debug, PartialEq, Eq, Hash)]
187pub struct NamedParameter<T> {
188    name: Option<Box<str>>,
189    parameter: T,
190}
191
192trait ParameterNamer: Sized {
193    fn named(self, name: Option<Box<str>>) -> NamedParameter<Self> {
194        NamedParameter {
195            name,
196            parameter: self,
197        }
198    }
199}
200
201impl<T> ParameterNamer for T {}
202
203type NamedColorParameter = NamedParameter<ColorParameter>;
204type NamedTimingParameter = NamedParameter<TimingParameter>;
205type NamedObjectImageParameter = NamedParameter<ObjectImageParameter>;
206type NamedObjectAnchorParameter = NamedParameter<ObjectAnchorParameter>;
207type NamedObjectScaleParameter = NamedParameter<ObjectScaleParameter>;
208type NamedLayerImageParameter = NamedParameter<LayerImageParameter>;
209type NamedLayerLayoutParameter = NamedParameter<LayerLayoutParameter>;
210type NamedLayerAnchorParameter = NamedParameter<LayerAnchorParameter>;
211type NamedLayoutParameter = NamedParameter<LayoutParameter>;
212
213#[derive(Clone, Debug, PartialEq, Eq, Hash)]
214pub enum Parameter {
215    Color(NamedColorParameter),
216    Timing(NamedTimingParameter),
217    ObjectImage(NamedObjectImageParameter),
218    ObjectAnchor(NamedObjectAnchorParameter),
219    ObjectScale(NamedObjectScaleParameter),
220    LayerImage(NamedLayerImageParameter),
221    LayerLayout(NamedLayerLayoutParameter),
222    LayerAnchor(NamedLayerAnchorParameter),
223    Layout(NamedLayoutParameter),
224    Name(Box<str>),
225}
226
227pub struct Object {
228    index: usize,
229    images: HashMap<Box<str>, usize>,
230}
231
232impl Object {
233    fn new(index: usize) -> Self {
234        Self {
235            index,
236            images: HashMap::new(),
237        }
238    }
239}
240
241pub struct LayerInfo {
242    pub name: Box<str>,
243    pub path: Box<str>,
244}
245
246pub fn extract_layers(layers: &mut Vec<LayerInfo>, config_map: &mut IndexMap<Box<str>, Box<str>>) {
247    let keys: Vec<_> = config_map.keys().cloned().collect();
248    for key in keys {
249        let Some(("Layer", name)) = key.split_once(':') else {
250            continue;
251        };
252
253        let path = config_map.shift_remove(&key).expect("Invalid layer");
254        layers.push(LayerInfo {
255            name: name.into(),
256            path,
257        });
258    }
259
260    if layers.is_empty() {
261        layers.push(LayerInfo {
262            name: "Background".into(),
263            path: Box::default(),
264        });
265        layers.push(LayerInfo {
266            name: "Character".into(),
267            path: Box::default(),
268        });
269    }
270}
271
272#[derive(Default)]
273pub struct SettingsContext {
274    pub object_cache: HashMap<Box<str>, Object>,
275    pub layers: Vec<LayerInfo>,
276    pub anchors: HashMap<Box<str>, usize>,
277}
278
279impl SettingsContext {
280    pub fn new() -> Self {
281        Self::default()
282    }
283}
284
285impl Parameter {
286    fn create_character(name: &str, context: &mut SettingsContext) -> Option<Self> {
287        let (main, sub) = name.split_once(':')?;
288
289        if main != "Character" {
290            return None;
291        }
292
293        let (character_name, option) = sub.split_once(':')?;
294
295        let character_name = character_name.into();
296        if option == "name" {
297            Some(Self::Name(character_name))
298        } else {
299            create_parameter(option, Some(character_name), context)
300        }
301    }
302
303    pub fn value_setter(self, value: &str, context: &mut SettingsContext) -> Setter {
304        fn color(repr: &str) -> Color {
305            match repr {
306                "black" => Color::BLACK,
307                "white" => Color::WHITE,
308
309                "red" => Color::RED,
310                "yellow" => Color::YELLOW,
311                "green" => Color::GREEN,
312                "cyan" => Color::CYAN,
313                "blue" => Color::BLUE,
314                "magenta" => Color::MAGENTA,
315
316                _ => repr
317                    .parse::<Color>()
318                    .unwrap_or_else(|_| panic!("Color '{repr}' does not exist")),
319            }
320        }
321
322        match self {
323            Self::Color(parameter) => Setter::Color(parameter, color(value)),
324            Self::Timing(parameter) => Setter::Timing(
325                parameter,
326                value.parse().expect("Parsing timing parameter failed"),
327            ),
328            Self::ObjectImage(parameter) => Setter::ObjectImage(parameter, Some(value.into())),
329            Self::ObjectAnchor(parameter) => Setter::ObjectAnchor(parameter, {
330                let (x, y) = value
331                    .split_once(char::is_whitespace)
332                    .expect("Parsing object anchor parameter failed");
333                let x = x.parse().expect("Parsing object anchor parameter failed");
334                let y = y.parse().expect("Parsing object anchor parameter failed");
335                [x, y]
336            }),
337            Self::ObjectScale(parameter) => Setter::ObjectScale(
338                parameter,
339                value.parse().expect("Parsing image scale parameter failed"),
340            ),
341            Self::LayerImage(parameter) => {
342                let index = if value.is_empty() {
343                    None
344                } else {
345                    let path = &context.layers[parameter.parameter.0].path;
346                    let path_holder;
347                    let full_path = if path.is_empty() {
348                        value
349                    } else {
350                        path_holder = format!("{path}:{value}");
351                        &path_holder
352                    };
353                    if let Some(Object { index, .. }) = context.object_cache.get(full_path) {
354                        Some(*index)
355                    } else {
356                        eprintln!("Undefined image object {value:?}");
357                        None
358                    }
359                };
360                Setter::LayerImage(parameter, index)
361            }
362            Self::LayerLayout(parameter) => Setter::LayerLayout(
363                parameter,
364                value
365                    .parse()
366                    .expect("Parsing object layout parameter failed"),
367            ),
368            Self::LayerAnchor(parameter) => {
369                let index = if value.is_empty() {
370                    None
371                } else {
372                    let anchor_index = context.anchors.len();
373                    Some(*context.anchors.entry(value.into()).or_insert(anchor_index))
374                };
375                Setter::LayerAnchor(parameter, index)
376            }
377            Self::Layout(parameter) => Setter::Layout(
378                parameter,
379                value.parse().expect("Parsing layout parameter failed"),
380            ),
381            Self::Name(parameter) => Setter::Name(parameter, value.into()),
382        }
383    }
384}
385
386fn create_parameter(
387    parameter_name: &str,
388    character_name: Option<Box<str>>,
389    context: &mut SettingsContext,
390) -> Option<Parameter> {
391    let (path, parameter_name) = parameter_name.split_once(':')?;
392    Some(match path {
393        "Color" => Parameter::Color(
394            match parameter_name {
395                "background" => ColorParameter::Background,
396                "foreground" => ColorParameter::Foreground,
397                "dialog-text-fill" => ColorParameter::Dialog(BoxColorParameter::TextFill),
398                "dialog-text-line" => ColorParameter::Dialog(BoxColorParameter::TextLine),
399                "dialog-name-fill" => ColorParameter::Dialog(BoxColorParameter::NameFill),
400                "dialog-name-line" => ColorParameter::Dialog(BoxColorParameter::NameLine),
401
402                "choice-default-text-fill" => ColorParameter::Choice(SelectableBoxColorParameter {
403                    selected: false,
404                    parameter: BoxColorParameter::TextFill,
405                }),
406                "choice-default-text-line" => ColorParameter::Choice(SelectableBoxColorParameter {
407                    selected: false,
408                    parameter: BoxColorParameter::TextLine,
409                }),
410                "choice-default-name-fill" => ColorParameter::Choice(SelectableBoxColorParameter {
411                    selected: false,
412                    parameter: BoxColorParameter::NameFill,
413                }),
414                "choice-default-name-line" => ColorParameter::Choice(SelectableBoxColorParameter {
415                    selected: false,
416                    parameter: BoxColorParameter::NameLine,
417                }),
418                "choice-select-text-fill" => ColorParameter::Choice(SelectableBoxColorParameter {
419                    selected: true,
420                    parameter: BoxColorParameter::TextFill,
421                }),
422                "choice-select-text-line" => ColorParameter::Choice(SelectableBoxColorParameter {
423                    selected: true,
424                    parameter: BoxColorParameter::TextLine,
425                }),
426                "choice-select-name-fill" => ColorParameter::Choice(SelectableBoxColorParameter {
427                    selected: true,
428                    parameter: BoxColorParameter::NameFill,
429                }),
430                "choice-select-name-line" => ColorParameter::Choice(SelectableBoxColorParameter {
431                    selected: true,
432                    parameter: BoxColorParameter::NameLine,
433                }),
434
435                "revert-default-text-fill" => ColorParameter::Revert(SelectableBoxColorParameter {
436                    selected: false,
437                    parameter: BoxColorParameter::TextFill,
438                }),
439                "revert-default-text-line" => ColorParameter::Revert(SelectableBoxColorParameter {
440                    selected: false,
441                    parameter: BoxColorParameter::TextLine,
442                }),
443                "revert-default-name-fill" => ColorParameter::Revert(SelectableBoxColorParameter {
444                    selected: false,
445                    parameter: BoxColorParameter::NameFill,
446                }),
447                "revert-default-name-line" => ColorParameter::Revert(SelectableBoxColorParameter {
448                    selected: false,
449                    parameter: BoxColorParameter::NameLine,
450                }),
451                "revert-select-text-fill" => ColorParameter::Revert(SelectableBoxColorParameter {
452                    selected: true,
453                    parameter: BoxColorParameter::TextFill,
454                }),
455                "revert-select-text-line" => ColorParameter::Revert(SelectableBoxColorParameter {
456                    selected: true,
457                    parameter: BoxColorParameter::TextLine,
458                }),
459                "revert-select-name-fill" => ColorParameter::Revert(SelectableBoxColorParameter {
460                    selected: true,
461                    parameter: BoxColorParameter::NameFill,
462                }),
463                "revert-select-name-line" => ColorParameter::Revert(SelectableBoxColorParameter {
464                    selected: true,
465                    parameter: BoxColorParameter::NameLine,
466                }),
467
468                _ => return None,
469            }
470            .named(character_name),
471        ),
472
473        "Timing" => Parameter::Timing(
474            match parameter_name {
475                "auto-next" => TimingParameter::AutoNext,
476                "letter" => TimingParameter::Letter,
477                "line" => TimingParameter::Line,
478                "select" => TimingParameter::Select,
479                "view" => TimingParameter::View,
480
481                _ => return None,
482            }
483            .named(character_name),
484        ),
485
486        "Image" => {
487            let (object_name, parameter_name) = parameter_name.rsplit_once(':')?;
488
489            let entry_count = context.object_cache.len();
490            let Object { index, images } = context
491                .object_cache
492                .entry(object_name.into())
493                .or_insert_with(|| Object::new(entry_count));
494
495            let image_index = images.len();
496            let parameter_index = *images.entry(parameter_name.into()).or_insert(image_index);
497
498            Parameter::ObjectImage(
499                ObjectImageParameter(*index, parameter_index).named(character_name),
500            )
501        }
502
503        "Anchor" => {
504            let (object_name, parameter_name) = parameter_name.rsplit_once(':')?;
505
506            let entry_count = context.object_cache.len();
507            let Object { index, .. } = context
508                .object_cache
509                .entry(object_name.into())
510                .or_insert_with(|| Object::new(entry_count));
511
512            let anchor_index = context.anchors.len();
513            let parameter_index = *context
514                .anchors
515                .entry(parameter_name.into())
516                .or_insert(anchor_index);
517
518            Parameter::ObjectAnchor(
519                ObjectAnchorParameter(*index, parameter_index).named(character_name),
520            )
521        }
522
523        "Transform" => {
524            let (object_name, parameter_name) = parameter_name.rsplit_once(':')?;
525
526            if parameter_name != "scale" {
527                return None;
528            }
529
530            let entry_count = context.object_cache.len();
531            let Object { index, .. } = context
532                .object_cache
533                .entry(object_name.into())
534                .or_insert_with(|| Object::new(entry_count));
535
536            Parameter::ObjectScale(ObjectScaleParameter(*index).named(character_name))
537        }
538
539        "Object" => {
540            let (layer_name, parameter_name) = parameter_name.split_once(':')?;
541            let layer = context
542                .layers
543                .iter()
544                .position(|layer| &*layer.name == layer_name)?;
545
546            match parameter_name {
547                "image" => Parameter::LayerImage(LayerImageParameter(layer).named(character_name)),
548                "hor" => Parameter::LayerLayout(
549                    LayerLayoutParameter {
550                        layer,
551                        layout: LayerObjectLayoutParameter::Hor,
552                    }
553                    .named(character_name),
554                ),
555                "ver" => Parameter::LayerLayout(
556                    LayerLayoutParameter {
557                        layer,
558                        layout: LayerObjectLayoutParameter::Ver,
559                    }
560                    .named(character_name),
561                ),
562                "scale" => Parameter::LayerLayout(
563                    LayerLayoutParameter {
564                        layer,
565                        layout: LayerObjectLayoutParameter::Scale,
566                    }
567                    .named(character_name),
568                ),
569                "anchor" => {
570                    Parameter::LayerAnchor(LayerAnchorParameter(layer).named(character_name))
571                }
572
573                _ => return None,
574            }
575        }
576
577        "Layout" => Parameter::Layout(
578            {
579                let (subpath, parameter_name) = parameter_name.split_once(':')?;
580                let box_layout_parameter = || {
581                    Some(match parameter_name {
582                        "hor" => BoxLayoutParameter::Hor,
583                        "ver" => BoxLayoutParameter::Ver,
584                        "width" => BoxLayoutParameter::Width,
585                        "height" => BoxLayoutParameter::Height,
586                        "corner" => BoxLayoutParameter::Corner,
587                        "line" => BoxLayoutParameter::Line,
588                        "text-size" => BoxLayoutParameter::TextSize,
589                        "name-size" => BoxLayoutParameter::NameSize,
590
591                        _ => return None,
592                    })
593                };
594
595                let view_layout_parameter = || {
596                    Some(match parameter_name {
597                        "hor" => ViewLayoutParameter::Hor,
598                        "ver" => ViewLayoutParameter::Ver,
599                        "zoom" => ViewLayoutParameter::Zoom,
600
601                        _ => return None,
602                    })
603                };
604
605                match subpath {
606                    "Main" => box_layout_parameter()?.main(),
607                    "List" => box_layout_parameter()?.list(),
608                    "View" => LayoutParameter::View(view_layout_parameter()?),
609
610                    _ => return None,
611                }
612            }
613            .named(character_name),
614        ),
615
616        _ => return None,
617    })
618}
619
620impl DialogParameter for Parameter {
621    type Context = SettingsContext;
622
623    fn create(name: &str, context: &mut SettingsContext) -> Option<Self> {
624        if name == "-" {
625            None
626        } else if let Some(parameter) = create_parameter(name, None, context) {
627            Some(parameter)
628        } else {
629            let result = Self::create_character(name, context);
630            if result.is_none() {
631                eprintln!("Setting not availabe: {name}");
632            }
633            result
634        }
635    }
636}
637
638pub enum Setter {
639    Color(NamedColorParameter, Color),
640    Timing(NamedTimingParameter, f32),
641    ObjectImage(NamedObjectImageParameter, Option<Box<str>>),
642    ObjectAnchor(NamedObjectAnchorParameter, [f32; 2]),
643    ObjectScale(NamedObjectScaleParameter, f32),
644    LayerImage(NamedLayerImageParameter, Option<usize>),
645    LayerLayout(NamedLayerLayoutParameter, f32),
646    LayerAnchor(NamedLayerAnchorParameter, Option<usize>),
647    Layout(NamedLayoutParameter, f32),
648    Name(Box<str>, Box<str>),
649}
650
651impl Setter {
652    pub fn change(self) -> Change {
653        match self {
654            Self::Color(parameter, value) => Change::Color(parameter, Some(value)),
655            Self::Timing(parameter, value) => Change::Timing(parameter, Some(value)),
656            Self::ObjectImage(parameter, value) => Change::ObjectImage(parameter, Some(value)),
657            Self::ObjectAnchor(parameter, value) => Change::ObjectAnchor(parameter, Some(value)),
658            Self::ObjectScale(parameter, value) => Change::ObjectScale(parameter, Some(value)),
659            Self::LayerImage(parameter, value) => Change::LayerImage(parameter, Some(value)),
660            Self::LayerLayout(parameter, value) => Change::LayerLayout(parameter, Some(value)),
661            Self::LayerAnchor(parameter, value) => Change::LayerAnchor(parameter, Some(value)),
662            Self::Layout(parameter, value) => Change::Layout(parameter, Some(value)),
663            Self::Name(parameter, value) => Change::Name(parameter, Some(value)),
664        }
665    }
666}
667
668pub enum Change {
669    Color(NamedColorParameter, Option<Color>),
670    Timing(NamedTimingParameter, Option<f32>),
671    ObjectImage(NamedObjectImageParameter, Option<Option<Box<str>>>),
672    ObjectAnchor(NamedObjectAnchorParameter, Option<[f32; 2]>),
673    ObjectScale(NamedObjectScaleParameter, Option<f32>),
674    LayerImage(NamedLayerImageParameter, Option<Option<usize>>),
675    LayerLayout(NamedLayerLayoutParameter, Option<f32>),
676    LayerAnchor(NamedLayerAnchorParameter, Option<Option<usize>>),
677    Layout(NamedLayoutParameter, Option<f32>),
678    Name(Box<str>, Option<Box<str>>),
679}
680
681impl Change {
682    pub fn parameter(&self) -> Parameter {
683        match self {
684            Self::Color(parameter, _) => Parameter::Color(parameter.clone()),
685            Self::Timing(parameter, _) => Parameter::Timing(parameter.clone()),
686            Self::ObjectImage(parameter, _) => Parameter::ObjectImage(parameter.clone()),
687            Self::ObjectAnchor(parameter, _) => Parameter::ObjectAnchor(parameter.clone()),
688            Self::ObjectScale(parameter, _) => Parameter::ObjectScale(parameter.clone()),
689            Self::LayerImage(parameter, _) => Parameter::LayerImage(parameter.clone()),
690            Self::LayerLayout(parameter, _) => Parameter::LayerLayout(parameter.clone()),
691            Self::LayerAnchor(parameter, _) => Parameter::LayerAnchor(parameter.clone()),
692            Self::Layout(parameter, _) => Parameter::Layout(parameter.clone()),
693            Self::Name(parameter, _) => Parameter::Name(parameter.clone()),
694        }
695    }
696}
697
698impl DialogChange for Change {
699    type Parameter = Parameter;
700
701    fn default_change(parameter: Parameter) -> Self {
702        match parameter {
703            Parameter::Color(parameter) => Self::Color(parameter, None),
704            Parameter::Timing(parameter) => Self::Timing(parameter, None),
705            Parameter::ObjectImage(parameter) => Self::ObjectImage(parameter, None),
706            Parameter::ObjectAnchor(parameter) => Self::ObjectAnchor(parameter, None),
707            Parameter::ObjectScale(parameter) => Self::ObjectScale(parameter, None),
708            Parameter::LayerImage(parameter) => Self::LayerImage(parameter, None),
709            Parameter::LayerLayout(parameter) => Self::LayerLayout(parameter, None),
710            Parameter::LayerAnchor(parameter) => Self::LayerAnchor(parameter, None),
711            Parameter::Layout(parameter) => Self::Layout(parameter, None),
712            Parameter::Name(parameter) => Self::Name(parameter, None),
713        }
714    }
715
716    fn value_change(parameter: Parameter, value: &str, context: &mut SettingsContext) -> Self {
717        parameter.value_setter(value, context).change()
718    }
719}
720
721impl PlayerSettings {
722    pub fn revert(&mut self, parameter: &Parameter) {
723        use Parameter::*;
724        match parameter {
725            Color(parameter) => self
726                .colors
727                .get_mut(&parameter.parameter)
728                .set_scene(parameter.name.as_deref(), None),
729            Timing(parameter) => self
730                .timing
731                .get_mut(&parameter.parameter)
732                .set_scene(parameter.name.as_deref(), None),
733            ObjectImage(parameter) => self
734                .objects
735                .get_mut(&parameter.parameter)
736                .set_scene(parameter.name.as_deref(), None),
737            ObjectAnchor(parameter) => self
738                .objects
739                .get_mut(&parameter.parameter)
740                .set_scene(parameter.name.as_deref(), None),
741            ObjectScale(parameter) => self
742                .objects
743                .get_mut(&parameter.parameter)
744                .set_scene(parameter.name.as_deref(), None),
745            LayerImage(parameter) => self
746                .layers
747                .get_mut(&parameter.parameter)
748                .set_scene(parameter.name.as_deref(), None),
749            LayerLayout(parameter) => self
750                .layers
751                .get_mut(&parameter.parameter)
752                .set_scene(parameter.name.as_deref(), None),
753            LayerAnchor(parameter) => self
754                .layers
755                .get_mut(&parameter.parameter)
756                .set_scene(parameter.name.as_deref(), None),
757            Layout(parameter) => self
758                .layout
759                .get_mut(&parameter.parameter)
760                .set_scene(parameter.name.as_deref(), None),
761            Name(parameter) => {
762                self.names.scene.remove(parameter);
763            }
764        }
765    }
766
767    pub fn change(&mut self, change: &Change) {
768        use Change::*;
769        match change {
770            Color(parameter, value) => self
771                .colors
772                .get_mut(&parameter.parameter)
773                .set_scene(parameter.name.as_deref(), *value),
774            Timing(parameter, value) => self
775                .timing
776                .get_mut(&parameter.parameter)
777                .set_scene(parameter.name.as_deref(), *value),
778            ObjectImage(parameter, value) => self
779                .objects
780                .get_mut(&parameter.parameter)
781                .set_scene(parameter.name.as_deref(), value.clone()),
782            ObjectScale(parameter, value) => self
783                .objects
784                .get_mut(&parameter.parameter)
785                .set_scene(parameter.name.as_deref(), *value),
786            ObjectAnchor(parameter, value) => self
787                .objects
788                .get_mut(&parameter.parameter)
789                .set_scene(parameter.name.as_deref(), *value),
790            LayerImage(parameter, value) => self
791                .layers
792                .get_mut(&parameter.parameter)
793                .set_scene(parameter.name.as_deref(), *value),
794            LayerLayout(parameter, value) => self
795                .layers
796                .get_mut(&parameter.parameter)
797                .set_scene(parameter.name.as_deref(), *value),
798            LayerAnchor(parameter, value) => self
799                .layers
800                .get_mut(&parameter.parameter)
801                .set_scene(parameter.name.as_deref(), *value),
802            Layout(parameter, value) => self
803                .layout
804                .get_mut(&parameter.parameter)
805                .set_scene(parameter.name.as_deref(), *value),
806            Name(parameter, value) => {
807                if let Some(value) = value {
808                    self.names.scene.insert(parameter.clone(), value.clone());
809                } else {
810                    self.names.scene.remove(parameter);
811                }
812            }
813        }
814    }
815
816    pub fn set_character_default(&mut self, change: Setter) {
817        use Setter::*;
818        match change {
819            Color(parameter, value) => self
820                .colors
821                .get_mut(&parameter.parameter)
822                .set_default(parameter.name, value),
823            Timing(parameter, value) => self
824                .timing
825                .get_mut(&parameter.parameter)
826                .set_default(parameter.name, value),
827            ObjectImage(parameter, value) => self
828                .objects
829                .get_mut(&parameter.parameter)
830                .set_default(parameter.name, value),
831            ObjectAnchor(parameter, value) => self
832                .objects
833                .get_mut(&parameter.parameter)
834                .set_default(parameter.name, value),
835            ObjectScale(parameter, value) => self
836                .objects
837                .get_mut(&parameter.parameter)
838                .set_default(parameter.name, value),
839            LayerImage(parameter, value) => self
840                .layers
841                .get_mut(&parameter.parameter)
842                .set_default(parameter.name, value),
843            LayerLayout(parameter, value) => self
844                .layers
845                .get_mut(&parameter.parameter)
846                .set_default(parameter.name, value),
847            LayerAnchor(parameter, value) => self
848                .layers
849                .get_mut(&parameter.parameter)
850                .set_default(parameter.name, value),
851            Layout(parameter, value) => self
852                .layout
853                .get_mut(&parameter.parameter)
854                .set_default(parameter.name, value),
855            Name(parameter, value) => {
856                self.names.default.insert(parameter, value);
857            }
858        }
859    }
860}
vn_settings/lib.rs

vn_settings/
lib.rs
