uint32_t Platform::getIdleTime()
{
uint32_t idleTime = 0;
Display *display = XOpenDisplay(NULL);
if (!display)
{
qDebug() << "XOpenDisplay(NULL) failed";
return 0;
}
int32_t x11event = 0, x11error = 0;
static int32_t hasExtension = XScreenSaverQueryExtension(display, &x11event, &x11error);
if (hasExtension)
{
XScreenSaverInfo *info = XScreenSaverAllocInfo();
if (info)
{
XScreenSaverQueryInfo(display, DefaultRootWindow(display), info);
idleTime = info->idle;
XFree(info);
}
else
qDebug() << "XScreenSaverAllocInfo() failed";
}
XCloseDisplay(display);
return idleTime;
}
HippoIdleMonitor*
hippo_idle_add (GdkDisplay *display,
HippoDataCache *cache,
HippoIdleChangedFunc func,
void *data)
{
int event_base, error_base;
Display *xdisplay;
HippoIdleMonitor *monitor;
xdisplay = GDK_DISPLAY_XDISPLAY(display);
if (!XScreenSaverQueryExtension(xdisplay, &event_base, &error_base)) {
g_warning("Screensaver extension not found on X display, can't detect user idleness");
return NULL;
}
monitor = g_new0(HippoIdleMonitor, 1);
monitor->display = g_object_ref(display);
monitor->cache = g_object_ref(cache);
monitor->info = XScreenSaverAllocInfo();
monitor->activity_time = get_time();
monitor->last_idle = 0;
monitor->currently_idle = FALSE;
monitor->func = func;
monitor->data = data;
monitor->poll_id = g_timeout_add(5000, poll_for_idleness, monitor);
monitor->applications_by_app_id = g_hash_table_new_full(g_str_hash, g_str_equal,
(GDestroyNotify)g_free, (GDestroyNotify)g_free);
monitor->applications_by_wm_class = g_hash_table_new_full(g_str_hash, g_str_equal,
(GDestroyNotify)g_free, (GDestroyNotify)g_free);
return monitor;
}
Bool
query_mit_saver_extension (saver_info *si)
{
return XScreenSaverQueryExtension (si->dpy,
&si->mit_saver_ext_event_number,
&si->mit_saver_ext_error_number);
}
void
X11_SuspendScreenSaver(_THIS)
{
#if SDL_VIDEO_DRIVER_X11_SCRNSAVER
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
int dummy;
int major_version, minor_version;
if (SDL_X11_HAVE_XSS) {
/* XScreenSaverSuspend was introduced in MIT-SCREEN-SAVER 1.1 */
if (!XScreenSaverQueryExtension(data->display, &dummy, &dummy) ||
!XScreenSaverQueryVersion(data->display,
&major_version, &minor_version) ||
major_version < 1 || (major_version == 1 && minor_version < 1)) {
return;
}
XScreenSaverSuspend(data->display, _this->suspend_screensaver);
XResetScreenSaver(data->display);
}
#endif
#ifdef GNOME_SCREENSAVER_HACK
if (_this->suspend_screensaver) {
gnome_screensaver_disable();
} else {
gnome_screensaver_enable();
}
#endif
}
bool
XInterface::QuerySSExtension()
{
#ifdef HAVE_XSS
static XScreenSaverInfo *xssi = 0;
if (needsCheck) {
needsCheck = false;
int notused = 0;
hasXss = XScreenSaverQueryExtension(_display, ¬used, ¬used);
dprintf(D_ALWAYS, "X server %s have the screen saver extension\n", hasXss ? "does" : "does not");
}
if (hasXss) {
if (!xssi) {
xssi = XScreenSaverAllocInfo();
}
XScreenSaverQueryInfo(_display,DefaultRootWindow(_display), xssi);
dprintf(D_FULLDEBUG, "Screen Saver extension claims idle time is %ld ms\n", xssi->idle);
if (xssi->idle < 20000l) {
return true;
}
}
return false;
#else
return false;
#endif
}
bool X11IdleDetector::idleCheckPossible()
{
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
int event_base, error_base;
if(XScreenSaverQueryExtension(QX11Info::display(), &event_base, &error_base))
return true;
#endif
return false;
}
XSSIdleQuerier::XSSIdleQuerier() : display(NULL), info(NULL) {
display = XOpenDisplay(NULL);
assert(display);
rootWindow = DefaultRootWindow(display);
int event, error;
available = XScreenSaverQueryExtension(display, &event, &error);
if (available) {
info = XScreenSaverAllocInfo();
}
else {
std::cerr << "Warning: XScreenSaver extension not found. Idle time detection will not work." << std::endl;
}
}
Idle::Idle()
{
if (ss_info == 0)
{
old_handler = XSetErrorHandler(xerrhandler);
int event_base, error_base;
if(XScreenSaverQueryExtension(QX11Info::display(), &event_base, &error_base))
{
ss_info = XScreenSaverAllocInfo();
}
}
}
Xidle::Xidle()
{
int event_basep, error_basep;
display = XOpenDisplay(NULL);
if (display == nullptr) {
throw std::runtime_error("could not open display");
}
if (!XScreenSaverQueryExtension(display, &event_basep, &error_basep)) {
throw std::runtime_error("screen saver extension not supported");
}
}
bool IdlePlatform::init()
{
if(d->ss_info)
return true;
old_handler = XSetErrorHandler(xerrhandler);
int event_base, error_base;
if(XScreenSaverQueryExtension(X11Info::display(), &event_base, &error_base)) {
d->ss_info = XScreenSaverAllocInfo();
return true;
}
return false;
}
IdleTimeDetector::IdleTimeDetector(int maxIdle)
{
_maxIdle = maxIdle;
#if defined(HAVE_LIBXSS) && defined(Q_WS_X11)
int event_base, error_base;
if(XScreenSaverQueryExtension(QX11Info::display(), &event_base, &error_base)) _idleDetectionPossible = true;
else _idleDetectionPossible = false;
_timer = new QTimer(this);
connect(_timer, SIGNAL(timeout()), this, SLOT(check()));
#else
_idleDetectionPossible = false;
#endif // HAVE_LIBXSS
}
unsigned AutoAwayPlugin::getIdleTime()
{
#ifdef WIN32
unsigned idle_time = 0;
if (_GetLastInputInfo == NULL){
POINT p;
GetCursorPos(&p);
time_t now;
time(&now);
if ((p.x != oldX) || (p.y != oldY)){
oldX = p.x;
oldY = p.y;
lastTime = now;
}
return now - lastTime;
}
LASTINPUTINFO lii;
ZeroMemory(&lii,sizeof(lii));
lii.cbSize=sizeof(lii);
_GetLastInputInfo(&lii);
return (GetTickCount()-lii.dwTime) / 1000;
#else
QWidgetList *list = QApplication::topLevelWidgets();
QWidgetListIt it(*list);
QWidget *w = it.current();
delete list;
if (w == NULL)
return 0;
static XScreenSaverInfo *mit_info = NULL;
if (mit_info == NULL) {
int event_base, error_base;
if(XScreenSaverQueryExtension(w->x11Display(), &event_base, &error_base)) {
mit_info = XScreenSaverAllocInfo ();
}
}
if (mit_info == NULL){
log(L_WARN, "No XScreenSaver extension found on current XServer, disabling auto-away.");
m_timer->stop();
return 0;
}
if (!XScreenSaverQueryInfo(w->x11Display(), qt_xrootwin(), mit_info)) {
log(L_WARN, "XScreenSaverQueryInfo failed, disabling auto-away.");
m_timer->stop();
return 0;
}
return (mit_info->idle / 1000);
#endif
}
unsigned AutoAwayPlugin::getIdleTime()
{
#ifdef WIN32
if (_GetLastInputInfo){
LASTINPUTINFO lii;
ZeroMemory(&lii,sizeof(lii));
lii.cbSize=sizeof(lii);
_GetLastInputInfo(&lii);
return (GetTickCount()-lii.dwTime) / 1000;
}
if (_IdleUIGetLastInputTime)
return _IdleUIGetLastInputTime() / 1000;
return 0;
#else
#ifdef HAVE_CARBON_CARBON_H
return mSecondsIdle;
#else
QWidgetList *list = QApplication::topLevelWidgets();
QWidgetListIt it(*list);
QWidget *w = it.current();
delete list;
if (w == NULL)
return 0;
static XScreenSaverInfo *mit_info = NULL;
if (mit_info == NULL) {
int event_base, error_base;
if(XScreenSaverQueryExtension(w->x11Display(), &event_base, &error_base)) {
mit_info = XScreenSaverAllocInfo ();
}
}
if (mit_info == NULL){
log(L_WARN, "No XScreenSaver extension found on current XServer, disabling auto-away.");
m_timer->stop();
return 0;
}
if (!XScreenSaverQueryInfo(w->x11Display(), qt_xrootwin(), mit_info)) {
log(L_WARN, "XScreenSaverQueryInfo failed, disabling auto-away.");
m_timer->stop();
return 0;
}
return (mit_info->idle / 1000);
#endif
#endif
}
bool IdlePlatform::init() const
{
if(d->ss_info)
return true;
old_handler = XSetErrorHandler(xerrhandler);
int event_base, error_base;
#if (QT_VERSION < 0x050000)
if(XScreenSaverQueryExtension(QX11Info::display(), &event_base, &error_base)) {
d->ss_info = XScreenSaverAllocInfo();
return true;
}
#else
// FIXME: Need a replacement for this?
#endif
return false;
}
long idleTime() {
long idlesecs;
#ifdef LINUX
bool _idleDetectionPossible;
XScreenSaverInfo *_mit_info;
int event_base, error_base;
if(XScreenSaverQueryExtension(QX11Info::display(), &event_base, &error_base))
_idleDetectionPossible = true;
else
_idleDetectionPossible = false;
_mit_info = XScreenSaverAllocInfo();
XScreenSaverQueryInfo(QX11Info::display(), QX11Info::appRootWindow(), _mit_info);
idlesecs = (_mit_info->idle/1000);
#endif
#ifdef WINDOWS
LASTINPUTINFO lif;
lif.cbSize = sizeof(LASTINPUTINFO);
GetLastInputInfo(&lif);
DWORD tickCount = GetTickCount();
idlesecs = (tickCount - lif.dwTime) / 1000;
#endif
#ifdef MAC
idlesecs = -1;//int64_t
io_iterator_t iter = 0;
if (IOServiceGetMatchingServices(kIOMasterPortDefault, IOServiceMatching("IOHIDSystem"), &iter) == KERN_SUCCESS) {
io_registry_entry_t entry = IOIteratorNext(iter);
if (entry) {
CFMutableDictionaryRef dict = NULL;
if (IORegistryEntryCreateCFProperties(entry, &dict, kCFAllocatorDefault, 0) == KERN_SUCCESS) {
CFNumberRef obj = (CFNumberRef)CFDictionaryGetValue(dict, CFSTR("HIDIdleTime"));
if (obj) {
int64_t nanoseconds = 0;
if (CFNumberGetValue(obj, kCFNumberSInt64Type, &nanoseconds)) {
idlesecs = (nanoseconds >> 30); // Divide by 10^9 to convert from nanoseconds to seconds.
}
}
CFRelease(dict);
}
int main(int argc, char *argv[])
{
Display *display;
int event_base, error_base;
XScreenSaverInfo info;
unsigned int ms;
if (argc != 3)
{
fprintf(stderr, "Usage: %s [DISPLAY] [Xauthority]\n", argv[0]);
return 1;
}
setenv("DISPLAY", argv[1], 1);
setenv("XAUTHORITY", argv[2], 2);
display = XOpenDisplay("");
if(display)
{
if (XScreenSaverQueryExtension(display, &event_base, &error_base))
{
XScreenSaverQueryInfo(display, DefaultRootWindow(display), &info);
ms = (unsigned int)info.idle;
printf("%u\n", ms);
return(0);
}
else
{
fprintf(stderr,"Error: XScreenSaver Extension not present\n");
return(1);
}
}
else
{
fprintf(stderr,"Error: Invalid Display\n");
return(1);
}
return 0;
}
void initfn()
{
int event_basep, error_basep;
dpy = XOpenDisplay(NULL);
if (NULL == dpy) {
release();
return;
}
if (!XScreenSaverQueryExtension(dpy, &event_basep, &error_basep)) {
release();
return;
}
ssi = XScreenSaverAllocInfo();
if (ssi == NULL) {
release();
return;
}
}
int
main(int argc, char *argv[])
{
XScreenSaverInfo info;
Display *dpy = XOpenDisplay(NULL);
if(NULL == dpy) {
fprintf(stderr, "failed to open display\n");
return 1;
}
int a = 0;
int b = 0;
XScreenSaverQueryExtension(dpy, &a, &b);
printf("%d %d\n", a, b);
XScreenSaverQueryInfo(dpy, RootWindow(dpy, DefaultScreen(dpy)), &info);
printf("%d %d %d %d\n", info.state, info.til_or_since, info.idle, info.kind);
return 0;
}
/*
* Class: net_java_sip_communicator_impl_sysactivity_SystemActivityNotifications
* Method: getLastInput
* Signature: ()J
*/
JNIEXPORT jlong JNICALL Java_net_java_sip_communicator_impl_sysactivity_SystemActivityNotifications_getLastInput
(JNIEnv* jniEnv, jclass clazz)
{
static XScreenSaverInfo *mit_info = NULL;
static int has_extension = -1;
int event_base, error_base;
if(GDK_DISPLAY())
has_extension = XScreenSaverQueryExtension(GDK_DISPLAY(), &event_base, &error_base);
if (has_extension != -1)
{
mit_info = XScreenSaverAllocInfo();
XScreenSaverQueryInfo(GDK_DISPLAY(), GDK_ROOT_WINDOW(), mit_info);
return (mit_info->idle);
}
else
return 0;
}
static gboolean
drw_monitor_setup (DrwMonitor *monitor)
{
DrwMonitorPriv *priv;
int event_base;
int error_base;
priv = monitor->priv;
if (!XScreenSaverQueryExtension (GDK_DISPLAY (), &event_base, &error_base)) {
return FALSE;
}
priv->ss_info = XScreenSaverAllocInfo ();
priv->last_activity = time (NULL);
priv->timeout_id = g_timeout_add_seconds (3, (GSourceFunc) drw_monitor_timeout, monitor);
return TRUE;
}
static void screenSaverSetXScreenSaver( CompDisplay *d, Bool enable )
{
SCREENSAVER_DISPLAY(d);
if( enable && !sd->XSScontext.init )
{
int dummy;
if( !XScreenSaverQueryExtension(d->display, &sd->XSScontext.first_event, &dummy ) )
{
compLogMessage ("screensaver", CompLogLevelWarn,
"XScreenSaver Extension not available");
return;
}
sd->XSScontext.init = True;
XGetScreenSaver( d->display, &sd->XSScontext.timeout, &sd->XSScontext.interval, \
&sd->XSScontext.prefer_blanking, &sd->XSScontext.allow_exposures);
XSetScreenSaver( d->display, (int)(screensaverGetAfter(d)*60.0), sd->XSScontext.interval, 0, AllowExposures);
Window root = DefaultRootWindow (d->display);
XSetWindowAttributes attr;
int mask = 0;
XScreenSaverSetAttributes( d->display,root, -100,-100,1,1,0 ,CopyFromParent,CopyFromParent,CopyFromParent,mask,&attr);
XScreenSaverSelectInput( d->display, root, ScreenSaverNotifyMask );
}
if( !enable && sd->XSScontext.init )
{
sd->XSScontext.init = False;
XSetScreenSaver( d->display, sd->XSScontext.timeout, sd->XSScontext.interval, \
sd->XSScontext.prefer_blanking, sd->XSScontext.allow_exposures);
Window root = DefaultRootWindow (d->display);
XScreenSaverSelectInput( d->display, root, 0 );
XScreenSaverUnsetAttributes( d->display, root );
}
}
int main(int argc, char **argv) {
long started, wait_idle_ms, timeout_ms;
int event_base, error_base, timed_out = 0;
if (argc > 1) wait_idle_ms = parse_long(argv[1], DEFAULT_WAIT_MS);
if (argc > 2) timeout_ms = parse_long(argv[2], DEFAULT_TIMEOUT_MS);
started = now();
Display *disp = XOpenDisplay(NULL);
OK(disp);
OK(XScreenSaverQueryExtension(disp, &event_base, &error_base));
XScreenSaverInfo *info = XScreenSaverAllocInfo();
OK(info);
while (1) {
if (now() >= started + timeout_ms * NANOS / MILLIS) BREAK(timed_out);
OK(XScreenSaverQueryInfo(disp, DefaultRootWindow(disp), info));
if (info->idle >= wait_idle_ms) break;
}
XFree(info);
XCloseDisplay(disp);
exit(timed_out ? EXIT_FAILURE : EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
XScreenSaverInfo *ssi;
Display *dpy;
int event_basep, error_basep;
if (argc != 1) {
usage(argv[0]);
return 1;
}
dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
fprintf(stderr, "couldn't open display\n");
return 1;
}
if (!XScreenSaverQueryExtension(dpy, &event_basep, &error_basep)) {
fprintf(stderr, "screen saver extension not supported\n");
return 1;
}
ssi = XScreenSaverAllocInfo();
if (ssi == NULL) {
fprintf(stderr, "couldn't allocate screen saver info\n");
return 1;
}
if (!XScreenSaverQueryInfo(dpy, DefaultRootWindow(dpy), ssi)) {
fprintf(stderr, "couldn't query screen saver info\n");
return 1;
}
printf("%lu\n", workaroundCreepyXServer(dpy, ssi->idle));
XFree(ssi);
XCloseDisplay(dpy);
return 0;
}
long
Tk_GetUserInactiveTime(
Display *dpy) /* The display for which to query the inactive
* time. */
{
long inactiveTime = -1;
#ifdef HAVE_XSS
int eventBase, errorBase, major, minor;
/*
* Calling XScreenSaverQueryVersion seems to be needed to prevent a crash
* on some buggy versions of XFree86.
*/
if (
#ifdef __APPLE__
XScreenSaverQueryInfo != NULL && /* Support for weak-linked libXss. */
#endif
XScreenSaverQueryExtension(dpy, &eventBase, &errorBase) &&
XScreenSaverQueryVersion(dpy, &major, &minor)) {
XScreenSaverInfo *info = XScreenSaverAllocInfo();
if (info == NULL) {
/*
* We are out of memory.
*/
Tcl_Panic("Out of memory: XScreenSaverAllocInfo failed in Tk_GetUserInactiveTime");
}
if (XScreenSaverQueryInfo(dpy, DefaultRootWindow(dpy), info)) {
inactiveTime = info->idle;
}
XFree(info);
}
#endif /* HAVE_XSS */
return inactiveTime;
}
int
main(int argc, char *argv[])
{
XEvent ev;
struct sigaction act = { };
int evbase, errbase;
if (argc < 2)
errx(2, "usage: xssstart command [argument ...]\n");
if ((dpy = XOpenDisplay(NULL)) == NULL)
errx(1, "no display");
atexit(closedisplay);
if (!XScreenSaverQueryExtension(dpy, &evbase, &errbase))
errx(1, "X11 extension MIT-SCREEN-SAVER not supported");
XSetErrorHandler(eh);
XScreenSaverSelectInput(dpy, DefaultRootWindow(dpy),
ScreenSaverNotifyMask);
act.sa_handler = sigchld;
act.sa_flags = SA_NOCLDSTOP | SA_RESTART;
if (sigaction(SIGCHLD, &act, NULL) == -1)
err(1, "sigaction");
while (XNextEvent(dpy, &ev) == 0) {
if (((XScreenSaverNotifyEvent *)&ev)->state == ScreenSaverOn &&
child == 0) {
switch ((child = fork())) {
case -1:
err(1, "fork");
case 0:
execvp(argv[1], argv + 1);
dpy = NULL;
err(1, "exec");
}
}
}
return 0;
}
unsigned long getIdleTime()
{
XScreenSaverInfo ssi;
Display *dpy;
int event_basep, error_basep;
dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
//fprintf(stderr, "Couldn't open display\n");
return -1;
}
if (!XScreenSaverQueryExtension(dpy, &event_basep, &error_basep)) {
//fprintf(stderr, "Screen saver extension not supported\n");
return -1;
}
if (!XScreenSaverQueryInfo(dpy, DefaultRootWindow(dpy), &ssi)) {
//fprintf(stderr, "Couldn't query screen saver info\n");
return -1;
}
return workaroundCreepyXServer(dpy, ssi.idle);
}
int main(int argc, char** argv)
{
gdk_init(&argc, &argv);
#if defined(HAVE_LIBXSS) && defined(MOZ_WIDGET_GTK)
int event_base, error_base;
Bool have_xscreensaver =
XScreenSaverQueryExtension(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()),
&event_base, &error_base);
if (!have_xscreensaver) {
fprintf(stderr, "No XScreenSaver extension on display\n");
} else {
XScreenSaverInfo* info = XScreenSaverAllocInfo();
if (!info) {
fprintf(stderr, "%s: Out of memory\n", argv[0]);
return 1;
}
XScreenSaverQueryInfo(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()),
GDK_ROOT_WINDOW(), info);
const char* state;
const char* til_or_since = nullptr;
switch (info->state) {
case ScreenSaverOff:
state = "Off";
til_or_since = "XScreenSaver will activate after another %lu seconds idle time\n";
break;
case ScreenSaverOn:
state = "On";
if (info->til_or_since) {
til_or_since = "XScreenSaver idle timer activated %lu seconds ago\n";
} else {
til_or_since = "XScreenSaver idle activation is disabled\n";
}
break;
case ScreenSaverDisabled:
state = "Disabled";
break;
default:
state = "unknown";
}
const char* kind;
switch (info->kind) {
case ScreenSaverBlanked:
kind = "Blanked";
break;
case ScreenSaverInternal:
state = "Internal";
break;
case ScreenSaverExternal:
state = "External";
break;
default:
state = "unknown";
}
fprintf(stderr, "XScreenSaver state: %s\n", state);
if (til_or_since) {
fprintf(stderr, "XScreenSaver kind: %s\n", kind);
fprintf(stderr, til_or_since, info->til_or_since / 1000);
}
fprintf(stderr, "User input has been idle for %lu seconds\n", info->idle / 1000);
XFree(info);
}
#endif
GdkPixbuf* screenshot = nullptr;
GdkWindow* window = gdk_get_default_root_window();
#if (MOZ_WIDGET_GTK == 2)
screenshot = gdk_pixbuf_get_from_drawable(nullptr, window, nullptr,
0, 0, 0, 0,
gdk_screen_width(),
gdk_screen_height());
#else
screenshot = gdk_pixbuf_get_from_window(window, 0, 0,
gdk_window_get_width(window),
gdk_window_get_height(window));
#endif
if (!screenshot) {
fprintf(stderr, "%s: failed to create screenshot GdkPixbuf\n", argv[0]);
return 1;
}
GError* error = nullptr;
if (argc > 1) {
gdk_pixbuf_save(screenshot, argv[1], "png", &error, nullptr);
} else {
gdk_pixbuf_save_to_callback(screenshot, save_to_stdout, nullptr,
"png", &error, nullptr);
}
if (error) {
fprintf(stderr, "%s: failed to write screenshot as png: %s\n",
argv[0], error->message);
return error->code;
}
return 0;
}
uint32_t
get_idle_milliseconds(Display *d)
{
XScreenSaverInfo *ssi;
int evbase, errbase;
if (!XScreenSaverQueryExtension(d, &evbase, &errbase))
{
fprintf(stderr, "screen saver extension not supported\n");
return 1;
}
ssi = XScreenSaverAllocInfo();
if (ssi == NULL)
{
fprintf(stderr, "couldn't allocate screen saver info\n");
return 1;
}
if (!XScreenSaverQueryInfo(d, DefaultRootWindow(d), ssi))
{
fprintf(stderr, "couldn't query screen saver info\n");
return 1;
}
uint32_t idle = (uint32_t) ssi->idle;
XFree(ssi);
// ugh. ssi->idle is wrong if DPMS is enabled, we have
// to compensate.
if (DPMSQueryExtension(d, &evbase, &errbase))
{
if (DPMSCapable(d))
{
CARD16 standby, suspend, off, state;
BOOL onoff;
DPMSGetTimeouts(d, &standby, &suspend, &off);
DPMSInfo(d, &state, &onoff);
if (onoff)
{
uint32_t offset = 0;
switch (state)
{
case DPMSModeStandby:
offset = (uint32_t) (standby * 1000);
break;
case DPMSModeSuspend:
offset = (uint32_t) ((suspend + standby) * 1000);
break;
case DPMSModeOff:
offset = (uint32_t) ((off + suspend + standby) * 1000);
break;
default:
/*nothing*/;
}
if (offset != 0 && idle < offset)
idle += offset;
}
}
}
return idle;
}
// Check if the XScreenSaver extension is supported by the X server
static void check_xss_supported(int event_basep, int error_basep) {
if(!XScreenSaverQueryExtension(dpy, &event_basep, &error_basep)) {
fprintf(stderr, _("Error: screen saver extension not supported\n"));
exit(EXIT_FAILURE);
}
}
// ===================================
// main...
// -----------------------------------
int main (int argc,char *argv[]) {
XSetWindowAttributes attr;
Display* dpy;
Window root;
char mydisp [256] = "";
int fg = 0;
int screen;
int c;
// ============================
// get commandline options...
// ----------------------------
while (1) {
int option_index = 0;
static struct option long_options[] =
{
{"display" , 1 , 0 , 'd'},
{"pid" , 1 , 0 , 'p'},
{"help" , 0 , 0 , 'h'},
{"timeout" , 1 , 0 , 't'},
{"foreground" , 0 , 0 , 'f'},
{"output" , 0 , 0 , 'o'},
{0 , 0 , 0 , 0 }
};
c = getopt_long (
argc, argv, "hd:p:t:fo",long_options, &option_index
);
if (c == -1)
break;
switch (c) {
case 'h':
usage();
exit(0);
case 't':
timeout = atoi(optarg);
break;
case 'd':
strcpy(mydisp,optarg);
break;
case 'p':
pid = atoi(optarg);
break;
case 'o':
output = 1;
break;
case 'f':
fg = 1;
break;
default:
usage();
exit(1);
}
}
// prove pid...
// --------------
if (pid == 0) {
printf("xidle: no valid pid defined\n");
exit(1);
}
// open display...
// ------------------
if (strcmp(mydisp,"") == 0) {
dpy = XOpen("null");
} else {
dpy = XOpen(mydisp);
}
if (dpy == NULL) {
printf("xidle: unable to open display: %s\n",mydisp);
exit(1);
}
// go for daemon...
// -----------------
if (fg == 0) {
daemon(1,0);
}
// install signal handler...
// --------------------------
signal( SIGHUP , handlesighup );
signal( SIGCHLD , handlesigchld );
signal( SIGTRAP , timerstatus );
signal( SIGCONT , handlesigreset );
// default window is the root window...
// -------------------------------------
root = DefaultRootWindow(dpy);
screen = DefaultScreen(dpy);
// look if the MIT extension is available...
// -------------------------------------------
if (!XScreenSaverQueryExtension (dpy, &ss_event, &ss_error)) {
exit(1);
}
XScreenSaverSelectInput (dpy, root, ScreenSaverNotifyMask);
XSync (dpy, False);
// select keyboard for press and release...
// ------------------------------------------
attr.event_mask = KeyPressMask | PointerMotionMask;
XSelectInput(dpy, DefaultRootWindow(dpy), attr.event_mask);
// set internal screen saver timeout...
// ---------------------------------------
timersignal();
setsaver(dpy,timeout);
while(1) {
XEvent event;
XScreenSaverNotifyEvent *sevent;
XNextEvent (dpy, &event);
// ==========================================
// reset timer for pointer motion events...
// ------------------------------------------
if (event.type == MotionNotify) {
triggerreset();
}
// =====================================================
// reset timer for keyevents differently from Escape...
// -----------------------------------------------------
else if (event.type == KeyPress) {
XKeyEvent *e = (XKeyEvent*)&event;
if (e->keycode == ESC) {
Exit();
} else {
triggerreset();
}
}
// ==========================================
// catch screen saver event...
// ------------------------------------------
else if (event.type == ss_event) {
sevent = (XScreenSaverNotifyEvent *) &event;
if (sevent->state == ScreenSaverOn) {
// get screen saver event...
// --------------------------
Exit();
}
}
// ==============================================
// put back event to the queue if not handled...
// ----------------------------------------------
else {
XPutBackEvent(dpy,&event);
}
}
XCloseDisplay(dpy);
return(0);
}