x-graphics 0.2.1

Graphics framework for X
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

#![windows_subsystem = "windows"]
use std::error::Error;

use winit::{
    application::ApplicationHandler,
    event::WindowEvent,
    event_loop::{ActiveEventLoop, EventLoop},
    window::{Window, WindowId},
};
use x_graphics::{
    brush::Brush,
    canvas::Canvas,
    device::DeviceContext,
    font::{FontStyle, FontWeight},
    gradient::Gradient,
    paint::{self, DrawMode, TRANSPARENT},
    text::TextAlignment,
    DefaultDeviceContext,
};

struct GraphicsSample {
    window: Option<Window>,
    device_context: Option<DeviceContext<DefaultDeviceContext>>,
}

impl ApplicationHandler for GraphicsSample {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        if self.window.is_none() {
            let mut window_attributes = Window::default_attributes().with_title("Graphics Sample");

            #[cfg(target_os = "windows")]
            {
                window_attributes = window_attributes.with_transparent(true);
            }

            #[cfg(target_family = "wasm")]
            {
                use winit::platform::web::WindowAttributesExtWebSys;
                window_attributes = window_attributes.with_append(true);
            }

            self.window = Some(event_loop.create_window(window_attributes).unwrap());
        }
    }

    fn window_event(&mut self, event_loop: &ActiveEventLoop, _window_id: WindowId, event: WindowEvent) {
        let window = match self.window.as_ref() {
            Some(window) => window,
            None => return,
        };

        match event {
            WindowEvent::CloseRequested => {
                let _ = self.window.take();
                event_loop.exit();
            }
            WindowEvent::RedrawRequested => {
                let canvas = Canvas::default_from_window(self.device_context.as_ref(), window);
                if let Ok(mut canvas) = canvas {
                    canvas.set_smooth(true);
                    canvas.begin_draw();
                    canvas.clear(TRANSPARENT);
                    canvas.save();
                    canvas.set_opacity(0.5);
                    canvas.set_line_dash(&[5.0, 5.0], 1.0);
                    canvas.set_draw_mode(DrawMode::FillStroke);
                    canvas.set_brush(&Brush::new_solid(paint::RED));
                    canvas.draw_rounded_rect(50.0, 50.0, 200.0, 200.0, 5.0);
                    canvas.set_brush(&Brush::new_solid(paint::GREEN));
                    canvas.draw_rounded_rect(100.0, 100.0, 200.0, 200.0, 5.0);
                    canvas.set_brush(&Brush::new_solid(paint::BLUE));
                    canvas.draw_rounded_rect(150.0, 150.0, 200.0, 200.0, 5.0);
                    let mut gradient = Gradient::new_linear(200.0, 200.0, 400.0, 400.0);
                    gradient.add_color_stop(0.0, paint::RED);
                    gradient.add_color_stop(0.2, paint::YELLOW);
                    gradient.add_color_stop(0.4, paint::GREEN);
                    gradient.add_color_stop(0.6, paint::CYAN);
                    gradient.add_color_stop(0.8, paint::BLUE);
                    gradient.add_color_stop(1.0, paint::MAGENTA);
                    canvas.set_brush(&Brush::default_new_gradient(gradient));
                    canvas.draw_rounded_rect(200.0, 200.0, 200.0, 200.0, 5.0);
                    let mut gradient = Gradient::new_radial(350.0, 350.0, 350.0, 350.0, 100.0);
                    gradient.add_color_stop(0.0, paint::RED);
                    gradient.add_color_stop(0.2, paint::YELLOW);
                    gradient.add_color_stop(0.4, paint::GREEN);
                    gradient.add_color_stop(0.6, paint::CYAN);
                    gradient.add_color_stop(0.8, paint::BLUE);
                    gradient.add_color_stop(1.0, paint::MAGENTA);
                    canvas.set_brush(&Brush::default_new_gradient(gradient));
                    canvas.draw_rounded_rect(250.0, 250.0, 200.0, 200.0, 5.0);
                    canvas.set_text_alignment(TextAlignment::Center);
                    canvas.set_font_size(72.0);
                    canvas.set_font_weight(FontWeight::ExtraBold);
                    canvas.set_font_style(FontStyle::Italic | FontStyle::Underline);
                    canvas.set_text_color(paint::BLUE);
                    canvas.draw_text("Hello World\n你好🌏", canvas.bounds());
                    canvas.restore();
                    canvas.end_draw();
                }
            }
            _ => (),
        }
    }
}

fn main() -> Result<(), impl Error> {
    #[cfg(target_family = "wasm")]
    console_error_panic_hook::set_once();
    let event_loop = EventLoop::new().unwrap();
    let mut sample = GraphicsSample {
        window: None,
        device_context: DeviceContext::default_new().ok(),
    };

    event_loop.run_app(&mut sample)
}