Finish refactoring so unit tests run in VS2015

The mock of the console api is complete enough so unit tests run.

It's still a hack, not exactly factored nicely to support other hosts,
but at least some of the real interface is in one place, not scattered
about.

Author: lzybkr

PSReadLine/ConsoleLib.cs

@@ -409,6 +409,38 @@ public static string ToGestureString(this ConsoleKeyInfo key)
 
     internal class ConhostConsole : IConsole
     {
+        [SuppressMessage("Microsoft.Reliability", "CA2006:UseSafeHandleToEncapsulateNativeResources")]
+        private IntPtr _hwnd = (IntPtr)0;
+        [SuppressMessage("Microsoft.Reliability", "CA2006:UseSafeHandleToEncapsulateNativeResources")]
+        private IntPtr _hDC = (IntPtr)0;
+        private uint _codePage;
+        private bool _istmInitialized = false;
+        private TEXTMETRIC _tm = new TEXTMETRIC();
+        private bool _trueTypeInUse = false;
+
+        private readonly Lazy<SafeFileHandle> _outputHandle = new Lazy<SafeFileHandle>(() =>
+        {
+            // We use CreateFile here instead of GetStdWin32Handle, as GetStdWin32Handle will return redirected handles
+            var handle = NativeMethods.CreateFile(
+                "CONOUT$",
+                (UInt32)(AccessQualifiers.GenericRead | AccessQualifiers.GenericWrite),
+                (UInt32)ShareModes.ShareWrite,
+                (IntPtr)0,
+                (UInt32)CreationDisposition.OpenExisting,
+                0,
+                (IntPtr)0);
+
+            if (handle == NativeMethods.INVALID_HANDLE_VALUE)
+            {
+                int err = Marshal.GetLastWin32Error();
+                Win32Exception innerException = new Win32Exception(err);
+                throw new Exception("Failed to retreive the input console handle.", innerException);
+            }
+
+            return new SafeFileHandle(handle, true);
+        }
+        );
+
         private readonly Lazy<SafeFileHandle> _inputHandle = new Lazy<SafeFileHandle>(() =>
         {
             // We use CreateFile here instead of GetStdWin32Handle, as GetStdWin32Handle will return redirected handles
@@ -613,5 +645,197 @@ public CHAR_INFO[] ReadBufferLines(int top, int count)
                 readBufferSize, readBufferCoord, ref readRegion);
             return result;
         }
+
+        [SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods",
+            Justification = "Then the API we pass the handle to will return an error if it is invalid. They are not exposed.")]
+        internal static CONSOLE_FONT_INFO_EX GetConsoleFontInfo(SafeFileHandle consoleHandle)
+        {
+
+            CONSOLE_FONT_INFO_EX fontInfo = new CONSOLE_FONT_INFO_EX();
+            fontInfo.cbSize = Marshal.SizeOf(fontInfo);
+            bool result = NativeMethods.GetCurrentConsoleFontEx(consoleHandle.DangerousGetHandle(), false, ref fontInfo);
+
+            if (result == false)
+            {
+                int err = Marshal.GetLastWin32Error();
+                Win32Exception innerException = new Win32Exception(err);
+                throw new Exception("Failed to get console font information.", innerException);
+            }
+            return fontInfo;
+        }
+
+        public int LengthInBufferCells(char c)
+        {
+            if (!IsCJKOutputCodePage() || !_trueTypeInUse)
+                return 1;
+
+            return LengthInBufferCellsFE(c);
+        }
+
+        internal static bool IsAnyDBCSCharSet(uint charSet)
+        {
+            const uint SHIFTJIS_CHARSET = 128;
+            const uint HANGEUL_CHARSET = 129;
+            const uint CHINESEBIG5_CHARSET = 136;
+            const uint GB2312_CHARSET = 134;
+            return charSet == SHIFTJIS_CHARSET || charSet == HANGEUL_CHARSET ||
+                   charSet == CHINESEBIG5_CHARSET || charSet == GB2312_CHARSET;
+        }
+
+        internal uint CodePageToCharSet()
+        {
+            CHARSETINFO csi;
+            const uint TCI_SRCCODEPAGE = 2;
+            const uint OEM_CHARSET = 255;
+            if (!NativeMethods.TranslateCharsetInfo((IntPtr)_codePage, out csi, TCI_SRCCODEPAGE))
+            {
+                csi.ciCharset = OEM_CHARSET;
+            }
+            return csi.ciCharset;
+        }
+
+        /// <summary>
+        /// Check if the output buffer code page is Japanese, Simplified Chinese, Korean, or Traditional Chinese
+        /// </summary>
+        /// <returns>true if it is CJK code page; otherwise, false.</returns>
+        internal bool IsCJKOutputCodePage()
+        {
+            return _codePage == 932 || // Japanese
+                   _codePage == 936 || // Simplified Chinese
+                   _codePage == 949 || // Korean
+                   _codePage == 950;  // Traditional Chinese
+        }
+
+        internal bool IsAvailableFarEastCodePage()
+        {
+            uint charSet = CodePageToCharSet();
+            return IsAnyDBCSCharSet(charSet);
+        }
+
+        internal int LengthInBufferCellsFE(char c)
+        {
+            if (0x20 <= c && c <= 0x7e)
+            {
+                /* ASCII */
+                return 1;
+            }
+            else if (0x3041 <= c && c <= 0x3094)
+            {
+                /* Hiragana */
+                return 2;
+            }
+            else if (0x30a1 <= c && c <= 0x30f6)
+            {
+                /* Katakana */
+                return 2;
+            }
+            else if (0x3105 <= c && c <= 0x312c)
+            {
+                /* Bopomofo */
+                return 2;
+            }
+            else if (0x3131 <= c && c <= 0x318e)
+            {
+                /* Hangul Elements */
+                return 2;
+            }
+            else if (0xac00 <= c && c <= 0xd7a3)
+            {
+                /* Korean Hangul Syllables */
+                return 2;
+            }
+            else if (0xff01 <= c && c <= 0xff5e)
+            {
+                /* Fullwidth ASCII variants */
+                return 2;
+            }
+            else if (0xff61 <= c && c <= 0xff9f)
+            {
+                /* Halfwidth Katakana variants */
+                return 1;
+            }
+            else if ((0xffa0 <= c && c <= 0xffbe) ||
+                     (0xffc2 <= c && c <= 0xffc7) ||
+                     (0xffca <= c && c <= 0xffcf) ||
+                     (0xffd2 <= c && c <= 0xffd7) ||
+                     (0xffda <= c && c <= 0xffdc))
+            {
+                /* Halfwidth Hangule variants */
+                return 1;
+            }
+            else if (0xffe0 <= c && c <= 0xffe6)
+            {
+                /* Fullwidth symbol variants */
+                return 2;
+            }
+            else if (0x4e00 <= c && c <= 0x9fa5)
+            {
+                /* Han Ideographic */
+                return 2;
+            }
+            else if (0xf900 <= c && c <= 0xfa2d)
+            {
+                /* Han Compatibility Ideographs */
+                return 2;
+            }
+            else
+            {
+                /* Unknown character: need to use GDI*/
+                if (_hDC == (IntPtr)0)
+                {
+                    _hwnd = NativeMethods.GetConsoleWindow();
+                    if ((IntPtr)0 == _hwnd)
+                    {
+                        return 1;
+                    }
+                    _hDC = NativeMethods.GetDC(_hwnd);
+                    if ((IntPtr)0 == _hDC)
+                    {
+                        //Don't throw exception so that output can continue
+                        return 1;
+                    }
+                }
+                bool result = true;
+                if (!_istmInitialized)
+                {
+                    result = NativeMethods.GetTextMetrics(_hDC, out _tm);
+                    if (!result)
+                    {
+                        return 1;
+                    }
+                    _istmInitialized = true;
+                }
+                int width;
+                result = NativeMethods.GetCharWidth32(_hDC, (uint)c, (uint)c, out width);
+                if (!result)
+                {
+                    return 1;
+                }
+                if (width >= _tm.tmMaxCharWidth)
+                {
+                    return 2;
+                }
+            }
+            return 1;
+        }
+
+        public void StartRender()
+        {
+            _codePage = NativeMethods.GetConsoleOutputCP();
+            _istmInitialized = false;
+            var consoleHandle = _outputHandle.Value;
+            CONSOLE_FONT_INFO_EX fontInfo = ConhostConsole.GetConsoleFontInfo(consoleHandle);
+            int fontType = fontInfo.FontFamily & NativeMethods.FontTypeMask;
+            _trueTypeInUse = (fontType & NativeMethods.TrueTypeFont) == NativeMethods.TrueTypeFont;
+
+        }
+
+        public void EndRender()
+        {
+            if (_hwnd != (IntPtr)0 && _hDC != (IntPtr)0)
+            {
+                NativeMethods.ReleaseDC(_hwnd, _hDC);
+            }
+        }
     }
 }

PSReadLine/PublicAPI.cs

@@ -50,6 +50,10 @@ public interface IConsole
             void WriteBufferLines(CHAR_INFO[] buffer, ref int top, bool ensureBottomLineVisible);
             void ScrollBuffer(int lines);
             CHAR_INFO[] ReadBufferLines(int top, int count);
+
+            void StartRender();
+            int LengthInBufferCells(char c);
+            void EndRender();
         }
     }