-
Notifications
You must be signed in to change notification settings - Fork 673
/
ConsoleDriver.cs
1530 lines (1343 loc) · 49.5 KB
/
ConsoleDriver.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
//
// ConsoleDriver.cs: Base class for Terminal.Gui ConsoleDriver implementations.
//
using NStack;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
namespace Terminal.Gui {
/// <summary>
/// Colors that can be used to set the foreground and background colors in console applications.
/// </summary>
/// <remarks>
/// The <see cref="Attribute.HasValidColors"/> value indicates either no-color has been set or the color is invalid.
/// </remarks>
public enum Color {
/// <summary>
/// The black color.
/// </summary>
Black,
/// <summary>
/// The blue color.
/// </summary>
Blue,
/// <summary>
/// The green color.
/// </summary>
Green,
/// <summary>
/// The cyan color.
/// </summary>
Cyan,
/// <summary>
/// The red color.
/// </summary>
Red,
/// <summary>
/// The magenta color.
/// </summary>
Magenta,
/// <summary>
/// The brown color.
/// </summary>
Brown,
/// <summary>
/// The gray color.
/// </summary>
Gray,
/// <summary>
/// The dark gray color.
/// </summary>
DarkGray,
/// <summary>
/// The bright bBlue color.
/// </summary>
BrightBlue,
/// <summary>
/// The bright green color.
/// </summary>
BrightGreen,
/// <summary>
/// The bright cyan color.
/// </summary>
BrightCyan,
/// <summary>
/// The bright red color.
/// </summary>
BrightRed,
/// <summary>
/// The bright magenta color.
/// </summary>
BrightMagenta,
/// <summary>
/// The bright yellow color.
/// </summary>
BrightYellow,
/// <summary>
/// The White color.
/// </summary>
White
}
/// <summary>
/// Indicates the RGB for true colors.
/// </summary>
public class TrueColor {
/// <summary>
/// Red color component.
/// </summary>
public int Red { get; }
/// <summary>
/// Green color component.
/// </summary>
public int Green { get; }
/// <summary>
/// Blue color component.
/// </summary>
public int Blue { get; }
/// <summary>
/// Initializes a new instance of the <see cref="TrueColor"/> struct.
/// </summary>
/// <param name="red"></param>
/// <param name="green"></param>
/// <param name="blue"></param>
public TrueColor (int red, int green, int blue)
{
Red = red;
Green = green;
Blue = blue;
}
/// <summary>
/// Converts true color to console color.
/// </summary>
/// <returns></returns>
public Color ToConsoleColor ()
{
var trueColorMap = new Dictionary<TrueColor, Color> () {
{ new TrueColor (0,0,0),Color.Black},
{ new TrueColor (0, 0, 0x80),Color.Blue},
{ new TrueColor (0, 0x80, 0),Color.Green},
{ new TrueColor (0, 0x80, 0x80),Color.Cyan},
{ new TrueColor (0x80, 0, 0),Color.Red},
{ new TrueColor (0x80, 0, 0x80),Color.Magenta},
{ new TrueColor (0xC1, 0x9C, 0x00),Color.Brown}, // TODO confirm this
{ new TrueColor (0xC0, 0xC0, 0xC0),Color.Gray},
{ new TrueColor (0x80, 0x80, 0x80),Color.DarkGray},
{ new TrueColor (0, 0, 0xFF),Color.BrightBlue},
{ new TrueColor (0, 0xFF, 0),Color.BrightGreen},
{ new TrueColor (0, 0xFF, 0xFF),Color.BrightCyan},
{ new TrueColor (0xFF, 0, 0),Color.BrightRed},
{ new TrueColor (0xFF, 0, 0xFF),Color.BrightMagenta },
{ new TrueColor (0xFF, 0xFF, 0),Color.BrightYellow},
{ new TrueColor (0xFF, 0xFF, 0xFF),Color.White},
};
// Iterate over all colors in the map
var distances = trueColorMap.Select (
k => Tuple.Create (
// the candidate we are considering matching against (RGB)
k.Key,
CalculateDistance (k.Key, this)
));
// get the closest
var match = distances.OrderBy (t => t.Item2).First ();
return trueColorMap [match.Item1];
}
private float CalculateDistance (TrueColor color1, TrueColor color2)
{
// use RGB distance
return
Math.Abs (color1.Red - color2.Red) +
Math.Abs (color1.Green - color2.Green) +
Math.Abs (color1.Blue - color2.Blue);
}
}
/// <summary>
/// Attributes are used as elements that contain both a foreground and a background or platform specific features.
/// </summary>
/// <remarks>
/// <see cref="Attribute"/>s are needed to map colors to terminal capabilities that might lack colors.
/// They encode both the foreground and the background color and are used in the <see cref="ColorScheme"/>
/// class to define color schemes that can be used in an application.
/// </remarks>
public struct Attribute {
/// <summary>
/// The <see cref="ConsoleDriver"/>-specific color attribute value. If <see cref="Initialized"/> is <see langword="false"/>
/// the value of this property is invalid (typically because the Attribute was created before a driver was loaded)
/// and the attribute should be re-made (see <see cref="Make(Color, Color)"/>) before it is used.
/// </summary>
public int Value { get; }
/// <summary>
/// The foreground color.
/// </summary>
public Color Foreground { get; }
/// <summary>
/// The background color.
/// </summary>
public Color Background { get; }
/// <summary>
/// Initializes a new instance of the <see cref="Attribute"/> struct with only the value passed to
/// and trying to get the colors if defined.
/// </summary>
/// <param name="value">Value.</param>
public Attribute (int value)
{
Color foreground = default;
Color background = default;
Initialized = false;
if (Application.Driver != null) {
Application.Driver.GetColors (value, out foreground, out background);
Initialized = true;
}
Value = value;
Foreground = foreground;
Background = background;
}
/// <summary>
/// Initializes a new instance of the <see cref="Attribute"/> struct.
/// </summary>
/// <param name="value">Value.</param>
/// <param name="foreground">Foreground</param>
/// <param name="background">Background</param>
public Attribute (int value, Color foreground, Color background)
{
Value = value;
Foreground = foreground;
Background = background;
Initialized = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="Attribute"/> struct.
/// </summary>
/// <param name="foreground">Foreground</param>
/// <param name="background">Background</param>
public Attribute (Color foreground = new Color (), Color background = new Color ())
{
var make = Make (foreground, background);
Initialized = make.Initialized;
Value = make.Value;
Foreground = foreground;
Background = background;
}
/// <summary>
/// Initializes a new instance of the <see cref="Attribute"/> struct
/// with the same colors for the foreground and background.
/// </summary>
/// <param name="color">The color.</param>
public Attribute (Color color) : this (color, color) { }
/// <summary>
/// Implicit conversion from an <see cref="Attribute"/> to the underlying, driver-specific, Int32 representation
/// of the color.
/// </summary>
/// <returns>The driver-specific color value stored in the attribute.</returns>
/// <param name="c">The attribute to convert</param>
public static implicit operator int (Attribute c)
{
if (!c.Initialized) throw new InvalidOperationException ("Attribute: Attributes must be initialized by a driver before use.");
return c.Value;
}
/// <summary>
/// Implicitly convert an driver-specific color value into an <see cref="Attribute"/>
/// </summary>
/// <returns>An attribute with the specified driver-specific color value.</returns>
/// <param name="v">value</param>
public static implicit operator Attribute (int v) => new Attribute (v);
/// <summary>
/// Creates an <see cref="Attribute"/> from the specified foreground and background colors.
/// </summary>
/// <remarks>
/// If a <see cref="ConsoleDriver"/> has not been loaded (<c>Application.Driver == null</c>) this
/// method will return an attribute with <see cref="Initialized"/> set to <see langword="false"/>.
/// </remarks>
/// <returns>The new attribute.</returns>
/// <param name="foreground">Foreground color to use.</param>
/// <param name="background">Background color to use.</param>
public static Attribute Make (Color foreground, Color background)
{
if (Application.Driver == null) {
// Create the attribute, but show it's not been initialized
return new Attribute (-1, foreground, background) {
Initialized = false
};
}
return Application.Driver.MakeAttribute (foreground, background);
}
/// <summary>
/// Gets the current <see cref="Attribute"/> from the driver.
/// </summary>
/// <returns>The current attribute.</returns>
public static Attribute Get ()
{
if (Application.Driver == null)
throw new InvalidOperationException ("The Application has not been initialized");
return Application.Driver.GetAttribute ();
}
/// <summary>
/// If <see langword="true"/> the attribute has been initialized by a <see cref="ConsoleDriver"/> and
/// thus has <see cref="Value"/> that is valid for that driver. If <see langword="false"/> the <see cref="Foreground"/>
/// and <see cref="Background"/> colors may have been set '-1' but
/// the attribute has not been mapped to a <see cref="ConsoleDriver"/> specific color value.
/// </summary>
/// <remarks>
/// Attributes that have not been initialized must eventually be initialized before being passed to a driver.
/// </remarks>
public bool Initialized { get; internal set; }
/// <summary>
/// Returns <see langword="true"/> if the Attribute is valid (both foreground and background have valid color values).
/// </summary>
/// <returns></returns>
public bool HasValidColors { get => (int)Foreground > -1 && (int)Background > -1; }
}
/// <summary>
/// Defines the color <see cref="Attribute"/>s for common visible elements in a <see cref="View"/>.
/// Containers such as <see cref="Window"/> and <see cref="FrameView"/> use <see cref="ColorScheme"/> to determine
/// the colors used by sub-views.
/// </summary>
/// <remarks>
/// See also: <see cref="Colors.ColorSchemes"/>.
/// </remarks>
public class ColorScheme : IEquatable<ColorScheme> {
Attribute _normal = new Attribute (Color.White, Color.Black);
Attribute _focus = new Attribute (Color.White, Color.Black);
Attribute _hotNormal = new Attribute (Color.White, Color.Black);
Attribute _hotFocus = new Attribute (Color.White, Color.Black);
Attribute _disabled = new Attribute (Color.White, Color.Black);
/// <summary>
/// Used by <see cref="Colors.SetColorScheme(ColorScheme, string)"/> and <see cref="Colors.GetColorScheme(string)"/> to track which ColorScheme
/// is being accessed.
/// </summary>
internal string schemeBeingSet = "";
/// <summary>
/// The foreground and background color for text when the view is not focused, hot, or disabled.
/// </summary>
public Attribute Normal {
get { return _normal; }
set {
if (!value.HasValidColors) {
return;
}
_normal = value;
}
}
/// <summary>
/// The foreground and background color for text when the view has the focus.
/// </summary>
public Attribute Focus {
get { return _focus; }
set {
if (!value.HasValidColors) {
return;
}
_focus = value;
}
}
/// <summary>
/// The foreground and background color for text when the view is highlighted (hot).
/// </summary>
public Attribute HotNormal {
get { return _hotNormal; }
set {
if (!value.HasValidColors) {
return;
}
_hotNormal = value;
}
}
/// <summary>
/// The foreground and background color for text when the view is highlighted (hot) and has focus.
/// </summary>
public Attribute HotFocus {
get { return _hotFocus; }
set {
if (!value.HasValidColors) {
return;
}
_hotFocus = value;
}
}
/// <summary>
/// The default foreground and background color for text, when the view is disabled.
/// </summary>
public Attribute Disabled {
get { return _disabled; }
set {
if (!value.HasValidColors) {
return;
}
_disabled = value;
}
}
/// <summary>
/// Compares two <see cref="ColorScheme"/> objects for equality.
/// </summary>
/// <param name="obj"></param>
/// <returns>true if the two objects are equal</returns>
public override bool Equals (object obj)
{
return Equals (obj as ColorScheme);
}
/// <summary>
/// Compares two <see cref="ColorScheme"/> objects for equality.
/// </summary>
/// <param name="other"></param>
/// <returns>true if the two objects are equal</returns>
public bool Equals (ColorScheme other)
{
return other != null &&
EqualityComparer<Attribute>.Default.Equals (_normal, other._normal) &&
EqualityComparer<Attribute>.Default.Equals (_focus, other._focus) &&
EqualityComparer<Attribute>.Default.Equals (_hotNormal, other._hotNormal) &&
EqualityComparer<Attribute>.Default.Equals (_hotFocus, other._hotFocus) &&
EqualityComparer<Attribute>.Default.Equals (_disabled, other._disabled);
}
/// <summary>
/// Returns a hashcode for this instance.
/// </summary>
/// <returns>hashcode for this instance</returns>
public override int GetHashCode ()
{
int hashCode = -1242460230;
hashCode = hashCode * -1521134295 + _normal.GetHashCode ();
hashCode = hashCode * -1521134295 + _focus.GetHashCode ();
hashCode = hashCode * -1521134295 + _hotNormal.GetHashCode ();
hashCode = hashCode * -1521134295 + _hotFocus.GetHashCode ();
hashCode = hashCode * -1521134295 + _disabled.GetHashCode ();
return hashCode;
}
/// <summary>
/// Compares two <see cref="ColorScheme"/> objects for equality.
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns><c>true</c> if the two objects are equivalent</returns>
public static bool operator == (ColorScheme left, ColorScheme right)
{
return EqualityComparer<ColorScheme>.Default.Equals (left, right);
}
/// <summary>
/// Compares two <see cref="ColorScheme"/> objects for inequality.
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns><c>true</c> if the two objects are not equivalent</returns>
public static bool operator != (ColorScheme left, ColorScheme right)
{
return !(left == right);
}
internal void Initialize ()
{
// If the new scheme was created before a driver was loaded, we need to re-make
// the attributes
if (!_normal.Initialized) {
_normal = new Attribute (_normal.Foreground, _normal.Background);
}
if (!_focus.Initialized) {
_focus = new Attribute (_focus.Foreground, _focus.Background);
}
if (!_hotNormal.Initialized) {
_hotNormal = new Attribute (_hotNormal.Foreground, _hotNormal.Background);
}
if (!_hotFocus.Initialized) {
_hotFocus = new Attribute (_hotFocus.Foreground, _hotFocus.Background);
}
if (!_disabled.Initialized) {
_disabled = new Attribute (_disabled.Foreground, _disabled.Background);
}
}
}
/// <summary>
/// The default <see cref="ColorScheme"/>s for the application.
/// </summary>
/// <remarks>
/// This property can be set in a Theme to change the default <see cref="Colors"/> for the application.
/// </remarks>
public static class Colors {
private class SchemeNameComparerIgnoreCase : IEqualityComparer<string> {
public bool Equals (string x, string y)
{
if (x != null && y != null) {
return string.Equals (x, y, StringComparison.InvariantCultureIgnoreCase);
}
return false;
}
public int GetHashCode (string obj)
{
return obj.ToLowerInvariant ().GetHashCode ();
}
}
static Colors ()
{
ColorSchemes = Create ();
}
/// <summary>
/// Creates a new dictionary of new <see cref="ColorScheme"/> objects.
/// </summary>
public static Dictionary<string, ColorScheme> Create ()
{
// Use reflection to dynamically create the default set of ColorSchemes from the list defined
// by the class.
return typeof (Colors).GetProperties ()
.Where (p => p.PropertyType == typeof (ColorScheme))
.Select (p => new KeyValuePair<string, ColorScheme> (p.Name, new ColorScheme ()))
.ToDictionary (t => t.Key, t => t.Value, comparer: new SchemeNameComparerIgnoreCase ());
}
/// <summary>
/// The application toplevel color scheme, for the default toplevel views.
/// </summary>
/// <remarks>
/// <para>
/// This API will be deprecated in the future. Use <see cref="Colors.ColorSchemes"/> instead (e.g. <c>edit.ColorScheme = Colors.ColorSchemes["TopLevel"];</c>
/// </para>
/// </remarks>
public static ColorScheme TopLevel { get => GetColorScheme (); set => SetColorScheme (value); }
/// <summary>
/// The base color scheme, for the default toplevel views.
/// </summary>
/// <remarks>
/// <para>
/// This API will be deprecated in the future. Use <see cref="Colors.ColorSchemes"/> instead (e.g. <c>edit.ColorScheme = Colors.ColorSchemes["Base"];</c>
/// </para>
/// </remarks>
public static ColorScheme Base { get => GetColorScheme (); set => SetColorScheme (value); }
/// <summary>
/// The dialog color scheme, for standard popup dialog boxes
/// </summary>
/// <remarks>
/// <para>
/// This API will be deprecated in the future. Use <see cref="Colors.ColorSchemes"/> instead (e.g. <c>edit.ColorScheme = Colors.ColorSchemes["Dialog"];</c>
/// </para>
/// </remarks>
public static ColorScheme Dialog { get => GetColorScheme (); set => SetColorScheme (value); }
/// <summary>
/// The menu bar color
/// </summary>
/// <remarks>
/// <para>
/// This API will be deprecated in the future. Use <see cref="Colors.ColorSchemes"/> instead (e.g. <c>edit.ColorScheme = Colors.ColorSchemes["Menu"];</c>
/// </para>
/// </remarks>
public static ColorScheme Menu { get => GetColorScheme (); set => SetColorScheme (value); }
/// <summary>
/// The color scheme for showing errors.
/// </summary>
/// <remarks>
/// <para>
/// This API will be deprecated in the future. Use <see cref="Colors.ColorSchemes"/> instead (e.g. <c>edit.ColorScheme = Colors.ColorSchemes["Error"];</c>
/// </para>
/// </remarks>
public static ColorScheme Error { get => GetColorScheme (); set => SetColorScheme (value); }
static ColorScheme GetColorScheme ([CallerMemberName] string schemeBeingSet = null)
{
return ColorSchemes [schemeBeingSet];
}
static void SetColorScheme (ColorScheme colorScheme, [CallerMemberName] string schemeBeingSet = null)
{
ColorSchemes [schemeBeingSet] = colorScheme;
colorScheme.schemeBeingSet = schemeBeingSet;
}
/// <summary>
/// Provides the defined <see cref="ColorScheme"/>s.
/// </summary>
public static Dictionary<string, ColorScheme> ColorSchemes { get; private set; }
}
/// <summary>
/// Cursors Visibility that are displayed
/// </summary>
//
// Hexa value are set as 0xAABBCCDD where :
//
// AA stand for the TERMINFO DECSUSR parameter value to be used under Linux & MacOS
// BB stand for the NCurses curs_set parameter value to be used under Linux & MacOS
// CC stand for the CONSOLE_CURSOR_INFO.bVisible parameter value to be used under Windows
// DD stand for the CONSOLE_CURSOR_INFO.dwSize parameter value to be used under Windows
//
public enum CursorVisibility {
/// <summary>
/// Cursor caret has default
/// </summary>
/// <remarks>Works under Xterm-like terminal otherwise this is equivalent to <see ref="Underscore"/>. This default directly depends of the XTerm user configuration settings so it could be Block, I-Beam, Underline with possible blinking.</remarks>
Default = 0x00010119,
/// <summary>
/// Cursor caret is hidden
/// </summary>
Invisible = 0x03000019,
/// <summary>
/// Cursor caret is normally shown as a blinking underline bar _
/// </summary>
Underline = 0x03010119,
/// <summary>
/// Cursor caret is normally shown as a underline bar _
/// </summary>
/// <remarks>Under Windows, this is equivalent to <see ref="UnderscoreBlinking"/></remarks>
UnderlineFix = 0x04010119,
/// <summary>
/// Cursor caret is displayed a blinking vertical bar |
/// </summary>
/// <remarks>Works under Xterm-like terminal otherwise this is equivalent to <see ref="Underscore"/></remarks>
Vertical = 0x05010119,
/// <summary>
/// Cursor caret is displayed a blinking vertical bar |
/// </summary>
/// <remarks>Works under Xterm-like terminal otherwise this is equivalent to <see ref="Underscore"/></remarks>
VerticalFix = 0x06010119,
/// <summary>
/// Cursor caret is displayed as a blinking block ▉
/// </summary>
Box = 0x01020164,
/// <summary>
/// Cursor caret is displayed a block ▉
/// </summary>
/// <remarks>Works under Xterm-like terminal otherwise this is equivalent to <see ref="Block"/></remarks>
BoxFix = 0x02020164,
}
/// <summary>
/// ConsoleDriver is an abstract class that defines the requirements for a console driver.
/// There are currently three implementations: <see cref="CursesDriver"/> (for Unix and Mac), <see cref="WindowsDriver"/>, and <see cref="NetDriver"/> that uses the .NET Console API.
/// </summary>
public abstract class ConsoleDriver {
/// <summary>
/// The handler fired when the terminal is resized.
/// </summary>
protected Action TerminalResized;
/// <summary>
/// The current number of columns in the terminal.
/// </summary>
public abstract int Cols { get; }
/// <summary>
/// The current number of rows in the terminal.
/// </summary>
public abstract int Rows { get; }
/// <summary>
/// The current left in the terminal.
/// </summary>
public abstract int Left { get; }
/// <summary>
/// The current top in the terminal.
/// </summary>
public abstract int Top { get; }
/// <summary>
/// Get the operation system clipboard.
/// </summary>
public abstract IClipboard Clipboard { get; }
/// <summary>
/// <para>
/// If <see langword="false"/> (the default) the height of the Terminal.Gui application (<see cref="Rows"/>)
/// tracks to the height of the visible console view when the console is resized. In this case
/// scrolling in the console will be disabled and all <see cref="Rows"/> will remain visible.
/// </para>
/// <para>
/// If <see langword="true"/> then height of the Terminal.Gui application <see cref="Rows"/> only tracks
/// the height of the visible console view when the console is made larger (the application will only grow in height, never shrink).
/// In this case console scrolling is enabled and the contents (<see cref="Rows"/> high) will scroll
/// as the console scrolls.
/// </para>
/// </summary>
/// <remarks>
/// NOTE: Changes to Windows Terminal prevents this functionality from working. It only really worked on Windows 'conhost' previously.
/// </remarks>
[Obsolete ("This API is deprecated and has no impact when enabled.", false)]
public abstract bool EnableConsoleScrolling { get; set; }
/// <summary>
/// This API is deprecated and has no impact when enabled.
/// </summary>
[Obsolete ("This API is deprecated and has no impact when enabled.", false)]
public abstract bool HeightAsBuffer { get; set; }
/// <summary>
/// The format is rows, columns and 3 values on the last column: Rune, Attribute and Dirty Flag
/// </summary>
public virtual int [,,] Contents { get; }
/// <summary>
/// Initializes the driver
/// </summary>
/// <param name="terminalResized">Method to invoke when the terminal is resized.</param>
public abstract void Init (Action terminalResized);
/// <summary>
/// Moves the cursor to the specified column and row.
/// </summary>
/// <param name="col">Column to move the cursor to.</param>
/// <param name="row">Row to move the cursor to.</param>
public abstract void Move (int col, int row);
/// <summary>
/// Adds the specified rune to the display at the current cursor position.
/// </summary>
/// <param name="rune">Rune to add.</param>
public abstract void AddRune (Rune rune);
/// <summary>
/// Ensures a Rune is not a control character and can be displayed by translating characters below 0x20
/// to equivalent, printable, Unicode chars.
/// </summary>
/// <param name="c">Rune to translate</param>
/// <returns></returns>
public static Rune MakePrintable (Rune c)
{
if (c <= 0x1F || (c >= 0X7F && c <= 0x9F)) {
// ASCII (C0) control characters.
// C1 control characters (https://www.aivosto.com/articles/control-characters.html#c1)
return new Rune (c + 0x2400);
}
return c;
}
/// <summary>
/// Ensures that the column and line are in a valid range from the size of the driver.
/// </summary>
/// <param name="col">The column.</param>
/// <param name="row">The row.</param>
/// <param name="clip">The clip.</param>
/// <returns><c>true</c>if it's a valid range,<c>false</c>otherwise.</returns>
public bool IsValidContent (int col, int row, Rect clip) =>
col >= 0 && row >= 0 && col < Cols && row < Rows && clip.Contains (col, row);
/// <summary>
/// Adds the <paramref name="str"/> to the display at the cursor position.
/// </summary>
/// <param name="str">String.</param>
public abstract void AddStr (ustring str);
/// <summary>
/// Prepare the driver and set the key and mouse events handlers.
/// </summary>
/// <param name="mainLoop">The main loop.</param>
/// <param name="keyHandler">The handler for ProcessKey</param>
/// <param name="keyDownHandler">The handler for key down events</param>
/// <param name="keyUpHandler">The handler for key up events</param>
/// <param name="mouseHandler">The handler for mouse events</param>
public abstract void PrepareToRun (MainLoop mainLoop, Action<KeyEvent> keyHandler, Action<KeyEvent> keyDownHandler, Action<KeyEvent> keyUpHandler, Action<MouseEvent> mouseHandler);
/// <summary>
/// Updates the screen to reflect all the changes that have been done to the display buffer
/// </summary>
public abstract void Refresh ();
/// <summary>
/// Updates the location of the cursor position
/// </summary>
public abstract void UpdateCursor ();
/// <summary>
/// Retreive the cursor caret visibility
/// </summary>
/// <param name="visibility">The current <see cref="CursorVisibility"/></param>
/// <returns>true upon success</returns>
public abstract bool GetCursorVisibility (out CursorVisibility visibility);
/// <summary>
/// Change the cursor caret visibility
/// </summary>
/// <param name="visibility">The wished <see cref="CursorVisibility"/></param>
/// <returns>true upon success</returns>
public abstract bool SetCursorVisibility (CursorVisibility visibility);
/// <summary>
/// Ensure the cursor visibility
/// </summary>
/// <returns>true upon success</returns>
public abstract bool EnsureCursorVisibility ();
/// <summary>
/// Ends the execution of the console driver.
/// </summary>
public abstract void End ();
/// <summary>
/// Resizes the clip area when the screen is resized.
/// </summary>
public abstract void ResizeScreen ();
/// <summary>
/// Reset and recreate the contents and the driver buffer.
/// </summary>
public abstract void UpdateOffScreen ();
/// <summary>
/// Redraws the physical screen with the contents that have been queued up via any of the printing commands.
/// </summary>
public abstract void UpdateScreen ();
/// <summary>
/// The current attribute the driver is using.
/// </summary>
public virtual Attribute CurrentAttribute {
get => currentAttribute;
set {
if (!value.Initialized && value.HasValidColors && Application.Driver != null) {
CurrentAttribute = Application.Driver.MakeAttribute (value.Foreground, value.Background);
return;
}
if (!value.Initialized) Debug.WriteLine ("ConsoleDriver.CurrentAttribute: Attributes must be initialized before use.");
currentAttribute = value;
}
}
/// <summary>
/// Selects the specified attribute as the attribute to use for future calls to AddRune and AddString.
/// </summary>
/// <remarks>
/// Implementations should call <c>base.SetAttribute(c)</c>.
/// </remarks>
/// <param name="c">C.</param>
public virtual void SetAttribute (Attribute c)
{
CurrentAttribute = c;
}
/// <summary>
/// Set Colors from limit sets of colors. Not implemented by any driver: See Issue #2300.
/// </summary>
/// <param name="foreground">Foreground.</param>
/// <param name="background">Background.</param>
public abstract void SetColors (ConsoleColor foreground, ConsoleColor background);
// Advanced uses - set colors to any pre-set pairs, you would need to init_color
// that independently with the R, G, B values.
/// <summary>
/// Advanced uses - set colors to any pre-set pairs, you would need to init_color
/// that independently with the R, G, B values. Not implemented by any driver: See Issue #2300.
/// </summary>
/// <param name="foregroundColorId">Foreground color identifier.</param>
/// <param name="backgroundColorId">Background color identifier.</param>
public abstract void SetColors (short foregroundColorId, short backgroundColorId);
/// <summary>
/// Gets the foreground and background colors based on the value.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="foreground">The foreground.</param>
/// <param name="background">The background.</param>
/// <returns></returns>
public abstract bool GetColors (int value, out Color foreground, out Color background);
/// <summary>
/// Allows sending keys without typing on a keyboard.
/// </summary>
/// <param name="keyChar">The character key.</param>
/// <param name="key">The key.</param>
/// <param name="shift">If shift key is sending.</param>
/// <param name="alt">If alt key is sending.</param>
/// <param name="control">If control key is sending.</param>
public abstract void SendKeys (char keyChar, ConsoleKey key, bool shift, bool alt, bool control);
/// <summary>
/// Set the handler when the terminal is resized.
/// </summary>
/// <param name="terminalResized"></param>
public void SetTerminalResized (Action terminalResized)
{
TerminalResized = terminalResized;
}
/// <summary>
/// Draws the title for a Window-style view incorporating padding.
/// </summary>
/// <param name="region">Screen relative region where the frame will be drawn.</param>
/// <param name="title">The title for the window. The title will only be drawn if <c>title</c> is not null or empty and paddingTop is greater than 0.</param>
/// <param name="paddingLeft">Number of columns to pad on the left (if 0 the border will not appear on the left).</param>
/// <param name="paddingTop">Number of rows to pad on the top (if 0 the border and title will not appear on the top).</param>
/// <param name="paddingRight">Number of columns to pad on the right (if 0 the border will not appear on the right).</param>
/// <param name="paddingBottom">Number of rows to pad on the bottom (if 0 the border will not appear on the bottom).</param>
/// <param name="textAlignment">Not yet implemented.</param>
/// <remarks></remarks>
public virtual void DrawWindowTitle (Rect region, ustring title, int paddingLeft, int paddingTop, int paddingRight, int paddingBottom, TextAlignment textAlignment = TextAlignment.Left)
{
var width = region.Width - (paddingLeft + 2) * 2;
if (!ustring.IsNullOrEmpty (title) && width > 4 && region.Y + paddingTop <= region.Y + paddingBottom) {
Move (region.X + 1 + paddingLeft, region.Y + paddingTop);
AddRune (' ');
var str = title.Sum (r => Math.Max (Rune.ColumnWidth (r), 1)) >= width
? TextFormatter.Format (title, width - 2, false, false) [0] : title;
AddStr (str);
AddRune (' ');
}
}
/// <summary>
/// Enables diagnostic functions
/// </summary>
[Flags]
public enum DiagnosticFlags : uint {
/// <summary>
/// All diagnostics off
/// </summary>
Off = 0b_0000_0000,
/// <summary>
/// When enabled, <see cref="DrawWindowFrame(Rect, int, int, int, int, bool, bool, Border)"/> will draw a
/// ruler in the frame for any side with a padding value greater than 0.
/// </summary>
FrameRuler = 0b_0000_0001,
/// <summary>
/// When Enabled, <see cref="DrawWindowFrame(Rect, int, int, int, int, bool, bool, Border)"/> will use
/// 'L', 'R', 'T', and 'B' for padding instead of ' '.
/// </summary>
FramePadding = 0b_0000_0010,
}
/// <summary>
/// Set flags to enable/disable <see cref="ConsoleDriver"/> diagnostics.
/// </summary>
public static DiagnosticFlags Diagnostics { get; set; }
/// <summary>
/// Draws a frame for a window with padding and an optional visible border inside the padding.
/// </summary>
/// <param name="region">Screen relative region where the frame will be drawn.</param>
/// <param name="paddingLeft">Number of columns to pad on the left (if 0 the border will not appear on the left).</param>
/// <param name="paddingTop">Number of rows to pad on the top (if 0 the border and title will not appear on the top).</param>
/// <param name="paddingRight">Number of columns to pad on the right (if 0 the border will not appear on the right).</param>
/// <param name="paddingBottom">Number of rows to pad on the bottom (if 0 the border will not appear on the bottom).</param>
/// <param name="border">If set to <c>true</c> and any padding dimension is > 0 the border will be drawn.</param>
/// <param name="fill">If set to <c>true</c> it will clear the content area (the area inside the padding) with the current color, otherwise the content area will be left untouched.</param>
/// <param name="borderContent">The <see cref="Border"/> to be used if defined.</param>
public virtual void DrawWindowFrame (Rect region, int paddingLeft = 0, int paddingTop = 0, int paddingRight = 0,
int paddingBottom = 0, bool border = true, bool fill = false, Border borderContent = null)
{
char clearChar = ' ';
char leftChar = clearChar;
char rightChar = clearChar;
char topChar = clearChar;
char bottomChar = clearChar;
if ((Diagnostics & DiagnosticFlags.FramePadding) == DiagnosticFlags.FramePadding) {
leftChar = 'L';
rightChar = 'R';
topChar = 'T';
bottomChar = 'B';
clearChar = 'C';
}
void AddRuneAt (int col, int row, Rune ch)
{
Move (col, row);
AddRune (ch);
}
// fwidth is count of hLine chars
int fwidth = (int)(region.Width - (paddingRight + paddingLeft));
// fheight is count of vLine chars
int fheight = (int)(region.Height - (paddingBottom + paddingTop));
// fleft is location of left frame line
int fleft = region.X + paddingLeft - 1;
// fright is location of right frame line
int fright = fleft + fwidth + 1;
// ftop is location of top frame line
int ftop = region.Y + paddingTop - 1;
// fbottom is location of bottom frame line
int fbottom = ftop + fheight + 1;
var borderStyle = borderContent == null ? BorderStyle.Single : borderContent.BorderStyle;