Initial commit

src/main.rs

@@ -0,0 +1,450 @@
+#![feature(seek_convenience)]
+
+extern crate byteorder;
+extern crate chrono;
+extern crate smithay_client_toolkit as sctk;
+
+use std::collections::VecDeque;
+use std::os::unix::io::AsRawFd;
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use memmap::MmapMut;
+
+use nix::poll::{poll, PollFd, PollFlags};
+
+use chrono::{Date, DateTime, Datelike, Local, Timelike};
+
+use rusttype::{point, Font, Scale};
+
+use sctk::keyboard::{map_keyboard_auto_with_repeat, Event as KbEvent, KeyRepeatKind};
+use sctk::reexports::client::protocol::wl_shm;
+use sctk::reexports::client::{Display, EventQueue, NewProxy};
+use sctk::utils::DoubleMemPool;
+use sctk::window::{ConceptFrame, Event as WEvent, Window};
+use sctk::Environment;
+
+static DEJAVUSANS_MONO: &'static [u8] = include_bytes!("../fonts/dejavu/DejaVuSansMono.ttf");
+static ROBOTO_REGULAR: &'static [u8] = include_bytes!("../fonts/Roboto-Regular.ttf");
+
+enum Cmd {
+    Exit,
+    Configure,
+    MaybeDraw,
+    Draw,
+}
+
+struct App {
+    pools: DoubleMemPool,
+    display: Display,
+    event_queue: EventQueue,
+    window: Window<ConceptFrame>,
+    cmd_queue: Arc<Mutex<VecDeque<Cmd>>>,
+    dimensions: (u32, u32),
+}
+
+fn draw_text(
+    font_data: &'static [u8],
+    mmap: &mut MmapMut,
+    pos: (u32, u32),
+    dimensions: (u32, u32),
+    size: f32,
+    color: (u8, u8, u8),
+    s: &str,
+) -> Result<(), ::std::io::Error> {
+    // Load the font
+    // This only succeeds if collection consists of one font
+    let font = Font::from_bytes(font_data as &[u8]).expect("Error constructing Font");
+
+    // The font size to use
+    let scale = Scale::uniform(size);
+
+    let v_metrics = font.v_metrics(scale);
+
+    // layout the glyphs in a line with 20 pixels padding
+    let glyphs: Vec<_> = font
+        .layout(s, scale, point(20.0, 20.0 + v_metrics.ascent))
+        .collect();
+
+    // Loop through the glyphs in the text, positing each one on a line
+    for glyph in glyphs {
+        if let Some(bounding_box) = glyph.pixel_bounding_box() {
+            // Draw the glyph into the image per-pixel by using the draw closure
+            glyph.draw(|x, y, o| {
+                let p = (((pos.1 + y + bounding_box.min.y as u32) * dimensions.0)
+                    + (pos.0 + x + bounding_box.min.x as u32))
+                    * 4;
+                let a: u32 = 255 << 24;
+                let r: u32 = (((color.0 as f32) * o) as u32) << 16;
+                let g: u32 = (((color.1 as f32) * o) as u32) << 8;
+                let b: u32 = ((color.2 as f32) * o) as u32;
+                let v = a | r | g | b;
+                unsafe {
+                    let ptr = mmap.as_mut_ptr().offset(p as isize);
+                    *(ptr as *mut u32) = v;
+                }
+            });
+        }
+    }
+
+    Ok(())
+}
+
+fn draw_clock(
+    mmap: &mut MmapMut,
+    time: &DateTime<Local>,
+    pos: (u32, u32),
+    dimensions: (u32, u32),
+) -> Result<(), ::std::io::Error> {
+    draw_text(
+        ROBOTO_REGULAR,
+        mmap,
+        pos,
+        dimensions,
+        64.0,
+        (255, 255, 255),
+        &format!(
+            "{:?}, {:02}/{:02}/{:4}",
+            time.weekday(),
+            time.day(),
+            time.month(),
+            time.year()
+        ),
+    )?;
+
+    draw_text(
+        ROBOTO_REGULAR,
+        mmap,
+        (pos.0, pos.1 + 64),
+        dimensions,
+        256.0,
+        (255, 255, 255),
+        &format!("{:02}", time.hour()),
+    )?;
+
+    draw_text(
+        ROBOTO_REGULAR,
+        mmap,
+        (pos.0 + 256, pos.1 + 64),
+        dimensions,
+        256.0,
+        (255, 255, 255),
+        ":",
+    )?;
+
+    draw_text(
+        ROBOTO_REGULAR,
+        mmap,
+        (pos.0 + 320, pos.1 + 64),
+        dimensions,
+        256.0,
+        (255, 255, 255),
+        &format!("{:02}", time.minute()),
+    )?;
+    Ok(())
+}
+
+fn draw_month(
+    mmap: &mut MmapMut,
+    orig: &Date<Local>,
+    time: &Date<Local>,
+    pos: (u32, u32),
+    dimensions: (u32, u32),
+) -> Result<(), ::std::io::Error> {
+    let mut time = time.clone();
+    let mut y_off = 1;
+    let mut done = false;
+
+    let month_str = match time.month() {
+        1 => "January",
+        2 => "February",
+        3 => "March",
+        4 => "April",
+        5 => "May",
+        6 => "June",
+        7 => "July",
+        8 => "August",
+        9 => "September",
+        10 => "October",
+        11 => "November",
+        12 => "December",
+        _ => panic!("impossible value"),
+    };
+
+    draw_text(
+        ROBOTO_REGULAR,
+        mmap,
+        pos,
+        dimensions,
+        68.0,
+        (255, 255, 255),
+        month_str,
+    )?;
+
+    while !done {
+        let mut x_pos = 0;
+        let mut wk = time.weekday();
+        while wk != chrono::Weekday::Sun {
+            x_pos += 1;
+            wk = wk.pred();
+        }
+
+        while x_pos < 7 {
+            let c = if time.day() == orig.day() && time.month() == orig.month() {
+                (255, 255, 255)
+            } else {
+                (96, 96, 96)
+            };
+            draw_text(
+                DEJAVUSANS_MONO,
+                mmap,
+                (pos.0 + (x_pos * 48), pos.1 + (y_off * 32) + 64),
+                dimensions,
+                32.0,
+                c,
+                &format!("{:02}", time.day()),
+            )?;
+            let t = time.with_day(time.day() + 1);
+            if t.is_none() {
+                done = true;
+                break;
+            }
+            time = t.unwrap();
+            x_pos += 1;
+        }
+
+        y_off += 1;
+    }
+
+    Ok(())
+}
+
+fn draw_calendar(
+    mmap: &mut MmapMut,
+    time: &Date<Local>,
+    pos: (u32, u32),
+    dimensions: (u32, u32),
+) -> Result<(), ::std::io::Error> {
+    // ~1546x384px
+    let t = time.with_day(1).unwrap();
+    draw_month(
+        mmap,
+        time,
+        &t.pred().with_day(1).unwrap(),
+        (pos.0, pos.1),
+        dimensions,
+    )?;
+    draw_month(mmap, time, &t, (pos.0 + 512, pos.1), dimensions)?;
+    let n = if t.month() == 12 {
+        t.with_year(t.year() + 1).unwrap().with_month(1).unwrap()
+    } else {
+        t.with_month(t.month() + 1).unwrap()
+    };
+    draw_month(mmap, time, &n, (pos.0 + 1024, pos.1), dimensions)?;
+    Ok(())
+}
+
+impl App {
+    fn redraw(&mut self) -> Result<(), ::std::io::Error> {
+        let pool = match self.pools.pool() {
+            Some(pool) => pool,
+            None => return Ok(()),
+        };
+
+        let (buf_x, buf_y) = self.dimensions;
+
+        // resize the pool if relevant
+
+        pool.resize((4 * buf_x * buf_y) as usize)
+            .expect("Failed to resize the memory pool.");
+
+        let mmap = pool.mmap();
+        {
+            unsafe {
+                let ptr = mmap.as_mut_ptr();
+                for p in 0..(buf_x * buf_y) {
+                    *((ptr as *mut u32).offset(p as isize)) = 0xC0000000;
+                }
+            }
+        }
+
+        let time = Local::now();
+
+        draw_clock(mmap, &time, (0, 0), (buf_x, buf_y))?;
+        draw_calendar(mmap, &time.date(), (0, 384), (buf_x, buf_y))?;
+
+        mmap.flush().unwrap();
+
+        // get a buffer and attach it
+        let new_buffer = pool.buffer(
+            0,
+            buf_x as i32,
+            buf_y as i32,
+            4 * buf_x as i32,
+            wl_shm::Format::Argb8888,
+        );
+        self.window.surface().attach(Some(&new_buffer), 0, 0);
+        self.window.surface().commit();
+        Ok(())
+    }
+
+    fn window(&mut self) -> &mut Window<ConceptFrame> {
+        &mut self.window
+    }
+
+    fn cmd_queue(&self) -> Arc<Mutex<VecDeque<Cmd>>> {
+        self.cmd_queue.clone()
+    }
+
+    fn flush_display(&mut self) {
+        self.display.flush().expect("unable to flush display");
+    }
+
+    fn dimensions(&self) -> (u32, u32) {
+        self.dimensions
+    }
+
+    fn event_queue(&mut self) -> &mut EventQueue {
+        &mut self.event_queue
+    }
+
+    fn new(dimensions: (u32, u32)) -> App {
+        let cmd_queue = Arc::new(Mutex::new(VecDeque::new()));
+
+        let (display, mut event_queue) = Display::connect_to_env().unwrap();
+        let env = Environment::from_display(&*display, &mut event_queue).unwrap();
+
+        let pools = DoubleMemPool::new(&env.shm, || {}).expect("Failed to create a memory pool !");
+
+        let surface = env
+            .compositor
+            .create_surface(NewProxy::implement_dummy)
+            .unwrap();
+
+        let event_clone = cmd_queue.clone();
+        let mut window =
+            Window::<ConceptFrame>::init_from_env(&env, surface, dimensions.clone(), move |evt| {
+                match evt {
+                    WEvent::Close => return,
+                    WEvent::Refresh => {
+                        event_clone.lock().unwrap().push_back(Cmd::MaybeDraw);
+                    }
+                    WEvent::Configure {
+                        new_size: _,
+                        states: _,
+                    } => {
+                        event_clone.lock().unwrap().push_back(Cmd::Configure);
+                    }
+                }
+            })
+            .expect("Failed to create a window !");
+
+        let seat = env
+            .manager
+            .instantiate_range(1, 6, NewProxy::implement_dummy)
+            .unwrap();
+
+        window.new_seat(&seat);
+
+        let kbd_clone = cmd_queue.clone();
+        map_keyboard_auto_with_repeat(
+            &seat,
+            KeyRepeatKind::System,
+            move |event: KbEvent, _| match event {
+                KbEvent::Key { keysym, .. } => match keysym {
+                    0xFF1B => kbd_clone.lock().unwrap().push_back(Cmd::Exit),
+                    _ => (),
+                },
+                _ => (),
+            },
+            |_, _| {},
+        )
+        .expect("Failed to map keyboard");
+
+        window.set_title("dashboard".to_string());
+        window.set_app_id("dashboard".to_string());
+
+        App {
+            window: window,
+            display: display,
+            event_queue: event_queue,
+            cmd_queue: cmd_queue,
+            pools: pools,
+            dimensions: dimensions,
+        }
+    }
+}
+
+fn main() {
+    let mut app = App::new((1408u32, 734u32));
+
+    let mut last_time = Local::now();
+
+    let mut tfd = timerfd::TimerFd::new_custom(timerfd::ClockId::Monotonic, true, true).unwrap();
+    tfd.set_state(
+        timerfd::TimerState::Periodic {
+            current: Duration::from_millis(2000),
+            interval: Duration::from_millis(2000),
+        },
+        timerfd::SetTimeFlags::Default,
+    );
+
+    let q = app.cmd_queue();
+    loop {
+        let cmd = q.lock().unwrap().pop_front();
+        match cmd {
+            Some(cmd) => match cmd {
+                Cmd::Configure => {
+                    let d = app.dimensions();
+                    app.window().resize(d.0, d.1);
+                    q.lock().unwrap().push_back(Cmd::Draw);
+                }
+                Cmd::Draw => {
+                    app.redraw().expect("Failed to draw");
+                    app.flush_display();
+                    last_time = Local::now();
+                }
+                Cmd::MaybeDraw => {
+                    let t = Local::now();
+                    if t.hour() != last_time.hour() || t.minute() != last_time.minute() {
+                        q.lock().unwrap().push_back(Cmd::Draw);
+                    }
+                }
+                Cmd::Exit => {
+                    std::process::exit(0);
+                }
+            },
+            None => {
+                app.flush_display();
+
+                let mut fds = [
+                    PollFd::new(app.event_queue().get_connection_fd(), PollFlags::POLLIN),
+                    PollFd::new(tfd.as_raw_fd(), PollFlags::POLLIN),
+                ];
+                poll(&mut fds, -1).unwrap();
+
+                if fds[0].revents().unwrap().contains(PollFlags::POLLIN) {
+                    if let Some(guard) = app.event_queue().prepare_read() {
+                        if let Err(e) = guard.read_events() {
+                            if e.kind() != ::std::io::ErrorKind::WouldBlock {
+                                eprintln!(
+                                    "Error while trying to read from the wayland socket: {:?}",
+                                    e
+                                );
+                            }
+                        }
+                    }
+
+                    app.event_queue()
+                        .dispatch_pending()
+                        .expect("Failed to dispatch all messages.");
+                }
+
+                if fds[1].revents().unwrap().contains(PollFlags::POLLIN) {
+                    tfd.read();
+                    q.lock().unwrap().push_back(Cmd::MaybeDraw);
+                }
+            }
+        }
+    }
+}