saudade 0.5.0

Classic looking retained-mode, cross-platform Rust GUI library
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

//! dnd — drop files from your file manager onto the window. The drop zone
//! highlights while a drag hovers over it and lists the paths that land.
//!
//! File drag-and-drop works on every saudade backend: macOS, Windows and X11
//! through winit, and Wayland through smithay-client-toolkit. On Wayland the
//! highlight tracks the pointer as you drag and the drop reports an exact
//! position; on the winit backends winit doesn't report cursor coordinates
//! during a file drag, so the whole window behaves as a single drop zone.

use std::path::PathBuf;

use saudade::{App, Color, Column, Event, EventCtx, Painter, Rect, Theme, Widget, WindowConfig};

const W: i32 = 460;
const H: i32 = 320;

fn main() {
    let root = Column::new()
        .with_background(Color::WHITE)
        .add_fill(DropZone::new());

    App::new(WindowConfig::new("Drag & Drop", W, H).resizable(true), root)
        .with_theme(Theme::windows_31())
        .run();
}

/// Fills its slot with a sunken panel that floods navy (the Win 3.1 "selected"
/// look) while a file drag hovers, and lists whatever was last dropped on it.
struct DropZone {
    bounds: Rect,
    hovering: bool,
    dropped: Vec<PathBuf>,
}

impl DropZone {
    fn new() -> Self {
        Self {
            bounds: Rect::new(0, 0, W, H),
            hovering: false,
            dropped: Vec::new(),
        }
    }
}

impl Widget for DropZone {
    fn bounds(&self) -> Rect {
        self.bounds
    }

    fn layout(&mut self, bounds: Rect) {
        self.bounds = bounds;
    }

    fn paint(&mut self, p: &mut Painter, theme: &Theme) {
        let area = self.bounds.inset(8);
        let (fill, fg) = if self.hovering {
            (theme.highlight_bg, theme.highlight_text)
        } else {
            (Color::WHITE, theme.text)
        };
        p.fill_rect(area, fill);
        p.sunken_bevel(area, theme.highlight, theme.shadow);

        let inner = area.inset(8);
        if self.dropped.is_empty() {
            p.text_centered(area, "Drop files here", theme.font_size, fg);
            return;
        }

        let line_h = (theme.font_size * 1.5).round() as i32;
        let mut y = inner.y;
        p.text(inner.x, y, "Dropped:", theme.font_size, fg);
        y += line_h;
        for path in &self.dropped {
            if y > inner.bottom() - line_h {
                break;
            }
            p.text(inner.x, y, &path.display().to_string(), theme.font_size, fg);
            y += line_h;
        }
    }

    fn event(&mut self, event: &Event, ctx: &mut EventCtx) {
        match event {
            // A drag is hovering: opt in as a drop target (so the source sees a
            // valid drop here) and light up so the user sees it too.
            Event::DragEnter { .. } | Event::DragMove { .. } => {
                ctx.accept_drop();
                if !self.hovering {
                    self.hovering = true;
                    ctx.request_paint();
                }
            }
            // It left without dropping: back to normal.
            Event::DragLeave => {
                if self.hovering {
                    self.hovering = false;
                    ctx.request_paint();
                }
            }
            // The payload landed: take the paths and stop highlighting.
            Event::Drop { data, .. } => {
                self.hovering = false;
                self.dropped = data.paths.clone();
                ctx.request_paint();
            }
            _ => {}
        }
    }
}