wlroots 0.4.0

Wayland compositor framework
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

//! Hooks into the wlroots logging functionality. Internally many events are logged
//! and are reported on standard error. The verbosity of the logs is determined by
//! [the verbosity level](type.LogVerbosity.html) when
//! [initializing the logs](fn.init_logging.html).
//!
//! To log using this system please utilize the [`wlr_log!`](../../macro.wlr_log.html) macro.

use libc::c_char;
use vsprintf::vsprintf;
use wlroots_sys::{wlr_log_importance, __va_list_tag, wlr_log_init, _wlr_log};

use utils::c_to_rust_string;

use std::ffi::CString;

// Export these so it can be used in `wlr_log!`.
pub use self::wlr_log_importance::{WLR_SILENT, WLR_ERROR, WLR_INFO,
                                   WLR_DEBUG};

/// How verbose you want the logging. Lower levels prints more.
pub type LogVerbosity = wlr_log_importance;

/// The signature for the callback function you can hook into the logging
/// functionality of wlroots.
///
/// `message` is the formatted string ready to be displayed on the screen.
pub type LogCallback = fn(verbosity: LogVerbosity, message: String);

static mut RUST_LOGGING_FN: LogCallback = dummy_callback;

/// Initialize wlroots logging at a certain level of verbosity with
/// an optional callback that will be called for every log.
///
/// To log using this system, use the
/// [`wlr_log!`](../../macro.wlr_log.html) macro.
pub fn init_logging<F>(verbosity: LogVerbosity, callback: F)
where F: Into<Option<LogCallback>>
{
    unsafe {
        match callback.into() {
            None => wlr_log_init(verbosity, None),
            Some(callback) => {
                RUST_LOGGING_FN = callback;
                wlr_log_init(verbosity, Some(log_callback));
            }
        }
    }
}

/// Dummy callback to fill in RUST_LOGGING_FN when it's not in use.
fn dummy_callback(_: LogVerbosity, _: String) {}

/// Real hook into the logging callback, calls the real user-supplied callback
/// with nice Rust inputs.
unsafe extern "C" fn log_callback(importance: wlr_log_importance,
                                  fmt: *const c_char,
                                  va_list: *mut __va_list_tag) {
    let message = vsprintf(fmt, va_list).unwrap_or_else(|_| {
        c_to_rust_string(fmt).unwrap_or_else(|| "".into())
    });
    RUST_LOGGING_FN(importance, message);
}

pub struct Logger;

static LOGGER: Logger = Logger;

impl Logger {
    /// Attempts to initialize the global logger with a Logger around _wlr_log.
    ///
    /// This should be called early in the execution of the program, as all log events
    /// that occur before initialization with be ignored.
    ///
    /// # Errors
    ///
    /// This function will fail if it is called more than once, or if another library
    /// has already initialized a global logger.
    pub fn init<F>(level: log::LevelFilter, callback: F)
        where F: Into<Option<LogCallback>>
        {
        init_logging(
            match level {
                log::LevelFilter::Off => WLR_SILENT,
                log::LevelFilter::Warn | log::LevelFilter::Error => WLR_ERROR,
                log::LevelFilter::Info => WLR_INFO,
                log::LevelFilter::Debug | log::LevelFilter::Trace => WLR_DEBUG,
            },
            callback,
        );

        log::set_logger(&LOGGER).expect(
            "Attempted to set a logger after the logging system was already initialized"
        );
        log::set_max_level(level);
    }
}

impl log::Log for Logger {
    fn enabled(&self, metadata: &log::Metadata) -> bool {
        metadata.level() <= log::max_level()
    }

    fn log(&self, record: &log::Record) {
        if self.enabled(record.metadata()) {
            let wlr_level = match record.level() {
                log::Level::Warn | log::Level::Error => WLR_ERROR,
                log::Level::Info => WLR_INFO,
                log::Level::Debug | log::Level::Trace => WLR_DEBUG,
            };

            let formatted_msg = match (record.file(), record.line()) {
                (Some(file), Some(line)) => format!("[{}:{}] {}", file, line, record.args()),
                (Some(file), None) => format!("[{}] {}", file, record.args()),
                (None, _) => format!("{}", record.args()),
            };
            let msg = CString::new(formatted_msg)
                .expect("Could not convert log message to CString");

            unsafe {
                _wlr_log(wlr_level, msg.as_ptr());
            }
        }
    }

    fn flush(&self) {}
}