Glib::SignalTimeout Class Reference

#include <glibmm/main.h>

Public Member Functions
sigc::connection	connect (const sigc::slot< bool()> &slot, unsigned int interval, int priority=PRIORITY_DEFAULT)
	Connects a timeout handler.
void	connect_once (const sigc::slot< void()> &slot, unsigned int interval, int priority=PRIORITY_DEFAULT)
	Connects a timeout handler that runs only once.
sigc::connection	connect_seconds (const sigc::slot< bool()> &slot, unsigned int interval, int priority=PRIORITY_DEFAULT)
	Connects a timeout handler with whole second granularity.
void	connect_seconds_once (const sigc::slot< void()> &slot, unsigned int interval, int priority=PRIORITY_DEFAULT)
	Connects a timeout handler that runs only once with whole second granularity.

Member Function Documentation

connect()

sigc::connection Glib::SignalTimeout::connect	(	const sigc::slot< bool()> &	slot,
		unsigned int	interval,
		int	priority = PRIORITY_DEFAULT
	)

Connects a timeout handler.

Note that timeout functions may be delayed, due to the processing of other event sources. Thus they should not be relied on for precise timing. After each call to the timeout function, the time of the next timeout is recalculated based on the current time and the given interval (it does not try to 'catch up' time lost in delays).

If you want to have a timer in the "seconds" range and do not care about the exact time of the first call of the timer, use the connect_seconds() function; this function allows for more optimizations and more efficient system power usage.

bool timeout_handler() { ... }
Glib::signal_timeout().connect(sigc::ptr_fun(&timeout_handler), 1000);

is equivalent to:

bool timeout_handler() { ... }
const auto timeout_source = Glib::TimeoutSource::create(1000);
timeout_source->connect(sigc::ptr_fun(&timeout_handler));
timeout_source->attach(Glib::MainContext::get_default());

This method is not thread-safe. You should call it, or manipulate the returned sigc::connection object, only from the thread where the SignalTimeout object's MainContext runs.

Parameters

slot	A slot to call when interval has elapsed. If timeout_handler() returns false the handler is disconnected.
interval	The timeout in milliseconds.
priority	The priority of the new event source.

Returns

A connection handle, which can be used to disconnect the handler.

connect_once()

void Glib::SignalTimeout::connect_once	(	const sigc::slot< void()> &	slot,
		unsigned int	interval,
		int	priority = PRIORITY_DEFAULT
	)

Connects a timeout handler that runs only once.

This method takes a function pointer to a function with a void return and no parameters. After running once it is not called again.

Because sigc::trackable is not thread-safe, if the slot represents a non-static method of a class deriving from sigc::trackable, and the slot is created by sigc::mem_fun(), connect_once() should only be called from the thread where the SignalTimeout object's MainContext runs. You can use, say, boost::bind() or, in C++11, std::bind() or a C++11 lambda expression instead of sigc::mem_fun().

See also

connect()

Parameters

slot	A slot to call when interval has elapsed. For example: void on_timeout_once()
interval	The timeout in milliseconds.
priority	The priority of the new event source.

connect_seconds()

sigc::connection Glib::SignalTimeout::connect_seconds	(	const sigc::slot< bool()> &	slot,
		unsigned int	interval,
		int	priority = PRIORITY_DEFAULT
	)

Connects a timeout handler with whole second granularity.

Unlike connect(), this operates at whole second granularity. The initial starting point of the timer is determined by the implementation and the implementation is expected to group multiple timers together so that they fire all at the same time.

To allow this grouping, the interval to the first timer is rounded and can deviate up to one second from the specified interval. Subsequent timer iterations will generally run at the specified interval.

bool timeout_handler() { ... }
Glib::signal_timeout().connect_seconds(sigc::ptr_fun(&timeout_handler), 5);

is equivalent to:

bool timeout_handler() { ... }
const auto timeout_source = Glib::TimeoutSource::create(5000);
timeout_source->connect(sigc::ptr_fun(&timeout_handler));
timeout_source->attach(Glib::MainContext::get_default());

This method is not thread-safe. You should call it, or manipulate the returned sigc::connection object, only from the thread where the SignalTimeout object's MainContext runs.

Parameters

slot	A slot to call when interval has elapsed. If timeout_handler() returns false the handler is disconnected.
interval	The timeout in seconds.
priority	The priority of the new event source.

Returns

A connection handle, which can be used to disconnect the handler.

Since glibmm 2.14:

connect_seconds_once()

void Glib::SignalTimeout::connect_seconds_once	(	const sigc::slot< void()> &	slot,
		unsigned int	interval,
		int	priority = PRIORITY_DEFAULT
	)

Connects a timeout handler that runs only once with whole second granularity.

This method takes a function pointer to a function with a void return and no parameters. After running once it is not called again.

Because sigc::trackable is not thread-safe, if the slot represents a non-static method of a class deriving from sigc::trackable, and the slot is created by sigc::mem_fun(), connect_seconds_once() should only be called from the thread where the SignalTimeout object's MainContext runs. You can use, say, boost::bind() or, in C++11, std::bind() or a C++11 lambda expression instead of sigc::mem_fun().

See also

connect_seconds()

Parameters

slot	A slot to call when interval has elapsed. For example: void on_timeout_once()
interval	The timeout in seconds.
priority	The priority of the new event source.