void set_dpms_mode(char *mode) {
#if NO_X11
return;
#else
RAWFB_RET_VOID
#if LIBVNCSERVER_HAVE_DPMS
if (dpy && DPMSCapable(dpy)) {
CARD16 level;
CARD16 want;
BOOL enabled;
if (!strcmp(mode, "off")) {
want = DPMSModeOff;
} else if (!strcmp(mode, "on")) {
want = DPMSModeOn;
} else if (!strcmp(mode, "standby")) {
want = DPMSModeStandby;
} else if (!strcmp(mode, "suspend")) {
want = DPMSModeSuspend;
} else if (!strcmp(mode, "enable")) {
DPMSEnable(dpy);
return;
} else if (!strcmp(mode, "disable")) {
DPMSDisable(dpy);
return;
} else {
return;
}
if (DPMSInfo(dpy, &level, &enabled)) {
char *from = "unk";
if (enabled && level != want) {
XErrorHandler old_handler = XSetErrorHandler(trap_xerror);
trapped_xerror = 0;
rfbLog("DPMSInfo level: %d enabled: %d\n", level, enabled);
if (level == DPMSModeStandby) {
from = "DPMSModeStandby";
} else if (level == DPMSModeSuspend) {
from = "DPMSModeSuspend";
} else if (level == DPMSModeOff) {
from = "DPMSModeOff";
} else if (level == DPMSModeOn) {
from = "DPMSModeOn";
}
rfbLog("switching DPMS state from %s to %s\n", from, mode);
DPMSForceLevel(dpy, want);
XSetErrorHandler(old_handler);
trapped_xerror = 0;
}
}
}
#endif
#endif
}
/**
* Checks if the X server is capable of DPMS.
* @return @c 1 if the X server is capable of DPMS, @c 0 otherwise.
* @ingroup Ecore_X_DPMS_Group
*/
EAPI Eina_Bool
ecore_x_dpms_capable_get(void)
{
#ifdef ECORE_XDPMS
LOGFN(__FILE__, __LINE__, __FUNCTION__);
return DPMSCapable(_ecore_x_disp) ? EINA_TRUE : EINA_FALSE;
#else /* ifdef ECORE_XDPMS */
return EINA_FALSE;
#endif /* ifdef ECORE_XDPMS */
}
/**
* gpm_dpms_init:
**/
static void
gpm_dpms_init (GpmDpms *dpms)
{
dpms->priv = GPM_DPMS_GET_PRIVATE (dpms);
/* DPMSCapable() can never change for a given display */
dpms->priv->dpms_capable = DPMSCapable (GDK_DISPLAY ());
dpms->priv->timer_id = g_timeout_add_seconds (GPM_DPMS_POLL_TIME, (GSourceFunc)gpm_dpms_poll_mode_cb, dpms);
/* ensure we clear the default timeouts (Standby: 1200s, Suspend: 1800s, Off: 2400s) */
gpm_dpms_clear_timeouts (dpms);
}
/*!
* This function works around an XServer idleTime bug in the
* XScreenSaverExtension if dpms is running. In this case the current
* dpms-state time is always subtracted from the current idletime.
* This means: XScreenSaverInfo->idle is not the time since the last
* user activity, as descriped in the header file of the extension.
* This result in SUSE bug # and sf.net bug #. The bug in the XServer itself
* is reported at https://bugs.freedesktop.org/buglist.cgi?quicksearch=6439.
*
* Workaround: Check if if XServer is in a dpms state, check the
* current timeout for this state and add this value to
* the current idle time and return.
*
* \param _idleTime an unsigned long value with the current idletime from
* XScreenSaverInfo->idle
* \return an unsigned long with the corrected idletime
*/
static unsigned long workaroundX11(Display *dpy, unsigned long _idle) {
int dummy;
CARD16 standby, suspend, off;
CARD16 state;
BOOL onoff;
if(DPMSQueryExtension(dpy, &dummy, &dummy)) {
if(DPMSCapable(dpy)) {
DPMSGetTimeouts(dpy, &standby, &suspend, &off);
DPMSInfo(dpy, &state, &onoff);
if(onoff) {
switch(state) {
case DPMSModeStandby:
// this check is a little bit paranoid, but just to be sure
if(_idle < (unsigned) (standby * 1000)) {
_idle += (standby * 1000);
}
break;
case DPMSModeSuspend:
if(_idle < (unsigned) ((suspend + standby) * 1000)) {
_idle += ((suspend + standby) * 1000);
}
break;
case DPMSModeOff:
if(_idle < (unsigned) ((off + suspend + standby) * 1000)) {
_idle += ((off + suspend + standby) * 1000);
}
break;
case DPMSModeOn:
break;
default:
break;
}
}
}
}
return _idle;
}
void DPMSSupport::PlatformSpecificInit()
{
Display* dpy = g_Windowing.GetDisplay();
if (dpy == NULL) return;
int event_base, error_base; // we ignore these
if (!DPMSQueryExtension(dpy, &event_base, &error_base)) {
CLog::Log(LOGINFO, "DPMS: X11 extension not present, power-saving"
" will not be available");
return;
}
if (!DPMSCapable(dpy)) {
CLog::Log(LOGINFO, "DPMS: display does not support power-saving");
return;
}
m_supportedModes.push_back(SUSPEND); // best compromise
m_supportedModes.push_back(OFF); // next best
m_supportedModes.push_back(STANDBY); // rather lame, < 80% power according to
// DPMS spec
}
/*!
* This function works around an XServer idleTime bug in the
* XScreenSaverExtension if dpms is running. In this case the current
* dpms-state time is always subtracted from the current idletime.
* This means: XScreenSaverInfo->idle is not the time since the last
* user activity, as descriped in the header file of the extension.
* This result in SUSE bug # and sf.net bug #. The bug in the XServer itself
* is reported at https://bugs.freedesktop.org/buglist.cgi?quicksearch=6439.
*
* Workaround: Check if if XServer is in a dpms state, check the
* current timeout for this state and add this value to
* the current idle time and return.
*
* \param _idleTime a unsigned long value with the current idletime from
* XScreenSaverInfo->idle
* \return a unsigned long with the corrected idletime
*/
unsigned long workaroundCreepyXServer(Display *dpy, unsigned long _idleTime ){
int dummy;
CARD16 standby, suspend, off;
CARD16 state;
BOOL onoff;
if (DPMSQueryExtension(dpy, &dummy, &dummy)) {
if (DPMSCapable(dpy)) {
DPMSGetTimeouts(dpy, &standby, &suspend, &off);
DPMSInfo(dpy, &state, &onoff);
if (onoff) {
switch (state) {
case DPMSModeStandby:
/* this check is a littlebit paranoid, but be sure */
if (_idleTime < (unsigned) (standby * 1000))
_idleTime += (standby * 1000);
break;
case DPMSModeSuspend:
if (_idleTime < (unsigned) ((suspend + standby) * 1000))
_idleTime += ((suspend + standby) * 1000);
break;
case DPMSModeOff:
if (_idleTime < (unsigned) ((off + suspend + standby) * 1000))
_idleTime += ((off + suspend + standby) * 1000);
break;
case DPMSModeOn:
default:
break;
}
}
}
}
XCloseDisplay(dpy);
return _idleTime;
}
static void check_dpms(void) {
static int init_dpms = 0;
#if LIBVNCSERVER_HAVE_DPMS
static int dpms_capable = 0;
static time_t last_dpms = 0;
int db = 0;
CARD16 level;
BOOL enabled;
RAWFB_RET_VOID
if (! init_dpms) {
if (getenv("DPMS_DEBUG")) {
db = atoi(getenv("DPMS_DEBUG"));
}
if (DPMSCapable(dpy)) {
dpms_capable = 1;
rfbLog("X display is capable of DPMS.\n");
if (watch_dpms) {
rfbLog("Preventing low-power DPMS modes when"
" clients are connected.\n");
}
} else {
if (! raw_fb_str) {
rfbLog("X display is not capable of DPMS.\n");
}
dpms_capable = 0;
}
init_dpms = 1;
}
if (force_dpms || (client_dpms && client_count)) {
static int last_enable = 0;
if (time(NULL) > last_enable) {
set_dpms_mode("enable");
last_enable = time(NULL);
}
set_dpms_mode("off");
}
if (! watch_dpms) {
return;
}
if (! dpms_capable) {
return;
}
if (! client_count) {
return;
}
if (time(NULL) < last_dpms + 5) {
return;
}
last_dpms = time(NULL);
if (DPMSInfo(dpy, &level, &enabled)) {
if (db) fprintf(stderr, "DPMSInfo level: %d enabled: %d\n", level, enabled);
if (enabled && level != DPMSModeOn) {
char *from = "unknown-dpms-state";
XErrorHandler old_handler = XSetErrorHandler(trap_xerror);
trapped_xerror = 0;
if (level == DPMSModeStandby) {
from = "DPMSModeStandby";
} else if (level == DPMSModeSuspend) {
from = "DPMSModeSuspend";
} else if (level == DPMSModeOff) {
from = "DPMSModeOff";
}
rfbLog("switching DPMS state from %s to DPMSModeOn\n", from);
DPMSForceLevel(dpy, DPMSModeOn);
XSetErrorHandler(old_handler);
trapped_xerror = 0;
}
} else {
if (db) fprintf(stderr, "DPMSInfo failed.\n");
}
#else
RAWFB_RET_VOID
if (! init_dpms) {
if (! raw_fb_str) {
rfbLog("X DPMS extension not supported.\n");
}
init_dpms = 1;
}
#endif
}
int
main(int argc, char **argv) {
char curs[] = {0, 0, 0, 0, 0, 0, 0, 0};
char buf[32], passwd[256];
int num, screen;
#ifndef HAVE_BSD_AUTH
const char *pws;
#endif
unsigned int len;
Bool running = True;
Cursor invisible;
Display *dpy;
KeySym ksym;
Pixmap pmap;
Window root, w;
XColor black, dummy;
XEvent ev;
XSetWindowAttributes wa;
if((argc == 2) && !strcmp("-v", argv[1]))
die("slock-"VERSION", © 2006-2008 Anselm R Garbe\n");
else if(argc != 1)
die("usage: slock [-vb]\n");
backlight_of();
#ifndef HAVE_BSD_AUTH
pws = get_password();
#endif
if(!(dpy = XOpenDisplay(0)))
die("slock: cannot open display\n");
screen = DefaultScreen(dpy);
root = RootWindow(dpy, screen);
/* init */
wa.override_redirect = 1;
wa.background_pixel = BlackPixel(dpy, screen);
w = XCreateWindow(dpy, root, 0, 0, DisplayWidth(dpy, screen), DisplayHeight(dpy, screen),
0, DefaultDepth(dpy, screen), CopyFromParent,
DefaultVisual(dpy, screen), CWOverrideRedirect | CWBackPixel, &wa);
XAllocNamedColor(dpy, DefaultColormap(dpy, screen), "black", &black, &dummy);
pmap = XCreateBitmapFromData(dpy, w, curs, 8, 8);
invisible = XCreatePixmapCursor(dpy, pmap, pmap, &black, &black, 0, 0);
XDefineCursor(dpy, w, invisible);
XMapRaised(dpy, w);
for(len = 1000; len; len--) {
if(XGrabPointer(dpy, root, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync, None, invisible, CurrentTime) == GrabSuccess)
break;
usleep(1000);
}
if((running = running && (len > 0))) {
for(len = 1000; len; len--) {
if(XGrabKeyboard(dpy, root, True, GrabModeAsync, GrabModeAsync, CurrentTime)
== GrabSuccess)
break;
usleep(1000);
}
running = (len > 0);
}
len = 0;
XSync(dpy, False);
/* main event loop */
while(running && !XNextEvent(dpy, &ev)) {
if(len == 0 && DPMSCapable(dpy)) {
DPMSEnable(dpy);
DPMSForceLevel(dpy, DPMSModeOff);
}
if(ev.type == KeyPress) {
buf[0] = 0;
num = XLookupString(&ev.xkey, buf, sizeof buf, &ksym, 0);
if(IsKeypadKey(ksym)) {
if(ksym == XK_KP_Enter)
ksym = XK_Return;
else if(ksym >= XK_KP_0 && ksym <= XK_KP_9)
ksym = (ksym - XK_KP_0) + XK_0;
}
if(IsFunctionKey(ksym) || IsKeypadKey(ksym)
|| IsMiscFunctionKey(ksym) || IsPFKey(ksym)
|| IsPrivateKeypadKey(ksym))
continue;
switch(ksym) {
case XK_Return:
passwd[len] = 0;
#ifdef HAVE_BSD_AUTH
running = !auth_userokay(getlogin(), NULL, "auth-xlock", passwd);
#else
running = strcmp(crypt(passwd, pws), pws);
#endif
if (running != 0)
XBell(dpy, 100);
len = 0;
break;
case XK_Escape:
len = 0;
break;
case XK_BackSpace:
if(len)
--len;
break;
default:
if(num && !iscntrl((int) buf[0]) && (len + num < sizeof passwd)) {
memcpy(passwd + len, buf, num);
len += num;
}
break;
}
}
}
XUngrabPointer(dpy, CurrentTime);
XFreePixmap(dpy, pmap);
XDestroyWindow(dpy, w);
XCloseDisplay(dpy);
backlight_on();
return 0;
}
CXWindowsScreenSaver::CXWindowsScreenSaver(
Display* display, Window window, void* eventTarget, IEventQueue* events) :
m_display(display),
m_xscreensaverSink(window),
m_eventTarget(eventTarget),
m_xscreensaver(None),
m_xscreensaverActive(false),
m_dpms(false),
m_disabled(false),
m_suppressDisable(false),
m_disableTimer(NULL),
m_disablePos(0),
m_events(events)
{
// get atoms
m_atomScreenSaver = XInternAtom(m_display,
"SCREENSAVER", False);
m_atomScreenSaverVersion = XInternAtom(m_display,
"_SCREENSAVER_VERSION", False);
m_atomScreenSaverActivate = XInternAtom(m_display,
"ACTIVATE", False);
m_atomScreenSaverDeactivate = XInternAtom(m_display,
"DEACTIVATE", False);
// check for DPMS extension. this is an alternative screen saver
// that powers down the display.
#if HAVE_X11_EXTENSIONS_DPMS_H
int eventBase, errorBase;
if (DPMSQueryExtension(m_display, &eventBase, &errorBase)) {
if (DPMSCapable(m_display)) {
// we have DPMS
m_dpms = true;
}
}
#endif
// watch top-level windows for changes
bool error = false;
{
CXWindowsUtil::CErrorLock lock(m_display, &error);
Window root = DefaultRootWindow(m_display);
XWindowAttributes attr;
XGetWindowAttributes(m_display, root, &attr);
m_rootEventMask = attr.your_event_mask;
XSelectInput(m_display, root, m_rootEventMask | SubstructureNotifyMask);
}
if (error) {
LOG((CLOG_DEBUG "didn't set root event mask"));
m_rootEventMask = 0;
}
// get the built-in settings
XGetScreenSaver(m_display, &m_timeout, &m_interval,
&m_preferBlanking, &m_allowExposures);
// get the DPMS settings
m_dpmsEnabled = isDPMSEnabled();
// get the xscreensaver window, if any
if (!findXScreenSaver()) {
setXScreenSaver(None);
}
// install disable timer event handler
m_events->adoptHandler(CEvent::kTimer, this,
new TMethodEventJob<CXWindowsScreenSaver>(this,
&CXWindowsScreenSaver::handleDisableTimer));
}
int
main(int argc, char **argv) {
char curs[] = {0, 0, 0, 0, 0, 0, 0, 0};
char buf[32], passwd[256], passdisp[256];
int num, screen, width, height, update, sleepmode, term, pid;
#ifndef HAVE_BSD_AUTH
const char *pws;
#endif
unsigned int len;
Bool running = True;
Cursor invisible;
Display *dpy;
KeySym ksym;
Pixmap pmap;
Window root, w;
XColor black, red, dummy;
XEvent ev;
XSetWindowAttributes wa;
XFontStruct* font;
GC gc;
XGCValues values;
// defaults
char* passchar = "*";
char* fontname = "-*-dejavu sans-bold-r-*-*-*-420-100-100-*-*-iso8859-1";
char* username = "******";
int showline = 1;
for (int i = 0; i < argc; i++) {
if (!strcmp(argv[i], "-c")) {
if (i + 1 < argc)
passchar = argv[i + 1];
else
die("error: no password character given.\n");
} else
if (!strcmp(argv[i], "-f")) {
if (i + 1 < argc)
fontname = argv[i + 1];
else
die("error: font not specified.\n");
}else
if (!strcmp(argv[i], "-u")) {
if (i + 1 < argc)
username = argv[i + 1];
else
die("error: username not specified.\n");
}
else
if (!strcmp(argv[i], "-v"))
die("sflock-"VERSION", © 2010 Ben Ruijl\n");
else
if (!strcmp(argv[i], "-h"))
showline = 0;
else
if (!strcmp(argv[i], "?"))
die("usage: sflock [-v] [-c passchars] [-f fontname] [-u username]\n");
}
// fill with password characters
for (int i = 0; i < sizeof passdisp; i+= strlen(passchar))
for (int j = 0; j < strlen(passchar); j++)
passdisp[i + j] = passchar[j];
/* disable tty switching */
if ((term = open("/dev/console", O_RDWR)) == -1) {
perror("error opening console");
}
if ((ioctl(term, VT_LOCKSWITCH)) == -1) {
perror("error locking console");
}
/* deamonize */
pid = fork();
if (pid < 0)
die("Could not fork sflock.");
if (pid > 0)
exit(0); // exit parent
#ifndef HAVE_BSD_AUTH
pws = get_password(username);
#else
username = getlogin();
#endif
if(!(dpy = XOpenDisplay(0)))
die("sflock: cannot open dpy\n");
screen = DefaultScreen(dpy);
root = RootWindow(dpy, screen);
width = DisplayWidth(dpy, screen);
height = DisplayHeight(dpy, screen);
wa.override_redirect = 1;
wa.background_pixel = XBlackPixel(dpy, screen);
w = XCreateWindow(dpy, root, 0, 0, width, height,
0, DefaultDepth(dpy, screen), CopyFromParent,
DefaultVisual(dpy, screen), CWOverrideRedirect | CWBackPixel, &wa);
XAllocNamedColor(dpy, DefaultColormap(dpy, screen), "orange red", &red, &dummy);
XAllocNamedColor(dpy, DefaultColormap(dpy, screen), "black", &black, &dummy);
pmap = XCreateBitmapFromData(dpy, w, curs, 8, 8);
invisible = XCreatePixmapCursor(dpy, pmap, pmap, &black, &black, 0, 0);
XDefineCursor(dpy, w, invisible);
XMapRaised(dpy, w);
font = XLoadQueryFont(dpy, fontname);
if (font == 0) {
die("error: could not find font. Try using a full description.\n");
}
gc = XCreateGC(dpy, w, (unsigned long)0, &values);
XSetFont(dpy, gc, font->fid);
XSetForeground(dpy, gc, XWhitePixel(dpy, screen));
for(len = 1000; len; len--) {
if(XGrabPointer(dpy, root, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync, None, invisible, CurrentTime) == GrabSuccess)
break;
usleep(1000);
}
if((running = running && (len > 0))) {
for(len = 1000; len; len--) {
if(XGrabKeyboard(dpy, root, True, GrabModeAsync, GrabModeAsync, CurrentTime)
== GrabSuccess)
break;
usleep(1000);
}
running = (len > 0);
}
len = 0;
XSync(dpy, False);
update = True;
sleepmode = False;
/* main event loop */
while(running && !XNextEvent(dpy, &ev)) {
if (sleepmode) {
DPMSEnable(dpy);
DPMSForceLevel(dpy, DPMSModeOff);
XFlush(dpy);
}
if (update) {
int x, y, dir, ascent, descent;
XCharStruct overall;
XClearWindow(dpy, w);
XTextExtents (font, passdisp, len, &dir, &ascent, &descent, &overall);
x = (width - overall.width) / 2;
y = (height + ascent - descent) / 2;
XDrawString(dpy,w,gc, (width - XTextWidth(font, username, strlen(username))) / 2, y - ascent - 20, username, strlen(username));
if (showline)
XDrawLine(dpy, w, gc, width * 3 / 8 , y - ascent - 10, width * 5 / 8, y - ascent - 10);
XDrawString(dpy,w,gc, x, y, passdisp, len);
update = False;
}
if (ev.type == MotionNotify) {
sleepmode = False;
}
if(ev.type == KeyPress) {
sleepmode = False;
buf[0] = 0;
num = XLookupString(&ev.xkey, buf, sizeof buf, &ksym, 0);
if(IsKeypadKey(ksym)) {
if(ksym == XK_KP_Enter)
ksym = XK_Return;
else if(ksym >= XK_KP_0 && ksym <= XK_KP_9)
ksym = (ksym - XK_KP_0) + XK_0;
}
if(IsFunctionKey(ksym) || IsKeypadKey(ksym)
|| IsMiscFunctionKey(ksym) || IsPFKey(ksym)
|| IsPrivateKeypadKey(ksym))
continue;
switch(ksym) {
case XK_Return:
passwd[len] = 0;
#ifdef HAVE_BSD_AUTH
running = !auth_userokay(getlogin(), NULL, "auth-xlock", passwd);
#else
running = strcmp(crypt(passwd, pws), pws);
#endif
if (running != 0)
// change background on wrong password
XSetWindowBackground(dpy, w, red.pixel);
len = 0;
break;
case XK_Escape:
len = 0;
if (DPMSCapable(dpy)) {
sleepmode = True;
}
break;
case XK_BackSpace:
if(len)
--len;
break;
default:
if(num && !iscntrl((int) buf[0]) && (len + num < sizeof passwd)) {
memcpy(passwd + len, buf, num);
len += num;
}
break;
}
update = True; // show changes
}
}
/* free and unlock */
setreuid(geteuid(), 0);
if ((ioctl(term, VT_UNLOCKSWITCH)) == -1) {
perror("error unlocking console");
}
close(term);
setuid(getuid()); // drop rights permanently
XUngrabPointer(dpy, CurrentTime);
XFreePixmap(dpy, pmap);
XFreeFont(dpy, font);
XFreeGC(dpy, gc);
XDestroyWindow(dpy, w);
XCloseDisplay(dpy);
return 0;
}
int main(int argc, char **argv) {
Display *dpy;
int g15screen_fd;
int event;
int error;
BOOL enabled = True;
CARD16 power = 0;
int dummy = 0, lights = True, change = 0;
int i;
struct sigaction new_action;
char * enable_cmd = NULL;
char * disable_cmd = NULL;
int dpms_timeout = 0;
for (i=0;i<argc;i++) {
char argument[20];
memset(argument,0,20);
strncpy(argument,argv[i],19);
if (!strncmp(argument, "-a",2) || !strncmp(argument, "--activate",10)) {
if(argv[i+1]!=NULL){
sscanf(argv[i+1],"%i",&dpms_timeout);
i++;
}else{
printf("%s --activate requires an argument <minutes to activation>\n",argv[0]);
exit(1);
}
}
if (!strncmp(argument, "-e",2) || !strncmp(argument, "--cmd-enable",12)) {
if(argv[i+1]!=NULL){
enable_cmd = malloc(strlen(argv[i+1])+1);
memcpy(enable_cmd, argv[i+1], strlen(argv[i+1]));
i++;
}
}
if (!strncmp(argument, "-d",2) || !strncmp(argument, "--cmd-disable",13)) {
if(argv[i+1]!=NULL){
disable_cmd = malloc(strlen(argv[i+1])+1);
memcpy(disable_cmd, argv[i+1], strlen(argv[i+1]));
i++;
}
}
if (!strncmp(argument, "-v",2) || !strncmp(argument, "--version",9)) {
printf("%s version %s\n",argv[0],VERSION);
exit(0);
}
if (!strncmp(argument, "-b",2) || !strncmp(argument, "--bright",13)) {
bright=1;
}
if (!strncmp(argument, "-h",2) || !strncmp(argument, "--help",6)) {
printf(" %s version %s\n (c)2007 Mike Lampard\n\n",argv[0],VERSION);
printf(" -a or --activate <minutes> - cause DPMS to be activated in <minutes> if no activity.\n");
printf(" By default, %s will simply monitor DPMS status, and\n",argv[0]);
printf(" requires a screensaver to activate. \n");
printf(" In this mode, no screensver is needed.\n");
printf(" %s will shut the monitor down on its own after <minutes>\n",argv[0]);
printf(" with no keyboard or mouse activity.\n");
printf(" -e or --cmd-enable <cmd to run> - Run program <cmd> when DPMS is activated.\n\n");
printf(" -d or --cmd-disable <cmd to run> - Run program <cmd> when DPMS is de-activated.\n\n");
printf(" -b or --bright - When the keyboard is woken up, set the LEDs to bright.\n\n");
printf(" -v or --version - Show program version\n\n");
printf(" -h or --help - This page\n\n");
exit(0);
}
}
dpy = XOpenDisplay(getenv("DISPLAY"));
if (!dpy) {
printf("Unable to open display %s - exiting\n",getenv("DISPLAY"));
return 1;
}
do {
if((g15screen_fd = new_g15_screen(G15_G15RBUF))<0){
printf("Sorry, cant connect to the G15daemon - retrying\n");
sleep(2);
}
}while(g15screen_fd<0);
if (!DPMSQueryExtension (dpy, &event, &error)) {
printf ("XDPMS extension not supported.\n");
return 1;
}
if (!DPMSCapable(dpy)) {
printf("DPMS is not enabled... exiting\n");
return 1;
}
if (dpms_timeout>0) {
DPMSEnable(dpy);
DPMSSetTimeouts(dpy,dpms_timeout*60,dpms_timeout*60,0);
}
new_action.sa_handler = sighandler;
new_action.sa_flags = 0;
sigaction(SIGINT, &new_action, NULL);
sigaction(SIGQUIT, &new_action, NULL);
while(!leaving) {
int fg_check = g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, dummy);
if (! DPMSInfo (dpy, &power, &enabled)) {
printf ("unable to get DPMS state.\n");
return 1;
}
switch(power) {
case DPMSModeOn: {
if (lights == False) {
change = 1;
fork_child(enable_cmd);
}
lights = True;
break;
}
case DPMSModeStandby:
case DPMSModeSuspend:
case DPMSModeOff: {
if(lights == True){
change = 1;
fork_child(disable_cmd);
}
lights = False;
break;
}
}
if (fg_check==1 && lights == True && change == 0) { // foreground
g15_send_cmd (g15screen_fd, G15DAEMON_SWITCH_PRIORITIES, dummy);
}
if(change) {
toggle_g15lights(g15screen_fd,lights,fg_check);
change=0;
}
sleep (1);
}
close(g15screen_fd);
if(enable_cmd!=NULL)
free(enable_cmd);
if(disable_cmd!=NULL)
free(disable_cmd);
XCloseDisplay(dpy);
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;
}
int main(int argc, char** argv) {
int verbose = 0, bg = 0;
int i, ev, er;
char *lock_cmd = "xlock";
char *flag_file = NULL;
char estr[100], cmd[500];
struct stat sbuf;
CARD16 power;
CARD16 desired = DPMSModeOff;
BOOL state;
/* setup the lock command. it may be reset by -lock below. */
if (getenv("XLOCK_CMD")) {
lock_cmd = (char *) getenv("XLOCK_CMD");
}
/* process cmd line: */
for (i=1; i<argc; i++) {
if (!strcmp(argv[i], "-display")) {
sprintf(estr, "DISPLAY=%s", argv[++i]);
putenv(strdup(estr));
} else if (!strcmp(argv[i], "-auth")) {
sprintf(estr, "XAUTHORITY=%s", argv[++i]);
putenv(strdup(estr));
} else if (!strcmp(argv[i], "-lock")) {
lock_cmd = argv[++i];
} else if (!strcmp(argv[i], "-f")) {
flag_file = argv[++i];
unlink(flag_file);
} else if (!strcmp(argv[i], "-grab")) {
grab = 1;
} else if (!strcmp(argv[i], "-bg")) {
bg = 1;
} else if (!strcmp(argv[i], "-v")) {
verbose = 1;
} else if (!strcmp(argv[i], "-standby")) {
desired = DPMSModeStandby;
} else if (!strcmp(argv[i], "-suspend")) {
desired = DPMSModeSuspend;
} else if (!strcmp(argv[i], "-off")) {
desired = DPMSModeOff;
}
}
/* we want it to go into background to avoid blocking, so add '&'. */
strcpy(cmd, lock_cmd);
strcat(cmd, " &");
lock_cmd = cmd;
/* close any file descriptors we may have inherited (e.g. port 5900) */
for (i=3; i<=100; i++) {
close(i);
}
/* open DISPLAY */
dpy = XOpenDisplay(NULL);
if (! dpy) {
fprintf(stderr, "XOpenDisplay failed.\n");
exit(1);
}
/* check for DPMS extension */
if (! DPMSQueryExtension(dpy, &ev, &er)) {
fprintf(stderr, "DPMSQueryExtension failed.\n");
exit(1);
}
if (! DPMSCapable(dpy)) {
fprintf(stderr, "DPMSCapable failed.\n");
exit(1);
}
/* make sure DPMS is enabled */
if (! DPMSEnable(dpy)) {
fprintf(stderr, "DPMSEnable failed.\n");
exit(1);
}
/* retrieve the timeouts for later resetting */
if (! DPMSGetTimeouts(dpy, &standby, &suspend, &off)) {
fprintf(stderr, "DPMSGetTimeouts failed.\n");
exit(1);
}
if (! standby || ! suspend || ! off) {
/* if none, set to some reasonable values */
standby = 900;
suspend = 1200;
off = 1800;
}
if (verbose) {
fprintf(stderr, "DPMS timeouts: %d %d %d\n", standby,
suspend, off);
}
/* now set them to very small values */
if (desired == DPMSModeOff) {
if (! DPMSSetTimeouts(dpy, 1, 1, 1)) {
fprintf(stderr, "DPMSSetTimeouts failed.\n");
exit(1);
}
} else if (desired == DPMSModeSuspend) {
if (! DPMSSetTimeouts(dpy, 1, 1, 0)) {
fprintf(stderr, "DPMSSetTimeouts failed.\n");
exit(1);
}
} else if (desired == DPMSModeStandby) {
if (! DPMSSetTimeouts(dpy, 1, 0, 0)) {
fprintf(stderr, "DPMSSetTimeouts failed.\n");
exit(1);
}
}
XFlush(dpy);
/* set handlers for clean up in case we terminate via signal */
signal(SIGHUP, reset);
signal(SIGINT, reset);
signal(SIGQUIT, reset);
signal(SIGABRT, reset);
signal(SIGTERM, reset);
/* force state into DPMS Off (lowest power) mode */
if (! DPMSForceLevel(dpy, desired)) {
fprintf(stderr, "DPMSForceLevel failed.\n");
exit(1);
}
XFlush(dpy);
/* read state */
msleep(500);
if (! DPMSInfo(dpy, &power, &state)) {
fprintf(stderr, "DPMSInfo failed.\n");
exit(1);
}
fprintf(stderr, "power: %d state: %d\n", power, state);
/* grab display if desired. NOT WORKING */
if (grab) {
if (verbose) {
fprintf(stderr, "calling XGrabServer()\n");
}
XGrabServer(dpy);
}
/* go into background if desired. */
if (bg) {
pid_t p;
if ((p = fork()) != 0) {
if (p < 0) {
fprintf(stderr, "problem forking.\n");
exit(1);
} else {
/* XXX no fd closing */
exit(0);
}
}
}
/* main loop: */
while (1) {
/* reassert DPMSModeOff (desired) */
if (verbose) fprintf(stderr, "reasserting desired DPMSMode\n");
DPMSForceLevel(dpy, desired);
XFlush(dpy);
/* wait a bit */
msleep(200);
/* check for flag file appearence */
if (flag_file && stat(flag_file, &sbuf) == 0) {
if (verbose) {
fprintf(stderr, "flag found: %s\n", flag_file);
}
unlink(flag_file);
reset(0);
exit(0);
}
/* check state and power level */
if (! DPMSInfo(dpy, &power, &state)) {
fprintf(stderr, "DPMSInfo failed.\n");
reset(0);
exit(1);
}
if (verbose) {
fprintf(stderr, "power: %d state: %d\n", power, state);
}
if (!state || power != desired) {
/* Someone (or maybe a cat) is evidently watching... */
fprintf(stderr, "DPMS CHANGE: power: %d state: %d\n",
power, state);
break;
}
}
reset(0);
fprintf(stderr, "locking screen with command: \"%s\"\n", lock_cmd);
system(lock_cmd);
exit(0);
}
