disabling screen saver to user

Question

I want to disable a screen saver to another user. How it can be done?

I have administrative privileges. I have an application that can't be interrupted by the screen saver.

Answer 1

Controlling The Screen Saver With C#

public static class ScreenSaver
{
   // Signatures for unmanaged calls

   [DllImport( "user32.dll", CharSet = CharSet.Auto )]
   private static extern bool SystemParametersInfo( 
      int uAction, int uParam, ref int lpvParam, 
      int flags );

   [DllImport( "user32.dll", CharSet = CharSet.Auto )]
   private static extern bool SystemParametersInfo( 
      int uAction, int uParam, ref bool lpvParam, 
      int flags );

   [DllImport( "user32.dll", CharSet = CharSet.Auto )]
   private static extern int PostMessage( IntPtr hWnd, 
      int wMsg, int wParam, int lParam );

   [DllImport( "user32.dll", CharSet = CharSet.Auto )]
   private static extern IntPtr OpenDesktop( 
      string hDesktop, int Flags, bool Inherit, 
      uint DesiredAccess );

   [DllImport( "user32.dll", CharSet = CharSet.Auto )]
   private static extern bool CloseDesktop( 
      IntPtr hDesktop );

   [DllImport( "user32.dll", CharSet = CharSet.Auto )]
   private static extern bool EnumDesktopWindows( 
      IntPtr hDesktop, EnumDesktopWindowsProc callback, 
      IntPtr lParam );

   [DllImport( "user32.dll", CharSet = CharSet.Auto )]
   private static extern bool IsWindowVisible( 
      IntPtr hWnd );

   [DllImport( "user32.dll", CharSet = CharSet.Auto )]
   public static extern IntPtr GetForegroundWindow( );

   // Callbacks

   private delegate bool EnumDesktopWindowsProc( 
      IntPtr hDesktop, IntPtr lParam );

   // Constants

   private const int SPI_GETSCREENSAVERACTIVE = 16;
   private const int SPI_SETSCREENSAVERACTIVE = 17;
   private const int SPI_GETSCREENSAVERTIMEOUT = 14;
   private const int SPI_SETSCREENSAVERTIMEOUT = 15;
   private const int SPI_GETSCREENSAVERRUNNING = 114;
   private const int SPIF_SENDWININICHANGE = 2;

   private const uint DESKTOP_WRITEOBJECTS = 0x0080;
   private const uint DESKTOP_READOBJECTS = 0x0001;
   private const int WM_CLOSE = 16;


   // Returns TRUE if the screen saver is active 

   // (enabled, but not necessarily running).

   public static bool GetScreenSaverActive( )
   {
      bool isActive = false;

      SystemParametersInfo( SPI_GETSCREENSAVERACTIVE, 0, 
         ref isActive, 0 );
      return isActive;
   }

   // Pass in TRUE(1) to activate or FALSE(0) to deactivate

   // the screen saver.

   public static void SetScreenSaverActive( int Active )
   {
      int nullVar = 0;

      SystemParametersInfo( SPI_SETSCREENSAVERACTIVE, 
         Active, ref nullVar, SPIF_SENDWININICHANGE );
   }

   // Returns the screen saver timeout setting, in seconds

   public static Int32 GetScreenSaverTimeout( )
   {
      Int32 value = 0;

      SystemParametersInfo( SPI_GETSCREENSAVERTIMEOUT, 0, 
         ref value, 0 );
      return value;
   }

   // Pass in the number of seconds to set the screen saver

   // timeout value.

   public static void SetScreenSaverTimeout( Int32 Value )
   {
      int nullVar = 0;

      SystemParametersInfo( SPI_SETSCREENSAVERTIMEOUT, 
         Value, ref nullVar, SPIF_SENDWININICHANGE );
   }

   // Returns TRUE if the screen saver is actually running

   public static bool GetScreenSaverRunning( )
   {
      bool isRunning = false;

      SystemParametersInfo( SPI_GETSCREENSAVERRUNNING, 0, 
         ref isRunning, 0 );
      return isRunning;
   }

   // From Microsoft's Knowledge Base article #140723: 

   // http://support.microsoft.com/kb/140723

   // "How to force a screen saver to close once started 

   // in Windows NT, Windows 2000, and Windows Server 2003"


   public static void KillScreenSaver( )
   {
      IntPtr hDesktop = OpenDesktop( "Screen-saver", 0, 
         false,DESKTOP_READOBJECTS | DESKTOP_WRITEOBJECTS);
      if( hDesktop != IntPtr.Zero )
      {
         EnumDesktopWindows( hDesktop, new 
            EnumDesktopWindowsProc( KillScreenSaverFunc ),
            IntPtr.Zero );
         CloseDesktop( hDesktop );
      }
      else
      {
         PostMessage( GetForegroundWindow( ), WM_CLOSE, 
            0, 0 );
      }
   }

   private static bool KillScreenSaverFunc( IntPtr hWnd, 
      IntPtr lParam )
   {
      if( IsWindowVisible( hWnd ) )
         PostMessage( hWnd, WM_CLOSE, 0, 0 );
      return true;
   }
}

KillScreenSaver( )

private void KillTimer_Elapsed( object state )
{
   // Toggle kill state to indicate activity

   killState = ( killState == 1 ) ? 0 : 1;
   this.SetText( killState.ToString( ) );

   // Stop the screen saver if it's active and running, 

   // otherwise reset the screen saver timer.

   // Apparently it's possible for GetScreenSaverRunning()

   // to return TRUE before the screen saver has time to 

   // actually become the foreground application. So...

   // Make sure we're not the foreground window to avoid 

   // killing ourself.


   if( ScreenSaver.GetScreenSaverActive( ) )
   {
      if( ScreenSaver.GetScreenSaverRunning( ) )
      {
         if( ScreenSaver.GetForegroundWindow() != hThisWnd)
            ScreenSaver.KillScreenSaver( );
      }
      else
      {
         // Reset the screen saver timer, so the screen 

         // saver doesn't turn on until after a full

         // timeout period. If killPeriod is less than 

         // ssTimeout the screen saver should never 

         // activate.

         ScreenSaver.SetScreenSaverActive( TRUE );
      }
   }
}

Answer 2

If you're writing the application yourself, look into calling the unmanaged API SetThreadExecutionState (PInvoke reference). Copying from my answer to how do i prevent screen-savers and sleeps during my program execution?:

Don't mess with the screensaver settings, use SetThreadExecutionState. This is the API for informing windows on the fact that your application is active:

Enables an application to inform the system that it is in use, thereby preventing the system from entering sleep or turning off the display while the application is running.

, and

Multimedia applications, such as video players and presentation applications, must use ES_DISPLAY_REQUIRED when they display video for long periods of time without user input

If you don't have control over the application, but the screen saver kicking in causes problems, then push this information back to the developers.

Disabling the screensaver is almost always the wrong solution to the problem, since it affects the users whole experience, not just when the application is running.