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

use std::collections::HashMap;
use std::ffi::{CStr, CString};
use std::fmt::Debug;
use std::os::raw::*;

use parking_lot::Mutex;

use super::*;

type AtomCache = HashMap<CString, ffi::Atom>;

lazy_static! {
    static ref ATOM_CACHE: Mutex<AtomCache> = Mutex::new(HashMap::with_capacity(2048));
}

impl XConnection {
    pub fn get_atom<T: AsRef<CStr> + Debug>(&self, name: T) -> ffi::Atom {
        let name = name.as_ref();
        let mut atom_cache_lock = ATOM_CACHE.lock();
        let cached_atom = (*atom_cache_lock).get(name).cloned();
        if let Some(atom) = cached_atom {
            atom
        } else {
            let atom = unsafe { (self.xlib.XInternAtom)(
                self.display,
                name.as_ptr() as *const c_char,
                ffi::False,
            ) };
            if atom == 0 {
                let msg = format!(
                    "`XInternAtom` failed, which really shouldn't happen. Atom: {:?}, Error: {:#?}",
                    name,
                    self.check_errors(),
                );
                panic!(msg);
            }
            /*println!(
                "XInternAtom name:{:?} atom:{:?}",
                name,
                atom,
            );*/
            (*atom_cache_lock).insert(name.to_owned(), atom);
            atom
        }
    }

    pub unsafe fn get_atom_unchecked(&self, name: &[u8]) -> ffi::Atom {
        debug_assert!(CStr::from_bytes_with_nul(name).is_ok());
        let name = CStr::from_bytes_with_nul_unchecked(name);
        self.get_atom(name)
    }

    // Note: this doesn't use caching, for the sake of simplicity.
    // If you're dealing with this many atoms, you'll usually want to cache them locally anyway.
    pub unsafe fn get_atoms(&self,  names: &[*mut c_char]) -> Result<Vec<ffi::Atom>, XError> {
        let mut atoms = Vec::with_capacity(names.len());
        (self.xlib.XInternAtoms)(
            self.display,
            names.as_ptr() as *mut _,
            names.len() as c_int,
            ffi::False,
            atoms.as_mut_ptr(),
        );
        self.check_errors()?;
        atoms.set_len(names.len());
        /*println!(
            "XInternAtoms atoms:{:?}",
            atoms,
        );*/
        Ok(atoms)
    }
}