Struct xidlehook_core::Xidlehook

pub struct Xidlehook<T: Timer, M: Module> where
    T: Timer,
    M: Module,  { /* fields omitted */ }

The main xidlehook instance that allows you to schedule things

Implementations

impl<T: Timer> Xidlehook<T, ()>

pub fn new(timers: Vec<T>) -> Self

An empty instance without any modules

impl<T, M> Xidlehook<T, M> where
    T: Timer,
    M: Module, 

pub fn with_module<N: Module>(self, other: N) -> Xidlehook<T, N>

Return this xidlehook instance but with this module replaced.

pub fn register<N: Module>(self, other: N) -> Xidlehook<T, (M, N)>

Return this xidlehook instance but with an additional module activated. This works using the timer impl for (A, B) to get a fixed-size list of modules at compile time.

pub fn timers(&self) -> &Vec<T>

Returns an immutable list of all timers

pub fn timers_mut(&mut self) -> Result<&mut Vec<T>>

Returns a mutable list of all timers. Use this to add or remove timers as you wish. This will abort the idle chain as that may otherwise panic.

pub fn trigger(
    &mut self,
    index: usize,
    absolute_time: Duration,
    force: bool
) -> Result<Progress>

Skip ahead to the selected timer. Timers leading up to this point will not be ran. If you pass force, modules will not even be able to prevent this from happening (all requests pre-timer would be ignored). Post-timer requests are fully complied with.

Whatever the return value is, it's already been handled. If the return value is Err(...), that means this function invoked the module's warning function and that still wanted to propagate the error. If the return value is Ok(Progress::Abort), never mind it. The self.abort() function has already been invoked - it's all cool.

Panics

• If the index is out of bounds

pub fn poll(&mut self, absolute_time: Duration) -> Result<Option<Duration>>

Polls the scheduler for any activated timers. On success, returns the max amount of time a program can sleep for. Only fatal errors cause this function to return, and at that point, the state of xidlehook is undefined so it should not be used.

pub fn main_sync<F>(self, xcb: &Xcb, callback: F) -> Result<()> where
    F: FnMut() -> bool, 

Runs a standard poll-sleep-repeat loop.

static EXITED: AtomicBool = AtomicBool::new(false);

extern "C" fn exit_handler(_signo: libc::c_int) {
    EXITED.store(true, Ordering::SeqCst);
}

unsafe {
    signal::sigaction(
        signal::Signal::SIGINT,
        &signal::SigAction::new(
            signal::SigHandler::Handler(exit_handler),
            signal::SaFlags::empty(),
            signal::SigSet::empty(),
        ),
    )?;
}
xidlehook.main_sync(&xcb, || EXITED.load(Ordering::SeqCst));

Trait Implementations

impl<T, M> Debug for Xidlehook<T, M> where
    T: Timer,
    M: Module + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.