miniview 0.6.1

Display an image within a (graphical) window. Callable from a CLI interface.
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
132
133
134
135
136

//! In order to display the miniview window, a configuration which defines how the view should be
//! presented is required. This [`configuration`] may be constructed manually, or by using the
//! [`ConfigBuilder`] which leverages the builder pattern.
//!
//! [`configuration`]: struct.Config.html
//! [`ConfigBuilder`]: struct.ConfigBuilder.html
//! [`show`]: ../struct.MiniView.html#method.show

use crate::Source;
use std::fmt::{Debug, Formatter};

/// Configuration which can be [`provided`] to a miniview window controlling instance which enables
/// different program behaviours
///
/// [`provided`]: ../struct.MiniView.html#method.show
pub struct Config {
    source: Source,
    fullscreen: bool,
    resizable_window: bool,
    lazy_window: bool,
    window_name: &'static str,
}

impl Config {
    /// Source of the image
    pub fn source(&self) -> &Source {
        &self.source
    }

    /// Whether the window should open in fullscreen mode or not
    pub fn fullscreen(&self) -> bool {
        self.fullscreen
    }

    /// Whether the window should be resizable or not
    ///
    /// If [`fullscreen`] mode is active for the window, this setting is implied.
    ///
    /// [`fullscreen`]: struct.Config.html#method.fullscreen
    pub fn resizable_window(&self) -> bool {
        self.resizable_window
    }

    /// Whether the window continuously or lazily checks for input events
    ///
    /// Note: if this is set to true, the [`MiniView.close`] method will only close upon receiving
    /// some input event.
    pub fn lazy_window(&self) -> bool {
        self.lazy_window
    }

    pub fn window_name(&self) -> &str {
        self.window_name
    }
}

impl Debug for Config {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str(&format!("Config(source = {:?}, fullscreen = {:?}, resizable_window = {:?}, window_name = {:?}, ...)",
                             self.source, self.fullscreen, self.resizable_window, self.window_name))
    }
}

/// Builder to conveniently create a miniview [`configuration`]
///
/// [`configuration`]: struct.Config.html
#[derive(Debug)]
pub struct ConfigBuilder {
    config: Config,
}

impl ConfigBuilder {
    /// Create a builder from the provided [`source`]
    ///
    /// [`source`]: ../enum.Source.html
    pub fn new(source: Source) -> Self {
        ConfigBuilder {
            config: Config {
                source,
                fullscreen: false,
                resizable_window: false,
                lazy_window: false,
                window_name: "miniview",
            },
        }
    }

    /// Creates a builder from the provided path
    ///
    /// Path should point to an image on the filesystem.
    pub fn from_path<P: AsRef<std::path::Path>>(path: P) -> Self {
        Self::new(Source::ByPath(path.as_ref().to_path_buf()))
    }

    /// Source of the image to be shown by the window. Can be a path or raw bytes imported from the
    /// stdin pipe
    pub fn source(mut self, value: Source) -> Self {
        self.config.source = value;
        self
    }

    /// Activates fullscreen mode
    pub fn set_fullscreen(mut self, value: bool) -> Self {
        self.config.fullscreen = value;
        self
    }

    /// Allow window resizing
    ///
    /// Note: Upon resizing of the window, the image itself is not resized
    /// Note: Fullscreen mode implies window resizing
    pub fn allow_resizable_window(mut self, value: bool) -> Self {
        self.config.resizable_window = value;
        self
    }

    /// Lazily update the window
    ///
    /// Warning: if the window uses lazy updates, events may not work as expected (input events are
    /// is required to poll successive window events in lazy window mode).
    pub fn set_lazy_window(mut self, value: bool) -> Self {
        self.config.lazy_window = value;
        self
    }

    /// Title of the window; useful when trying to capture the window from another program.
    pub fn window_name(mut self, value: &'static str) -> Self {
        self.config.window_name = value;
        self
    }

    /// Construct a configuration from the default and overridden configuration values.
    pub fn build(self) -> Config {
        self.config
    }
}