How to block/cancel standby/hibernate operation in Windows Vista

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;

namespace zTestWindowsForms
{
    public partial class Form1 : Form
    {
        internal const UInt32 SE_PRIVILEGE_ENABLED = 0x00000002;
        internal const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;
        internal const int TOKEN_QUERY = 0x8;
        internal const string SE_SHUTDOWN_NAME = "SeShutdownPrivilege";

        [DllImport("Kernel32.dll")]
        public static extern EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE esFlags);

        // Use this signature if you do not want the previous state
        [DllImport("advapi32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool AdjustTokenPrivileges(IntPtr TokenHandle,
           [MarshalAs(UnmanagedType.Bool)]bool DisableAllPrivileges,
           ref TOKEN_PRIVILEGES NewState,
           UInt32 Zero,
           IntPtr Null1,
           IntPtr Null2);

        [DllImport("advapi32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool OpenProcessToken(IntPtr ProcessHandle, UInt32 DesiredAccess, out IntPtr TokenHandle);

        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool LookupPrivilegeValue(string lpSystemName, string lpName, out LUID lpLuid);

        public Form1()
        {
            InitializeComponent();
            GetPrivilege();
        }

        private static void GetPrivilege()
        {
            // Get the current process token handle so we can get shutdown privilege. 
            IntPtr processHandle = Process.GetCurrentProcess().Handle;
            IntPtr tokenHandle;
            if (OpenProcessToken(processHandle, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, out tokenHandle))
            {
                // Get the LUID for shutdown privilege. 
                LUID luid = new LUID();
                LookupPrivilegeValue(null, SE_SHUTDOWN_NAME, out luid);

                TOKEN_PRIVILEGES tkp = new TOKEN_PRIVILEGES();       // pointer to token structure 
                tkp.PrivilegeCount = 1;  // one privilege to set    
                tkp.Luid = luid;
                tkp.Attributes = SE_PRIVILEGE_ENABLED;

                // Get shutdown privilege for this process. 
                bool b = AdjustTokenPrivileges(tokenHandle, false, ref tkp, 0, IntPtr.Zero, IntPtr.Zero);

                int result = Marshal.GetLastWin32Error();
                MessageBox.Show("result = " + result);
            }
        }

        protected override void WndProc(ref System.Windows.Forms.Message m)
        {
            // Power status event triggered
            if (m.Msg == (int)WindowMessage.WM_POWERBROADCAST)
            {
                // prevent sleep/hibernate
                SetThreadExecutionState(EXECUTION_STATE.ES_CONTINUOUS | EXECUTION_STATE.ES_DISPLAY_REQUIRED | EXECUTION_STATE.ES_SYSTEM_REQUIRED | EXECUTION_STATE.ES_AWAYMODE_REQUIRED);

                MessageBox.Show("Gotcha!!");
                Thread.Sleep(10000);

                //
                // Clear EXECUTION_STATE flags to disable away mode and allow the system to idle to sleep normally.
                //
                SetThreadExecutionState(EXECUTION_STATE.ES_CONTINUOUS);
            }

            base.WndProc(ref m);
        }
    }

    internal enum WindowMessage
    {
        WM_POWERBROADCAST = 0x218,
        PBT_APMQUERYSUSPEND = 0x0,
        PBT_APMQUERYSTANDBY = 0x0001,
        BROADCAST_QUERY_DENY = 0x424D5144,
        PBT_APMSUSPEND = 0x4,
    }

    public enum EXECUTION_STATE : uint
    {
        ES_AWAYMODE_REQUIRED = 0x00000040,
        ES_CONTINUOUS = 0x80000000,
        ES_DISPLAY_REQUIRED = 0x00000002,
        ES_SYSTEM_REQUIRED = 0x00000001,
        ES_USER_PRESENT = 0x00000004,
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct TOKEN_PRIVILEGES
    {
        public UInt32 PrivilegeCount;
        public LUID Luid;
        public UInt32 Attributes;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct LUID
    {
        public uint LowPart;
        public int HighPart;
    }
}