mcs/class/corlib/System/Console.cs

   1 //
   2 // System.Console.cs
   3 //
   4 // Author:
   5 //      Dietmar Maurer (dietmar@ximian.com)
   6 //      Gonzalo Paniagua Javier (gonzalo@ximian.com)
   7 //
   8 // (C) Ximian, Inc.  http://www.ximian.com
   9 // (C) 2004,2005 Novell, Inc. (http://www.novell.com)
  10 // Copyright 2013 Xamarin Inc. (http://www.xamarin.com)
  11
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using System.Diagnostics;
  33 using System.IO;
  34 using System.Runtime.CompilerServices;
  35 using System.Runtime.InteropServices;
  36 using System.Security;
  37 using System.Security.Permissions;
  38 using System.Text;
  39 using System.Threading;
  40
  41 namespace System
  42 {
  43         public static partial class Console
  44         {
  45 #if MONO_FEATURE_CONSOLE
  46                 private class WindowsConsole
  47                 {
  48                         public static bool ctrlHandlerAdded = false;
  49                         private delegate bool WindowsCancelHandler (int keyCode);
  50                         private static WindowsCancelHandler cancelHandler = new WindowsCancelHandler (DoWindowsConsoleCancelEvent);
  51
  52                         [DllImport ("kernel32.dll", CharSet=CharSet.Auto, ExactSpelling=true)]
  53                         private static extern int GetConsoleCP ();
  54                         [DllImport ("kernel32.dll", CharSet=CharSet.Auto, ExactSpelling=true)]
  55                         private static extern int GetConsoleOutputCP ();
  56
  57                         [DllImport ("kernel32.dll", CharSet=CharSet.Auto, ExactSpelling=true)]
  58                         private static extern bool SetConsoleCtrlHandler (WindowsCancelHandler handler, bool addHandler);
  59
  60                         // Only call the event handler if Control-C was pressed (code == 0), nothing else
  61                         private static bool DoWindowsConsoleCancelEvent (int keyCode)
  62                         {
  63                                 if (keyCode == 0)
  64                                         DoConsoleCancelEvent ();
  65                                 return keyCode == 0;
  66                         }
  67
  68                         [MethodImpl (MethodImplOptions.NoInlining)]
  69                         public static int GetInputCodePage ()
  70                         {
  71                                 return GetConsoleCP ();
  72                         }
  73
  74                         [MethodImpl (MethodImplOptions.NoInlining)]
  75                         public static int GetOutputCodePage ()
  76                         {
  77                                 return GetConsoleOutputCP ();
  78                         }
  79
  80                         public static void AddCtrlHandler ()
  81                         {
  82                                 SetConsoleCtrlHandler (cancelHandler, true);
  83                                 ctrlHandlerAdded = true;
  84                         }
  85
  86                         public static void RemoveCtrlHandler ()
  87                         {
  88                                 SetConsoleCtrlHandler (cancelHandler, false);
  89                                 ctrlHandlerAdded = false;
  90                         }
  91                 }
  92 #endif
  93
  94                 internal static TextWriter stdout;
  95                 private static TextWriter stderr;
  96                 private static TextReader stdin;
  97
  98                 static Console ()
  99                 {
 100 #if MONO_FEATURE_CONSOLE
 101                         if (Environment.IsRunningOnWindows) {
 102                                 //
 103                                 // On Windows, follow the Windows tradition
 104                                 //
 105                                 try {
 106                                         inputEncoding = Encoding.GetEncoding (WindowsConsole.GetInputCodePage ());
 107                                         outputEncoding = Encoding.GetEncoding (WindowsConsole.GetOutputCodePage ());
 108                                         // ArgumentException and NotSupportedException can be thrown as well
 109                                 } catch {
 110                                         // FIXME: I18N assemblies are not available when compiling mcs
 111                                         // Use Latin 1 as it is fast and UTF-8 is never used as console code page
 112                                         inputEncoding = outputEncoding = Encoding.Default;
 113                                 }
 114                         } else
 115 #endif
 116                         {
 117                                 //
 118                                 // On Unix systems (128), do not output the
 119                                 // UTF-8 ZWNBSP (zero-width non-breaking space).
 120                                 //
 121                                 int code_page = 0;
 122                                 EncodingHelper.InternalCodePage (ref code_page);
 123
 124                                 if (code_page != -1 && ((code_page & 0x0fffffff) == 3 // UTF8Encoding.UTF8_CODE_PAGE
 125                                         || ((code_page & 0x10000000) != 0)))
 126                                         inputEncoding = outputEncoding = EncodingHelper.UTF8Unmarked;
 127                                 else
 128                                         inputEncoding = outputEncoding = Encoding.Default;
 129                         }
 130
 131                         SetupStreams (inputEncoding, outputEncoding);
 132                 }
 133
 134                 static void SetupStreams (Encoding inputEncoding, Encoding outputEncoding)
 135                 {
 136 #if MONO_FEATURE_CONSOLE
 137                         if (!Environment.IsRunningOnWindows && ConsoleDriver.IsConsole) {
 138                                 stdin = new CStreamReader (OpenStandardInput (0), inputEncoding);
 139                                 stdout = TextWriter.Synchronized (new CStreamWriter (OpenStandardOutput (0), outputEncoding, true) { AutoFlush = true });
 140                                 stderr = TextWriter.Synchronized (new CStreamWriter (OpenStandardError (0), outputEncoding, true) { AutoFlush = true });
 141                         } else
 142 #endif
 143                         {
 144                                 stdin = TextReader.Synchronized (new UnexceptionalStreamReader (OpenStandardInput (0), inputEncoding));
 145
 146 #if MONOTOUCH
 147                                 stdout = new NSLogWriter ();
 148                                 stderr = new NSLogWriter ();
 149 #else
 150                                 stdout = TextWriter.Synchronized (new UnexceptionalStreamWriter (OpenStandardOutput (0), outputEncoding) { AutoFlush = true });
 151                                 stderr = TextWriter.Synchronized (new UnexceptionalStreamWriter (OpenStandardError (0), outputEncoding) { AutoFlush = true });
 152
 153 #if MONODROID && !MOBILE_DESKTOP_HOST
 154                                 if (LogcatTextWriter.IsRunningOnAndroid ()) {
 155                                         stdout = TextWriter.Synchronized (new LogcatTextWriter ("mono-stdout", stdout));
 156                                         stderr = TextWriter.Synchronized (new LogcatTextWriter ("mono-stderr", stderr));
 157                                 }
 158 #endif // MONODROID
 159 #endif // MONOTOUCH
 160                         }
 161
 162                         GC.SuppressFinalize (stdout);
 163                         GC.SuppressFinalize (stderr);
 164                         GC.SuppressFinalize (stdin);
 165                 }
 166
 167                 public static TextWriter Error {
 168                         get {
 169                                 return stderr;
 170                         }
 171                 }
 172
 173                 public static TextWriter Out {
 174                         get {
 175                                 return stdout;
 176                         }
 177                 }
 178
 179                 public static TextReader In {
 180                         get {
 181                                 return stdin;
 182                         }
 183                 }
 184
 185                 private static Stream Open (IntPtr handle, FileAccess access, int bufferSize)
 186                 {
 187                         try {
 188                                 // TODO: Should use __ConsoleStream from reference sources
 189                                 var stream = new FileStream (handle, access, false, bufferSize, false, true);
 190                                 // Don't run the finalizer on the underlying stream so that System.WriteLine can be
 191                                 // called inside a finalizer during shutdown or domain unload.
 192                                 GC.SuppressFinalize (stream);
 193                                 return stream;
 194                         } catch (IOException) {
 195                                 return Stream.Null;
 196                         }
 197                 }
 198
 199                 public static Stream OpenStandardError ()
 200                 {
 201                         return OpenStandardError (0);
 202                 }
 203
 204                 // calling any FileStream constructor with a handle normally
 205                 // requires permissions UnmanagedCode permissions. In this
 206                 // case we assert this permission so the console can be used
 207                 // in partial trust (i.e. without having UnmanagedCode).
 208                 [SecurityPermission (SecurityAction.Assert, UnmanagedCode = true)]
 209                 public static Stream OpenStandardError (int bufferSize)
 210                 {
 211                         return Open (MonoIO.ConsoleError, FileAccess.Write, bufferSize);
 212                 }
 213
 214                 public static Stream OpenStandardInput ()
 215                 {
 216                         return OpenStandardInput (0);
 217                 }
 218
 219                 // calling any FileStream constructor with a handle normally
 220                 // requires permissions UnmanagedCode permissions. In this
 221                 // case we assert this permission so the console can be used
 222                 // in partial trust (i.e. without having UnmanagedCode).
 223                 [SecurityPermission (SecurityAction.Assert, UnmanagedCode = true)]
 224                 public static Stream OpenStandardInput (int bufferSize)
 225                 {
 226                         return Open (MonoIO.ConsoleInput, FileAccess.Read, bufferSize);
 227                 }
 228
 229                 public static Stream OpenStandardOutput ()
 230                 {
 231                         return OpenStandardOutput (0);
 232                 }
 233
 234                 // calling any FileStream constructor with a handle normally
 235                 // requires permissions UnmanagedCode permissions. In this
 236                 // case we assert this permission so the console can be used
 237                 // in partial trust (i.e. without having UnmanagedCode).
 238                 [SecurityPermission (SecurityAction.Assert, UnmanagedCode = true)]
 239                 public static Stream OpenStandardOutput (int bufferSize)
 240                 {
 241                         return Open (MonoIO.ConsoleOutput, FileAccess.Write, bufferSize);
 242                 }
 243
 244                 [SecurityPermission (SecurityAction.Demand, UnmanagedCode = true)]
 245                 public static void SetError (TextWriter newError)
 246                 {
 247                         if (newError == null)
 248                                 throw new ArgumentNullException ("newError");
 249
 250                         stderr = TextWriter.Synchronized (newError);
 251                 }
 252
 253                 [SecurityPermission (SecurityAction.Demand, UnmanagedCode = true)]
 254                 public static void SetIn (TextReader newIn)
 255                 {
 256                         if (newIn == null)
 257                                 throw new ArgumentNullException ("newIn");
 258
 259                         stdin = TextReader.Synchronized (newIn);
 260                 }
 261
 262                 [SecurityPermission (SecurityAction.Demand, UnmanagedCode = true)]
 263                 public static void SetOut (TextWriter newOut)
 264                 {
 265                         if (newOut == null)
 266                                 throw new ArgumentNullException ("newOut");
 267
 268                         stdout = TextWriter.Synchronized (newOut);
 269                 }
 270
 271                 public static void Write (bool value)
 272                 {
 273                         stdout.Write (value);
 274                 }
 275
 276                 public static void Write (char value)
 277                 {
 278                         stdout.Write (value);
 279                 }
 280
 281                 public static void Write (char[] buffer)
 282                 {
 283                         stdout.Write (buffer);
 284                 }
 285
 286                 public static void Write (decimal value)
 287                 {
 288                         stdout.Write (value);
 289                 }
 290
 291                 public static void Write (double value)
 292                 {
 293                         stdout.Write (value);
 294                 }
 295
 296                 public static void Write (int value)
 297                 {
 298                         stdout.Write (value);
 299                 }
 300
 301                 public static void Write (long value)
 302                 {
 303                         stdout.Write (value);
 304                 }
 305
 306                 public static void Write (object value)
 307                 {
 308                         stdout.Write (value);
 309                 }
 310
 311                 public static void Write (float value)
 312                 {
 313                         stdout.Write (value);
 314                 }
 315
 316                 public static void Write (string value)
 317                 {
 318                         stdout.Write (value);
 319                 }
 320
 321                 [CLSCompliant (false)]
 322                 public static void Write (uint value)
 323                 {
 324                         stdout.Write (value);
 325                 }
 326
 327                 [CLSCompliant (false)]
 328                 public static void Write (ulong value)
 329                 {
 330                         stdout.Write (value);
 331                 }
 332
 333                 public static void Write (string format, object arg0)
 334                 {
 335                         stdout.Write (format, arg0);
 336                 }
 337
 338                 public static void Write (string format, params object[] arg)
 339                 {
 340                         if (arg == null)
 341                                 stdout.Write (format);
 342                         else
 343                                 stdout.Write (format, arg);
 344                 }
 345
 346                 public static void Write (char[] buffer, int index, int count)
 347                 {
 348                         stdout.Write (buffer, index, count);
 349                 }
 350
 351                 public static void Write (string format, object arg0, object arg1)
 352                 {
 353                         stdout.Write (format, arg0, arg1);
 354                 }
 355
 356                 public static void Write (string format, object arg0, object arg1, object arg2 )
 357                 {
 358                         stdout.Write (format, arg0, arg1, arg2);
 359                 }
 360
 361                 [CLSCompliant (false)]
 362                 public static void Write (string format, object arg0, object arg1, object arg2, object arg3, __arglist)
 363                 {
 364                         ArgIterator iter = new ArgIterator (__arglist);
 365                         int argCount = iter.GetRemainingCount();
 366
 367                         object[] args = new object [argCount + 4];
 368                         args [0] = arg0;
 369                         args [1] = arg1;
 370                         args [2] = arg2;
 371                         args [3] = arg3;
 372                         for (int i = 0; i < argCount; i++) {
 373                                 TypedReference typedRef = iter.GetNextArg ();
 374                                 args [i + 4] = TypedReference.ToObject (typedRef);
 375                         }
 376
 377                         stdout.Write (String.Format (format, args));
 378                 }
 379
 380                 public static void WriteLine ()
 381                 {
 382                         stdout.WriteLine ();
 383                 }
 384
 385                 public static void WriteLine (bool value)
 386                 {
 387                         stdout.WriteLine (value);
 388                 }
 389
 390                 public static void WriteLine (char value)
 391                 {
 392                         stdout.WriteLine (value);
 393                 }
 394
 395                 public static void WriteLine (char[] buffer)
 396                 {
 397                         stdout.WriteLine (buffer);
 398                 }
 399
 400                 public static void WriteLine (decimal value)
 401                 {
 402                         stdout.WriteLine (value);
 403                 }
 404
 405                 public static void WriteLine (double value)
 406                 {
 407                         stdout.WriteLine (value);
 408                 }
 409
 410                 public static void WriteLine (int value)
 411                 {
 412                         stdout.WriteLine (value);
 413                 }
 414
 415                 public static void WriteLine (long value)
 416                 {
 417                         stdout.WriteLine (value);
 418                 }
 419
 420                 public static void WriteLine (object value)
 421                 {
 422                         stdout.WriteLine (value);
 423                 }
 424
 425                 public static void WriteLine (float value)
 426                 {
 427                         stdout.WriteLine (value);
 428                 }
 429
 430                 public static void WriteLine (string value)
 431                 {
 432                         stdout.WriteLine (value);
 433                 }
 434
 435                 [CLSCompliant (false)]
 436                 public static void WriteLine (uint value)
 437                 {
 438                         stdout.WriteLine (value);
 439                 }
 440
 441                 [CLSCompliant (false)]
 442                 public static void WriteLine (ulong value)
 443                 {
 444                         stdout.WriteLine (value);
 445                 }
 446
 447                 public static void WriteLine (string format, object arg0)
 448                 {
 449                         stdout.WriteLine (format, arg0);
 450                 }
 451
 452                 public static void WriteLine (string format, params object[] arg)
 453                 {
 454                         if (arg == null)
 455                                 stdout.WriteLine (format);
 456                         else
 457                                 stdout.WriteLine (format, arg);
 458                 }
 459
 460                 public static void WriteLine (char[] buffer, int index, int count)
 461                 {
 462                         stdout.WriteLine (buffer, index, count);
 463                 }
 464
 465                 public static void WriteLine (string format, object arg0, object arg1)
 466                 {
 467                         stdout.WriteLine (format, arg0, arg1);
 468                 }
 469
 470                 public static void WriteLine (string format, object arg0, object arg1, object arg2)
 471                 {
 472                         stdout.WriteLine (format, arg0, arg1, arg2);
 473                 }
 474
 475                 [CLSCompliant (false)]
 476                 public static void WriteLine (string format, object arg0, object arg1, object arg2, object arg3, __arglist)
 477                 {
 478                         ArgIterator iter = new ArgIterator (__arglist);
 479                         int argCount = iter.GetRemainingCount();
 480
 481                         object[] args = new object [argCount + 4];
 482                         args [0] = arg0;
 483                         args [1] = arg1;
 484                         args [2] = arg2;
 485                         args [3] = arg3;
 486                         for (int i = 0; i < argCount; i++) {
 487                                 TypedReference typedRef = iter.GetNextArg ();
 488                                 args [i + 4] = TypedReference.ToObject (typedRef);
 489                         }
 490
 491                         stdout.WriteLine (String.Format (format, args));
 492                 }
 493 #if MONO_FEATURE_CONSOLE
 494                 public static int Read ()
 495                 {
 496                         if ((stdin is CStreamReader) && ConsoleDriver.IsConsole) {
 497                                 return ConsoleDriver.Read ();
 498                         } else {
 499                                 return stdin.Read ();
 500                         }
 501                 }
 502
 503                 public static string ReadLine ()
 504                 {
 505                         if ((stdin is CStreamReader) && ConsoleDriver.IsConsole) {
 506                                 return ConsoleDriver.ReadLine ();
 507                         } else {
 508                                 return stdin.ReadLine ();
 509                         }
 510                 }
 511 #else
 512                 public static int Read ()
 513                 {
 514                         return stdin.Read ();
 515                 }
 516
 517                 public static string ReadLine ()
 518                 {
 519                         return stdin.ReadLine ();
 520                 }
 521 #endif
 522
 523                 // FIXME: Console should use these encodings when changed
 524                 static Encoding inputEncoding;
 525                 static Encoding outputEncoding;
 526
 527                 public static Encoding InputEncoding {
 528                         get { return inputEncoding; }
 529                         set {
 530                                 inputEncoding = value;
 531                                 SetupStreams (inputEncoding, outputEncoding);
 532                         }
 533                 }
 534
 535                 public static Encoding OutputEncoding {
 536                         get { return outputEncoding; }
 537                         set {
 538                                 outputEncoding = value;
 539                                 SetupStreams (inputEncoding, outputEncoding);
 540                         }
 541                 }
 542
 543 #if MONO_FEATURE_CONSOLE
 544                 public static ConsoleColor BackgroundColor {
 545                         get { return ConsoleDriver.BackgroundColor; }
 546                         set { ConsoleDriver.BackgroundColor = value; }
 547                 }
 548
 549                 public static int BufferHeight {
 550                         get { return ConsoleDriver.BufferHeight; }
 551                         [MonoLimitation ("Implemented only on Windows")]
 552                         set { ConsoleDriver.BufferHeight = value; }
 553                 }
 554
 555                 public static int BufferWidth {
 556                         get { return ConsoleDriver.BufferWidth; }
 557                         [MonoLimitation ("Implemented only on Windows")]
 558                         set { ConsoleDriver.BufferWidth = value; }
 559                 }
 560
 561                 [MonoLimitation ("Implemented only on Windows")]
 562                 public static bool CapsLock {
 563                         get { return ConsoleDriver.CapsLock; }
 564                 }
 565
 566                 public static int CursorLeft {
 567                         get { return ConsoleDriver.CursorLeft; }
 568                         set { ConsoleDriver.CursorLeft = value; }
 569                 }
 570
 571                 public static int CursorTop {
 572                         get { return ConsoleDriver.CursorTop; }
 573                         set { ConsoleDriver.CursorTop = value; }
 574                 }
 575
 576                 public static int CursorSize {
 577                         get { return ConsoleDriver.CursorSize; }
 578                         set { ConsoleDriver.CursorSize = value; }
 579                 }
 580
 581                 public static bool CursorVisible {
 582                         get { return ConsoleDriver.CursorVisible; }
 583                         set { ConsoleDriver.CursorVisible = value; }
 584                 }
 585
 586                 public static ConsoleColor ForegroundColor {
 587                         get { return ConsoleDriver.ForegroundColor; }
 588                         set { ConsoleDriver.ForegroundColor = value; }
 589                 }
 590
 591                 public static bool KeyAvailable {
 592                         get { return ConsoleDriver.KeyAvailable; }
 593                 }
 594
 595                 public static int LargestWindowHeight {
 596                         get { return ConsoleDriver.LargestWindowHeight; }
 597                 }
 598
 599                 public static int LargestWindowWidth {
 600                         get { return ConsoleDriver.LargestWindowWidth; }
 601                 }
 602
 603                 public static bool NumberLock {
 604                         get { return ConsoleDriver.NumberLock; }
 605                 }
 606
 607                 public static string Title {
 608                         get { return ConsoleDriver.Title; }
 609                         set { ConsoleDriver.Title = value; }
 610                 }
 611
 612                 public static bool TreatControlCAsInput {
 613                         get { return ConsoleDriver.TreatControlCAsInput; }
 614                         set { ConsoleDriver.TreatControlCAsInput = value; }
 615                 }
 616
 617                 public static int WindowHeight {
 618                         get { return ConsoleDriver.WindowHeight; }
 619                         set { ConsoleDriver.WindowHeight = value; }
 620                 }
 621
 622                 public static int WindowLeft {
 623                         get { return ConsoleDriver.WindowLeft; }
 624                         set { ConsoleDriver.WindowLeft = value; }
 625                 }
 626
 627                 public static int WindowTop {
 628                         get { return ConsoleDriver.WindowTop; }
 629                         set { ConsoleDriver.WindowTop = value; }
 630                 }
 631
 632                 public static int WindowWidth {
 633                         get { return ConsoleDriver.WindowWidth; }
 634                         set { ConsoleDriver.WindowWidth = value; }
 635                 }
 636
 637                 public static bool IsErrorRedirected {
 638                         get {
 639                                 return ConsoleDriver.IsErrorRedirected;
 640                         }
 641                 }
 642
 643                 public static bool IsOutputRedirected {
 644                         get {
 645                                 return ConsoleDriver.IsOutputRedirected;
 646                         }
 647                 }
 648
 649                 public static bool IsInputRedirected {
 650                         get {
 651                                 return ConsoleDriver.IsInputRedirected;
 652                         }
 653                 }
 654
 655                 public static void Beep ()
 656                 {
 657                         Beep (1000, 500);
 658                 }
 659
 660                 public static void Beep (int frequency, int duration)
 661                 {
 662                         if (frequency < 37 || frequency > 32767)
 663                                 throw new ArgumentOutOfRangeException ("frequency");
 664
 665                         if (duration <= 0)
 666                                 throw new ArgumentOutOfRangeException ("duration");
 667
 668                         ConsoleDriver.Beep (frequency, duration);
 669                 }
 670
 671                 public static void Clear ()
 672                 {
 673                         ConsoleDriver.Clear ();
 674                 }
 675
 676                 [MonoLimitation ("Implemented only on Windows")]
 677                 public static void MoveBufferArea (int sourceLeft, int sourceTop, int sourceWidth, int sourceHeight,
 678                                                 int targetLeft, int targetTop)
 679                 {
 680                         ConsoleDriver.MoveBufferArea (sourceLeft, sourceTop, sourceWidth, sourceHeight, targetLeft, targetTop);
 681                 }
 682
 683                 [MonoLimitation ("Implemented only on Windows")]
 684                 public static void MoveBufferArea (int sourceLeft, int sourceTop, int sourceWidth, int sourceHeight,
 685                                                 int targetLeft, int targetTop, Char sourceChar,
 686                                                 ConsoleColor sourceForeColor, ConsoleColor sourceBackColor)
 687                 {
 688                         ConsoleDriver.MoveBufferArea (sourceLeft, sourceTop, sourceWidth, sourceHeight, targetLeft, targetTop,
 689                                                         sourceChar, sourceForeColor, sourceBackColor);
 690                 }
 691
 692                 public static ConsoleKeyInfo ReadKey ()
 693                 {
 694                         return ReadKey (false);
 695                 }
 696
 697                 public static ConsoleKeyInfo ReadKey (bool intercept)
 698                 {
 699                         return ConsoleDriver.ReadKey (intercept);
 700                 }
 701
 702                 public static void ResetColor ()
 703                 {
 704                         ConsoleDriver.ResetColor ();
 705                 }
 706
 707                 [MonoLimitation ("Only works on windows")]
 708                 public static void SetBufferSize (int width, int height)
 709                 {
 710                         ConsoleDriver.SetBufferSize (width, height);
 711                 }
 712
 713                 public static void SetCursorPosition (int left, int top)
 714                 {
 715                         ConsoleDriver.SetCursorPosition (left, top);
 716                 }
 717
 718                 public static void SetWindowPosition (int left, int top)
 719                 {
 720                         ConsoleDriver.SetWindowPosition (left, top);
 721                 }
 722
 723                 public static void SetWindowSize (int width, int height)
 724                 {
 725                         ConsoleDriver.SetWindowSize (width, height);
 726                 }
 727
 728                 static ConsoleCancelEventHandler cancel_event;
 729                 public static event ConsoleCancelEventHandler CancelKeyPress {
 730                         add {
 731                                 if (ConsoleDriver.Initialized == false)
 732                                         ConsoleDriver.Init ();
 733
 734                                 cancel_event += value;
 735
 736                                 if (Environment.IsRunningOnWindows && !WindowsConsole.ctrlHandlerAdded)
 737                                         WindowsConsole.AddCtrlHandler();
 738                         }
 739                         remove {
 740                                 if (ConsoleDriver.Initialized == false)
 741                                         ConsoleDriver.Init ();
 742
 743                                 cancel_event -= value;
 744
 745                                 if (cancel_event == null && Environment.IsRunningOnWindows)
 746                                 {
 747                                         // Need to remove our hook if there's nothing left in the event
 748                                         if (WindowsConsole.ctrlHandlerAdded)
 749                                                 WindowsConsole.RemoveCtrlHandler();
 750                                 }
 751                         }
 752                 }
 753
 754                 static void DoConsoleCancelEventInBackground ()
 755                 {
 756                         ThreadPool.UnsafeQueueUserWorkItem (_ => DoConsoleCancelEvent(), null);
 757                 }
 758
 759                 static void DoConsoleCancelEvent ()
 760                 {
 761                         bool exit = true;
 762                         if (cancel_event != null) {
 763                                 ConsoleCancelEventArgs args = new ConsoleCancelEventArgs (ConsoleSpecialKey.ControlC);
 764                                 Delegate [] delegates = cancel_event.GetInvocationList ();
 765                                 foreach (ConsoleCancelEventHandler d in delegates){
 766                                         try {
 767                                                 // Sender is always null here.
 768                                                 d (null, args);
 769                                         } catch {} // Ignore any exception.
 770                                 }
 771                                 exit = !args.Cancel;
 772                         }
 773
 774                         if (exit)
 775                                 Environment.Exit (58);
 776                 }
 777 #else
 778                 // largely inspired by https://github.com/dotnet/corefx/blob/be8d2ce3964968cec9322a64211e37682085db70/src/System.Console/src/System/ConsolePal.WinRT.cs, because it's a similar platform where a console might not be available
 779
 780                 // provide simply color tracking that allows round-tripping
 781                 internal const ConsoleColor UnknownColor = (ConsoleColor)(-1);
 782                 private static ConsoleColor s_trackedForegroundColor = UnknownColor;
 783                 private static ConsoleColor s_trackedBackgroundColor = UnknownColor;
 784
 785                 public static ConsoleColor ForegroundColor
 786                 {
 787                         get
 788                         {
 789                                 return s_trackedForegroundColor;
 790                         }
 791                         set
 792                         {
 793                                 lock (Console.Out) // synchronize with other writers
 794                                 {
 795                                         s_trackedForegroundColor = value;
 796                                 }
 797                         }
 798                 }
 799
 800                 public static ConsoleColor BackgroundColor
 801                 {
 802                         get
 803                         {
 804                                 return s_trackedBackgroundColor;
 805                         }
 806                         set
 807                         {
 808                                 lock (Console.Out) // synchronize with other writers
 809                                 {
 810                                         s_trackedBackgroundColor = value;
 811                                 }
 812                         }
 813                 }
 814
 815                 public static int BufferWidth
 816                 {
 817                         get { throw new PlatformNotSupportedException (); }
 818                         set { throw new PlatformNotSupportedException (); }
 819                 }
 820
 821                 public static int BufferHeight
 822                 {
 823                         get { throw new PlatformNotSupportedException (); }
 824                         set { throw new PlatformNotSupportedException (); }
 825                 }
 826
 827                 public static bool CapsLock { get { throw new PlatformNotSupportedException (); } }
 828
 829                 public static int CursorLeft
 830                 {
 831                         get { throw new PlatformNotSupportedException (); }
 832                         set { throw new PlatformNotSupportedException (); }
 833                 }
 834
 835                 public static int CursorTop
 836                 {
 837                         get { throw new PlatformNotSupportedException (); }
 838                         set { throw new PlatformNotSupportedException (); }
 839                 }
 840
 841                 public static int CursorSize
 842                 {
 843                         get { return 100; }
 844                         set { throw new PlatformNotSupportedException(); }
 845                 }
 846
 847                 public static bool CursorVisible
 848                 {
 849                         get { throw new PlatformNotSupportedException (); }
 850                         set { throw new PlatformNotSupportedException (); }
 851                 }
 852
 853                 public static bool KeyAvailable { get { throw new PlatformNotSupportedException (); } }
 854
 855                 public static int LargestWindowWidth
 856                 {
 857                         get { throw new PlatformNotSupportedException (); }
 858                         set { throw new PlatformNotSupportedException (); }
 859                 }
 860
 861                 public static int LargestWindowHeight
 862                 {
 863                         get { throw new PlatformNotSupportedException (); }
 864                         set { throw new PlatformNotSupportedException (); }
 865                 }
 866
 867                 public static bool NumberLock { get { throw new PlatformNotSupportedException (); } }
 868
 869                 public static string Title
 870                 {
 871                         get { throw new PlatformNotSupportedException (); }
 872                         set { throw new PlatformNotSupportedException (); }
 873                 }
 874
 875                 public static bool TreatControlCAsInput
 876                 {
 877                         get { throw new PlatformNotSupportedException (); }
 878                         set { throw new PlatformNotSupportedException (); }
 879                 }
 880
 881                 public static int WindowHeight
 882                 {
 883                         get { throw new PlatformNotSupportedException (); }
 884                         set { throw new PlatformNotSupportedException (); }
 885                 }
 886
 887                 public static int WindowLeft
 888                 {
 889                         get { return 0; }
 890                         set { throw new PlatformNotSupportedException (); }
 891                 }
 892
 893                 public static int WindowTop
 894                 {
 895                         get { return 0; }
 896                         set { throw new PlatformNotSupportedException (); }
 897                 }
 898
 899                 public static int WindowWidth
 900                 {
 901                         get { throw new PlatformNotSupportedException (); }
 902                         set { throw new PlatformNotSupportedException (); }
 903                 }
 904
 905                 public static bool IsErrorRedirected { get { throw new PlatformNotSupportedException (); } }
 906
 907                 public static bool IsInputRedirected { get { throw new PlatformNotSupportedException (); } }
 908
 909                 public static bool IsOutputRedirected { get { throw new PlatformNotSupportedException (); } }
 910
 911                 public static void Beep () { throw new PlatformNotSupportedException (); }
 912
 913                 public static void Beep (int frequency, int duration) { throw new PlatformNotSupportedException (); }
 914
 915                 public static void Clear () { throw new PlatformNotSupportedException (); }
 916
 917                 public static void MoveBufferArea (int sourceLeft, int sourceTop, int sourceWidth, int sourceHeight, int targetLeft, int targetTop) { throw new PlatformNotSupportedException(); }
 918
 919                 public static void MoveBufferArea (int sourceLeft, int sourceTop, int sourceWidth, int sourceHeight, int targetLeft, int targetTop, char sourceChar, ConsoleColor sourceForeColor, ConsoleColor sourceBackColor) { throw new PlatformNotSupportedException(); }
 920
 921
 922                 public static ConsoleKeyInfo ReadKey ()
 923                 {
 924                         return ReadKey (false);
 925                 }
 926
 927                 public static ConsoleKeyInfo ReadKey (bool intercept) { throw new PlatformNotSupportedException (); }
 928
 929                 public static void ResetColor ()
 930                 {
 931                         lock (Console.Out) // synchronize with other writers
 932                         {
 933                                 s_trackedForegroundColor = UnknownColor;
 934                                 s_trackedBackgroundColor = UnknownColor;
 935                         }
 936                 }
 937
 938                 public static void SetBufferSize (int width, int height) { throw new PlatformNotSupportedException (); }
 939
 940                 public static void SetCursorPosition (int left, int top) { throw new PlatformNotSupportedException (); }
 941
 942                 public static void SetWindowPosition (int left, int top) { throw new PlatformNotSupportedException (); }
 943
 944                 public static void SetWindowSize (int width, int height) { throw new PlatformNotSupportedException (); }
 945
 946                 public static event ConsoleCancelEventHandler CancelKeyPress {
 947                         add {
 948                                 throw new PlatformNotSupportedException ();
 949                         }
 950                         remove {
 951                                 throw new PlatformNotSupportedException ();
 952                         }
 953                 }
 954 #endif
 955         }
 956 }
 957