Example #1
0
void wsScreenSaverOn(Display *mDisplay)
{
    int nothing;

#ifdef CONFIG_XDPMS

    if (dpms_disabled) {
        if (DPMSQueryExtension(mDisplay, &nothing, &nothing)) {
            if (!DPMSEnable(mDisplay))
                mp_msg(MSGT_GPLAYER, MSGL_ERR, MSGTR_WS_DpmsUnavailable);                     // restoring power saving settings
            else {
                // DPMS does not seem to be enabled unless we call DPMSInfo
                BOOL onoff;
                CARD16 state;
                DPMSInfo(mDisplay, &state, &onoff);

                if (onoff)
                    mp_msg(MSGT_GPLAYER, MSGL_V, "Successfully enabled DPMS.\n");
                else
                    mp_msg(MSGT_GPLAYER, MSGL_STATUS, MSGTR_WS_DpmsNotEnabled);
            }
        }
    }

#endif

    if (timeout_save) {
        int dummy, interval, prefer_blank, allow_exp;
        XGetScreenSaver(mDisplay, &dummy, &interval, &prefer_blank, &allow_exp);
        XSetScreenSaver(mDisplay, timeout_save, interval, prefer_blank, allow_exp);
        XGetScreenSaver(mDisplay, &timeout_save, &interval, &prefer_blank, &allow_exp);
    }
}
Example #2
0
void wsScreenSaverOff(Display *mDisplay)
{
    int interval, prefer_blank, allow_exp, nothing;

#ifdef CONFIG_XDPMS

    if (DPMSQueryExtension(mDisplay, &nothing, &nothing)) {
        BOOL onoff;
        CARD16 state;
        DPMSInfo(mDisplay, &state, &onoff);

        if (onoff) {
            Status stat;
            mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "Disabling DPMS.\n");
            dpms_disabled = 1;
            stat = DPMSDisable(mDisplay); // monitor powersave off
            mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "stat: %d.\n", stat);
        }
    }

#endif
    XGetScreenSaver(mDisplay, &timeout_save, &interval, &prefer_blank, &allow_exp);

    if (timeout_save)
        XSetScreenSaver(mDisplay, 0, interval, prefer_blank, allow_exp);              // turning off screensaver
}
Example #3
0
bool X11Helper::OpenXConnection()
{
	DEBUG_ASSERT( Dpy == nullptr && Win == None );
	Dpy = XOpenDisplay(0);
	if( Dpy == nullptr )
		return false;

	XSetIOErrorHandler( FatalCallback );
	XSetErrorHandler( ErrorCallback );
	int event_base, error_base;
	display_supports_dpms_extension= DPMSQueryExtension(Dpy, &event_base, &error_base);
	if(display_supports_dpms_extension)
	{
		LOG->Trace("DPMSQueryExtension returned true.  Stepmania will disable power management, and restore the original state on exit.");
		CARD16 power_level;
		BOOL state;
		if(DPMSInfo(Dpy, &power_level, &state))
		{
			dpms_state_at_startup= state;
			DPMSDisable(Dpy);
		}
		else
		{
			LOG->Trace("DPMSInfo returned false.  Stepmania will not be able to disable power management.");
		}
	}
	else
	{
		LOG->Trace("DPMSQueryExtension returned false, which means this display does not support the DPMS extension.  Stepmania will not be able to disable power management.");
	}
	return true;
}
Example #4
0
/**
 * gpm_dpms_x11_set_mode:
 **/
static gboolean
gpm_dpms_x11_set_mode (GpmDpms *dpms, GpmDpmsMode mode, GError **error)
{
	GpmDpmsMode current_mode;
	CARD16 state;
	CARD16 current_state;
	BOOL current_enabled;

	if (!dpms->priv->dpms_capable) {
		egg_debug ("not DPMS capable");
		g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
			     "Display is not DPMS capable");
		return FALSE;
	}

	if (!DPMSInfo (dpms->priv->display, &current_state, &current_enabled)) {
		egg_debug ("couldn't get DPMS info");
		g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
			     "Unable to get DPMS state");
		return FALSE;
	}

	if (!current_enabled) {
		egg_debug ("DPMS not enabled");
		g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
			     "DPMS is not enabled");
		return FALSE;
	}

	switch (mode) {
	case GPM_DPMS_MODE_ON:
		state = DPMSModeOn;
		break;
	case GPM_DPMS_MODE_STANDBY:
		state = DPMSModeStandby;
		break;
	case GPM_DPMS_MODE_SUSPEND:
		state = DPMSModeSuspend;
		break;
	case GPM_DPMS_MODE_OFF:
		state = DPMSModeOff;
		break;
	default:
		state = DPMSModeOn;
		break;
	}

	gpm_dpms_x11_get_mode (dpms, &current_mode, NULL);
	if (current_mode != mode) {
		if (! DPMSForceLevel (dpms->priv->display, state)) {
			g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
				     "Could not change DPMS mode");
			return FALSE;
		}
		XSync (dpms->priv->display, FALSE);
	}

	return TRUE;
}
Example #5
0
File: pm.c Project: clcarwin/x11vnc
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
}
/**
 * Actually this is a big mess. By default the libSDL disables the screen
 * saver during the SDL_InitSubSystem() call and restores the saved settings
 * during the SDL_QuitSubSystem() call. This mechanism can be disabled by
 * setting the environment variable SDL_VIDEO_ALLOW_SCREENSAVER to 1. However,
 * there is a known bug in the Debian libSDL: If this environment variable is
 * set, the screen saver is still disabled but the old state is not restored
 * during SDL_QuitSubSystem()! So the only solution to overcome this problem
 * is to save and restore the state prior and after each of these function
 * calls.
 */
void X11ScreenSaverSettingsSave()
{
    int     dummy;
    CARD16  dummy2;
    Display *display = QX11Info::display();

    XGetScreenSaver(display, &gX11ScreenSaverTimeout, &dummy, &dummy, &dummy);
    if (gX11ScreenSaverDpmsAvailable)
        DPMSInfo(display, &dummy2, &gX11DpmsState);
}
Example #7
0
/**
 * Checks the DPMS state of the display.
 * @return @c 1 if DPMS is enabled, @c 0 otherwise.
 * @ingroup Ecore_X_DPMS_Group
 */
EAPI Eina_Bool
ecore_x_dpms_enabled_get(void)
{
#ifdef ECORE_XDPMS
   unsigned char state;
   unsigned short power_lvl;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   DPMSInfo(_ecore_x_disp, &power_lvl, &state);
   return state ? EINA_TRUE : EINA_FALSE;
#else /* ifdef ECORE_XDPMS */
   return EINA_FALSE;
#endif /* ifdef ECORE_XDPMS */
}
Example #8
0
bool ScreenSaverX11::Asleep(void)
{
    if (!d->IsDPMSEnabled())
        return false;

    if (d->DeactivatedDPMS())
        return false;

    BOOL on;
    CARD16 power_level;

    DPMSInfo(qt_xdisplay(), &power_level, &on);

    return (power_level != DPMSModeOn);
}
Example #9
0
bool
CXWindowsScreenSaver::isDPMSActivated() const
{
#if HAVE_X11_EXTENSIONS_DPMS_H
	if (m_dpms) {
		CARD16 level;
		BOOL state;
		DPMSInfo(m_display, &level, &state);
		return (level != DPMSModeOn);
	}
	else {
		return false;
	}
#else
	return false;
#endif
}
Example #10
0
void X11ScreenSaverSettingsSave()
{
    /* Actually this is a big mess. By default the libSDL disables the screen saver
     * during the SDL_InitSubSystem() call and restores the saved settings during
     * the SDL_QuitSubSystem() call. This mechanism can be disabled by setting the
     * environment variable SDL_VIDEO_ALLOW_SCREENSAVER to 1. However, there is a
     * known bug in the Debian libSDL: If this environment variable is set, the
     * screen saver is still disabled but the old state is not restored during
     * SDL_QuitSubSystem()! So the only solution to overcome this problem is to
     * save and restore the state prior and after each of these function calls. */

    int     dummy;
    CARD16  dummy2;
    Display *display = QX11Info::display();

    XGetScreenSaver(display, &gX11ScreenSaverTimeout, &dummy, &dummy, &dummy);
    if (gX11ScreenSaverDpmsAvailable)
        DPMSInfo(display, &dummy2, &gX11DpmsState);
}
Example #11
0
/**
 * gpm_dpms_x11_get_mode:
 **/
static gboolean
gpm_dpms_x11_get_mode (GpmDpms *dpms, GpmDpmsMode *mode, GError **error)
{
	GpmDpmsMode result;
	BOOL enabled = FALSE;
	CARD16 state;

	if (dpms->priv->dpms_capable == FALSE) {
		/* Server or monitor can't DPMS -- assume the monitor is on. */
		result = GPM_DPMS_MODE_ON;
		goto out;
	}

	DPMSInfo (dpms->priv->display, &state, &enabled);
	if (!enabled) {
		/* Server says DPMS is disabled -- so the monitor is on. */
		result = GPM_DPMS_MODE_ON;
		goto out;
	}

	switch (state) {
	case DPMSModeOn:
		result = GPM_DPMS_MODE_ON;
		break;
	case DPMSModeStandby:
		result = GPM_DPMS_MODE_STANDBY;
		break;
	case DPMSModeSuspend:
		result = GPM_DPMS_MODE_SUSPEND;
		break;
	case DPMSModeOff:
		result = GPM_DPMS_MODE_OFF;
		break;
	default:
		result = GPM_DPMS_MODE_ON;
		break;
	}
out:
	if (mode)
		*mode = result;
	return TRUE;
}
Example #12
0
/*!
 * 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;
}
Example #13
0
    ScreenSaverX11Private(ScreenSaverX11 *outer) : m_dpmsenabled(FALSE),
        m_dpmsdeactivated(false), m_timeoutInterval(-1), m_resetTimer(0)
    {
        m_xscreensaverRunning =
                myth_system("xscreensaver-command -version >&- 2>&-") == 0;
        m_gscreensaverRunning =
                myth_system("gnome-screensaver-command --help >&- 2>&-") == 0;

        if (IsScreenSaverRunning())
        {
            m_resetTimer = new QTimer(outer);
            QObject::connect(m_resetTimer, SIGNAL(timeout()),
                             outer, SLOT(resetSlot()));
            VERBOSE(VB_GENERAL, "XScreenSaver support enabled");
        }

        int dummy;
        if ((m_dpmsaware = DPMSQueryExtension(qt_xdisplay(), &dummy, &dummy)))
        {
            CARD16 power_level;

            /* If someone runs into X server weirdness that goes away when
            * they externally disable DPMS, then the 'dpmsenabled' test should
            * be short circuited by a call to 'DPMSCapable()'. Be sure to
            * manually initialize dpmsenabled to false.
            */

            DPMSInfo(qt_xdisplay(), &power_level, &m_dpmsenabled);

            if (m_dpmsenabled)
                VERBOSE(VB_GENERAL, "DPMS is active.");
            else
                VERBOSE(VB_GENERAL, "DPMS is disabled.");
        }
        else
        {
            VERBOSE(VB_GENERAL, "DPMS is not supported.");
        }
    }
Example #14
0
/*!
 * 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;
}
Example #15
0
    ScreenSaverX11Private(ScreenSaverX11 *outer) :
        m_dpmsaware(false),           m_dpmsdeactivated(false),
        m_xscreensaverRunning(false), m_gscreensaverRunning(false),
        m_dpmsenabled(false),
        m_timeoutInterval(-1),        m_resetTimer(NULL),
        m_display(NULL)
    {
        const uint flags = kMSDontBlockInputDevs | kMSDontDisableDrawing |
                           kMSProcessEvents;
        m_xscreensaverRunning =
                myth_system("xscreensaver-command -version >&- 2>&-",
                            flags) == 0;
        m_gscreensaverRunning =
                myth_system("gnome-screensaver-command --help >&- 2>&-",
                            flags) == 0;

        if (IsScreenSaverRunning())
        {
            m_resetTimer = new QTimer(outer);
            m_resetTimer->setSingleShot(false);
            QObject::connect(m_resetTimer, SIGNAL(timeout()),
                             outer, SLOT(resetSlot()));
            if (m_xscreensaverRunning)
                LOG(VB_GENERAL, LOG_INFO, LOC + "XScreenSaver support enabled");
            if (m_gscreensaverRunning)
                LOG(VB_GENERAL, LOG_INFO, LOC +
                    "Gnome screen saver support enabled");
        }

        m_display = OpenMythXDisplay();
        if (m_display)
        {
            int dummy0, dummy1;
            m_dpmsaware = DPMSQueryExtension(m_display->GetDisplay(),
                                            &dummy0, &dummy1);
        }
        else
        {
            LOG(VB_GENERAL, LOG_ERR, LOC +
                "Failed to open connection to X11 server");
        }

        if (m_dpmsaware)
        {
            CARD16 power_level;

            /* If someone runs into X server weirdness that goes away when
             * they externally disable DPMS, then the 'dpmsenabled' test should
             * be short circuited by a call to 'DPMSCapable()'. Be sure to
             * manually initialize dpmsenabled to false.
             */

            DPMSInfo(m_display->GetDisplay(), &power_level, &m_dpmsenabled);

            if (m_dpmsenabled)
                LOG(VB_GENERAL, LOG_INFO, LOC + "DPMS is active.");
            else
                LOG(VB_GENERAL, LOG_INFO, LOC + "DPMS is disabled.");
        }
        else
        {
            LOG(VB_GENERAL, LOG_INFO, LOC + "DPMS is not supported.");
        }
    }
Example #16
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;
}
Example #17
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;
}
Example #18
0
File: pm.c Project: clcarwin/x11vnc
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
}
Example #19
0
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);
}