コード例 #1
0
    public static HIGHCONTRAST SystemParameterInfo_GetHIGHCONTRAST()
    {
        HIGHCONTRAST result = new HIGHCONTRAST
        {
            cbSize = Marshal.SizeOf(typeof(HIGHCONTRAST))
        };

        if (!NativeMethods._SystemParametersInfo_HIGHCONTRAST(SPI.GETHIGHCONTRAST, result.cbSize, ref result, SPIF.None))
        {
            HRESULT.ThrowLastError();
        }
        return(result);
    }
コード例 #2
0
        private void _InitializeHighContrast()
        {
            HIGHCONTRAST hc = NativeMethods.SystemParameterInfo_GetHIGHCONTRAST();

            HighContrast = (hc.dwFlags & HCF.HIGHCONTRASTON) != 0;
        }
コード例 #3
0
        private void _InitializeHighContrast()
        {
            HIGHCONTRAST hIGHCONTRAST = Standard.NativeMethods.SystemParameterInfo_GetHIGHCONTRAST();

            this.HighContrast = (int)(hIGHCONTRAST.dwFlags & HCF.HIGHCONTRASTON) != 0;
        }
コード例 #4
0
 private static extern bool _SystemParametersInfo_HIGHCONTRAST(SPI uiAction, int uiParam, [In][Out] ref HIGHCONTRAST pvParam, SPIF fWinIni);
コード例 #5
0
        TOGGLEKEYS TK;        // ToggleKeys

        public frmMain()
        {
            Int32 DataSize;            // Size of the data structure.

            // Required for Windows Form Designer support
            InitializeComponent();

            // Initialize the data structures.
            AT      = new ACCESSTIMEOUT(); // Access Timeout
            FK      = new FILTERKEYS();    // FilterKeys
            HC      = new HIGHCONTRAST();  // High Contrast
            MK      = new MOUSEKEYS();     // MouseKeys
            SR      = false;               // ScreenReader
            SC      = new SERIALKEYS();    // SerialKeys
            SSound  = false;               // ShowSounds
            SSentry = new SOUNDSENTRY();   // SoundSentry
            SK      = new STICKYKEYS();    // StickyKeys
            TK      = new TOGGLEKEYS();    // ToggleKeys

            // Initialize the data structures and Choose menu options. The
            // process includes getting the current option status (which
            // fills out the data structure) and then comparing the flag
            // values to see if the option is on.

            // Access Timeout
            DataSize  = Marshal.SizeOf(AT);
            AT.cbSize = Convert.ToUInt32(DataSize);
            AT        = (ACCESSTIMEOUT)GetAccessibleOption(
                AT,
                DataSize,
                AccessType.SPI_GETACCESSTIMEOUT,
                WinIniFlags.SPIF_NONE);
            if ((AT.dwFlags & (Int32)AccessTimeoutFlags.ATF_TIMEOUTON) ==
                (Int32)AccessTimeoutFlags.ATF_TIMEOUTON)
            {
                mnuChooseAccessTimeout.Checked = true;
            }

            // FilterKeys
            DataSize  = Marshal.SizeOf(FK);
            FK.cbSize = Convert.ToUInt32(DataSize);
            FK        = (FILTERKEYS)GetAccessibleOption(
                FK,
                DataSize,
                AccessType.SPI_GETFILTERKEYS,
                WinIniFlags.SPIF_NONE);
            if ((FK.dwFlags & (Int32)FilterKeysFlags.FKF_FILTERKEYSON) ==
                (Int32)FilterKeysFlags.FKF_FILTERKEYSON)
            {
                mnuChooseFilterKeys.Checked = true;
            }

            // High Contrast
            DataSize  = Marshal.SizeOf(HC);
            HC.cbSize = Convert.ToUInt32(DataSize);
            HC        = (HIGHCONTRAST)GetAccessibleOption(
                HC,
                DataSize,
                AccessType.SPI_GETHIGHCONTRAST,
                WinIniFlags.SPIF_NONE);
            if ((HC.dwFlags & (Int32)HighContrastFlags.HCF_HIGHCONTRASTON) ==
                (Int32)HighContrastFlags.HCF_HIGHCONTRASTON)
            {
                mnuChooseHighContrast.Checked = true;
            }

            // MouseKeys
            DataSize  = Marshal.SizeOf(MK);
            MK.cbSize = Convert.ToUInt32(DataSize);
            MK        = (MOUSEKEYS)GetAccessibleOption(
                MK,
                DataSize,
                AccessType.SPI_GETMOUSEKEYS,
                WinIniFlags.SPIF_NONE);
            if ((MK.dwFlags & (Int32)MouseKeysFlags.MKF_MOUSEKEYSON) ==
                (Int32)MouseKeysFlags.MKF_MOUSEKEYSON)
            {
                mnuChooseMouseKeys.Checked = true;
            }

            // Screen Reader
            DataSize = Marshal.SizeOf(SR);
            SR       = (bool)GetAccessibleOption(
                SR,
                DataSize,
                AccessType.SPI_GETSCREENREADER,
                WinIniFlags.SPIF_NONE);
            if (SR)
            {
                mnuChooseScreenReader.Checked = true;
            }

            // SerialKeys
            DataSize  = Marshal.SizeOf(SC);
            SC.cbSize = Convert.ToUInt32(DataSize);
            SC        = (SERIALKEYS)GetAccessibleOption(
                SC,
                DataSize,
                AccessType.SPI_GETSERIALKEYS,
                WinIniFlags.SPIF_NONE);
            if ((SC.dwFlags & (Int32)SerialKeysFlags.SERKF_SERIALKEYSON) ==
                (Int32)SerialKeysFlags.SERKF_SERIALKEYSON)
            {
                mnuChooseSerialKeys.Checked = true;
            }
            else if (SC.lpszActivePort == null)
            {
                // This is one of the few accessibility options not supported
                // under Windows 2000/XP. Microsoft changed this behavior to
                // ensure that SerialKeys devices would appear as standard
                // input devices to the application.  The lpszActivePort member
                // will always contain a value for operating systems that
                // support the SerialKeys feature.
                mnuChooseSerialKeys.Enabled = false;
            }

            // ShowSounds
            DataSize = Marshal.SizeOf(SSound);
            SSound   = (bool)GetAccessibleOption(
                SSound,
                DataSize,
                AccessType.SPI_GETSHOWSOUNDS,
                WinIniFlags.SPIF_NONE);
            if (SSound)
            {
                mnuChooseShowSounds.Checked = true;
            }

            // SoundSentry
            DataSize       = Marshal.SizeOf(SSentry);
            SSentry.cbSize = Convert.ToUInt32(DataSize);
            SSentry        = (SOUNDSENTRY)GetAccessibleOption(
                SSentry,
                DataSize,
                AccessType.SPI_GETSOUNDSENTRY,
                WinIniFlags.SPIF_NONE);
            if ((SSentry.dwFlags & (Int32)SoundSentryFlags.SSF_SOUNDSENTRYON) ==
                (Int32)SoundSentryFlags.SSF_SOUNDSENTRYON)
            {
                mnuChooseSoundSentry.Checked = true;
            }

            // StickyKeys
            DataSize  = Marshal.SizeOf(SK);
            SK.cbSize = Convert.ToUInt32(DataSize);
            SK        = (STICKYKEYS)GetAccessibleOption(
                SK,
                DataSize,
                AccessType.SPI_GETSTICKYKEYS,
                WinIniFlags.SPIF_NONE);
            if ((SK.dwFlags & (Int32)StickyKeysFlags.SKF_STICKYKEYSON) ==
                (Int32)StickyKeysFlags.SKF_STICKYKEYSON)
            {
                mnuChooseStickyKeys.Checked = true;
            }

            // ToggleKeys
            DataSize  = Marshal.SizeOf(TK);
            TK.cbSize = Convert.ToUInt32(DataSize);
            TK        = (TOGGLEKEYS)GetAccessibleOption(
                TK,
                DataSize,
                AccessType.SPI_GETTOGGLEKEYS,
                WinIniFlags.SPIF_NONE);
            if ((TK.dwFlags & (Int32)ToggleKeysFlags.TKF_TOGGLEKEYSON) ==
                (Int32)ToggleKeysFlags.TKF_TOGGLEKEYSON)
            {
                mnuChooseToggleKeys.Checked = true;
            }
        }