КД>И через пять лет чтения, я таки понял эти "25 интерфейсов" Правда не понял этот вопрос на вопрос.

КД> И на текущий момент, лично для меня, ничего не поменялось. Правда основная херня в том что MS не предоставила шлюз OLEDB провайдер<->OLEDB.NET провайдер, как это было сделано для ADODB в виде незадокументированных интерфейсов конструирования. Но, слава Богу, не первый год замужем

IP>вот это _очень_ сильно. только сильно сомневаюсь что сам этот юкон будет managed.

А тут и сомневаться нечено. Конечно... не будет. Но от этого ничего не меняется. Менеджед интерфейс к MSSQL и сегодня самый быстрый из существующих. Так что...

КД> И постепенно уровень сложности реализации станет такого уровня, что один два лишних вызова (слоя) — это даже не копейки. Спрашиваете "почему"? Да потому, что драйвер (перешедший на промышленный уровень) однозначно будет состоять из двух уровней — того, с которым вы общаетесь наверху, и того, который общается с БД. А между этими двумя уровнями будут лежать абстрактные интерфейсы

#include <windows.h>

// Эти константы надо потому, что у меня дома 6-я старая вижуалка в .h которой этих определений нету
#define FE_FONTSMOOTHINGCLEARTYPE    0x0002
#define SPI_SETFONTSMOOTHINGTYPE    0x200B

void main ()
{
    DWORD smoothType = FE_FONTSMOOTHINGCLEARTYPE;
    SystemParametersInfo (SPI_SETFONTSMOOTHING, TRUE, NULL, 0);
    SystemParametersInfo (SPI_SETFONTSMOOTHINGTYPE, 0, (void*)FE_FONTSMOOTHINGCLEARTYPE, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);
    
    MessageBox (NULL,"Cleartype включен.","Мессага",MB_OK);

    SystemParametersInfo (SPI_SETFONTSMOOTHINGTYPE, 0, 0, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);
    SystemParametersInfo (SPI_SETFONTSMOOTHING, FALSE, NULL, 0);

    MessageBox (NULL,"Фу! Cleartype + CRT моник = уродская картинка. Нафиг этот Cleartype","Мессага",MB_OK);
}

CC>Так что тут надо дать по голове пьяным индусам из микрософт

CC>#include <windows.h>

CC>// Эти константы надо потому, что у меня дома 6-я старая вижуалка в .h которой этих определений нету
CC>#define FE_FONTSMOOTHINGCLEARTYPE    0x0002
CC>#define SPI_SETFONTSMOOTHINGTYPE    0x200B

CC>void main ()
CC>{
CC>    DWORD smoothType = FE_FONTSMOOTHINGCLEARTYPE;
CC>    SystemParametersInfo (SPI_SETFONTSMOOTHING, TRUE, NULL, 0);
CC>    SystemParametersInfo (SPI_SETFONTSMOOTHINGTYPE, 0, (void*)FE_FONTSMOOTHINGCLEARTYPE, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);
    
CC>    MessageBox (NULL,"Cleartype включен.","Мессага",MB_OK);

CC>    SystemParametersInfo (SPI_SETFONTSMOOTHINGTYPE, 0, 0, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);
CC>    SystemParametersInfo (SPI_SETFONTSMOOTHING, FALSE, NULL, 0);

CC>    MessageBox (NULL,"Фу! Cleartype + CRT моник = уродская картинка. Нафиг этот Cleartype","Мессага",MB_OK);
CC>}
CC>

// Запоминаем исходное значение настроек сглаживания.
FontSmoothingType initialFontSmoothingType = SysInfo.FontSmoothingType;

foreach (FontSmoothingType value in Enum.GetValues(typeof(FontSmoothingType)))
{
  SysInfo.FontSmoothingType = value;
  MessageBox.Show("Режим сглаживания - " + value + ".", "Мессага");
}

SysInfo.FontSmoothingType = initialFontSmoothingType;

using System;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Windows.Forms;
using System.Drawing;
using System.Diagnostics;
using Microsoft.Win32;

namespace Rsdn.Windows.Forms
{
    /// <summary>
    /// <b>FontSmoothingTypes</b> Specifies fontsmoothing/antialiasing.
    /// </summary>
    public enum FontSmoothingType : uint
    {
        None = 0,
        /// <summary>FE_FONTSMOOTHINGSTANDARD</summary>
        Standard = 1,
        /// <summary>FE_FONTSMOOTHINGCLEARTYPE</summary>
        ClearType = 2
    }

    public class VideoAdapterInfo
    {
        public VideoAdapterInfo(string name, Rectangle bounds)
        {
            _name = name;
            _bounds = bounds;
        }

        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        string _name;

        public string Name
        {
            get { return _name; }
        }

        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        Rectangle _bounds;

        public Rectangle Bounds
        {
            get { return _bounds; }
        }
    }

    /// <summary>
    /// <b>ClearTypeController</b> Wrapper class for Win32 IsFontSmoothingEnabled API. 
    /// Use Redraw() to perform instant changes.
    /// </summary>
    public class SysInfo
    {
        #region Импорт API-шных функций

        #region Константы

        enum RDW : uint
        {
            Invalidate = 1,    // 0x1;
            InternalPaint = 2,    // 0x2;
            Erase = 4,    // 0x4;
            AllChildren = 128,    // 0x80;
            UpdateNow = 256,    // 0x100;
            EraseNow = 512,    // 0x200;
            Frame = 1024,    // 0x400;
        }

        enum SPI : uint
        {
            GetFontSmoothing = 74,    // 0x004A;
            SetFontSmoothing = 75,    // 0x004B;
            GetFontSmoothingType = 8202,    // 0x200A;
            SetFontSmoothingType = 8203,    // 0x200B;
            GetFontSmoothingContrast = 8204,    // 0x200C;
            SetFontSmoothingContrast = 8205,    // 0x200D;
        }

        enum SPIF : uint
        {
            UpdateInifile = 1, // 0x1;
            SendChange = 2, // 0x2;
            SendWininiChange = 2, // 0x2;
            TELLALL = UpdateInifile | SendWininiChange, // 0x1 | 0x2;
        }

        #endregion


        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern bool RedrawWindow(IntPtr hWnd, int lprcUpdate,
            int hrgnUpdate, [MarshalAs(UnmanagedType.U4)] RDW flags);

        // SPI_SETFONTSMOOTHING
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern bool SystemParametersInfo(SPI uiAction, bool uiParam,
            IntPtr pvParam, SPIF fWinIni);

        // SPI_GETFONTSMOOTHING
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern bool SystemParametersInfo(SPI uiAction, int uiParam,
            out bool pvParam, SPIF fWinIni);

        // SPI_SETFONTSMOOTHINGTYPE &&  SPI_SETFONTSMOOTHINGCONTRAST
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern bool SystemParametersInfo(SPI uiAction, int uiParam,
            IntPtr pvParam, SPIF fWinIni);

        // SPI_GETFONTSMOOTHINGTYPE &&  SPI_GETFONTSMOOTHINGCONTRAST
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern bool SystemParametersInfo(SPI uiAction, int uiParam,
            out int pvParam, SPIF fWinIni);

        // SPI_GETFONTSMOOTHINGTYPE
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern bool SystemParametersInfo(SPI uiAction, int uiParam,
            out FontSmoothingType pvParam, SPIF fWinIni);

        enum Monitor : uint
        {
            DefaultToNull = 0,
            DefaultToPrimary = 1,
            DefaultToNearest = 2,
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="hwnd">handle to a window</param>
        /// <param name="dwFlags">determine return value</param>
        /// <returns></returns>
        [DllImport("user32.dll")]
        private static extern IntPtr MonitorFromWindow(IntPtr hwnd, Monitor flags);

        [StructLayout(LayoutKind.Sequential)]
        public struct RECT
        {
            public int left;
            public int top;
            public int right;
            public int bottom;

            public RECT(Rectangle r)
            {
                this.left = r.Left;
                this.top = r.Top;
                this.right = r.Right;
                this.bottom = r.Bottom;
            }

            public RECT(int left, int top, int right, int bottom)
            {
                this.left = left;
                this.top = top;
                this.right = right;
                this.bottom = bottom;
            }

            public static RECT FromXYWH(int x, int y, int width, int height)
            {
                return new RECT(x, y, x + width, y + height);
            }

            public int Width { get { return right - left; } }
            public int Height { get { return bottom - top; } }

            public Rectangle ToRectangle()
            {
                return new Rectangle(left, top, Width, Height);
            }

            public Size Size { get { return new Size(right - left, bottom - top); } }
        }


        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto, Pack = 4)]
        class MONITORINFOEX
        {
            public MONITORINFOEX()
            {
                cbSize = Marshal.SizeOf(typeof(MONITORINFOEX));
            }

            private const int szDeviceSize = 0x20;

            public int cbSize;
            public RECT rcMonitor;
            public RECT rcWork;
            public int dwFlags;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = szDeviceSize)]
            public string Device;
        }

        //[DllImport("user32.dll")]
        //static extern bool GetMonitorInfo(IntPtr hMonitor, MONITORINFOEX lpmi);

        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        static extern bool GetMonitorInfo(IntPtr hmonitor,
            [In, Out] MONITORINFOEX info);



        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto, Pack = 4)]
        class DISPLAY_DEVICE
        {
            internal DISPLAY_DEVICE()
            {
                cb = Marshal.SizeOf(typeof(DISPLAY_DEVICE));
            }

            private const int DeviceNameSize = 32;
            private const int OtherSize = 128;

            int cb;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = DeviceNameSize)]
            internal string DeviceName;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = OtherSize)]
            internal string DeviceString;

            internal uint StateFlags;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = OtherSize)]
            string DeviceID;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = OtherSize)]
            internal string DeviceKey;
        };

        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        static extern bool EnumDisplayDevices(string lpDevice, int iDevNum,
             [In, Out] DISPLAY_DEVICE lpDisplayDevice, uint dwFlags);

        #endregion

        #region Font smoothing information

        /// <summary>
        /// Gets or sets a value indicating whether font smoothing is enabled.
        /// </summary>
        public static bool IsFontSmoothingEnabled
        {
            get
            {
                bool fontSmoothing;
                Verify(SystemParametersInfo(SPI.GetFontSmoothing, 0,
                    out fontSmoothing, 0));
                return fontSmoothing;
            }

            set
            {
                Verify(SystemParametersInfo(SPI.SetFontSmoothing, value, IntPtr.Zero,
                    SPIF.SendWininiChange | SPIF.UpdateInifile));
            }
        }

        /// <summary>
        /// Gets or sets the current type of font smoothing.
        /// </summary>
        public static FontSmoothingType FontSmoothingType
        {
            get
            {
                FontSmoothingType fontSmoothingType;

                if (!IsFontSmoothingEnabled)
                    return FontSmoothingType.None;

                Verify(SystemParametersInfo(SPI.GetFontSmoothingType, 0,
                    out fontSmoothingType, 0));

                return fontSmoothingType;
            }

            set
            {
                bool isFontSmoothing = value != FontSmoothingType.None;

                IsFontSmoothingEnabled = isFontSmoothing;

                if (isFontSmoothing)
                    Verify(SystemParametersInfo(SPI.SetFontSmoothingType, 0,
                        (IntPtr)value, SPIF.SendWininiChange | SPIF.UpdateInifile));
            }
        }

        /// <summary>
        /// Gets or sets the font smoothing contrast value used in ClearType 
        /// smoothing.
        /// The value must be betwin 1000 and 2200. Default value 1400.
        /// </summary>
        public static int FontSmoothingContrast
        {
            get
            {
                int fontSmoothingContrast;

                Verify(SystemParametersInfo(SPI.GetFontSmoothingContrast, 0,
                    out fontSmoothingContrast, 0));

                return fontSmoothingContrast;
            }

            set
            {
                if (value > 2200 || value < 1000)
                    throw new ArgumentException(
                        "The value must be between 1000 and 2200.");

                Verify(SystemParametersInfo(SPI.SetFontSmoothingContrast, 0,
                    (IntPtr)value, SPIF.SendWininiChange | SPIF.UpdateInifile));
            }
        }

        #endregion

        #region Video Adapter information

        public static VideoAdapterInfo GetVideoAdapterInfo(IWin32Window wnd)
        {
            IntPtr hMonitor = MonitorFromWindow(wnd.Handle, Monitor.DefaultToNearest);
            Verify(hMonitor != IntPtr.Zero);

            // Получаем описание монитора
            MONITORINFOEX monitorInfoEx = new MONITORINFOEX();
            Verify(GetMonitorInfo(hMonitor, monitorInfoEx));

            // Ищем описание адаптера...

            string adapterDevName = monitorInfoEx.Device;
            string adapterName = "";

            // Перебираем все адаптеры и ищем среди них адаптер имя которого
            // совпадает с adapterDevName (полученным ранее из монитора).
            for (int i = 0; ; i++)
            {
                DISPLAY_DEVICE displayDevice = new DISPLAY_DEVICE();


                if (!EnumDisplayDevices(null, i, displayDevice, 0))
                    break;

                if (adapterDevName == displayDevice.DeviceName)
                {
                    adapterName = displayDevice.DeviceString;
                    break;
                }
            }

            return new VideoAdapterInfo(adapterName,
                monitorInfoEx.rcMonitor.ToRectangle());
        }

        #endregion

        #region Processor information

        public static string GetProcessorName()
        {
            using (RegistryKey hKey = Registry.LocalMachine.OpenSubKey(
                    @"Hardware\Description\System\CentralProcessor\0"))
            {

                string processor = (string)hKey.GetValue(
                    "ProcessorNameString", "unknown");

                int mhz = Convert.ToInt32(hKey.GetValue("~MHz", 0));

                if (mhz > 0)
                    processor += string.Format(" ({0} MHz)", mhz);

                return processor;
            }
        }

        #endregion

        #region Вспомогательные методы

        /// <summary>
        /// Проверяет значение параметра <paramref name="test"/> и возбуждает
        /// исключение Win32Exception если оно равно false.
        /// </summary>
        [DebuggerHidden]
        private static void Verify(bool test)
        {
            if (!test)
                throw new Win32Exception();
        }

        /// <summary>
        /// Redraw the Windows desktop area and active windows. Returns true on 
        /// success and false if it fails.
        /// </summary>
        public static bool Redraw()
        {
            bool status = RedrawWindow(IntPtr.Zero, 0, 0,
                RDW.Erase | RDW.Frame | RDW.AllChildren | RDW.InternalPaint
                | RDW.Invalidate | RDW.EraseNow | RDW.UpdateNow);

            return status;
        }

        #endregion
    }
}