inno 0.4.2

Library for reading Inno Setup executables
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

mod color;
mod image_alpha_format;
mod light_control_styling;
mod style;
mod wizard_size_percent;

use std::io;

pub use color::Color;
pub use image_alpha_format::ImageAlphaFormat;
pub use light_control_styling::LightControlStyling;
pub use style::WizardStyle;
pub use wizard_size_percent::WizardSizePercent;

use crate::{read::ReadBytesExt, version::InnoVersion};

#[derive(Copy, Clone, Default, Eq, PartialEq)]
pub struct WizardSettings {
    image_alpha_format: ImageAlphaFormat,
    pub(crate) image_back_color: Color,
    pub(crate) small_image_back_color: Color,
    pub(crate) back_color: Color,
    pub(crate) image_back_color_dynamic_dark: Color,
    pub(crate) small_image_back_color_dynamic_dark: Color,
    pub(crate) back_color_dynamic_dark: Color,
    pub(crate) image_opacity: Option<u8>,
    pub(crate) back_image_opacity: Option<u8>,
    pub(crate) light_control_setting: Option<LightControlStyling>,
    size_percent: WizardSizePercent,
    style: WizardStyle,
}

impl WizardSettings {
    pub fn read_from<R>(mut reader: R, version: InnoVersion) -> io::Result<Self>
    where
        R: io::Read,
    {
        let mut wizard_settings = Self::default();

        if version < (5, 5, 7) {
            wizard_settings.image_back_color = reader.read_t::<Color>()?;
        }

        if ((2, 0, 0)..(5, 0, 4)).contains(&version) || version.is_isx() {
            wizard_settings.small_image_back_color = reader.read_t::<Color>()?;
        }

        if (6.0..6.6).contains(&version) {
            wizard_settings.style = WizardStyle::try_read_from(&mut reader, version)?;
        }

        if version >= 6 {
            wizard_settings.size_percent = reader.read_t::<WizardSizePercent>()?;
        }

        if version >= 6.6 {
            wizard_settings.style = WizardStyle::try_read_from(&mut reader, version)?;
        }

        if version >= (5, 5, 7) {
            wizard_settings.image_alpha_format = ImageAlphaFormat::try_read_from_io(&mut reader)?;
        }

        Ok(wizard_settings)
    }

    /// Returns the image alpha format.
    #[must_use]
    #[inline]
    pub const fn image_alpha_format(&self) -> ImageAlphaFormat {
        self.image_alpha_format
    }

    /// Returns the image background color.
    #[must_use]
    #[inline]
    pub const fn image_back_color(&self) -> Color {
        self.image_back_color
    }

    /// Returns the small image background color.
    #[must_use]
    #[inline]
    pub const fn small_image_back_color(&self) -> Color {
        self.small_image_back_color
    }

    /// Returns the image background color used in dark mode when a dynamic theme is enabled.
    #[must_use]
    #[inline]
    pub const fn image_back_color_dynamic_dark(&self) -> Color {
        self.image_back_color_dynamic_dark
    }

    /// Returns the small image background color used in dark mode when a dynamic theme is enabled.
    #[must_use]
    #[inline]
    pub const fn small_image_back_color_dynamic_dark(&self) -> Color {
        self.small_image_back_color_dynamic_dark
    }

    /// Returns the image opacity.
    #[must_use]
    #[inline]
    pub const fn image_opacity(&self) -> Option<u8> {
        self.image_opacity
    }

    /// Returns the background image opacity.
    ///
    /// Added in Inno Setup 6.7.0.
    #[must_use]
    #[inline]
    pub const fn back_image_opacity(&self) -> Option<u8> {
        self.back_image_opacity
    }

    /// Returns the wizard size percent
    #[must_use]
    #[inline]
    pub const fn size_percent(&self) -> WizardSizePercent {
        self.size_percent
    }

    /// Returns the wizard style.
    #[must_use]
    #[inline]
    pub const fn style(&self) -> WizardStyle {
        self.style
    }
}