├── EntityFX.ScoreboardUI
    ├── .vs
    │   └── EntityFX.ScoreboardUI
    │   │   └── v15
    │   │       └── Server
    │   │           └── sqlite3
    │   │               ├── db.lock
    │   │               ├── storage.ide
    │   │               ├── storage.ide-shm
    │   │               └── storage.ide-wal
    ├── EntityFX.ScoreboardUI
    │   ├── .vs
    │   │   ├── ProjectSettings.json
    │   │   ├── VSWorkspaceState.json
    │   │   └── slnx.sqlite
    │   ├── Elements
    │   │   ├── Controls
    │   │   │   ├── Label.cs
    │   │   │   ├── Checkbox.cs
    │   │   │   ├── PasswordBox.cs
    │   │   │   ├── Table
    │   │   │   │   ├── TableHeaderCell.cs
    │   │   │   │   ├── TableViewRow.cs
    │   │   │   │   ├── TableCellBase.cs
    │   │   │   │   ├── TableButtonCellBaseBase.cs
    │   │   │   │   ├── TableHeaderRow.cs
    │   │   │   │   ├── ITableCell.cs
    │   │   │   │   ├── ITableRow.cs
    │   │   │   │   ├── TableCheckboxCell.cs
    │   │   │   │   ├── TableRow.cs
    │   │   │   │   ├── TableCell.cs
    │   │   │   │   ├── Table.cs
    │   │   │   │   └── TableViewCell.cs
    │   │   │   ├── PositionEnum.cs
    │   │   │   ├── RichtextBox.cs
    │   │   │   ├── ItemLocationEnum.cs
    │   │   │   ├── ComboBoxItem.cs
    │   │   │   ├── Menu
    │   │   │   │   ├── SubmenuContext.cs
    │   │   │   │   ├── MenuItem.cs
    │   │   │   │   ├── MenuItemButton.cs
    │   │   │   │   └── Menu.cs
    │   │   │   ├── StatusBar
    │   │   │   │   ├── IStatusStripItem.cs
    │   │   │   │   ├── StatusStripLabel.cs
    │   │   │   │   ├── StatusStripButton.cs
    │   │   │   │   ├── StatusStripItem.cs
    │   │   │   │   ├── StatusStrip.cs
    │   │   │   │   └── StatusStripProgressBar.cs
    │   │   │   ├── IListView.cs
    │   │   │   ├── Panel.cs
    │   │   │   ├── ListViewItem.cs
    │   │   │   ├── Button.cs
    │   │   │   ├── BorderPanel.cs
    │   │   │   ├── IProgressBar.cs
    │   │   │   ├── ToggleButtonBase.cs
    │   │   │   ├── RadioButton.cs
    │   │   │   ├── ButtonBase.cs
    │   │   │   ├── Charts
    │   │   │   │   └── PlotChart.cs
    │   │   │   ├── TextBox.cs
    │   │   │   ├── Control.cs
    │   │   │   ├── DateTimeBox.cs
    │   │   │   ├── ListControlBase.cs
    │   │   │   ├── Image.cs
    │   │   │   ├── ListView.cs
    │   │   │   ├── ComboBox.cs
    │   │   │   ├── NumericBox.cs
    │   │   │   ├── ProgressBar.cs
    │   │   │   └── ControlBase.cs
    │   │   ├── ILinearable.cs
    │   │   ├── ISizable.cs
    │   │   ├── Scoreboards
    │   │   │   ├── TitleAligment.cs
    │   │   │   ├── MessageBox
    │   │   │   │   ├── MessageBoxButtonsDirectionEnum.cs
    │   │   │   │   ├── MessageBoxButtonsEnum.cs
    │   │   │   │   ├── MessageBoxResultEnum.cs
    │   │   │   │   ├── MessageBoxTypeEnum.cs
    │   │   │   │   └── MessageBox.cs
    │   │   │   └── Scoreboard.cs
    │   │   ├── IRenderable.cs
    │   │   └── IBorderable.cs
    │   ├── FocusChangeEventHandler.cs
    │   ├── NavigationType.cs
    │   ├── KeyPressEventHandler.cs
    │   ├── Drawing
    │   │   ├── Size.cs
    │   │   └── Point.cs
    │   ├── KeyPressEventArgs.cs
    │   ├── CheckedChangeEventHandler.cs
    │   ├── Render
    │   │   ├── IRenderOptions.cs
    │   │   ├── IRenderer.cs
    │   │   ├── DefaultRenderOptions.cs
    │   │   ├── BorderCharType.cs
    │   │   ├── IConsoleAdapter.cs
    │   │   ├── ColorScheme.cs
    │   │   ├── ConsoleAdapter.cs
    │   │   ├── ColorSchemas.cs
    │   │   └── DefaultRenderer.cs
    │   ├── NavigatedEventArgs.cs
    │   ├── Exceptions
    │   │   ├── ControlCantBeFocusedException.cs
    │   │   └── ScoreboardExceptoinBase.cs
    │   ├── StateItem.cs
    │   ├── ArrayExtensions.cs
    │   ├── ReferenceEqualityComparer.cs
    │   ├── IUiApplication.cs
    │   ├── IStoreboardNavigationEngine.cs
    │   ├── IScoreboardState.cs
    │   ├── ArrayTraverse.cs
    │   ├── EntityFX.ScoreboardUI.csproj
    │   ├── ScoreboardContext.cs
    │   ├── ObjectExtensions.cs
    │   ├── UiElement.cs
    │   ├── UiApplication.cs
    │   ├── StoreboardNavigationEngine.cs
    │   └── ScoreboardState.cs
    ├── EntityFX.ScoreboardUI.TestExample
    │   ├── EntityFX.ScoreboardUI.TestExample.csproj
    │   ├── Program.cs
    │   ├── FourthScoreboard.cs
    │   ├── SecondScoreboard.cs
    │   ├── ThirdScoreboard.cs
    │   └── MainScoreboard.cs
    └── EntityFX.ScoreboardUI.sln
├── ScoreboardUI.code-workspace
├── .gitignore
├── .vscode
    ├── tasks.json
    └── launch.json
├── Readme.md
└── LICENSE


/EntityFX.ScoreboardUI/.vs/EntityFX.ScoreboardUI/v15/Server/sqlite3/db.lock:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/.vs/ProjectSettings.json:
--------------------------------------------------------------------------------
1 | {
2 |   "CurrentProjectSetting": null
3 | }


--------------------------------------------------------------------------------
/ScoreboardUI.code-workspace:
--------------------------------------------------------------------------------
1 | {
2 | 	"folders": [
3 | 		{
4 | 			"path": "."
5 | 		}
6 | 	],
7 | 	"settings": {}
8 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/.vs/VSWorkspaceState.json:
--------------------------------------------------------------------------------
1 | {
2 |   "ExpandedNodes": [
3 |     ""
4 |   ],
5 |   "PreviewInSolutionExplorer": false
6 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/.vs/slnx.sqlite:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/EntityFX/ScoreboardUI/HEAD/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/.vs/slnx.sqlite


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Label.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements.Controls
2 | {
3 |     public class Label : ControlBase
4 |     {
5 | 
6 |     }
7 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Checkbox.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements.Controls
2 | {
3 |     public class Checkbox : ToggleButtonBase
4 |     {
5 |     }
6 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/PasswordBox.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements.Controls
2 | {
3 |     public class PasswordBox : TextBox
4 |     {
5 |     }
6 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/.vs/EntityFX.ScoreboardUI/v15/Server/sqlite3/storage.ide:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/EntityFX/ScoreboardUI/HEAD/EntityFX.ScoreboardUI/.vs/EntityFX.ScoreboardUI/v15/Server/sqlite3/storage.ide


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/ILinearable.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements
2 | {
3 |     public interface ILinearable
4 |     {
5 |         int Width { get; set; } 
6 |     }
7 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/FocusChangeEventHandler.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI
2 | {
3 |     public delegate void FocusChangeEventHandler(
4 |         UiElement sender
5 |         );
6 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/.vs/EntityFX.ScoreboardUI/v15/Server/sqlite3/storage.ide-shm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/EntityFX/ScoreboardUI/HEAD/EntityFX.ScoreboardUI/.vs/EntityFX.ScoreboardUI/v15/Server/sqlite3/storage.ide-shm


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/.vs/EntityFX.ScoreboardUI/v15/Server/sqlite3/storage.ide-wal:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/EntityFX/ScoreboardUI/HEAD/EntityFX.ScoreboardUI/.vs/EntityFX.ScoreboardUI/v15/Server/sqlite3/storage.ide-wal


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/NavigationType.cs:
--------------------------------------------------------------------------------
 1 | namespace EntityFX.ScoreboardUI
 2 | {
 3 |     public enum NavigationType
 4 |     {
 5 |         Navigate,
 6 |         GoBack
 7 |     }
 8 | 
 9 | }
10 | 


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Table/TableHeaderCell.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements.Controls.Table
2 | {
3 |     public class TableHeaderCell : TableCell<Label>
4 |     {
5 |     }
6 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/PositionEnum.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements.Controls
2 | {
3 |     public enum PositionEnum
4 |     {
5 |         ABSOLUTE,
6 |         RELATIVE
7 |     }
8 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/KeyPressEventHandler.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI
2 | {
3 |     public delegate void KeyPressEventHandler(
4 |         UiElement sender,
5 |         KeyPressEventArgs e
6 |         );
7 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/RichtextBox.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements.Controls
2 | {
3 |     public class RichtextBox : TextBox
4 |     {
5 |         public int Lines { get; set; }
6 |     }
7 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Table/TableViewRow.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements.Controls.Table
2 | {
3 |     public class TableViewRow : TableRow<TableCellBase, ControlBase>
4 |     {
5 |     }
6 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Table/TableCellBase.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements.Controls.Table
2 | {
3 |     public class TableCellBase: TableCell<ControlBase>
4 |     {
5 |          
6 |     }
7 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Drawing/Size.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Drawing
2 | {
3 |     public struct Size
4 |     {
5 |         public int Height { get; set; }
6 | 
7 |         public int Width { get; set; }
8 |     }
9 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/ISizable.cs:
--------------------------------------------------------------------------------
1 | using EntityFX.ScoreboardUI.Drawing;
2 | 
3 | namespace EntityFX.ScoreboardUI.Elements
4 | {
5 |     public interface ISizable
6 |     {
7 |         Size Size { get; set; }
8 |     }
9 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Table/TableButtonCellBaseBase.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements.Controls.Table
2 | {
3 |     public class TableButtonCellBaseBase : TableCellBase
4 |     {
5 |          
6 |     }
7 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Scoreboards/TitleAligment.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements.Scoreboards
2 | {
3 |     public enum TitleAligment
4 |     {
5 |         Left,
6 |         Center,
7 |         Right
8 |     }
9 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/ItemLocationEnum.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls
 4 | {
 5 |     public enum ItemLocationEnum
 6 |     {
 7 |         Left,
 8 |         Right
 9 |     }
10 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/KeyPressEventArgs.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | 
3 | namespace EntityFX.ScoreboardUI
4 | {
5 |     public partial class KeyPressEventArgs : EventArgs
6 |     {
7 |         public ConsoleKeyInfo KeyInfo { get; set; }
8 |     }
9 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/CheckedChangeEventHandler.cs:
--------------------------------------------------------------------------------
1 | using EntityFX.ScoreboardUI.Elements.Controls;
2 | 
3 | namespace EntityFX.ScoreboardUI
4 | {
5 |     public delegate void CheckedChangeEventHandler(
6 |         ToggleButtonBase sender
7 |         );
8 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/IRenderable.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements
 4 | {
 5 |     public interface IRenderable
 6 |     {
 7 |         void Render();
 8 | 
 9 |         event EventHandler Rendered;
10 |     }
11 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/ComboBoxItem.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements.Controls
2 | {
3 |     public class ComboBoxItem
4 |     {
5 |         public object Key { get; set; }
6 | 
7 |         public string Text { get; set; }
8 |     }
9 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Table/TableHeaderRow.cs:
--------------------------------------------------------------------------------
1 | using System.Collections.Generic;
2 | 
3 | namespace EntityFX.ScoreboardUI.Elements.Controls.Table
4 | {
5 |     public class TableHeaderRow : TableRow<TableHeaderCell, Label>
6 |     {
7 |     }
8 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Scoreboards/MessageBox/MessageBoxButtonsDirectionEnum.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements.MessageBox
2 | {
3 |     public enum MessageBoxButtonsDirectionEnum
4 |     {
5 |         Vertical,
6 |         Horizontal
7 |     }
8 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Table/ITableCell.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Elements.Controls.Table
2 | {
3 |     public interface ITableCell<out TControl> where TControl : ControlBase
4 |     {
5 |         TControl RootControl { get; }
6 |     }
7 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Scoreboards/MessageBox/MessageBoxButtonsEnum.cs:
--------------------------------------------------------------------------------
 1 | namespace EntityFX.ScoreboardUI.Elements.MessageBox
 2 | {
 3 |     public enum MessageBoxButtonsEnum
 4 |     {
 5 |         Ok,
 6 |         OkCancel,
 7 |         YesNo,
 8 |         YesNoCancel
 9 |     }
10 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Scoreboards/MessageBox/MessageBoxResultEnum.cs:
--------------------------------------------------------------------------------
 1 | namespace EntityFX.ScoreboardUI.Elements.MessageBox
 2 | {
 3 |     public enum MessageBoxResultEnum
 4 |     {
 5 |         Ok,
 6 |         Yes,
 7 |         No,
 8 |         Cancel,
 9 |         None
10 |     }
11 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Scoreboards/MessageBox/MessageBoxTypeEnum.cs:
--------------------------------------------------------------------------------
 1 | namespace EntityFX.ScoreboardUI.Elements.MessageBox
 2 | {
 3 |     public enum MessageBoxTypeEnum
 4 |     {
 5 |         Error,
 6 |         Warning,
 7 |         Info,
 8 |         Question,
 9 |         None
10 |     }
11 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Render/IRenderOptions.cs:
--------------------------------------------------------------------------------
 1 | namespace EntityFX.ScoreboardUI.Render
 2 | {
 3 |     public interface IRenderOptions
 4 |     {
 5 |         int WindowHeight { get; set; }
 6 | 
 7 |         int WindowWidth { get; set; }
 8 | 
 9 |         ColorScheme ColorScheme { get; set; }
10 |     }
11 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/NavigatedEventArgs.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI
 4 | {
 5 |     public class NavigatedEventArgs : EventArgs
 6 |     {
 7 |         public object Data { get; set; }
 8 | 
 9 |         public NavigationType NavigationType { get; set; }
10 |     }
11 | 
12 | }
13 | 


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Menu/SubmenuContext.cs:
--------------------------------------------------------------------------------
 1 | namespace EntityFX.ScoreboardUI.Elements.Controls.Menu
 2 | {
 3 |     public class SubmenuContext<TData>
 4 |     {
 5 |         public string Text { get; set; }
 6 | 
 7 |         public TData Data { get; set; }
 8 | 
 9 |         public bool IsEnabled { get; set; }
10 |     }
11 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Render/IRenderer.cs:
--------------------------------------------------------------------------------
 1 | namespace EntityFX.ScoreboardUI.Render
 2 | {
 3 |     public interface IRenderer
 4 |     {
 5 |         IRenderOptions RenderOptions { get; set; }
 6 |         IConsoleAdapter ConsoleAdapter { get; set; }
 7 |         void Initialize();
 8 | 
 9 |         void Render(UiElement uiElement);
10 |     }
11 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Table/ITableRow.cs:
--------------------------------------------------------------------------------
1 | using System.Collections.Generic;
2 | 
3 | namespace EntityFX.ScoreboardUI.Elements.Controls.Table
4 | {
5 |     public interface ITableRow<out TCell, out TControl> where TCell : ITableCell<TControl> where TControl : ControlBase
6 |     {
7 |         IReadOnlyList<TCell> Cells { get; }
8 |     }
9 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Exceptions/ControlCantBeFocusedException.cs:
--------------------------------------------------------------------------------
1 | namespace EntityFX.ScoreboardUI.Exceptions
2 | {
3 |     public class ControlCantBeFocusedException : ScoreboardExceptoinBase
4 |     {
5 |         public ControlCantBeFocusedException(string message, UiElement uiElement) : base(message, uiElement)
6 |         {
7 |         }
8 |     }
9 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/StatusBar/IStatusStripItem.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | namespace EntityFX.ScoreboardUI.Elements.Controls.StatusBar
 3 | {
 4 |     public interface IStatusStripItem<TControl> where TControl : ControlBase
 5 |     {
 6 |         TControl InternalControl { get; set; }
 7 | 
 8 |         ItemLocationEnum ItemLocation { get; set; }
 9 |     }
10 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/IBorderable.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements
 4 | {
 5 |     public interface IBorderable
 6 |     {
 7 |         bool IsBorderVisible { get; set; }
 8 | 
 9 |         ConsoleColor BorderBackgroundColor { get; set; }
10 | 
11 |         ConsoleColor BorderForegroundColor { get; set; }
12 |     }
13 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/StateItem.cs:
--------------------------------------------------------------------------------
 1 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
 2 | 
 3 | namespace EntityFX.ScoreboardUI
 4 | {
 5 |     public class StateItem
 6 |     {
 7 |         public Scoreboard Scoreboard { get; set; }
 8 | 
 9 |         public IScoreboardState ScoreboardState { get; set; }
10 |         
11 |         public object NavigationData { get; set; }
12 |     }
13 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Table/TableCheckboxCell.cs:
--------------------------------------------------------------------------------
 1 | namespace EntityFX.ScoreboardUI.Elements.Controls.Table
 2 | {
 3 |     public class TableCheckboxCell : TableCellBase
 4 |     {
 5 |         public TableCheckboxCell()
 6 |         {
 7 |             RootControl = new Checkbox()
 8 |             {
 9 |                 Parent = this
10 |             };
11 |         }
12 |     }
13 | }


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | 
 2 | #ignore thumbnails created by windows
 3 | Thumbs.db
 4 | #Ignore files build by Visual Studio
 5 | *.obj
 6 | *.exe
 7 | *.pdb
 8 | *.user
 9 | *.aps
10 | *.pch
11 | *.vspscc
12 | *_i.c
13 | *_p.c
14 | *.ncb
15 | *.suo
16 | *.tlb
17 | *.tlh
18 | *.bak
19 | *.cache
20 | *.ilk
21 | *.log
22 | [Bb]in
23 | [Dd]ebug*/
24 | *.lib
25 | *.sbr
26 | obj/
27 | [Rr]elease*/
28 | _ReSharper*/
29 | [Tt]est[Rr]esult*
30 | 


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/IListView.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls
 4 | {
 5 |     public interface IListView
 6 |     {
 7 |         int ItemHeight { get; set; }
 8 |         IEnumerable<ListViewItem> ItemsControls { get; }
 9 |         ListViewItem Template { get; set; }
10 |         int Width { get; set; }
11 |     }
12 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Panel.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using EntityFX.ScoreboardUI.Drawing;
 3 | 
 4 | namespace EntityFX.ScoreboardUI.Elements.Controls
 5 | {
 6 |     public class Panel : Control<ControlBase>, ISizable
 7 |     {
 8 |         public Panel()
 9 |         {
10 |             DisplayText = false;
11 |         }
12 |         public ConsoleColor BorderColor { get; set; }
13 |         public Size Size { get; set; }
14 |     }
15 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Exceptions/ScoreboardExceptoinBase.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Exceptions
 4 | {
 5 |     public abstract class ScoreboardExceptoinBase : Exception
 6 |     {
 7 |         public ScoreboardExceptoinBase(String message, UiElement uiElement) : base(message)
 8 |         {
 9 |             UiElement = uiElement;
10 |         }
11 | 
12 |         public UiElement UiElement { get; private set; }
13 |     }
14 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/ListViewItem.cs:
--------------------------------------------------------------------------------
 1 | using EntityFX.ScoreboardUI.Drawing;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls
 4 | {
 5 |     public class ListViewItem : Control<ControlBase>, ISizable
 6 |     {
 7 |         public Size Size { get; set; }
 8 | 
 9 |         public override void AddChild(ControlBase childControl)
10 |         {
11 |             controls.Add(childControl);
12 |             childControl.Parent = this;
13 |         }
14 |     }
15 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Table/TableRow.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls.Table
 4 | {
 5 |     public class TableRow<TCell, TControl> : ControlBase, ITableRow<TCell, TControl> where TCell : TableCell<TControl> where TControl : ControlBase
 6 |     {
 7 |         IReadOnlyList<TCell> ITableRow<TCell, TControl>.Cells { get { return Cells; } }
 8 | 
 9 |         public List<TCell> Cells { get; set; }
10 | }
11 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Render/DefaultRenderOptions.cs:
--------------------------------------------------------------------------------
 1 | namespace EntityFX.ScoreboardUI.Render
 2 | {
 3 |     public class DefaultRenderOptions : IRenderOptions
 4 |     {
 5 |         public DefaultRenderOptions()
 6 |         {
 7 |             WindowHeight = 25;
 8 |             WindowWidth = 80;
 9 |         }
10 | 
11 |         public int WindowHeight { get; set; }
12 |         public int WindowWidth { get; set; }
13 |         public ColorScheme ColorScheme { get; set; }
14 |     }
15 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/ArrayExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.ArrayExtensions
 4 | {
 5 |     public static class ArrayExtensions
 6 |     {
 7 |         public static void ForEach(this Array array, Action<Array, int[]> action)
 8 |         {
 9 |             if (array.LongLength == 0) return;
10 |             ArrayTraverse walker = new ArrayTraverse(array);
11 |             do action(array, walker.Position);
12 |             while (walker.Step());
13 |         }
14 |     }
15 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Render/BorderCharType.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Render
 4 | {
 5 |     public struct BorderCharType
 6 |     {
 7 |         public Char TopLeftChar { get; set; }
 8 | 
 9 |         public Char BottomLeftChar { get; set; }
10 | 
11 |         public Char TopRightChar { get; set; }
12 | 
13 |         public Char BottomRightChar { get; set; }
14 | 
15 |         public Char VerticalChar { get; set; }
16 | 
17 |         public Char HorizontalChar { get; set; }     
18 |     }
19 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI.TestExample/EntityFX.ScoreboardUI.TestExample.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
 4 |     <OutputPath>bin\</OutputPath>
 5 |   </PropertyGroup>
 6 |   <PropertyGroup>
 7 |     <OutputType>Exe</OutputType>
 8 |     <TargetFramework>netcoreapp2.0</TargetFramework>
 9 |   </PropertyGroup>
10 |   <ItemGroup>
11 |     <ProjectReference Include="..\EntityFX.ScoreboardUI\EntityFX.ScoreboardUI.csproj" />
12 |   </ItemGroup>
13 | </Project>


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/ReferenceEqualityComparer.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | 
 3 | namespace EntityFX.ScoreboardUI
 4 | {
 5 |     public class ReferenceEqualityComparer : EqualityComparer<object>
 6 |     {
 7 |         public override bool Equals(object x, object y)
 8 |         {
 9 |             return ReferenceEquals(x, y);
10 |         }
11 |         public override int GetHashCode(object obj)
12 |         {
13 |             if (obj == null) return 0;
14 |             return obj.GetHashCode();
15 |         }
16 |     }
17 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Table/TableCell.cs:
--------------------------------------------------------------------------------
 1 | using EntityFX.ScoreboardUI.Drawing;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls.Table
 4 | {
 5 |     public abstract class TableCell<TControl> : ControlBase, ISizable, ITableCell<TControl> where TControl : ControlBase
 6 |     {
 7 |         public Size Size { get; set; }
 8 | 
 9 |         TControl ITableCell<TControl>.RootControl
10 |         {
11 |             get { return RootControl; }
12 |         }
13 | 
14 |         public TControl RootControl { get; protected set; }
15 |     }
16 | }


--------------------------------------------------------------------------------
/.vscode/tasks.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     // See https://go.microsoft.com/fwlink/?LinkId=733558
 3 |     // for the documentation about the tasks.json format
 4 |     "version": "2.0.0",
 5 |     "tasks": [
 6 |         {
 7 |             "label": "build",
 8 |             "command": "dotnet build",
 9 |             "type": "shell",
10 |             "group": {
11 |                 "kind": "build",
12 |                 "isDefault": true
13 |             },
14 |             "presentation": {
15 |                 "reveal": "always"
16 |             },
17 |             "problemMatcher": "$msCompile"
18 |         }
19 |     ]
20 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Table/Table.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Linq;
 3 | 
 4 | namespace EntityFX.ScoreboardUI.Elements.Controls.Table
 5 | {
 6 |     public class Table : ControlBase
 7 |     {
 8 |         public IList<TableCellBase> Columns
 9 |         {
10 |             get { return null; }
11 |         }
12 | 
13 |         public List<ITableRow<ITableCell<ControlBase>, ControlBase>> Rows { get; set; }
14 | 
15 |         public Table()
16 |         {
17 |             Rows = new List<ITableRow<ITableCell<ControlBase>, ControlBase>>();
18 |         }
19 |     }
20 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI.TestExample/Program.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using EntityFX.ScoreboardUI;
 3 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
 4 | using EntityFX.ScoreboardUI.Render;
 5 | 
 6 | namespace EntityFx.ScorbordUI.TestExample
 7 | {
 8 |     class Program
 9 |     {
10 |         static void Main()
11 |         {
12 |             IUiApplication application = new UiApplication();
13 |             application.RenderOptions.ColorScheme = ColorSchemas.Blue;
14 |             Scoreboard initialScoreboard = new MainScoreboard();
15 | 
16 |             application.Run(initialScoreboard);
17 |         }
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Button.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
 3 | 
 4 | namespace EntityFX.ScoreboardUI.Elements.Controls
 5 | {
 6 |     public class Button : ButtonBase
 7 |     {
 8 |         public Button()
 9 |         {
10 |             TextAligment = TitleAligment.Center;
11 |             BackgroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.ButtonsBackgroundColor;
12 |             ForegroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.ButtonsForegroundColor;
13 |         }
14 | 
15 |         public TitleAligment TextAligment { get; set; }
16 |     }
17 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/StatusBar/StatusStripLabel.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls.StatusBar
 4 | {
 5 |     public class StatusStripLabel : StatusStripItem
 6 |     {
 7 |         public StatusStripLabel()
 8 |         {
 9 |             BackgroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.MenuBackgroundColor;
10 |             InternalControl = new Label()
11 |             {
12 |                 Parent = this,
13 |                 ForegroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.MenuForegroundColor
14 |             };
15 |         }
16 |     }
17 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/IUiApplication.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
 3 | using EntityFX.ScoreboardUI.Render;
 4 | 
 5 | namespace EntityFX.ScoreboardUI
 6 | {
 7 |     public interface IUiApplication
 8 |     {
 9 |         bool IsClosed { get; }
10 | 
11 |         ConsoleKey FocusKey { get; set; }
12 | 
13 |         IRenderOptions RenderOptions { get; set; }
14 | 
15 |         void Run(Scoreboard initialScoreboard);
16 | 
17 |         void Close();
18 | 
19 |         event KeyPressEventHandler KeyPress;
20 | 
21 |         event FocusChangeEventHandler FocusChange;
22 | 
23 |         event EventHandler<EventArgs> Closed;
24 |     }
25 | }


--------------------------------------------------------------------------------
/Readme.md:
--------------------------------------------------------------------------------
 1 | # TUI Framework. 
 2 | 
 3 | TUI (Text User Interface) compatible with netstandard2.0
 4 | Uses only Console class.
 5 | 
 6 | ## Features
 7 | 
 8 | * Controls
 9 | 	* TextBox
10 | 	* PasswordBox
11 | 	* Label
12 | 	* CheckBox
13 | 	* RadioButton
14 | 	* Image (ASCII)
15 | 	* Panel
16 | 	* BorderPanel
17 | 	* ComboBox
18 | 	* ListView
19 | 	* Table
20 | 	* ProgressBar
21 | 	* Menu
22 | 	* StatusBar
23 | * MessageBoxes
24 | 	* Confirm
25 | 	* Prompt
26 | 	* Alert
27 | 	* Custom dialog
28 | * Navigation
29 | 	* Navigate to specific Scoreboard (Screen)
30 | 	* Go Back
31 | 	* Pass data
32 | 	
33 | [![Example application video on Windows](https://youtu.be/dqbhSkQzs80)](https://youtu.be/dqbhSkQzs80)
34 | 


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/StatusBar/StatusStripButton.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls.StatusBar
 4 | {
 5 |     public class StatusStripButton : StatusStripItem
 6 |     {
 7 |         public StatusStripButton()
 8 |         {
 9 |             BackgroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.ButtonsBackgroundColor;
10 |             ForegroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.ButtonsForegroundColor;
11 |             InternalControl = new Button
12 |             {
13 |                 Text = Text,
14 |                 Parent = this
15 |             };
16 |         }
17 |     }
18 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/BorderPanel.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls
 4 | {
 5 |     public class BorderPanel : Panel, IBorderable
 6 |     {
 7 | 
 8 |         public BorderPanel()
 9 |         {
10 |             BorderBackgroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.PrimaryBackgroundColor;
11 |             BorderForegroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.BorderColor;
12 |             DisplayText = true;
13 |         }
14 |         public bool IsBorderVisible { get; set; }
15 |         public ConsoleColor BorderBackgroundColor { get; set; }
16 |         public ConsoleColor BorderForegroundColor { get; set; }
17 |     }
18 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Drawing/Point.cs:
--------------------------------------------------------------------------------
 1 | namespace EntityFX.ScoreboardUI.Drawing
 2 | {
 3 |     public struct Point
 4 |     {
 5 |         public int Top { get; set; }
 6 | 
 7 |         public int Left { get; set; }
 8 | 
 9 |         public static Point operator +(Point left, Point right)
10 |         {
11 |             return new Point
12 |             {
13 |                 Left = left.Left + right.Left,
14 |                 Top = left.Top + right.Top
15 |             };
16 |         }
17 | 
18 |         public static Point operator -(Point left, Point right)
19 |         {
20 |             return new Point
21 |             {
22 |                 Left = left.Left - right.Left,
23 |                 Top = left.Top - right.Top
24 |             };
25 |         }
26 |     }
27 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Render/IConsoleAdapter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using EntityFX.ScoreboardUI.Drawing;
 3 | 
 4 | namespace EntityFX.ScoreboardUI.Render
 5 | {
 6 |     public interface IConsoleAdapter
 7 |     {
 8 |         Size Size { get; set; }
 9 | 
10 |         void Write(string value);
11 |         void Write(char value);
12 | 
13 |         void MoveCursor(int left, int top);
14 | 
15 |         ConsoleColor ForegroundColor { get; set; }
16 | 
17 |         ConsoleColor BackgroundColor { get; set; }
18 |         bool CursorVisible { get; set; }
19 | 
20 |         void MoveArea(int sourceLeft, int sourceTop, int sourceWidth, int sourceHeight, int targetLeft, int targetTop);
21 | 
22 |         ConsoleKeyInfo ReadKey(bool intercept);
23 |         void Beep();
24 |     }
25 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/IProgressBar.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls
 4 | {
 5 |     public interface IProgressBar
 6 |     {
 7 |         int Minimum
 8 |         {
 9 |             get;
10 |             set;
11 |         }
12 | 
13 |         int Maximum
14 |         {
15 |             get;
16 |             set;
17 |         }
18 | 
19 |         int Step { get; set; }
20 | 
21 |         int Width { get; set; }
22 | 
23 |         int Value
24 |         {
25 |             get;
26 |             set;
27 |         }
28 | 
29 |         ConsoleColor StripeColor { get; set; }
30 | 
31 |         event EventHandler<int> ValueChanged;
32 | 
33 |         void Increment(int? value = null);
34 | 
35 |         void Decrement(int? value = null);
36 |     }
37 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/IStoreboardNavigationEngine.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
 3 | 
 4 | namespace EntityFX.ScoreboardUI
 5 | {
 6 |     internal interface IStoreboardNavigationEngine
 7 |     {
 8 |         Stack<Scoreboard> NavigationStack { get; }
 9 | 
10 |         StateItem Previous { get; }
11 | 
12 |         StateItem Current { get; set; }
13 | 
14 |         void GoBack(object data = null);
15 | 
16 |         void Navigate<TScoreboard>(object data = null) where TScoreboard : Scoreboard, new();
17 | 
18 |         void NavigateFromStart<TScoreboard>(object data = null) where TScoreboard : Scoreboard, new();
19 | 
20 |         void Navigate(Scoreboard scoreboard, StateItem state = null, object data = null);
21 | 
22 |         void Reset();
23 |     }
24 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI.TestExample/FourthScoreboard.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using EntityFX.ScoreboardUI;
 3 | using EntityFX.ScoreboardUI.Elements.Controls;
 4 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
 5 | 
 6 | namespace EntityFx.ScorbordUI.TestExample
 7 | {
 8 |     class FourthScoreboard : Scoreboard
 9 |     {
10 |         public FourthScoreboard()
11 |             : base(new Panel())
12 |         {
13 |         }
14 | 
15 |         protected override void OnKeyPressed(KeyPressEventArgs e)
16 |         {
17 |             if (e.KeyInfo.Key == ConsoleKey.D1)
18 |             {
19 |                 Navigate<ThirdScoreboard>();
20 |             }
21 | 
22 |             if (e.KeyInfo.Key == ConsoleKey.D2)
23 |             {
24 |                 Navigate<MainScoreboard>();
25 |             }
26 |         }
27 |     }
28 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/IScoreboardState.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using EntityFX.ScoreboardUI.Elements.Controls;
 3 | 
 4 | namespace EntityFX.ScoreboardUI
 5 | {
 6 |     public interface IScoreboardState
 7 |     {
 8 |         int InternalTabIndex { get; }
 9 | 
10 |         IEnumerable<ControlBase> SortedControlsByFocusIndex { get; }
11 | 
12 |         IEnumerable<ControlBase> ControlsList { get; }
13 | 
14 |         bool ScoreboardInitialized { get; }
15 | 
16 |         bool IsNavigating { get; set; }
17 | 
18 |         ControlBase FocusedElement { get; }
19 |         void ChangeFocus(ControlBase control);
20 | 
21 |         void Initialized();
22 | 
23 |         void AddToControlList(ControlBase control);
24 | 
25 |         void RemoveFromControlList(ControlBase control);
26 | 
27 |         void NextFocus();
28 | 
29 |         void PreviousFocus();
30 | 
31 |         void ResetFocus();
32 |     }
33 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/StatusBar/StatusStripItem.cs:
--------------------------------------------------------------------------------
 1 | namespace EntityFX.ScoreboardUI.Elements.Controls.StatusBar
 2 | {
 3 |     public abstract class StatusStripItem : ControlBase
 4 |     {
 5 |         public ControlBase InternalControl { get; protected set; }
 6 | 
 7 |         public ItemLocationEnum ItemLocation { get; set; }
 8 | 
 9 |         public override string Text
10 |         {
11 |             get { return base.Text; }
12 |             set
13 |             {
14 |                 base.Text = value;
15 |                 if (InternalControl != null)
16 |                     InternalControl.Text = value;
17 |             }
18 |         }
19 | 
20 |         public override bool IsFocused {
21 |             get { return base.IsFocused; }
22 |             internal set
23 |             {
24 |                 base.IsFocused = value;
25 |                 InternalControl.IsFocused = value;
26 |             }
27 |         }
28 | 
29 |     }
30 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/ToggleButtonBase.cs:
--------------------------------------------------------------------------------
 1 | namespace EntityFX.ScoreboardUI.Elements.Controls
 2 | {
 3 |     public abstract class ToggleButtonBase : ButtonBase
 4 |     {
 5 |         protected bool? IsCheckedInternal;
 6 | 
 7 |         public virtual bool? IsChecked
 8 |         {
 9 |             get { return IsCheckedInternal; }
10 |             set
11 |             {
12 |                 IsCheckedInternal = value;
13 |                 ReRender();
14 |             }
15 |         }
16 | 
17 |         public override void Press(KeyPressEventArgs e)
18 |         {
19 |             base.Press(e);
20 |             IsChecked = IsChecked != null ? !IsChecked : true;
21 |             CheckedChanged?.Invoke(this);
22 |         }
23 | 
24 |         public event CheckedChangeEventHandler CheckedChanged;
25 | 
26 |         public override void ClearEvents()
27 |         {
28 |             base.ClearEvents();
29 |             CheckedChanged = null;
30 |         }
31 |     }
32 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Table/TableViewCell.cs:
--------------------------------------------------------------------------------
 1 | namespace EntityFX.ScoreboardUI.Elements.Controls.Table
 2 | {
 3 |     public class TableViewCell : TableCellBase
 4 |     {
 5 |         public TableViewCell()
 6 |         {
 7 |             RootControl = new Label()
 8 |             {
 9 |                 Text = Text,
10 |                 Parent = this
11 |             };
12 |         }
13 | 
14 |         public override string Text
15 |         {
16 |             get { return base.Text; }
17 |             set
18 |             {
19 |                 base.Text = value;
20 |                 if (RootControl != null)
21 |                     RootControl.Text = value;
22 |             }
23 |         }
24 | 
25 |         public override bool IsFocused
26 |         {
27 |             get { return base.IsFocused; }
28 |             internal set
29 |             {
30 |                 base.IsFocused = value;
31 |                 RootControl.IsFocused = value;
32 |             }
33 |         }
34 |     }
35 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/ArrayTraverse.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.ArrayExtensions
 4 | {
 5 |     internal class ArrayTraverse
 6 |     {
 7 |         public int[] Position;
 8 |         private int[] maxLengths;
 9 | 
10 |         public ArrayTraverse(Array array)
11 |         {
12 |             maxLengths = new int[array.Rank];
13 |             for (int i = 0; i < array.Rank; ++i)
14 |             {
15 |                 maxLengths[i] = array.GetLength(i) - 1;
16 |             }
17 |             Position = new int[array.Rank];
18 |         }
19 | 
20 |         public bool Step()
21 |         {
22 |             for (int i = 0; i < Position.Length; ++i)
23 |             {
24 |                 if (Position[i] < maxLengths[i])
25 |                 {
26 |                     Position[i]++;
27 |                     for (int j = 0; j < i; j++)
28 |                     {
29 |                         Position[j] = 0;
30 |                     }
31 |                     return true;
32 |                 }
33 |             }
34 |             return false;
35 |         }
36 |     }
37 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Menu/MenuItem.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text;
 4 | using EntityFX.ScoreboardUI.Elements.Controls;
 5 | 
 6 | namespace EntityFX.ScoreboardUI.Elements.Controls.Menu
 7 | {
 8 |     public class MenuItem<TData> : ControlBase
 9 |     {
10 |         public ControlBase InternalControl { get; protected set; }
11 | 
12 |         public ItemLocationEnum ItemLocation { get; set; }
13 | 
14 |         public TData Data { get; set; }
15 | 
16 |         public override string Text
17 |         {
18 |             get { return base.Text; }
19 |             set
20 |             {
21 |                 base.Text = value;
22 |                 if (InternalControl != null)
23 |                     InternalControl.Text = value;
24 |             }
25 |         }
26 | 
27 |         public override bool IsFocused
28 |         {
29 |             get { return base.IsFocused; }
30 |             internal set
31 |             {
32 |                 base.IsFocused = value;
33 |                 InternalControl.IsFocused = value;
34 |             }
35 |         }
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 |   <PropertyGroup>
 3 |     <OutputType>Library</OutputType>
 4 |     <TargetFramework>netstandard2.0</TargetFramework>
 5 |     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
 6 |     <Version>1.0.11</Version>
 7 |     <AssemblyVersion>1.0.11.0</AssemblyVersion>
 8 |     <FileVersion>1.0.11.0</FileVersion>
 9 |     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
10 |     <Description>TUI (Text User Interface) compatible with netstandard2.0 Uses only Console class.</Description>
11 |     <PackageLicenseUrl>https://raw.githubusercontent.com/EntityFX/ScoreboardUI/master/LICENSE</PackageLicenseUrl>
12 |     <Copyright>Copyright (c) 2018 Artem Solopiy &lt;artem.solopiy@gmail.com&gt;</Copyright>
13 |     <Authors>Artem Solopiy</Authors>
14 |     <PackageProjectUrl>https://github.com/EntityFX/ScoreboardUI</PackageProjectUrl>
15 |     <RepositoryUrl>https://github.com/EntityFX/ScoreboardUI</RepositoryUrl>
16 |     <RepositoryType>Git</RepositoryType>
17 |     <PackageTags>Tui, Console UI, Pseudo UI</PackageTags>
18 |   </PropertyGroup>
19 | </Project>


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Artem Solopiy <artem.solopiy@gmail.com>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/RadioButton.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Linq;
 3 | 
 4 | namespace EntityFX.ScoreboardUI.Elements.Controls
 5 | {
 6 |     public class RadioButton : ToggleButtonBase
 7 |     {
 8 |         public RadioButton()
 9 |         {
10 |             IsCheckedInternal = false;
11 |         }
12 | 
13 |         public override bool? IsChecked
14 |         {
15 |             get { return base.IsChecked; }
16 |             set
17 |             {
18 |                 if (base.IsChecked != true)
19 |                 {
20 |                     base.IsChecked = value;
21 |                     IEnumerable<RadioButton> otherRadios =
22 |                         ScoreboardContext.CurrentState.ControlsList.OfType<RadioButton>().Where(_ => _ != this && _.Parent == Parent);
23 |                     foreach (RadioButton radio in otherRadios)
24 |                     {
25 |                         if (radio.IsCheckedInternal != null)
26 |                         {
27 |                             radio.IsCheckedInternal = false;
28 |                             radio.ReRender();
29 |                         }
30 |                     }
31 |                 }
32 |             }
33 |         }
34 |     }
35 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/ScoreboardContext.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using EntityFX.ScoreboardUI.Render;
 3 | 
 4 | namespace EntityFX.ScoreboardUI
 5 | {
 6 |     internal static class ScoreboardContext
 7 |     {
 8 |         private static readonly Lazy<IStoreboardNavigationEngine> _navigation = new Lazy<IStoreboardNavigationEngine>(
 9 |             () => new StoreboardNavigationEngine()
10 |             );
11 | 
12 |         private static readonly Lazy<IRenderer> _renderer = new Lazy<IRenderer>(
13 |             () =>
14 |             {
15 |                 var renderer = new DefaultRenderer(new ConsoleAdapter(), new DefaultRenderOptions() { ColorScheme = ColorSchemas.Matrix });
16 |                 renderer.Initialize();
17 |                 return renderer;
18 |             }
19 |         );
20 | 
21 |         public static IStoreboardNavigationEngine Navigation => _navigation.Value;
22 | 
23 |         public static IScoreboardState CurrentState
24 |         {
25 |             get
26 |             {
27 |                 if (Navigation.Current == null)
28 |                     Navigation.Current = new StateItem {ScoreboardState = new ScoreboardState()};
29 |                 return Navigation.Current.ScoreboardState;
30 |             }
31 |         }
32 | 
33 |         public static IRenderer RenderEngine => _renderer.Value;
34 |     }
35 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Render/ColorScheme.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Render
 4 | {
 5 |     public class ColorScheme
 6 |     {
 7 |         public ConsoleColor PrimaryBackgroundColor { get; set; }
 8 |         public ConsoleColor PrimaryForegroundColor { get; set; }
 9 |         public ConsoleColor SecondaryBackgroundColor { get; set; }
10 |         public ConsoleColor SecondaryForegroundColor { get; set; }
11 |         public ConsoleColor BorderColor { get; set; }
12 |         public ConsoleColor BoxesBackgroundColor { get; set; }
13 |         public ConsoleColor BoxesForegroundColor { get; set; }
14 |         public ConsoleColor ButtonsBackgroundColor { get; set; }
15 | 
16 |         public ConsoleColor ButtonsForegroundColor { get; set; }
17 |         public ConsoleColor FocusedBackgroundColor { get; internal set; }
18 |         public ConsoleColor FocusedForegroundColor { get; internal set; }
19 |         public ConsoleColor DisabledBackgroundColor { get; set; }
20 |         public ConsoleColor DisabledForegroundColor { get; set; }
21 |         public ConsoleColor MenuForegroundColor { get; set; }
22 |         public ConsoleColor MenuBackgroundColor { get; set; }
23 |         public ConsoleColor MessageBoxBackgroundColor { get; set; }
24 |         public ConsoleColor MessageBoxForegroundColor { get; set; }
25 |         public ConsoleColor WarningMessageBoxBackgroundColor { get; set; }
26 |         public ConsoleColor WarningMessageBoxForegroundColor { get; set; }
27 |         public ConsoleColor ErrorMessageBoxBackgroundColor { get; set; }
28 |         public ConsoleColor ErrorMessageBoxForegroundColor { get; set; }
29 |     }
30 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Render/ConsoleAdapter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using EntityFX.ScoreboardUI.Drawing;
 3 | 
 4 | namespace EntityFX.ScoreboardUI.Render
 5 | {
 6 |     public class ConsoleAdapter : IConsoleAdapter
 7 |     {
 8 | 
 9 | 
10 |         public Size Size { get; set; }
11 | 
12 |         public void Write(string value)
13 |         {
14 |             Console.Write(value);
15 |         }
16 | 
17 |         public void Write(char value)
18 |         {
19 |             Console.Write(value);
20 |         }
21 | 
22 |         public void MoveCursor(int left, int top)
23 |         {
24 |             if (left <= Size.Width && top <= Size.Height)
25 |             {
26 |                 Console.SetCursorPosition(left, top);
27 |             }
28 | 
29 |         }
30 | 
31 |         public ConsoleColor ForegroundColor
32 |         {
33 |             get => Console.ForegroundColor;
34 |             set => Console.ForegroundColor = value;
35 |         }
36 | 
37 |         public ConsoleColor BackgroundColor
38 |         {
39 |             get => Console.BackgroundColor;
40 |             set =>
41 | 					Console.BackgroundColor = value;
42 |         }
43 |         public bool CursorVisible { get; set; }
44 | 
45 |         public void MoveArea(int sourceLeft, int sourceTop, int sourceWidth, int sourceHeight, int targetLeft, int targetTop)
46 |         {
47 |             //Console.MoveBufferArea(sourceLeft, sourceTop, sourceWidth, sourceHeight, targetLeft, targetTop);
48 |         }
49 | 
50 |         public ConsoleKeyInfo ReadKey(bool intercept)
51 |         {
52 |             return Console.ReadKey(intercept);
53 |         }
54 | 
55 |         public void Beep()
56 |         {
57 |             Console.Beep();
58 |         }
59 |     }
60 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/ButtonBase.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls
 4 | {
 5 |     public abstract class ButtonBase : ControlBase, ILinearable
 6 |     {
 7 |         public ButtonBase()
 8 |         {
 9 |             Width = 10;
10 |         }
11 | 
12 |         public int Width { get; set; }
13 | 
14 |         internal override string VisibleText
15 |         {
16 |             get
17 |             {
18 |                 int length = Text.Length;
19 |                 if (length > Width)
20 |                 {
21 |                     int startCharIndex = length - Width;
22 |                     return Text.Substring(startCharIndex, Width);
23 |                 }
24 |                 return base.VisibleText;
25 |             }
26 |         }
27 | 
28 |         public event EventHandler Pressed;
29 | 
30 |         public virtual void Press(KeyPressEventArgs e)
31 |         {
32 |             EventHandler handler = Pressed;
33 |             if (handler != null)
34 |             {
35 |                 handler(this, new KeyPressEventArgs
36 |                 {
37 |                     KeyInfo = e.KeyInfo
38 |                 });
39 |             }
40 |             OnPressed(e);
41 |         }
42 | 
43 |         public override void PressKey(KeyPressEventArgs e)
44 |         {
45 |             base.PressKey(e);
46 |             if (e.KeyInfo.Key == ConsoleKey.Spacebar || e.KeyInfo.Key == ConsoleKey.Enter)
47 |             {
48 |                 Press(e);
49 |             }
50 |         }
51 | 
52 |         protected virtual void OnPressed(KeyPressEventArgs e)
53 |         {
54 |         }
55 | 
56 |         public override void ClearEvents()
57 |         {
58 |             base.ClearEvents();
59 |             Pressed = null;
60 |         }
61 |     }
62 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 15
 4 | VisualStudioVersion = 15.0.27130.2027
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EntityFX.ScoreboardUI", "EntityFX.ScoreboardUI\EntityFX.ScoreboardUI.csproj", "{E3989F5D-632D-4625-982D-F4651133B0C8}"
 7 | EndProject
 8 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EntityFX.ScoreboardUI.TestExample", "EntityFX.ScoreboardUI.TestExample\EntityFX.ScoreboardUI.TestExample.csproj", "{FDC7940C-27DE-4238-B875-7FB6DA98705C}"
 9 | EndProject
10 | Global
11 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
12 | 		Debug|Any CPU = Debug|Any CPU
13 | 		Release|Any CPU = Release|Any CPU
14 | 	EndGlobalSection
15 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
16 | 		{E3989F5D-632D-4625-982D-F4651133B0C8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
17 | 		{E3989F5D-632D-4625-982D-F4651133B0C8}.Debug|Any CPU.Build.0 = Debug|Any CPU
18 | 		{E3989F5D-632D-4625-982D-F4651133B0C8}.Release|Any CPU.ActiveCfg = Release|Any CPU
19 | 		{E3989F5D-632D-4625-982D-F4651133B0C8}.Release|Any CPU.Build.0 = Release|Any CPU
20 | 		{FDC7940C-27DE-4238-B875-7FB6DA98705C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
21 | 		{FDC7940C-27DE-4238-B875-7FB6DA98705C}.Debug|Any CPU.Build.0 = Debug|Any CPU
22 | 		{FDC7940C-27DE-4238-B875-7FB6DA98705C}.Release|Any CPU.ActiveCfg = Release|Any CPU
23 | 		{FDC7940C-27DE-4238-B875-7FB6DA98705C}.Release|Any CPU.Build.0 = Release|Any CPU
24 | 	EndGlobalSection
25 | 	GlobalSection(SolutionProperties) = preSolution
26 | 		HideSolutionNode = FALSE
27 | 	EndGlobalSection
28 | 	GlobalSection(ExtensibilityGlobals) = postSolution
29 | 		SolutionGuid = {8622041C-A53E-4034-A6AC-BF68EF6DC261}
30 | 	EndGlobalSection
31 | EndGlobal
32 | 


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Charts/PlotChart.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using EntityFX.ScoreboardUI.Drawing;
 3 | 
 4 | namespace EntityFX.ScoreboardUI.Elements.Controls.Charts
 5 | {
 6 |     public class PlotChart : Control<ControlBase>, ISizable
 7 |     {
 8 |         private Image _image;
 9 |         private Size _size = new Size() {Height = 15, Width = 40};
10 |         private Point[] _points;
11 |         private object _valueLockObject = new {};
12 | 
13 | 
14 |         public Point[] Points
15 |         {
16 |             get { return _points; }
17 |             set
18 |             {
19 |                 _points = value;
20 |                 _image.Clear();
21 |                 foreach (var point in Points)
22 |                 {
23 |                     if (point.Left < _image.Size.Width && point.Top < _image.Size.Height)
24 |                     {
25 |                         _image.ImageArray[point.Top, point.Left] = (Color : BackgroundColor, Char : PlotSymbol);
26 |                     }
27 |                 }
28 | 
29 |                 lock (_valueLockObject)
30 |                 {
31 |                     ReRender();
32 |                 }
33 | 
34 |             }
35 |         }
36 | 
37 |         public ConsoleColor PointColor { get; set; } = ConsoleColor.Cyan;
38 | 
39 |         public char PlotSymbol { get; set; } = '*';
40 | 
41 |         public PlotChart()
42 |         {
43 |             _image = new Image(new char[_size.Height, _size.Width]);
44 |             AddChild(_image);
45 |         }
46 | 
47 |         public Size Size
48 |         {
49 |             get { return _size; }
50 |             set
51 |             {
52 |                 _size = value;
53 |                 _image.ImageArray = new(ConsoleColor Color, char Char)[value.Height, value.Width];
54 |             }
55 |         }
56 |     }
57 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/TextBox.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls
 4 | {
 5 |     public class TextBox : ControlBase, IBorderable
 6 |     {
 7 |         public TextBox()
 8 |         {
 9 |             BackgroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.BoxesBackgroundColor;
10 |             ForegroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.BoxesForegroundColor; ;
11 |             InputLength = 15;
12 |             MaxTextSize = 30;
13 |         }
14 | 
15 |         public int InputLength { get; set; }
16 | 
17 |         public int MaxTextSize { get; set; }
18 | 
19 |         internal override string VisibleText
20 |         {
21 |             get
22 |             {
23 |                 string text = IsFocused ? Text + '_' : Text;
24 |                 int length = text.Length;
25 |                 if (length > InputLength)
26 |                 {
27 |                     int startCharIndex = length - InputLength;
28 |                     return text.Substring(startCharIndex, InputLength);
29 |                 }
30 |                 return text;
31 |             }
32 |         }
33 | 
34 |         public bool IsBorderVisible { get; set; }
35 |         public ConsoleColor BorderBackgroundColor { get; set; }
36 |         public ConsoleColor BorderForegroundColor { get; set; }
37 | 
38 |         public override void PressKey(KeyPressEventArgs e)
39 |         {
40 |             base.PressKey(e);
41 | 
42 |             char character = e.KeyInfo.KeyChar;
43 | 
44 |             int length = Text.Length;
45 |             if (!Char.IsControl(character) && length <= MaxTextSize)
46 |             {
47 |                 Text += character;
48 |             }
49 |             else
50 |             {
51 |                 if (e.KeyInfo.Key == ConsoleKey.Backspace && length > 0)
52 |                 {
53 |                     Text = Text.Remove(length - 1, 1);
54 |                 }
55 |             }
56 |             ReRender();
57 |         }
58 |     }
59 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Menu/MenuItemButton.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using EntityFX.ScoreboardUI.Drawing;
 4 | using EntityFX.ScoreboardUI.Elements.Controls.StatusBar;
 5 | 
 6 | namespace EntityFX.ScoreboardUI.Elements.Controls.Menu
 7 | {
 8 |     public class MenuItemButton<TData> : MenuItem<TData>
 9 |     {
10 |         private readonly IList<MenuItemButton<TData>> _subMenuItems = new List<MenuItemButton<TData>>();
11 | 
12 |         public IEnumerable<MenuItemButton<TData>> SubMenuItems
13 |         {
14 |             get { return _subMenuItems; }
15 |         }
16 | 
17 |         public virtual void AddChild(MenuItemButton<TData> childControl)
18 |         {
19 |             _subMenuItems.Add(childControl);
20 |             childControl.Parent = this;
21 |             //ScoreboardContext.CurrentState.AddToControlList(childControl);
22 |             //childControl.CompositionLevel = CompositionLevel + 1;
23 |         }
24 | 
25 |         public MenuItemButton()
26 |         {
27 |             BackgroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.ButtonsBackgroundColor;
28 |             ForegroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.ButtonsForegroundColor;
29 |             Location = new Point() { Top = 0 };
30 |             InternalControl = new Button
31 |             {
32 |                 Text = Text,
33 |                 Parent = this,
34 |                 Location = new Point() { Top = 0 },
35 |                 Position = PositionEnum.RELATIVE,
36 |                 IsEnabled = IsEnabled
37 |             };
38 |         }
39 | 
40 |         public override bool IsEnabled
41 |         {
42 |             get
43 |             {
44 |                 return base.IsEnabled;
45 |             }
46 |             set
47 |             {
48 |                 if (InternalControl != null) {
49 |                     InternalControl.IsEnabled = value;
50 |                 }
51 | 
52 |                 base.IsEnabled = value;
53 |             }
54 |         }
55 |     }
56 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI.TestExample/SecondScoreboard.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using EntityFX.ScoreboardUI;
 3 | using EntityFX.ScoreboardUI.Drawing;
 4 | using EntityFX.ScoreboardUI.Elements.Controls;
 5 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
 6 | 
 7 | namespace EntityFx.ScorbordUI.TestExample
 8 | {
 9 |     class SecondScoreboard : Scoreboard
10 |     {
11 |         private Checkbox _checkbox1;
12 | 
13 |         private Image _img1;
14 | 
15 |         public SecondScoreboard()
16 |             : base(new Panel())
17 |         {
18 |         }
19 | 
20 |         public override void Initialize()
21 |         {
22 |             base.Initialize();
23 |             _checkbox1 = new Checkbox { Location = new Point { Left = 3, Top = 3 }, Text = "Checkbox tentative" };
24 |             RootPanel.AddChild(_checkbox1);
25 | 
26 |             _img1 = new Image()
27 |             {
28 |                 Size = new Size() {  Height = 4, Width = 24},
29 |                 Location = new Point() {  Left = 3, Top = 10}
30 |             };
31 | 
32 |             var imageData = new (ConsoleColor Color, char Char)[_img1.Size.Height, _img1.Size.Width];
33 |             for (int y = 0; y < _img1.Size.Height; y++)
34 |             {
35 |                 for (int x = 0; x < _img1.Size.Width; x++)
36 |                 {
37 |                     ConsoleColor c = (ConsoleColor) (x / 3 + (_img1.Size.Width / 3) * (y / 2));
38 |                     imageData[y,x] = (Color: c, Char : ' ');
39 |                 }
40 |             }
41 |             _img1.ImageArray = imageData;
42 |             _img1.UseColors = true;
43 |             _img1.UseInvertedColors = true;
44 |             RootPanel.AddChild(_img1);
45 |         }
46 | 
47 |         protected override void OnKeyPressed(KeyPressEventArgs e)
48 |         {
49 |             if (e.KeyInfo.Key == ConsoleKey.D1)
50 |             {
51 |                 Navigate<FourthScoreboard>();
52 |             }
53 |         }
54 |         
55 |         protected override void OnEscapePressed(object data = null)
56 |         {
57 |             GoBack(255);
58 |         }
59 |     }
60 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Control.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls
 4 | {
 5 |     public class Control<T> : ControlBase where T : ControlBase
 6 |     {
 7 |         private bool _renderChildren = true;
 8 |         
 9 |         protected readonly IList<T> controls = new List<T>();
10 | 
11 |         public IEnumerable<T> Controls
12 |         {
13 |             get { return controls; }
14 |         }
15 | 
16 |         protected override void ReRender()
17 |         {
18 |             _renderChildren = false;
19 |             Render();
20 |             _renderChildren = true;
21 |         }
22 | 
23 |         public virtual void AddChild(T childControl)
24 |         {
25 |             controls.Add(childControl);
26 |             childControl.Parent = this;
27 |             ScoreboardContext.CurrentState.AddToControlList(childControl);
28 |             childControl.CompositionLevel = CompositionLevel + 1;
29 |         }
30 | 
31 |         public virtual void RemoveChild(T childControl)
32 |         {
33 |             childControl.Parent = null;
34 |             ScoreboardContext.CurrentState.RemoveFromControlList(childControl);
35 |             controls.Remove(childControl);
36 |         }
37 | 
38 |         protected override void PostRender()
39 |         {
40 |             if (_renderChildren)
41 |             {
42 |                 ((List<T>)controls).ForEach(c => c.Render());
43 |             }
44 |         }
45 | 
46 |         public override void Initialize()
47 |         {
48 |             base.Initialize();
49 |             foreach (var rootPanelControl in Controls)
50 |             {
51 |                 rootPanelControl.Initialize();
52 |             }
53 |         }
54 | 
55 |         protected override void Dispose(bool disposing)
56 |         {
57 |             if (disposing)
58 |             {
59 |                 foreach (var control in Controls)
60 |                 {
61 |                     control.Dispose();
62 |                 }
63 |             }
64 | 
65 |             base.Dispose(disposing);
66 |         }
67 |     }
68 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/StatusBar/StatusStrip.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using EntityFX.ScoreboardUI.Drawing;
 3 | 
 4 | namespace EntityFX.ScoreboardUI.Elements.Controls.StatusBar
 5 | {
 6 |     public class StatusStrip : Control<StatusStripItem>
 7 |     {
 8 |         private int _leftOffset;
 9 | 
10 |         private int _rightOffset = -1;
11 | 
12 |         public StatusStrip()
13 |         {
14 |             BackgroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.MenuBackgroundColor;
15 |             ForegroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.MenuForegroundColor;
16 |         }
17 | 
18 |         public override void AddChild(StatusStripItem childControl)
19 |         {
20 |             childControl.InternalControl.BackgroundColor = childControl.BackgroundColor;
21 |             childControl.InternalControl.ForegroundColor = childControl.ForegroundColor;
22 |             base.AddChild(childControl);
23 |             var itemWidth = GetItemWidth(childControl);
24 |             if (childControl.ItemLocation == ItemLocationEnum.Left)
25 |             {
26 |                 childControl.Location = new Point
27 |                 {
28 |                     Left = _leftOffset,
29 |                     Top = 0
30 |                 };
31 |                 _leftOffset += itemWidth + 1;
32 |             }
33 |             else
34 |             {
35 |                 if (_rightOffset == -1)
36 |                 {
37 |                     _rightOffset = ParentScoreboard.Size.Width - 3;
38 |                 }
39 |                 _rightOffset -= (itemWidth + 1);
40 | 
41 |                 childControl.Location = new Point
42 |                 {
43 |                     Left = _rightOffset,
44 |                     Top = 0
45 |                 };
46 |             }
47 |         }
48 | 
49 |         private int GetItemWidth(StatusStripItem childControl)
50 |         {
51 |             var linerableControl = childControl.InternalControl as ILinearable;
52 |             return linerableControl != null ? linerableControl.Width : childControl.Text.Length;
53 |         }
54 |     }
55 | }


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     // Используйте IntelliSense, чтобы узнать о возможных атрибутах.
 3 |     // Наведите указатель мыши, чтобы просмотреть описания существующих атрибутов.
 4 |     // Для получения дополнительной информации посетите: https://go.microsoft.com/fwlink/?linkid=830387
 5 |     "version": "0.2.0",
 6 |     "configurations": [
 7 |         {
 8 |             "name": "ScoreboardUI debug",
 9 |             "type": "coreclr",
10 |             "request": "launch",
11 |             "preLaunchTask": "build",
12 |             "program": "${workspaceFolder}/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI.TestExample/bin/netcoreapp2.0/EntityFX.ScoreboardUI.TestExample.dll",
13 |             "args": [],
14 |             "cwd": "${workspaceFolder}",
15 |             "console": "externalTerminal",
16 |             "stopAtEntry": false,
17 |             "internalConsoleOptions": "openOnSessionStart"
18 |         },
19 |         {
20 |             "name": ".NET Core Launch (web)",
21 |             "type": "coreclr",
22 |             "request": "launch",
23 |             "preLaunchTask": "build",
24 |             "program": "${workspaceFolder}/bin/Debug/<insert-target-framework-here>/<insert-project-name-here>.dll",
25 |             "args": [],
26 |             "cwd": "${workspaceFolder}",
27 |             "stopAtEntry": false,
28 |             "internalConsoleOptions": "openOnSessionStart",
29 |             "launchBrowser": {
30 |                 "enabled": true,
31 |                 "args": "${auto-detect-url}",
32 |                 "windows": {
33 |                     "command": "cmd.exe",
34 |                     "args": "/C start ${auto-detect-url}"
35 |                 },
36 |                 "osx": {
37 |                     "command": "open"
38 |                 },
39 |                 "linux": {
40 |                     "command": "xdg-open"
41 |                 }
42 |             },
43 |             "env": {
44 |                 "ASPNETCORE_ENVIRONMENT": "Development"
45 |             },
46 |             "sourceFileMap": {
47 |                 "/Views": "${workspaceFolder}/Views"
48 |             }
49 |         },
50 |         {
51 |             "name": ".NET Core Attach",
52 |             "type": "coreclr",
53 |             "request": "attach",
54 |             "processId": "${command:pickProcess}"
55 |         }
56 |     ]
57 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/DateTimeBox.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Runtime.Serialization;
 3 | 
 4 | namespace EntityFX.ScoreboardUI.Elements.Controls
 5 | {
 6 |     public class DateTimeBox : TextBox
 7 |     {
 8 |         public string Format { get; set; } = "d";
 9 | 
10 |         public DateTime? DateTime
11 |         {
12 |             get { return _dateTime; }
13 |             set
14 |             {
15 |                 _dateTime = value;
16 |                 if (value != null)
17 |                 {
18 |                     Text = DateTime?.ToString(Format);
19 |                 }
20 |             }
21 |         } 
22 | 
23 |         private DateTimeFormat _dateTimeFormat;
24 |         private DateTime? _dateTime;
25 | 
26 |         public DateTimeBox() : base()
27 |         {
28 |             _dateTimeFormat = new DateTimeFormat(Format);
29 | 
30 |             Initialize();
31 |         }
32 | 
33 |         public override void Initialize()
34 |         {
35 |             base.Initialize();
36 |             InitValue();
37 |         }
38 | 
39 |         private void InitValue()
40 |         {
41 |             if (Text != "")
42 |             {
43 | 
44 |                 if (_dateTimeFormat != null && DateTime != null)
45 |                 {
46 |                     DateTime initial = (DateTime)DateTime;
47 |                     DateTime dt;
48 |                     if (!System.DateTime.TryParse(Text, _dateTimeFormat.FormatProvider, _dateTimeFormat.DateTimeStyles, out dt))
49 |                     {
50 |                         dt = initial;
51 |                     }
52 |                     DateTime = dt;
53 |                 }
54 |                 Text = DateTime?.ToString(Format);
55 |             }
56 |         }
57 | 
58 |         public override void OnFocusChanged(bool isFocused)
59 |         {
60 |             base.OnFocusChanged(isFocused);
61 | 
62 |             if (!isFocused)
63 |             {
64 |                 if (_dateTimeFormat != null)
65 |                 {
66 |                     DateTime dt;
67 |                     System.DateTime.TryParse(Text, _dateTimeFormat.FormatProvider, _dateTimeFormat.DateTimeStyles, out dt);
68 |                     DateTime = dt;
69 |                 }
70 |                 Text = DateTime?.ToString(Format);
71 |             }
72 |         }
73 |     }
74 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/StatusBar/StatusStripProgressBar.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls.StatusBar
 4 | {
 5 |     public class StatusStripProgressBar : StatusStripItem, IProgressBar, ILinearable
 6 |     {
 7 |         private readonly ProgressBar _progressBar;
 8 |         
 9 |         public StatusStripProgressBar()
10 |         {
11 |             InternalControl = new ProgressBar
12 |             {
13 |                 Text = Text,
14 |                 Parent = this
15 |             };
16 |             _progressBar = (ProgressBar)InternalControl;
17 |             BackgroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.SecondaryBackgroundColor;
18 |             StripeColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.SecondaryForegroundColor;
19 |         }
20 | 
21 |         public int Minimum
22 |         {
23 |             get { return _progressBar.Minimum; }
24 |             set { _progressBar.Minimum = value; }
25 |         }
26 | 
27 |         public int Maximum
28 |         {
29 |             get { return _progressBar.Maximum; }
30 |             set { _progressBar.Maximum = value; }
31 |         }
32 | 
33 |         public int Step
34 |         {
35 |             get { return _progressBar.Step; }
36 |             set { _progressBar.Step = value; }
37 |         }
38 | 
39 |         public int Width
40 |         {
41 |             get { return _progressBar.Width; }
42 |             set { _progressBar.Width = value; }
43 |         }
44 | 
45 |         public int Value
46 |         {
47 |             get { return _progressBar.Value; }
48 |             set { _progressBar.Value = value; }
49 |         }
50 | 
51 |         public ConsoleColor StripeColor
52 |         {
53 |             get { return _progressBar.StripeColor; }
54 |             set { _progressBar.StripeColor = value; }
55 |         }
56 | 
57 |         public event EventHandler<int> ValueChanged
58 |         {
59 |             add { _progressBar.ValueChanged += value; }
60 |             remove { _progressBar.ValueChanged -= value; }
61 |         }
62 | 
63 |         public void Increment(int? value = null)
64 |         {
65 |             _progressBar.Increment(value);
66 |         }
67 | 
68 |         public void Decrement(int? value = null)
69 |         {
70 |             _progressBar.Decrement(value);
71 |         }
72 |     }
73 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/ListControlBase.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | 
 4 | namespace EntityFX.ScoreboardUI.Elements.Controls
 5 | {
 6 |     public class ListControlBase<TListItem> : ControlBase where TListItem : class
 7 |     {
 8 |         private List<TListItem> _items;
 9 | 
10 |         private int _selectedIndexInternal;
11 | 
12 |         public ListControlBase(List<TListItem> items = null)
13 |         {
14 |             Items = items ?? new List<TListItem>();
15 |         }
16 | 
17 |         public List<TListItem> Items
18 |         {
19 |             get { return _items; }
20 |             set
21 |             {
22 |                 _items = value;
23 |                 OnItemsChanged();
24 |             }
25 |         }
26 | 
27 |         public TListItem SelectedValue
28 |         {
29 |             get
30 |             {
31 |                 if (Items != null && Items.Count > 0)
32 |                 {
33 |                     return Items[SelectedIndex];
34 |                 }
35 |                 return null;
36 |             }
37 |             set
38 |             {
39 |                 if (Items != null)
40 |                 {
41 |                     Items[SelectedIndex] = value;
42 |                 }
43 |             }
44 |         }
45 | 
46 | 
47 |         public int SelectedIndex
48 |         {
49 |             get
50 |             {
51 |                 return Items == null ? -1 : _selectedIndexInternal;
52 |             }
53 |             set
54 |             {
55 |                 if (Items != null && (value > Items.Count || value <= -1))
56 |                 {
57 |                     throw new ArgumentOutOfRangeException("Selected Index");
58 |                 }
59 |                 _selectedIndexInternal = value;
60 |             }
61 |         }
62 | 
63 |         public event EventHandler<TListItem> SelectedValueChanged;
64 | 
65 |         protected virtual void OnItemsChanged()
66 |         {
67 |             
68 |         }
69 | 
70 |         public virtual void Clear()
71 |         {
72 | 
73 |         }
74 | 
75 |         public override void Initialize()
76 |         {
77 |             OnItemsChanged();
78 |             base.Initialize();
79 |         }
80 | 
81 |         protected virtual void OnSelectedValueChanged(TListItem e)
82 |         {
83 |             SelectedValueChanged?.Invoke(this, e);
84 |         }
85 |     }
86 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Image.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Linq;
 3 | using EntityFX.ScoreboardUI.Drawing;
 4 | 
 5 | namespace EntityFX.ScoreboardUI.Elements.Controls
 6 | {
 7 |     public class Image : ControlBase, ISizable
 8 |     {
 9 |         private (ConsoleColor Color, char Char)[,] _imageArray;
10 | 
11 |         public bool UseColors { get; set; } = false;
12 | 
13 |         public bool UseInvertedColors { get; set; } = false;
14 | 
15 |         public Image()
16 |         {
17 |             UseColors = false;
18 |         }
19 | 
20 |         public Image(char[,] imageArray)
21 |         {
22 |             UseColors = false;
23 |             (ConsoleColor Color, char Char)[,] coloredImageArray = new (ConsoleColor, char)[imageArray.GetLength(0), imageArray.GetLength(1)];
24 |             for (int y = 0; y < imageArray.GetLength(0); y++)
25 |             {
26 |                 for (int x = 0; x < imageArray.GetLength(1); x++)
27 |                 {
28 |                     coloredImageArray[y, x] = (Color : ForegroundColor, Char: imageArray[y, x]);
29 |                 }
30 |             }
31 |             ImageArray = coloredImageArray;
32 |         }
33 | 
34 |         public Image((ConsoleColor Color, char Char)[,] imageArray)
35 |         {
36 |             UseColors = true;
37 |             ImageArray = imageArray;
38 |         }
39 | 
40 |         public (ConsoleColor Color, char Char)[,] ImageArray
41 |         {
42 |             get { return _imageArray; }
43 |             set
44 |             {
45 |                 _imageArray = value;
46 |                 Size = new Size
47 |                 {
48 |                     Width = _imageArray.GetLength(1),
49 |                     Height = _imageArray.GetLength(0)
50 |                 };
51 |             }
52 |         }
53 | 
54 |         public Size Size { get; set; }
55 | 
56 |         public static Image FromString(string text)
57 |         {
58 |             var strings = text.Split('\n').Select(s => s.Replace("\r", "")).ToArray();
59 |             var maxString = strings.Max(s => s.Length);
60 |             char[,] imgChar = new Char[strings.Length, maxString];
61 | 
62 | 
63 |             for (int y = 0; y < strings.Length; y++)
64 |             {
65 |                 for (int x = 0; x < strings[y].Length; x++)
66 |                 {
67 |                     imgChar[y, x] = strings[y][x];
68 |                 }
69 |             }
70 | 
71 |             return new Image(imgChar);
72 |         }
73 | 
74 |         public void Clear()
75 |         {
76 |             _imageArray = new(ConsoleColor Color, char Char)[Size.Height, Size.Width]; 
77 |         }
78 |     }
79 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/ListView.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Diagnostics;
 4 | using System.Linq;
 5 | using EntityFX.ScoreboardUI.Drawing;
 6 | 
 7 | namespace EntityFX.ScoreboardUI.Elements.Controls
 8 | {
 9 | 
10 |     public class ListView<TItem> : ListControlBase<TItem>, ILinearable, ICloneable, IListView where TItem : class
11 |     {
12 |         public int Width { get; set; }
13 | 
14 |         public int ItemHeight { get; set; } = 1;
15 | 
16 |         public ListViewItem Template { get; set; }
17 | 
18 |         public IEnumerable<ListViewItem> ItemsControls { get; private set; }
19 | 
20 |         public event EventHandler<ItemInformation<TItem>> ItemDataBound;
21 | 
22 |         protected override void OnItemsChanged()
23 |         {
24 |             var itemsControls = new List<ListViewItem>();
25 |             var top = 0;
26 |             if (Template == null)
27 |             {
28 |                 new InvalidOperationException("Template is null");
29 |             }
30 |             foreach (var item in Items)
31 |             {
32 |                 var itemControls = (ListViewItem) Template.Clone();
33 |                 itemControls.Location = new Point() {Left = 0, Top = top};
34 |                 top += ItemHeight;
35 |                 itemControls.Position = PositionEnum.RELATIVE;
36 |                 itemControls.Parent = this;
37 |                 foreach (var control in itemControls.Controls)
38 |                 {
39 |                     ScoreboardContext.CurrentState.AddToControlList(control);
40 |                     control.CompositionLevel = CompositionLevel + 1;
41 |                 }
42 |                 itemsControls.Add(itemControls);
43 |                 ItemDataBound?.Invoke(this, new ItemInformation<TItem> { Item = item, ItemControls = itemControls.Controls.ToArray() });
44 |             }
45 |             Clear();
46 |             ItemsControls = itemsControls;
47 |         }
48 | 
49 | 
50 |         public override void Clear()
51 |         {
52 |             if (ItemsControls == null) return;
53 |             foreach (var item in ItemsControls)
54 |             {
55 |                 foreach (var control in item.Controls)
56 |                 {
57 |                     ScoreboardContext.CurrentState.RemoveFromControlList(control);
58 |                     control.Dispose();
59 |                 }
60 |             }
61 |         }
62 | 
63 |         public class ItemInformation<TItem> where TItem : class
64 |         {
65 |             public ControlBase[] ItemControls { get; set; }
66 | 
67 |             public TItem Item { get; set; }
68 |         }
69 | 
70 |         public override void ClearEvents()
71 |         {
72 |             base.ClearEvents();
73 |             ItemDataBound = null;
74 |         }
75 |     }
76 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI.TestExample/ThirdScoreboard.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Linq;
 3 | using EntityFX.ScoreboardUI.Drawing;
 4 | using EntityFX.ScoreboardUI.Elements.Controls;
 5 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
 6 | 
 7 | namespace EntityFx.ScorbordUI.TestExample
 8 | {
 9 |     class ThirdScoreboard : Scoreboard
10 |     {
11 |         class Item
12 |         {
13 |             public bool BoolValue { get; set; }
14 | 
15 |             public string StringValue { get; set; }
16 | 
17 |             public string SecondStringValue { get; set; }
18 |         }
19 | 
20 |         private ListView<Item> _listView;
21 | 
22 |         private Button _button;
23 | 
24 |         public ThirdScoreboard()
25 |             : base(new Panel())
26 |         {
27 |         }
28 | 
29 |         public override void Initialize()
30 |         {
31 |             base.Initialize();
32 | 
33 |             var template = new ListViewItem()
34 |             {
35 |             };
36 |             template.AddChild(new Checkbox()
37 |             {
38 |                 Text = ""
39 |             });
40 |             template.AddChild(new Label()
41 |             {
42 |                 Text = "",
43 |                 Location = new Point() { Left = 4 }
44 |             });
45 |             template.AddChild(new Label()
46 |             {
47 |                 Text = "",
48 |                 Location = new Point() { Left = 14 }
49 |             });
50 |             template.AddChild(new Button()
51 |             {
52 |                 Text = "Edit",
53 |                 Location = new Point() { Left = 30 }
54 |             });
55 | 
56 |             _listView = new ListView<Item>()
57 |             {
58 |                 Location = new Point() { Left = 2, Top = 2 },
59 |                 Template = template
60 |             };
61 |             _listView.ItemDataBound += _listView_ItemDataBound;
62 | 
63 |             _listView.Items = new List<Item>()
64 |             {
65 |                 new Item()
66 |                 {
67 |                     BoolValue = true,
68 |                     StringValue = "Value 1",
69 |                     SecondStringValue = "Long Value 1"
70 |                 },                new Item()
71 |                 {
72 |                     BoolValue = false,
73 |                     StringValue = "Value 2",
74 |                     SecondStringValue = "Long Value 2"
75 |                 }
76 |             };
77 |             RootPanel.AddChild(_listView);
78 | 
79 |             _button = new Button()
80 |             {
81 |                 Location = new Point() { Left = 2, Top = Size.Height - 3 },
82 |                 Text = "Button"
83 |             };
84 |             RootPanel.AddChild(_button);
85 |         }
86 | 
87 |         private void _listView_ItemDataBound(object sender, ListView<Item>.ItemInformation<Item> e)
88 |         {
89 |             ((Checkbox)e.ItemControls[0]).IsChecked = e.Item.BoolValue;
90 |             ((Label)e.ItemControls[1]).Text = e.Item.StringValue;
91 |             ((Label)e.ItemControls[2]).Text = e.Item.SecondStringValue;
92 |         }
93 | 
94 |         protected override bool PreRender()
95 |         {
96 |             return base.PreRender();
97 |         }
98 |     }
99 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/ComboBox.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Elements.Controls
 4 | {
 5 |     public class ComboBox : ListControlBase<ComboBoxItem>, ILinearable
 6 |     {
 7 |         public ComboBox()
 8 |         {
 9 |             Width = 15;
10 |             BackgroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.BoxesBackgroundColor;
11 |             ForegroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.BoxesForegroundColor;
12 |             ExpanderBackground = ConsoleColor.Gray;
13 |             SelectedColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.FocusedForegroundColor;
14 |             VisibleItemsCount = 5;
15 |         }
16 | 
17 |         public ConsoleColor ExpanderBackground { get; set; }
18 | 
19 |         public ConsoleColor SelectedColor { get; set; }
20 | 
21 |         public bool DroppedDown { get; set; }
22 | 
23 |         public int VisibleItemsCount { get; set; }
24 | 
25 |         public event EventHandler DropDown;
26 | 
27 |         public event EventHandler DropClosed;
28 | 
29 |         public override string Text
30 |         {
31 |             get { return SelectedIndex == -1 || Items.Count == 0 ? string.Empty : Items[SelectedIndex].Text; }
32 |             set
33 |             {
34 |                 if (SelectedIndex >= 0)
35 |                 {
36 |                     Items[SelectedIndex].Text = value;
37 |                 }
38 |             }
39 |         }
40 | 
41 |         public override void PressKey(KeyPressEventArgs e)
42 |         {
43 |             base.PressKey(e);
44 |             if (e.KeyInfo.Key == ConsoleKey.Enter)
45 |             {
46 |                 DroppedDown = !DroppedDown;
47 |                 if (DropDown != null)
48 |                 {
49 |                     DropDown(this, new EventArgs());
50 |                 }
51 |                 ReRender();
52 |             }
53 | 
54 |             if (e.KeyInfo.Key == ConsoleKey.DownArrow && DroppedDown)
55 |             {
56 |                 SelectedIndex = SelectedIndex == Items.Count - 1? 0 : SelectedIndex + 1;
57 |                 OnSelectedValueChanged(SelectedValue);
58 |                 ReRender();
59 |             }
60 | 
61 |             if (e.KeyInfo.Key == ConsoleKey.UpArrow && DroppedDown)
62 |             {
63 |                 SelectedIndex = SelectedIndex == 0 ? Items.Count - 1 : SelectedIndex - 1;
64 |                 OnSelectedValueChanged(SelectedValue);
65 |                 ReRender();
66 |             }
67 |         }
68 | 
69 |         internal override string VisibleText
70 |         {
71 |             get
72 |             {
73 |                 int length = Text.Length;
74 |                 var realWidth = Width - 1;
75 |                 if (length > realWidth)
76 |                 {
77 |                     int startCharIndex = length - realWidth;
78 |                     return Text.Substring(startCharIndex, realWidth);
79 |                 }
80 |                 return Text;
81 |             }
82 |         }
83 | 
84 |         public int Width { get; set; }
85 | 
86 |         public override void ClearEvents()
87 |         {
88 |             base.ClearEvents();
89 |             DropClosed = null;
90 |             DropDown = null;
91 |         }
92 |     }
93 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/NumericBox.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Globalization;
 3 | 
 4 | namespace EntityFX.ScoreboardUI.Elements.Controls
 5 | {
 6 |     public class NumericBox : TextBox
 7 |     {
 8 |         private decimal? _numberValue = null;
 9 | 
10 |         public Decimal? NumberValue
11 |         {
12 |             get { return _numberValue; }
13 |             set
14 |             {
15 |                 _numberValue = value;
16 |                 if (value != null)
17 |                 {
18 |                     Text = value.ToString();
19 |                 }
20 |             }
21 |         }
22 | 
23 |         public NumericBox() : base()
24 |         {
25 |             InitValue();
26 |         }
27 | 
28 |         public override void Initialize()
29 |         {
30 |             base.Initialize();
31 |             InitValue();
32 |         }
33 | 
34 |         private void InitValue()
35 |         {
36 |             if (Text != "")
37 |             {
38 | 
39 |                 Decimal dt = 0;
40 |                 if (!Decimal.TryParse(Text, NumberStyles.Number, CultureInfo.CurrentCulture, out dt))
41 |                 {
42 |                     dt = 0;
43 |                 }
44 |                 NumberValue = dt;
45 |                 Text = NumberValue.ToString();
46 |             }
47 |         }
48 | 
49 |         public override void OnFocusChanged(bool isFocused)
50 |         {
51 |             base.OnFocusChanged(isFocused);
52 | 
53 |             if (!isFocused && !string.IsNullOrWhiteSpace(Text))
54 |             {
55 |                 Decimal dt;
56 |                 Decimal.TryParse(Text, NumberStyles.Number, CultureInfo.CurrentCulture, out dt);
57 |                 NumberValue = dt;
58 |                 Text = NumberValue.ToString();
59 |             }
60 |         }
61 | 
62 |         public override void PressKey(KeyPressEventArgs e)
63 |         {
64 |             if ((
65 |                 (e.KeyInfo.KeyChar >= '0' && e.KeyInfo.KeyChar <= '9') ||
66 |                 (e.KeyInfo.KeyChar.ToString() == CultureInfo.CurrentCulture.NumberFormat.NegativeSign && Text == "") ||
67 |                 e.KeyInfo.KeyChar.ToString() == CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator && !Text.Contains(CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator))
68 | 
69 |                 && !Char.IsControl(e.KeyInfo.KeyChar))
70 |             {
71 |                 base.PressKey(e);
72 |                 if (Text != CultureInfo.CurrentCulture.NumberFormat.NegativeSign &&       
73 |                     !Text.EndsWith(CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator))
74 |                 {
75 |                     Decimal dt; 
76 |                     Decimal.TryParse(Text, NumberStyles.Number, CultureInfo.CurrentCulture, out dt);
77 |                     NumberValue = dt;
78 |                     Text = NumberValue != null ? ((decimal)NumberValue).ToString(CultureInfo.CurrentCulture) : "";
79 |                 }
80 |             }
81 |             else if (Char.IsControl(e.KeyInfo.KeyChar))
82 |             {
83 |                 base.PressKey(e);
84 |             }
85 | 
86 |             if (e.KeyInfo.Key == ConsoleKey.UpArrow)
87 |             {
88 |                 NumberValue++;
89 |                 Text = NumberValue.ToString();
90 |             }
91 | 
92 |             if (e.KeyInfo.Key == ConsoleKey.DownArrow)
93 |             {
94 |                 NumberValue--;
95 |                 Text = NumberValue.ToString();
96 |             }
97 |         }
98 |     }
99 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Render/ColorSchemas.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace EntityFX.ScoreboardUI.Render
 4 | {
 5 |     public static class ColorSchemas
 6 |     {
 7 |         public static ColorScheme Blue
 8 |         {
 9 |             get
10 |             {
11 |                 return new ColorScheme()
12 |                 {
13 |                     PrimaryBackgroundColor = ConsoleColor.DarkBlue,
14 |                     PrimaryForegroundColor = ConsoleColor.Yellow,
15 |                     SecondaryBackgroundColor = ConsoleColor.Gray,
16 |                     SecondaryForegroundColor = ConsoleColor.DarkRed,
17 |                     BorderColor = ConsoleColor.Gray,
18 |                     BoxesBackgroundColor = ConsoleColor.White,
19 |                     BoxesForegroundColor = ConsoleColor.DarkBlue,
20 |                     ButtonsBackgroundColor = ConsoleColor.DarkCyan,
21 |                     ButtonsForegroundColor = ConsoleColor.White,
22 |                     FocusedBackgroundColor = ConsoleColor.DarkYellow,
23 |                     FocusedForegroundColor = ConsoleColor.Black,
24 |                     DisabledBackgroundColor = ConsoleColor.Gray,
25 |                     DisabledForegroundColor = ConsoleColor.Black,
26 |                     MenuBackgroundColor = ConsoleColor.Gray,
27 |                     MenuForegroundColor = ConsoleColor.DarkBlue,
28 |                     MessageBoxBackgroundColor = ConsoleColor.DarkBlue,
29 |                     MessageBoxForegroundColor = ConsoleColor.Yellow,
30 |                     WarningMessageBoxBackgroundColor = ConsoleColor.DarkYellow,
31 |                     WarningMessageBoxForegroundColor = ConsoleColor.Black,
32 |                     ErrorMessageBoxBackgroundColor = ConsoleColor.DarkRed,
33 |                     ErrorMessageBoxForegroundColor = ConsoleColor.Black
34 |                 };
35 |             }
36 |         }
37 | 
38 |         public static ColorScheme Matrix { get
39 |             {
40 |                 return new ColorScheme()
41 |                 {
42 |                     PrimaryBackgroundColor = ConsoleColor.Black,
43 |                     PrimaryForegroundColor = ConsoleColor.DarkGreen,
44 |                     SecondaryBackgroundColor = ConsoleColor.Gray,
45 |                     SecondaryForegroundColor = ConsoleColor.DarkGreen,
46 |                     BorderColor = ConsoleColor.DarkGreen,
47 |                     BoxesBackgroundColor = ConsoleColor.Gray,
48 |                     BoxesForegroundColor = ConsoleColor.DarkGreen,
49 |                     ButtonsBackgroundColor = ConsoleColor.DarkGreen,
50 |                     ButtonsForegroundColor = ConsoleColor.White,
51 |                     FocusedBackgroundColor = ConsoleColor.Gray,
52 |                     FocusedForegroundColor = ConsoleColor.Black,
53 |                     DisabledBackgroundColor = ConsoleColor.Black,
54 |                     DisabledForegroundColor = ConsoleColor.Gray,
55 |                     MenuBackgroundColor = ConsoleColor.Gray,
56 |                     MenuForegroundColor = ConsoleColor.DarkGreen,
57 |                     MessageBoxBackgroundColor = ConsoleColor.Black,
58 |                     MessageBoxForegroundColor = ConsoleColor.DarkGreen,
59 |                     WarningMessageBoxBackgroundColor = ConsoleColor.DarkYellow,
60 |                     WarningMessageBoxForegroundColor = ConsoleColor.Black,
61 |                     ErrorMessageBoxBackgroundColor = ConsoleColor.DarkRed,
62 |                     ErrorMessageBoxForegroundColor = ConsoleColor.Black
63 |                 };
64 |             }
65 |         }
66 |     }
67 |     
68 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/ObjectExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Reflection;
 4 | using EntityFX.ScoreboardUI.ArrayExtensions;
 5 | 
 6 | namespace EntityFX.ScoreboardUI
 7 | {
 8 |     public static class ObjectExtensions
 9 |     {
10 |         private static readonly MethodInfo CloneMethod = typeof(Object).GetMethod("MemberwiseClone", BindingFlags.NonPublic | BindingFlags.Instance);
11 | 
12 |         public static bool IsPrimitive(this Type type)
13 |         {
14 |             if (type == typeof(String)) return true;
15 |             return (type.IsValueType & type.IsPrimitive);
16 |         }
17 | 
18 |         public static Object Copy(this Object originalObject)
19 |         {
20 |             return InternalCopy(originalObject, new Dictionary<Object, Object>(new ReferenceEqualityComparer()));
21 |         }
22 |         private static Object InternalCopy(Object originalObject, IDictionary<Object, Object> visited)
23 |         {
24 |             if (originalObject == null) return null;
25 |             var typeToReflect = originalObject.GetType();
26 |             if (IsPrimitive(typeToReflect)) return originalObject;
27 |             if (visited.ContainsKey(originalObject)) return visited[originalObject];
28 |             if (typeof(Delegate).IsAssignableFrom(typeToReflect)) return null;
29 |             var cloneObject = CloneMethod.Invoke(originalObject, null);
30 |             if (typeToReflect.IsArray)
31 |             {
32 |                 var arrayType = typeToReflect.GetElementType();
33 |                 if (IsPrimitive(arrayType) == false)
34 |                 {
35 |                     Array clonedArray = (Array)cloneObject;
36 |                     clonedArray.ForEach((array, indices) => array.SetValue(InternalCopy(clonedArray.GetValue(indices), visited), indices));
37 |                 }
38 | 
39 |             }
40 |             visited.Add(originalObject, cloneObject);
41 |             CopyFields(originalObject, visited, cloneObject, typeToReflect);
42 |             RecursiveCopyBaseTypePrivateFields(originalObject, visited, cloneObject, typeToReflect);
43 |             return cloneObject;
44 |         }
45 | 
46 |         private static void RecursiveCopyBaseTypePrivateFields(object originalObject, IDictionary<object, object> visited, object cloneObject, Type typeToReflect)
47 |         {
48 |             if (typeToReflect.BaseType != null)
49 |             {
50 |                 RecursiveCopyBaseTypePrivateFields(originalObject, visited, cloneObject, typeToReflect.BaseType);
51 |                 CopyFields(originalObject, visited, cloneObject, typeToReflect.BaseType, BindingFlags.Instance | BindingFlags.NonPublic, info => info.IsPrivate);
52 |             }
53 |         }
54 | 
55 |         private static void CopyFields(object originalObject, IDictionary<object, object> visited, object cloneObject, Type typeToReflect, BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy, Func<FieldInfo, bool> filter = null)
56 |         {
57 |             foreach (FieldInfo fieldInfo in typeToReflect.GetFields(bindingFlags))
58 |             {
59 |                 if (filter != null && filter(fieldInfo) == false) continue;
60 |                 if (IsPrimitive(fieldInfo.FieldType)) continue;
61 |                 var originalFieldValue = fieldInfo.GetValue(originalObject);
62 |                 var clonedFieldValue = InternalCopy(originalFieldValue, visited);
63 |                 fieldInfo.SetValue(cloneObject, clonedFieldValue);
64 |             }
65 |         }
66 |         public static T Copy<T>(this T original)
67 |         {
68 |             return (T)Copy((Object)original);
69 |         }
70 |     }
71 | 
72 |     namespace ArrayExtensions
73 |     {
74 |     }
75 | 
76 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/UiElement.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.ComponentModel;
  3 | using EntityFX.ScoreboardUI.Drawing;
  4 | 
  5 | namespace EntityFX.ScoreboardUI
  6 | {
  7 |     public abstract class UiElement : IDisposable
  8 |     {
  9 |         private static readonly object _syncObject = new object();
 10 | 
 11 |         public UiElement()
 12 |         {
 13 |             IsVisible = true;
 14 |             IsEnabled = true;
 15 |             BackgroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.PrimaryBackgroundColor;
 16 |             ForegroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.PrimaryForegroundColor;
 17 |         }
 18 | 
 19 |         public Guid Uid { get; set; } = Guid.NewGuid();
 20 | 
 21 |         public string Name { get; set; }
 22 | 
 23 |         public bool IsVisible { get; set; }
 24 | 
 25 |         public virtual bool IsEnabled { get; set; }
 26 | 
 27 |         public Point Location { get; set; }
 28 | 
 29 |         public ConsoleColor ForegroundColor { get; set; }
 30 | 
 31 |         public ConsoleColor BackgroundColor { get; set; }
 32 | 
 33 |         [TypeConverter(typeof (StringConverter))]
 34 |         [Bindable(true)]
 35 |         public Object Tag { get; set; }
 36 | 
 37 |         public event EventHandler Rendered;
 38 | 
 39 |         public event KeyPressEventHandler KeyPress;
 40 | 
 41 |         public virtual void PressKey(KeyPressEventArgs e)
 42 |         {
 43 |             KeyPressEventHandler handler = KeyPress;
 44 |             if (handler != null)
 45 |             {
 46 |                 handler(this, new KeyPressEventArgs
 47 |                 {
 48 |                     KeyInfo = e.KeyInfo
 49 |                 });
 50 |             }
 51 |             OnKeyPressed(e);
 52 |         }
 53 | 
 54 |         protected virtual void OnKeyPressed(KeyPressEventArgs e)
 55 |         {
 56 |         }
 57 | 
 58 |         protected virtual void OnRendered(EventArgs e)
 59 |         {
 60 |             EventHandler handler = Rendered;
 61 |             if (handler != null)
 62 |             {
 63 |                 handler(this, e);
 64 |             }
 65 |         }
 66 | 
 67 |         protected virtual bool PreRender()
 68 |         {
 69 |             return ScoreboardContext.CurrentState.ScoreboardInitialized;
 70 |         }
 71 | 
 72 |         protected abstract void PostRender();
 73 | 
 74 |         public virtual void Render()
 75 |         {
 76 |             lock (_syncObject)
 77 |             {
 78 |                 if (IsVisible && PreRender())
 79 |                 {
 80 |                     ScoreboardContext.RenderEngine.Render(this);
 81 | 
 82 |                     OnRendered(new EventArgs());
 83 |                     PostRender();
 84 |                 }
 85 |             }
 86 |         }
 87 | 
 88 |         public virtual void Initialize()
 89 |         {
 90 |         }
 91 | 
 92 |         protected virtual bool PreInitialize()
 93 |         {
 94 |             return true;
 95 |         }
 96 | 
 97 |         protected virtual void PostInitialize()
 98 |         {
 99 |         }
100 | 
101 |         public event EventHandler<EventArgs> Initialized;
102 | 
103 |         protected virtual void OnInitialized(EventArgs e)
104 |         {
105 |             EventHandler<EventArgs> handler = Initialized;
106 |             if (handler != null)
107 |             {
108 |                 handler(this, e);
109 |             }
110 |         }
111 | 
112 |         protected virtual void Dispose(bool disposing)
113 |         {
114 |             if (disposing)
115 |             {
116 |                 ClearEvents();
117 |             }
118 |         }
119 | 
120 |         public void Dispose()
121 |         {
122 |             Dispose(true);
123 |             GC.SuppressFinalize(this);
124 |         }
125 | 
126 |         public virtual void ClearEvents()
127 |         {
128 |             KeyPress = null;
129 |             Initialized = null;
130 |             Rendered = null;
131 |         }
132 |     }
133 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/UiApplication.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Threading;
  3 | using EntityFX.ScoreboardUI.Elements.MessageBox;
  4 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
  5 | using EntityFX.ScoreboardUI.Render;
  6 | 
  7 | namespace EntityFX.ScoreboardUI
  8 | {
  9 |     public class UiApplication : IUiApplication
 10 |     {
 11 |         private Scoreboard _initialScoreboard;
 12 | 
 13 |         public UiApplication()
 14 |         {
 15 |             IsClosed = false;
 16 |             FocusKey = ConsoleKey.Tab;
 17 |         }
 18 | 
 19 |         protected ConsoleKeyInfo PressedKey { get; private set; }
 20 | 
 21 |         public void Run(Scoreboard initialScoreboard)
 22 |         {
 23 |             _initialScoreboard = initialScoreboard;
 24 |             ScoreboardContext.Navigation.Navigate(initialScoreboard);
 25 | 
 26 |             while (!IsClosed)
 27 |             {
 28 |                 Thread.Sleep(1);
 29 |                 PerformStepInternal();
 30 |             }
 31 |         }
 32 | 
 33 |         public IRenderOptions RenderOptions
 34 |         {
 35 |             get => ScoreboardContext.RenderEngine.RenderOptions;
 36 |             set => ScoreboardContext.RenderEngine.RenderOptions = value;
 37 |         }
 38 | 
 39 |         public void Close()
 40 |         {
 41 |             IsClosed = true;
 42 |             if (Closed != null)
 43 |             {
 44 |                 Closed(this, new EventArgs());
 45 |             }
 46 |         }
 47 | 
 48 |         public bool IsClosed { get; private set; }
 49 | 
 50 |         public event KeyPressEventHandler KeyPress;
 51 | 
 52 |         public event FocusChangeEventHandler FocusChange;
 53 | 
 54 |         public ConsoleKey FocusKey { get; set; }
 55 | 
 56 |         public event EventHandler<EventArgs> Closed;
 57 | 
 58 |         private void PerformStepInternal()
 59 |         {
 60 |             PressedKey = ScoreboardContext.RenderEngine.ConsoleAdapter.ReadKey(true);
 61 |             KeyPressEventHandler handler = KeyPress;
 62 |             var keyPressArgs = new KeyPressEventArgs
 63 |             {
 64 |                 KeyInfo = PressedKey
 65 |             };
 66 |             try
 67 |             {
 68 |                 ScoreboardContext.Navigation.Current.Scoreboard.PressKey(keyPressArgs);
 69 |                 OnKeyPressed(keyPressArgs);
 70 | 
 71 |                 if (PressedKey.Key == ConsoleKey.Escape)
 72 |                 {
 73 |                     ScoreboardContext.Navigation.Current.Scoreboard.PressEscape(keyPressArgs);
 74 |                 }
 75 | 
 76 |                 if (PressedKey.Key == FocusKey && (PressedKey.Modifiers & ConsoleModifiers.Shift) == 0)
 77 |                 {
 78 |                     ScoreboardContext.CurrentState.NextFocus();
 79 |                 }
 80 | 
 81 |                 if (PressedKey.Key == FocusKey && (PressedKey.Modifiers & ConsoleModifiers.Shift) != 0)
 82 |                 {
 83 |                     ScoreboardContext.CurrentState.PreviousFocus();
 84 |                 }
 85 | 
 86 |                 if (PressedKey.Key == ConsoleKey.R && (PressedKey.Modifiers & ConsoleModifiers.Control) != 0)
 87 |                 {
 88 |                     ScoreboardContext.Navigation.Current.Scoreboard.Render();
 89 |                 }
 90 | 
 91 |                 if (handler != null)
 92 |                 {
 93 |                     handler(ScoreboardContext.Navigation.Current.Scoreboard, keyPressArgs);
 94 |                 }
 95 | 
 96 |                 CheckNavigationStatck();
 97 |                 PerformStep();
 98 |             }
 99 |             catch (Exception e)
100 |             {
101 |                 ScoreboardContext.Navigation.Reset();
102 |                 if (ScoreboardContext.CurrentState != null)
103 |                 {
104 |                     ScoreboardContext.Navigation.Navigate(_initialScoreboard);
105 |                     MessageBox.Alert("Application restarted after critical error", (@enum, o) => { }, "Critical Error", MessageBoxTypeEnum.Error);
106 |                 }
107 |             }
108 | 
109 |         }
110 | 
111 |         private void CheckNavigationStatck()
112 |         {
113 |             if (ScoreboardContext.Navigation.NavigationStack.Count == 0)
114 |             {
115 |                 Close();
116 |             }
117 |         }
118 | 
119 |         protected virtual void OnKeyPressed(KeyPressEventArgs eventArgs)
120 |         {
121 |         }
122 | 
123 |         protected virtual void OnFocusKeyPressed()
124 |         {
125 |         }
126 | 
127 |         protected virtual void PerformStep()
128 |         {
129 |         }
130 |     }
131 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/ProgressBar.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
  3 | 
  4 | namespace EntityFX.ScoreboardUI.Elements.Controls
  5 | {
  6 |     public class ProgressBar : ControlBase, IProgressBar, ILinearable
  7 |     {
  8 |         private readonly object _valueLockObject = new object();
  9 |         private int _maximumInternal;
 10 |         private int _minimumInternal;
 11 | 
 12 |         private int _valueInternal;
 13 | 
 14 |         public ProgressBar()
 15 |         {
 16 |             Minimum = 0;
 17 |             Maximum = 100;
 18 |             Step = 1;
 19 |             Width = 20;
 20 |             BackgroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.SecondaryBackgroundColor;
 21 |             StripeColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.SecondaryForegroundColor;
 22 |             Text = "Complete {0} %";
 23 |             TextAligment = TitleAligment.Center;
 24 |         }
 25 | 
 26 |         public TitleAligment TextAligment { get; set; }
 27 | 
 28 |         public int Minimum
 29 |         {
 30 |             get { return _minimumInternal; }
 31 |             set
 32 |             {
 33 |                 if (value > Maximum)
 34 |                     throw new ArgumentOutOfRangeException(
 35 |                         "Minimum",
 36 |                         value, string.Format(
 37 |                             "Minimum with value {0} is above than maximum value", value));
 38 |                 _minimumInternal = value;
 39 |             }
 40 |         }
 41 | 
 42 |         public int Maximum
 43 |         {
 44 |             get { return _maximumInternal; }
 45 |             set
 46 |             {
 47 |                 if (value < Minimum)
 48 |                     throw new ArgumentOutOfRangeException(
 49 |                         "Maximum",
 50 |                         value, string.Format(
 51 |                             "Maximum with value {0} is above than minimum value", value));
 52 |                 _maximumInternal = value;
 53 |             }
 54 |         }
 55 | 
 56 |         public int Step { get; set; }
 57 | 
 58 |         public int Width { get; set; }
 59 | 
 60 |         public int Value
 61 |         {
 62 |             get { return _valueInternal; }
 63 |             set
 64 |             {
 65 |                 if (value > Maximum || value < Minimum)
 66 |                     throw new ArgumentOutOfRangeException(
 67 |                         "Value",
 68 |                         value, "Value {0} is out of range");
 69 |                 lock (_valueLockObject)
 70 |                 {
 71 |                     _valueInternal = value;
 72 |                     EventHandler<int> handler = ValueChanged;
 73 |                     if (handler != null)
 74 |                     {
 75 |                         handler(this, _valueInternal);
 76 |                     }
 77 |                     ReRender();
 78 |                 }
 79 |             }
 80 |         }
 81 | 
 82 |         public ConsoleColor StripeColor { get; set; }
 83 | 
 84 |         internal override string VisibleText
 85 |         {
 86 |             get
 87 |             {
 88 |                 string text = string.Format(Text, Value);
 89 |                 int length = text.Length;
 90 |                 if (length > Width)
 91 |                 {
 92 |                     int startCharIndex = length - Width;
 93 |                     return Text.Substring(startCharIndex, Width);
 94 |                 }
 95 |                 return text;
 96 |             }
 97 |         }
 98 | 
 99 |         public event EventHandler<int> ValueChanged;
100 | 
101 |         public void Increment(int? value = null)
102 |         {
103 |             int newValue;
104 |             lock (_valueLockObject)
105 |             {
106 |                 newValue = Value + (value ?? Step);
107 |             }
108 |             if (newValue > Maximum)
109 |             {
110 |                 newValue = Maximum;
111 |             }
112 |             Value = newValue;
113 |         }
114 | 
115 |         public void Decrement(int? value = null)
116 |         {
117 |             int newValue;
118 |             lock (_valueLockObject)
119 |             {
120 |                 newValue = Value - (value ?? Step);
121 |             }
122 |             if (newValue < Minimum)
123 |             {
124 |                 newValue = Minimum;
125 |             }
126 |             Value = newValue;
127 |         }
128 | 
129 |         public override void ClearEvents()
130 |         {
131 |             base.ClearEvents();
132 |             ValueChanged = null;
133 |         }
134 |     }
135 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/Menu/Menu.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Diagnostics;
  4 | using System.Linq;
  5 | using EntityFX.ScoreboardUI.Drawing;
  6 | using EntityFX.ScoreboardUI.Elements.MessageBox;
  7 | 
  8 | namespace EntityFX.ScoreboardUI.Elements.Controls.Menu
  9 | {
 10 |     public class Menu : Control<MenuItem<object>>
 11 |     {
 12 |         private int _leftOffset;
 13 | 
 14 |         private int _rightOffset = -1;
 15 | 
 16 |         public Menu()
 17 |         {
 18 |             BackgroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.MenuBackgroundColor;
 19 |             ForegroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.MenuForegroundColor;
 20 |         }
 21 | 
 22 |         public override void AddChild(MenuItem<object> childControl)
 23 |         {
 24 |             childControl.InternalControl.BackgroundColor = childControl.BackgroundColor;
 25 |             childControl.InternalControl.ForegroundColor = childControl.ForegroundColor;
 26 |             base.AddChild(childControl);
 27 |             var itemWidth = GetItemWidth(childControl);
 28 |             if (childControl.ItemLocation == ItemLocationEnum.Left)
 29 |             {
 30 |                 childControl.Location = new Point
 31 |                 {
 32 |                     Left = _leftOffset,
 33 |                     Top = 0
 34 |                 };
 35 |                 _leftOffset += itemWidth + 1;
 36 |             }
 37 |             else
 38 |             {
 39 |                 if (_rightOffset == -1)
 40 |                 {
 41 |                     _rightOffset = ParentScoreboard.Size.Width - 3;
 42 |                 }
 43 |                 _rightOffset -= (itemWidth + 1);
 44 | 
 45 |                 childControl.Location = new Point
 46 |                 {
 47 |                     Left = _rightOffset,
 48 |                     Top = 0
 49 |                 };
 50 |             }
 51 | 
 52 |             if (childControl is MenuItemButton<object> button)
 53 |             {
 54 |                 button.KeyPress += Button_KeyPress;
 55 |             }
 56 |         }
 57 | 
 58 |         public virtual void Clear()
 59 |         {
 60 |             if (controls != null && controls.Any())
 61 |             {
 62 |                 var menuControls = controls.OfType<MenuItemButton<object>>().ToArray();
 63 |                 foreach (var item in menuControls)
 64 |                 {
 65 |                     item.KeyPress -= Button_KeyPress;
 66 |                     ClearInternal(item);
 67 |                     RemoveChild(item);
 68 |                 }
 69 |             }
 70 |         }
 71 | 
 72 |         protected virtual void ClearInternal(MenuItemButton<object> menuItem)
 73 |         {
 74 |             if (menuItem.SubMenuItems != null && menuItem.SubMenuItems.Any())
 75 |             {
 76 |                 foreach (var subMenu in menuItem.SubMenuItems)
 77 |                 {
 78 |                     subMenu.KeyPress -= Button_KeyPress;
 79 |                     ClearInternal(subMenu);
 80 |                     RemoveChild(subMenu);
 81 |                 }
 82 |             }
 83 |         }
 84 | 
 85 |         private void Button_KeyPress(UiElement sender, KeyPressEventArgs e)
 86 |         {
 87 |             if (e.KeyInfo.Key == ConsoleKey.Spacebar || e.KeyInfo.Key == ConsoleKey.Enter)
 88 |             {
 89 |                 Press(sender as MenuItemButton<object>, e);
 90 |             }
 91 |         }
 92 | 
 93 |         private int GetItemWidth(MenuItem<object> childControl)
 94 |         {
 95 |             var linerableControl = childControl.InternalControl as ILinearable;
 96 |             return linerableControl != null ? linerableControl.Width : childControl.Text.Length;
 97 |         }
 98 | 
 99 |         public event EventHandler<object> Pressed;
100 | 
101 |         public virtual void Press(MenuItemButton<object> sender, KeyPressEventArgs e)
102 |         {
103 |             OnPressed(sender, e);
104 |         }
105 | 
106 |         protected virtual void OnPressed(MenuItemButton<object> sender, KeyPressEventArgs e)
107 |         {
108 |             if (sender.SubMenuItems != null && sender.SubMenuItems.Any())
109 |             {
110 |                 MessageBox.MessageBox.Show("Select option",
111 |                     sender.SubMenuItems.Select(i => new SubmenuContext<object>()
112 |                     {
113 |                         Data = i.Data,
114 |                         Text = i.Text,
115 |                         IsEnabled = i.IsEnabled
116 |                     }), (e1, data) =>
117 | {
118 |     Pressed?.Invoke(sender, data);
119 | }, sender.Text, MessageBoxTypeEnum.None,
120 |                     MessageBoxButtonsDirectionEnum.Vertical);
121 |             }
122 |             else
123 |             {
124 |                 Pressed?.Invoke(sender, sender.Data);
125 |             }
126 |         }
127 | 
128 |         public override void ClearEvents()
129 |         {
130 |             base.ClearEvents();
131 |             Pressed = null;
132 |         }
133 |     }
134 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/StoreboardNavigationEngine.cs:
--------------------------------------------------------------------------------
  1 | using System.Collections.Generic;
  2 | using System.Linq;
  3 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
  4 | 
  5 | namespace EntityFX.ScoreboardUI
  6 | {
  7 |     internal class StoreboardNavigationEngine : IStoreboardNavigationEngine
  8 |     {
  9 |         private readonly Stack<StateItem> _scoreboardNavigationStack = new Stack<StateItem>();
 10 | 
 11 |         public Stack<Scoreboard> NavigationStack
 12 |         {
 13 |             get { return new Stack<Scoreboard>(_scoreboardNavigationStack.Select(_ => _.Scoreboard)); }
 14 |         }
 15 | 
 16 |         public StateItem Previous { get; private set; }
 17 | 
 18 |         public StateItem Current { get; set; }
 19 | 
 20 |         public void GoBack(object data = null)
 21 |         {
 22 |             Previous = _scoreboardNavigationStack.Pop();
 23 |             if (_scoreboardNavigationStack.Count != 0)
 24 |             {
 25 |                 StateItem stateItem = _scoreboardNavigationStack.Peek();
 26 |                 stateItem.NavigationData = data;
 27 |                 Current = stateItem;
 28 |                 Current.Scoreboard.IsVisible = true;
 29 |                 Current.Scoreboard.NavigateInternal(NavigationType.GoBack, stateItem.NavigationData);
 30 |                 Current.Scoreboard.Render();
 31 |             }
 32 |             else
 33 |             {
 34 |                 Current = null;
 35 |             }
 36 |         }
 37 | 
 38 |         public void Navigate<TScoreboard>(object data = null) where TScoreboard : Scoreboard, new()
 39 |         {
 40 |             StateItem firstOrDefault =
 41 |                 _scoreboardNavigationStack.FirstOrDefault(_ => _.Scoreboard is TScoreboard);
 42 |             Scoreboard scoreboard;
 43 |             StateItem state = null;
 44 |             if (firstOrDefault != null)
 45 |             {
 46 |                 scoreboard = firstOrDefault.Scoreboard;
 47 | 
 48 |                 NavigateBackward(firstOrDefault);
 49 |                 state = firstOrDefault;
 50 |             }
 51 |             else
 52 |             {
 53 |                 Current.ScoreboardState.IsNavigating = true;
 54 |                 scoreboard = new TScoreboard();
 55 |             }
 56 |             Navigate(scoreboard, state, data);
 57 |         }
 58 | 
 59 |         public void NavigateFromStart<TScoreboard>(object data = null) where TScoreboard : Scoreboard, new()
 60 |         {
 61 |             Current.ScoreboardState.IsNavigating = true;
 62 |             NavigateBackward(_scoreboardNavigationStack.First());
 63 |             Scoreboard scoreboard = new TScoreboard();
 64 |             Navigate(scoreboard, null, data);
 65 |         }
 66 | 
 67 |         private void NavigateBackward(StateItem stateItem)
 68 |         {
 69 |             var scoreboard = stateItem.Scoreboard;
 70 | 
 71 |             if (scoreboard != null)
 72 |             {
 73 |                 Scoreboard popScoreboard = null;
 74 |                 do
 75 |                 {
 76 |                     popScoreboard = _scoreboardNavigationStack.Pop().Scoreboard;
 77 |                     if (scoreboard != popScoreboard)
 78 |                     {
 79 |                         popScoreboard.Dispose();
 80 |                     }
 81 |                 } while (popScoreboard != null && scoreboard != popScoreboard);
 82 |             }
 83 | 
 84 |             scoreboard.IsVisible = true;
 85 |         }
 86 | 
 87 |         public void Navigate(Scoreboard scoreboard, StateItem state = null, object data = null)
 88 |         {
 89 |             Current.ScoreboardState.IsNavigating = true;
 90 |             var stateItem = state ?? new StateItem
 91 |             {
 92 |                 Scoreboard = scoreboard,
 93 |                 ScoreboardState = new ScoreboardState(),
 94 |                 NavigationData = data
 95 |             };
 96 | 
 97 |             Current = stateItem;
 98 | 
 99 |             if (_scoreboardNavigationStack.Count > 0)
100 |             {
101 |                 StateItem currentStackItem = _scoreboardNavigationStack.Peek();
102 |                 Previous = currentStackItem;
103 |                 Previous.Scoreboard.IsVisible = false;
104 |             }
105 | 
106 |             _scoreboardNavigationStack.Push(stateItem);
107 |             if (!Current.ScoreboardState.ScoreboardInitialized) Current.Scoreboard.InitializeInternal();
108 |             Current.Scoreboard.NavigateInternal(NavigationType.Navigate, stateItem.NavigationData);
109 |             ScoreboardContext.CurrentState.ResetFocus();
110 |             Current.ScoreboardState.IsNavigating = false;
111 |             scoreboard.Render();
112 |         }
113 | 
114 |         public void Reset()
115 |         {
116 |             NavigateBackward(_scoreboardNavigationStack.First());
117 |             if (_scoreboardNavigationStack.Count > 0)
118 |             {
119 |                 var popScoreboard = _scoreboardNavigationStack.Pop().Scoreboard;
120 |                 popScoreboard?.Dispose();
121 |             }
122 |             Current = null;
123 |             Previous = null;
124 |         }
125 |     }
126 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Controls/ControlBase.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Reflection;
  4 | using EntityFX.ScoreboardUI.Drawing;
  5 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
  6 | using EntityFX.ScoreboardUI.Exceptions;
  7 | 
  8 | namespace EntityFX.ScoreboardUI.Elements.Controls
  9 | {
 10 |     public abstract class ControlBase : UiElement, ICloneable
 11 |     {
 12 | 
 13 |         private readonly object _object = new object();
 14 |         private Scoreboard _parentScoreboard;
 15 | 
 16 | 
 17 |         private string _textValue;
 18 |         private bool _isFocused;
 19 | 
 20 |         public ControlBase()
 21 |         {
 22 |             Position = PositionEnum.ABSOLUTE;
 23 |             Text = GetType().Name;
 24 |             DisplayText = true;
 25 |             CanFocus = true;
 26 |             CompositionLevel = 0;
 27 |         }
 28 | 
 29 |         public UiElement Parent { get; internal set; }
 30 | 
 31 |         public PositionEnum Position { get; set; }
 32 | 
 33 |         public bool CanFocus { get; set; }
 34 | 
 35 |         public virtual bool IsFocused
 36 |         {
 37 |             get { return _isFocused; }
 38 |             internal set
 39 |             {
 40 |                 _isFocused = value;
 41 |                 OnFocusChanged(value);
 42 |             }
 43 |         }
 44 | 
 45 |         public int TabIndex { get; set; }
 46 | 
 47 |         public int CompositionLevel { get; internal set; }
 48 | 
 49 |         public virtual string Text
 50 |         {
 51 |             get { return _textValue; }
 52 |             set
 53 |             {
 54 |                 lock (_object)
 55 |                 {
 56 |                     _textValue = value;
 57 |                     ReRender();
 58 |                     OnTextChanged(new EventArgs());
 59 |                 }
 60 |             }
 61 |         }
 62 | 
 63 |         internal virtual string VisibleText
 64 |         {
 65 |             get { return Text; }
 66 |         }
 67 | 
 68 |         public Scoreboard ParentScoreboard
 69 |         {
 70 |             get
 71 |             {
 72 |                 if (_parentScoreboard != null)
 73 |                 {
 74 |                     return _parentScoreboard;
 75 |                 }
 76 |                 UiElement parent = this;
 77 |                 while (!(parent is Scoreboard) && parent != null)
 78 |                 {
 79 |                     parent = (parent as ControlBase).Parent;
 80 |                 }
 81 |                 _parentScoreboard = parent as Scoreboard;
 82 |                 return _parentScoreboard;
 83 |             }
 84 |         }
 85 | 
 86 |         public bool DisplayText { get; set; }
 87 | 
 88 |         public event EventHandler TextChanged;
 89 | 
 90 |         public event EventHandler<bool> FocusChanged;
 91 | 
 92 |         public void Show()
 93 |         {
 94 |             IsVisible = true;
 95 |             ReRender();
 96 |         }
 97 | 
 98 |         public void Hide()
 99 |         {
100 |             IsVisible = false;
101 |             ReRender();
102 |         }
103 | 
104 |         public virtual void Focus()
105 |         {
106 |             if (CanFocus)
107 |             {
108 |                 IsFocused = true;
109 |                 ScoreboardContext.CurrentState.ChangeFocus(this);
110 |             }
111 |             else
112 |             {
113 |                 throw new ControlCantBeFocusedException("Control cannot be focused", this);
114 |             }
115 |         }
116 | 
117 |         public virtual void OnFocusChanged(bool isFocused)
118 |         {
119 |             FocusChanged?.Invoke(this, isFocused);
120 |         }
121 | 
122 |         protected virtual void OnTextChanged(EventArgs e)
123 |         {
124 |             EventHandler handler = TextChanged;
125 |             if (handler != null)
126 |             {
127 |                 handler(this, e);
128 |             }
129 |         }
130 | 
131 | 
132 |         protected virtual void ReRender()
133 |         {
134 |             Render();
135 |         }
136 | 
137 |         protected override bool PreRender()
138 |         {
139 |             return base.PreRender() && ParentScoreboard != null && ParentScoreboard.IsVisible;
140 |         }
141 | 
142 |         protected override void PostRender()
143 |         {
144 |             
145 |         }
146 | 
147 |         public Point AbsoluteLocation()
148 |         {
149 |             Point res = Location;
150 |             UiElement parent = Parent;
151 |             ControlBase control;
152 |             do
153 |             {
154 |                 control = parent as ControlBase;
155 |                 if (parent != null)
156 |                 {
157 |                     res = res + parent.Location;
158 |                 }
159 | 
160 |                 if (control != null)
161 |                 {
162 |                     parent = control.Parent;
163 |                 }
164 |             } while (control != null);
165 |             return res;
166 |         }
167 | 
168 |         public object Clone()
169 |         {
170 |             return this.Copy();
171 |         }
172 | 
173 | 
174 |         public override void ClearEvents()
175 |         {
176 |             base.ClearEvents();
177 |             TextChanged = null;
178 |             FocusChanged = null;
179 |         }
180 |     }
181 | }       


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/ScoreboardState.cs:
--------------------------------------------------------------------------------
  1 | using System.Collections.Generic;
  2 | using System.Linq;
  3 | using EntityFX.ScoreboardUI.Elements.Controls;
  4 | using EntityFX.ScoreboardUI.Elements.Controls.Menu;
  5 | using EntityFX.ScoreboardUI.Elements.Controls.StatusBar;
  6 | 
  7 | namespace EntityFX.ScoreboardUI
  8 | {
  9 |     internal class ScoreboardState : IScoreboardState
 10 |     {
 11 |         private readonly List<ControlBase> _controlsList = new List<ControlBase>();
 12 |         private int _internalFocusIndex;
 13 |         private int _internalTabIndex;
 14 | 
 15 |         public ScoreboardState()
 16 |         {
 17 |             ScoreboardInitialized = false;
 18 |         }
 19 | 
 20 |         public void ChangeFocus(ControlBase control)
 21 |         {
 22 |             ControlBase oldFocusedElement = FocusedElement;
 23 |             SetFocus(control);
 24 |             _internalFocusIndex = _controlsList.IndexOf(control);
 25 |             oldFocusedElement?.Render();
 26 |             control.Render();
 27 |         }
 28 | 
 29 |         public void SetFocus(ControlBase control)
 30 |         {
 31 |             foreach (ControlBase itemControl in _controlsList)
 32 |             {
 33 |                 itemControl.IsFocused = false;
 34 |             }
 35 |             control.IsFocused = true;
 36 |         }
 37 | 
 38 |         public int InternalTabIndex
 39 |         {
 40 |             get { return _internalTabIndex; }
 41 |         }
 42 | 
 43 |         public IEnumerable<ControlBase> SortedControlsByFocusIndex { get; private set; }
 44 | 
 45 |         public IEnumerable<ControlBase> ControlsList
 46 |         {
 47 |             get { return _controlsList; }
 48 |         }
 49 | 
 50 |         public bool ScoreboardInitialized { get; private set; }
 51 |         public bool IsNavigating { get; set; }
 52 | 
 53 |         public ControlBase FocusedElement
 54 |         {
 55 |             get { return _controlsList.Count > 0 && _internalFocusIndex >=0 && _internalFocusIndex < _controlsList.Count ? _controlsList[_internalFocusIndex] : null; }
 56 |         }
 57 | 
 58 |         public void Initialized()
 59 |         {
 60 |             ScoreboardInitialized = true;
 61 |             SortControlsByFocusIndex();
 62 |         }
 63 | 
 64 |         public void AddToControlList(ControlBase control)
 65 |         {
 66 |             _internalTabIndex++;
 67 |             control.TabIndex = _internalTabIndex;
 68 |             _controlsList.Add(control);
 69 |             if (ScoreboardInitialized)
 70 |             {
 71 |                 SortControlsByFocusIndex();
 72 |             }
 73 |         }
 74 | 
 75 |         public void NextFocus()
 76 |         {
 77 |             ControlBase control;
 78 |             ControlBase previousControl = null;
 79 |             if (_controlsList.Count == 0) return;
 80 | 
 81 |             if (_controlsList.Count == 1)
 82 |             {
 83 |                 control = _controlsList[0];
 84 |             }
 85 |             else
 86 |             {
 87 |                 previousControl = _internalFocusIndex == -1 ? _controlsList[0] : _controlsList[_internalFocusIndex];
 88 |                 do
 89 |                 {
 90 |                     _internalFocusIndex++;
 91 | 
 92 |                     if (_internalFocusIndex == _controlsList.Count)
 93 |                     {
 94 |                         _internalFocusIndex = 0;
 95 |                     }
 96 | 
 97 |                     control = _controlsList[_internalFocusIndex];
 98 |                 } while (!control.IsEnabled || !control.IsVisible || (!(control is ButtonBase)
 99 |                                                 && !(control is TextBox)
100 |                                                 && !(control is StatusStripButton)
101 |                                                 && !(control is MenuItemButton<object>)
102 |                                                 && !(control is ComboBox)));
103 | 
104 |             }
105 | 
106 |             SetFocus(control);
107 |             previousControl?.Render();
108 |             control.Render();
109 |         }
110 | 
111 |         public void PreviousFocus()
112 |         {
113 |             ControlBase control;
114 |             ControlBase oldFocusedElement = FocusedElement;
115 |             if (_controlsList.Count == 0) return;
116 | 
117 |             var previousControl = _internalFocusIndex == _controlsList.Count - 1 ? _controlsList[0] : _controlsList[_internalFocusIndex];
118 |             do
119 |             {
120 |                 _internalFocusIndex--;
121 | 
122 |                 if (_internalFocusIndex == -1)
123 |                 {
124 |                     _internalFocusIndex = _controlsList.Count - 1;
125 |                 }
126 | 
127 |                 control = _controlsList[_internalFocusIndex];
128 |             } while (!control.IsEnabled || !control.IsVisible || (!(control is ButtonBase)
129 |                                             && !(control is TextBox)
130 |                                             && !(control is StatusStripButton)
131 |                                             && !(control is MenuItemButton<object>)
132 |                                             && !(control is ComboBox)));
133 | 
134 |             SetFocus(control);
135 |             oldFocusedElement?.Render();
136 |             previousControl.Render();
137 |             control.Render();
138 |         }
139 | 
140 |         public void ResetFocus()
141 |         {
142 |             _internalFocusIndex = -1;
143 |             NextFocus();
144 |         }
145 | 
146 |         private void SortControlsByFocusIndex()
147 |         {
148 |             SortedControlsByFocusIndex = _controlsList.OrderBy(key => key.TabIndex);
149 |         }
150 | 
151 |         public void RemoveFromControlList(ControlBase control)
152 |         {
153 | 
154 |             var controls = _controlsList.Where(i => i.TabIndex > control.TabIndex);
155 |             var controlIndex = _controlsList.IndexOf(control);
156 |             if (controlIndex >=0 && controlIndex < _controlsList.Count)
157 |             {
158 |                var nextItems = _controlsList.GetRange(controlIndex, _controlsList.Count - controlIndex);
159 |                 foreach (var item in nextItems)
160 |                 {
161 |                     item.TabIndex--;
162 |                 }
163 |             }
164 | 
165 | 
166 |             _controlsList.Remove(control);
167 |             if (ScoreboardInitialized)
168 |             {
169 |                 SortControlsByFocusIndex();
170 |             }
171 |         }
172 |     }
173 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Scoreboards/Scoreboard.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using EntityFX.ScoreboardUI.Drawing;
  3 | using EntityFX.ScoreboardUI.Elements.Controls;
  4 | using EntityFX.ScoreboardUI.Elements.Controls.Menu;
  5 | using EntityFX.ScoreboardUI.Elements.Controls.StatusBar;
  6 | 
  7 | namespace EntityFX.ScoreboardUI.Elements.Scoreboards
  8 | {
  9 |     public class Scoreboard : UiElement, ISizable, IBorderable, IDisposable
 10 |     {
 11 |         public Scoreboard(Panel rootPanel)
 12 |         {
 13 |             RootPanel = rootPanel;
 14 |             RootPanel.Parent = this;
 15 |             Title = GetType().Name;
 16 |             TitleAligment = TitleAligment.Center;
 17 |             IsBorderVisible = true;
 18 |             BorderBackgroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.PrimaryBackgroundColor;
 19 |             BorderForegroundColor = ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.BorderColor;
 20 |             Size = new Size
 21 |             {
 22 |                 Height = ScoreboardContext.RenderEngine.RenderOptions.WindowHeight,
 23 |                 Width = ScoreboardContext.RenderEngine.RenderOptions.WindowWidth
 24 |             };
 25 |         }
 26 | 
 27 |         public string Title { get; set; }
 28 | 
 29 |         public TitleAligment TitleAligment { get; set; }
 30 | 
 31 |         public Panel RootPanel { get; internal set; }
 32 |         public bool IsBorderVisible { get; set; }
 33 | 
 34 |         public ConsoleColor BorderBackgroundColor { get; set; }
 35 |         public ConsoleColor BorderForegroundColor { get; set; }
 36 |         public Size Size { get; set; }
 37 | 
 38 |         private StatusStrip _statusStrip;
 39 |         public StatusStrip StatusStrip
 40 |         {
 41 |             get { return _statusStrip; }
 42 |             set
 43 |             {
 44 |                 _statusStrip = value;
 45 |                 _statusStrip.Parent = this;
 46 |                 var stripLocation = new Point
 47 |                 {
 48 |                     Left = IsBorderVisible ? 1 : 0,
 49 |                     Top = Size.Height - 1
 50 |                 };
 51 |                 _statusStrip.Location = stripLocation;
 52 |             }
 53 |         }
 54 | 
 55 |         private Menu _menu;
 56 |         public Menu Menu
 57 |         {
 58 |             get { return _menu; }
 59 |             set
 60 |             {
 61 |                 if (value == null)
 62 |                 {
 63 |                     _menu.Parent = null;
 64 |                     _menu = null;
 65 |                     return;
 66 |                 }
 67 |                 _menu = value;
 68 |                 _menu.Parent = this;
 69 |                 var stripLocation = new Point
 70 |                 {
 71 |                     Left = IsBorderVisible ? 1 : 0,
 72 |                     Top = 1
 73 |                 };
 74 |                 _menu.Location = stripLocation;
 75 |             }
 76 |         }
 77 | 
 78 |         public event EventHandler<NavigatedEventArgs> ScoreboardNavigate;
 79 | 
 80 |         public event EventHandler EscapePress;
 81 | 
 82 |         public void Navigate<TScoreboard>(object data = null) where TScoreboard : Scoreboard, new()
 83 |         {
 84 |             if (PreNavigate())
 85 |             {
 86 |                 ScoreboardContext.Navigation.Navigate<TScoreboard>(data);
 87 |             }
 88 |         }
 89 | 
 90 |         public void NavigateFromStart<TScoreboard>(object data = null) where TScoreboard : Scoreboard, new()
 91 |         {
 92 |             if (PreNavigate())
 93 |             {
 94 |                 ScoreboardContext.Navigation.NavigateFromStart<TScoreboard>(data);
 95 |             }
 96 |         }
 97 | 
 98 |         protected virtual bool PreNavigate()
 99 |         {
100 |             return true;
101 |         }
102 | 
103 |         public virtual void GoBack(object data = null)
104 |         {
105 |             if (PreGoBack())
106 |             {
107 |                 ScoreboardContext.Navigation.GoBack(data);
108 |             }
109 |         }
110 | 
111 |         protected virtual bool PreGoBack()
112 |         {
113 |             return true;
114 |         }
115 | 
116 |         public override void PressKey(KeyPressEventArgs e)
117 |         {
118 |             base.PressKey(e);
119 |             var focusedElement = ScoreboardContext.CurrentState.FocusedElement;
120 |             if (focusedElement != null)
121 |                 focusedElement.PressKey(e);
122 |         }
123 | 
124 | 
125 | 
126 | 
127 |         protected virtual void OnScoreboardNavigated(NavigatedEventArgs e)
128 |         {
129 |             EventHandler<NavigatedEventArgs> handler = ScoreboardNavigate;
130 |             if (handler != null)
131 |             {
132 |                 handler(this, e);
133 |             }
134 |         }
135 | 
136 |         public void PressEscape(KeyPressEventArgs e)
137 |         {
138 |             EventHandler handler = EscapePress;
139 |             if (handler != null)
140 |             {
141 |                 handler(this, new KeyPressEventArgs
142 |                 {
143 |                     KeyInfo = e.KeyInfo
144 |                 });
145 |             }
146 |             OnEscapePressed();
147 |         }
148 | 
149 |         protected virtual void OnEscapePressed(object data = null)
150 |         {
151 |             GoBack(data);
152 |         }
153 | 
154 |         internal void InitializeInternal()
155 |         {
156 |             if (PreInitialize())
157 |             {
158 |                 Initialize();
159 |                 OnInitialized(new EventArgs());
160 |                 ScoreboardContext.CurrentState.Initialized();
161 |                 PostInitialize();
162 |             }
163 |         }
164 | 
165 |         internal void NavigateInternal(NavigationType navigationType, object navigationData)
166 |         {
167 |             var args = new NavigatedEventArgs() { Data = navigationData, NavigationType = navigationType };
168 |             OnScoreboardNavigated(args);
169 |             ScoreboardNavigated(args);
170 |         }
171 | 
172 |         protected virtual void ScoreboardNavigated(NavigatedEventArgs e)
173 |         {
174 | 
175 |         }
176 | 
177 |         protected override void PostRender()
178 |         {
179 |         }
180 | 
181 |         public override void Initialize()
182 |         {
183 |             base.Initialize();
184 |             foreach (var rootPanelControl in RootPanel.Controls)
185 |             {
186 |                 rootPanelControl.Initialize();
187 |             }
188 |         }
189 | 
190 |         protected override void Dispose(bool disposing)
191 |         {
192 |             if (disposing)
193 |             {
194 |                 ClearEvents();
195 |                 RootPanel.Dispose();
196 |             }
197 | 
198 |             base.Dispose(disposing);
199 |         }
200 | 
201 |         public override void ClearEvents()
202 |         {
203 |             base.ClearEvents();
204 |             EscapePress = null;
205 |             ScoreboardNavigate = null;
206 |         }
207 |     }
208 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI.TestExample/MainScoreboard.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Timers;
  4 | using EntityFX.ScoreboardUI;
  5 | using EntityFX.ScoreboardUI.Drawing;
  6 | using EntityFX.ScoreboardUI.Elements.Controls;
  7 | using EntityFX.ScoreboardUI.Elements.Controls.Charts;
  8 | using EntityFX.ScoreboardUI.Elements.Controls.Menu;
  9 | using EntityFX.ScoreboardUI.Elements.Controls.StatusBar;
 10 | using EntityFX.ScoreboardUI.Elements.Controls.Table;
 11 | using EntityFX.ScoreboardUI.Elements.MessageBox;
 12 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
 13 | 
 14 | namespace EntityFx.ScorbordUI.TestExample
 15 | {
 16 |     class MainScoreboard : Scoreboard, IDisposable
 17 |     {
 18 |         private Checkbox _checkbox1;
 19 | 
 20 |         private Checkbox _checkbox2;
 21 | 
 22 |         private Checkbox _checkbox3;
 23 | 
 24 |         private Checkbox _checkbox4;
 25 | 
 26 |         private Label _label1;
 27 | 
 28 |         private RadioButton _radioButton1;
 29 | 
 30 |         private RadioButton _radioButton2;
 31 | 
 32 |         private RadioButton _radioButton3;
 33 | 
 34 |         private TextBox _textBox1;
 35 | 
 36 |         private DateTimeBox _dateTimeBox1;
 37 | 
 38 |         private Button _button1;
 39 | 
 40 |         private Button _button2;
 41 | 
 42 |         private Button _button3;
 43 | 
 44 |         private ProgressBar _progressBar1;
 45 | 
 46 |         private Timer _timer = new Timer(500);
 47 | 
 48 |         private Timer _timer2 = new Timer(200);
 49 | 
 50 |         private Button _bnext1;
 51 | 
 52 |         private Button _bnext2;
 53 | 
 54 |         private Button _bnext3;
 55 | 
 56 |         private BorderPanel _panel1;
 57 | 
 58 |         private StatusStripItem _timeStripItem;
 59 | 
 60 |         private StatusStripProgressBar _statusStripProgressBar;
 61 | 
 62 |         private ComboBox _comboBox1;
 63 | 
 64 |         private Table _table1;
 65 | 
 66 |         private Image _image;
 67 | 
 68 |         private Menu _menu;
 69 | 
 70 |         private NumericBox _numericBox1;
 71 |         private PlotChart _plotChart;
 72 | 
 73 |         public MainScoreboard()
 74 |             : base(new Panel())
 75 |         {
 76 |         }
 77 | 
 78 |         public override void Initialize()
 79 |         {
 80 |             _menu = new Menu();
 81 |             var menuButton1 = new MenuItemButton<object>()
 82 |             {
 83 |                 Text = "Menu 1",
 84 |             };
 85 |             menuButton1.AddChild(new MenuItemButton<object>()
 86 |             {
 87 |                 Text = "Submenu 1.1"
 88 |             });
 89 |             _menu.AddChild(menuButton1);
 90 |             var menuButton2 = new MenuItemButton<object>()
 91 |             {
 92 |                 Text = "Menu 2",
 93 |             };
 94 |             menuButton2.AddChild(new MenuItemButton<object>()
 95 |             {
 96 |                 Text = "Submenu 2.1"
 97 |             });
 98 |             menuButton2.AddChild(new MenuItemButton<object>()
 99 |             {
100 |                 Text = "Submenu 2.2"
101 |             });
102 |             _menu.AddChild(menuButton2);
103 |             Menu = _menu;
104 | 
105 |             _checkbox1 = new Checkbox { Location = new Point { Left = 3, Top = 5 }, Text = "Checkbox tentative" };
106 |             _checkbox1.CheckedChanged += checkbox1_CheckedChanged;
107 |             RootPanel.AddChild(_checkbox1);
108 | 
109 |             _checkbox2 = new Checkbox { Location = new Point { Left = 3, Top = 7 }, IsChecked = true, Text = "Checkbox checked" };
110 |             RootPanel.AddChild(_checkbox2);
111 | 
112 |             _checkbox3 = new Checkbox { Location = new Point { Left = 3, Top = 9 }, IsChecked = false, Text = "Checkbox unchecked" };
113 |             RootPanel.AddChild(_checkbox3);
114 | 
115 |             _checkbox4 = new Checkbox { Location = new Point { Left = 3, Top = 11 }, IsChecked = false, Text = "Checkbox disabled", IsEnabled = false };
116 |             RootPanel.AddChild(_checkbox4);
117 | 
118 |             _label1 = new Label { Location = new Point { Left = 3, Top = 19 }, Text = "Label" };
119 |             RootPanel.AddChild(_label1);
120 | 
121 |             _radioButton1 = new RadioButton { Location = new Point { Left = 3, Top = 13 }, Text = "Radio unchecked" };
122 |             RootPanel.AddChild(_radioButton1);
123 | 
124 |             _radioButton2 = new RadioButton { Location = new Point { Left = 3, Top = 15 }, Text = "Radio checked", IsChecked = true };
125 |             RootPanel.AddChild(_radioButton2);
126 | 
127 |             _radioButton3 = new RadioButton { Location = new Point { Left = 3, Top = 17 }, Text = "Radio checked", IsChecked = true, IsEnabled = false };
128 |             RootPanel.AddChild(_radioButton3);
129 | 
130 |             _textBox1 = new TextBox { Location = new Point { Left = 29, Top = 16 } };
131 |             _textBox1.TextChanged += textBox1_TextChanged;
132 |             RootPanel.AddChild(_textBox1);
133 | 
134 |             _dateTimeBox1 = new DateTimeBox() { Location = new Point { Left = 29, Top = 18 } };
135 |             RootPanel.AddChild(_dateTimeBox1);
136 | 
137 |             _numericBox1 = new NumericBox() { Location = new Point { Left = 29, Top = 20 } };
138 |             RootPanel.AddChild(_numericBox1);
139 | 
140 |             _button1 = new Button { Location = new Point { Left = 3, Top = 22 }, Width = 10 };
141 |             _button1.Pressed += button1_Pressed;
142 |             RootPanel.AddChild(_button1);
143 | 
144 |             _button2 = new Button { Location = new Point { Left = 16, Top = 22 }, Width = 10, IsEnabled = false, Text = "Disabled button" };
145 |             _button2.Pressed += button2_Pressed;
146 |             RootPanel.AddChild(_button2);
147 | 
148 |             _progressBar1 = new ProgressBar { Location = new Point { Left = 3, Top = 3 }, Width = 74, TextAligment = TitleAligment.Left};
149 |             RootPanel.AddChild(_progressBar1);
150 | 
151 |             _bnext1 = new Button { Location = new Point { Left = 40, Top = 22 }, Width = 10, Text = "Next 1", Tag = 1 };
152 |             _bnext1.Pressed += bNextPressed;
153 |             RootPanel.AddChild(_bnext1);
154 | 
155 |             _bnext2 = new Button { Location = new Point { Left = 51, Top = 22 }, Width = 10, Text = "Next 2", Tag = 2 };
156 |             _bnext2.Pressed += bNextPressed;
157 |             RootPanel.AddChild(_bnext2);
158 | 
159 |             _bnext3 = new Button { Location = new Point { Left = 62, Top = 22 }, Width = 10, Text = "Next 3", Tag = 3 };
160 |             _bnext3.Pressed += bNextPressed;
161 |             RootPanel.AddChild(_bnext3);
162 | 
163 |             _panel1 = new BorderPanel
164 |             {
165 |                 Location = new Point { Left = 28, Top = 4 },
166 |                 Size = new Size { Height = 7, Width = 25 }
167 |             };
168 |             RootPanel.AddChild(_panel1);
169 | 
170 |             var subRadiobuton1 = new RadioButton
171 |             {
172 |                 Location = new Point
173 |                 {
174 |                     Left = 1,
175 |                     Top = 1
176 |                 }
177 |             };
178 |             _panel1.AddChild(subRadiobuton1);
179 | 
180 |             var subRadiobuton2 = new RadioButton
181 |             {
182 |                 Location = new Point
183 |                 {
184 |                     Left = 1,
185 |                     Top = 3
186 |                 }
187 |             };
188 |             _panel1.AddChild(subRadiobuton2);
189 | 
190 |             var subRadiobuton3 = new RadioButton
191 |             {
192 |                 Location = new Point
193 |                 {
194 |                     Left = 1,
195 |                     Top = 5
196 |                 }
197 |             };
198 |             _panel1.AddChild(subRadiobuton3);
199 | 
200 | 
201 |             _comboBox1 = new ComboBox
202 |             {
203 |                 Location = new Point { Left = 29, Top = 12 },
204 |                 VisibleItemsCount = 7
205 |             };
206 |             _comboBox1.Items.AddRange(new[]
207 |             {
208 |                 new ComboBoxItem(){ Key= 1, Text="EntityFX"},
209 |                 new ComboBoxItem(){ Key= 2, Text="Green.Dragon"},
210 |                 new ComboBoxItem(){ Key= 3, Text="Guzalianna"},
211 |                 new ComboBoxItem(){ Key= 4, Text="Prozz"},
212 |                 new ComboBoxItem(){ Key= 5, Text="Aik2029"},
213 |                 new ComboBoxItem(){ Key= 6, Text="Zombie"},
214 |                 new ComboBoxItem(){ Key= 7, Text="Wesker"},
215 |                 new ComboBoxItem(){ Key= 8, Text="Perez"},
216 |                 new ComboBoxItem(){ Key= 9, Text="Chuvak"},
217 |                 new ComboBoxItem(){ Key= 10, Text="Magistr"},
218 |                 new ComboBoxItem(){ Key= 11, Text="Mad"},
219 |                 new ComboBoxItem(){ Key= 12, Text="XOBAH"}
220 |             });
221 |             RootPanel.AddChild(_comboBox1);
222 | 
223 |             RootPanel.AddChild(new Checkbox { Location = new Point { Left = 29, Top = 14 }, Text = "Checkbox for overlapp" });
224 | 
225 |             _image = Image.FromString(
226 | @"───▄▄▄
227 | ─▄▀░▄░▀▄
228 | ─█░█▄▀░█
229 | ─█░▀▄▄▀█▄█▄▀
230 | ▄▄█▄▄▄▄███▀
231 | ");
232 |             _image.Location = new Point() { Left = 55, Top = 4 };
233 |             RootPanel.AddChild(_image);
234 | 
235 | 
236 |             _plotChart = new PlotChart()
237 |             {
238 |                 Size = new Size() { Height = 10, Width = 30 },
239 |                 Location = new Point() { Left = 48, Top = 11 },
240 |                 PlotSymbol = ':'
241 |             };
242 |             _plotChart.Points = GenerateSinChartPoints(_plotChart.Size, 7);
243 |             RootPanel.AddChild(_plotChart);
244 | 
245 |             StatusStrip = new StatusStrip();
246 |             StatusStrip.AddChild(new StatusStripLabel
247 |             {
248 |                 Text = "Item 1"
249 |             });
250 | 
251 |             StatusStrip.AddChild(new StatusStripLabel
252 |             {
253 |                 Text = "Item 2"
254 |             });
255 | 
256 |             _timeStripItem = new StatusStripLabel
257 |             {
258 |                 Text = "Item 3",
259 |                 ItemLocation = ItemLocationEnum.Right
260 |             };
261 |             StatusStrip.AddChild(_timeStripItem);
262 | 
263 |             StatusStrip.AddChild(new StatusStripLabel
264 |             {
265 |                 Text = "Item 4",
266 |                 ItemLocation = ItemLocationEnum.Right
267 |             });
268 | 
269 |             StatusStrip.AddChild(new StatusStripButton
270 |             {
271 |                 Text = "But 1",
272 |                 ItemLocation = ItemLocationEnum.Left
273 |             });
274 | 
275 |             StatusStrip.AddChild(new StatusStripButton
276 |             {
277 |                 Text = "But 2",
278 |                 ItemLocation = ItemLocationEnum.Left
279 |             });
280 | 
281 |             _statusStripProgressBar = new StatusStripProgressBar
282 |             {
283 |                 Text = "P: {0}",
284 |                 Width = 14,
285 |                 Minimum = 0,
286 |                 Value = 16,
287 |                 Maximum = 25
288 |             };
289 |             StatusStrip.AddChild(_statusStripProgressBar);
290 | 
291 | 
292 |             Initializetable();
293 | 
294 |             _timer.Elapsed += timer_Elapsed;
295 |             _timer.Start();
296 | 
297 |             _timer2.Elapsed += _timer2_Elapsed;
298 |             _timer2.Start();
299 |         }
300 | 
301 |         private void Initializetable()
302 |         {
303 |             _table1 = new Table();
304 | 
305 |             _table1.Rows.AddRange(new List<ITableRow<ITableCell<ControlBase>, ControlBase>> {
306 |                 new TableHeaderRow
307 |                 {
308 |                     Cells = new List<TableHeaderCell>
309 |                     {
310 |                         new TableHeaderCell(), new TableHeaderCell(), new TableHeaderCell()
311 |                     }
312 |                 },
313 |                 new TableViewRow
314 |                 {
315 |                     Cells = new List<TableCellBase>
316 |                     {
317 |                         new TableCheckboxCell(), new TableViewCell(), new TableViewCell()
318 |                     }
319 |                 }
320 |             });
321 |         }
322 | 
323 |         private int _shiftX = 0;
324 | 
325 |         private void _timer2_Elapsed(object sender, ElapsedEventArgs e)
326 |         {
327 |             if (_statusStripProgressBar.Value >= _statusStripProgressBar.Maximum)
328 |             {
329 |                 _statusStripProgressBar.Value = _statusStripProgressBar.Minimum;
330 |             }
331 |             _statusStripProgressBar.Increment();
332 |             _plotChart.Points = GenerateSinChartPoints(_plotChart.Size, _shiftX);
333 |             _shiftX = _shiftX < _plotChart.Size.Width ? _shiftX + 1 : 0;
334 |         }
335 | 
336 |         private void bNextPressed(object sender, EventArgs e)
337 |         {
338 |             var b = sender as Button;
339 |             if (b != null)
340 |             {
341 |                 switch ((int)b.Tag)
342 |                 {
343 |                     case 1:
344 |                         Navigate<SecondScoreboard>("Some Data");
345 |                         break;
346 |                     case 2:
347 |                         Navigate<ThirdScoreboard>();
348 |                         break;
349 |                     case 3:
350 |                         MessageBox.Show(@"Do you really want to do this\nSecond line is very-very-loooooong and so loooong 
351 | as you seee there as you can\nSecond Line\nLine three\nLine five?\nLine six\nSeven\nEight", MessageBoxResult, "Some title", MessageBoxTypeEnum.Warning, MessageBoxButtonsEnum.YesNo);
352 |                         break;
353 | 
354 |                 }
355 |             }
356 |         }
357 | 
358 |         private void MessageBoxResult(MessageBoxResultEnum result, object data)
359 |         {
360 | 
361 |         }
362 | 
363 |         private void timer_Elapsed(object sender, ElapsedEventArgs e)
364 |         {
365 |             if (_progressBar1.Value >= _progressBar1.Maximum)
366 |             {
367 |                 _progressBar1.Value = _progressBar1.Minimum;
368 |             }
369 |             _progressBar1.Increment();
370 |             _timeStripItem.Text = DateTime.Now.ToLongTimeString();
371 |         }
372 | 
373 |         private void button2_Pressed(object sender, EventArgs e)
374 |         {
375 | 
376 |         }
377 | 
378 |         private void textBox1_TextChanged(object sender, EventArgs e)
379 |         {
380 | 
381 |         }
382 | 
383 |         private void checkbox1_CheckedChanged(ToggleButtonBase sender)
384 |         {
385 | 
386 |         }
387 | 
388 |         private void button1_Pressed(object sender, EventArgs e)
389 |         {
390 | 
391 |         }
392 | 
393 |         protected override void OnKeyPressed(KeyPressEventArgs e)
394 |         {
395 | 
396 |         }
397 | 
398 |         private Point[] GenerateSinChartPoints(Size chartSize, int shiftX)
399 |         {
400 |             var points = new List<Point>();
401 |             for (int i = 0; i < chartSize.Width; i++)
402 |             {
403 |                 int step = chartSize.Width / 4;
404 |                 int shiftY = chartSize.Height / 2;
405 |                 int x, y;
406 |                 x = i + shiftX;
407 |                 y = (int)Math.Floor(Math.Sin(Math.PI / step * x) * shiftY) + shiftY;
408 |                 points.Add(new Point() { Left = i, Top = y });
409 |             }
410 |             return points.ToArray();
411 |         }
412 | 
413 |         public void Dispose()
414 |         {
415 |             _timer.Dispose();
416 |         }
417 |     }
418 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Elements/Scoreboards/MessageBox/MessageBox.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Diagnostics;
  4 | using System.Linq;
  5 | using EntityFX.ScoreboardUI.Drawing;
  6 | using EntityFX.ScoreboardUI.Elements.Controls;
  7 | using EntityFX.ScoreboardUI.Elements.Controls.Menu;
  8 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
  9 | 
 10 | namespace EntityFX.ScoreboardUI.Elements.MessageBox
 11 | {
 12 |     public class MessageBox : Scoreboard
 13 |     {
 14 |         private readonly MessageBoxButtonsEnum _buttonsType;
 15 |         private readonly MessageBoxButtonsDirectionEnum _direction;
 16 |         private readonly IEnumerable<SubmenuContext<object>> _buttonsList;
 17 |         private readonly string _message;
 18 | 
 19 |         private readonly MessageBoxTypeEnum _messageBoxType;
 20 |         private Label _labelMessage;
 21 | 
 22 |         private Image _messageBoxImage;
 23 | 
 24 |         private Action<MessageBoxResultEnum, object> _result;
 25 | 
 26 |         public MessageBox(string message, Action<MessageBoxResultEnum, object> result, string title, MessageBoxTypeEnum type,
 27 |             MessageBoxButtonsEnum buttons,
 28 |             MessageBoxButtonsDirectionEnum direction = MessageBoxButtonsDirectionEnum.Horizontal)
 29 |             : base(new Panel())
 30 |         {
 31 |             _message = message;
 32 |             _buttonsType = buttons;
 33 |             _direction = direction;
 34 |             _messageBoxType = type;
 35 |             _result = result;
 36 |             Title = title;
 37 |         }
 38 | 
 39 |         public MessageBox(string message, Action<MessageBoxResultEnum, object> result, string title, MessageBoxTypeEnum type,
 40 |             MessageBoxButtonsDirectionEnum direction = MessageBoxButtonsDirectionEnum.Horizontal,
 41 |             IEnumerable<SubmenuContext<object>> buttonsList = null)
 42 |             : base(new Panel())
 43 |         {
 44 |             _message = message;
 45 |             _direction = direction;
 46 |             _buttonsList = buttonsList;
 47 |             _messageBoxType = type;
 48 |             _result = result;
 49 |             Title = title;
 50 |         }
 51 | 
 52 |         public static void Show(string message, Action<MessageBoxResultEnum, object> resultAction, string title)
 53 |         {
 54 |             Show(message, resultAction, title, MessageBoxTypeEnum.Info, MessageBoxButtonsEnum.Ok);
 55 |         }
 56 | 
 57 |         public static void Show(string message, Action<MessageBoxResultEnum, object> resultAction, string title,
 58 |             MessageBoxTypeEnum type)
 59 |         {
 60 |             Show(message, resultAction, title, type, MessageBoxButtonsEnum.Ok);
 61 |         }
 62 | 
 63 |         public static void Show(string message,
 64 |     IEnumerable<SubmenuContext<object>> buttonsList, Action<MessageBoxResultEnum, object> resultAction = null,
 65 |     string title = "Message", MessageBoxTypeEnum type = MessageBoxTypeEnum.Info,
 66 |     MessageBoxButtonsDirectionEnum direction = MessageBoxButtonsDirectionEnum.Horizontal)
 67 |         {
 68 |             int width = 0;
 69 |             int height = 0;
 70 |             ScoreboardContext.CurrentState.IsNavigating = true;
 71 |             MessageBox mb;
 72 |             int minWidth = 16;
 73 |             var largestTextLength = buttonsList.Select(i => i.Text.Length).Max();
 74 |             width = largestTextLength + 6 > minWidth ? largestTextLength + 6 : minWidth;
 75 |             int left = ScoreboardContext.Navigation.Current.Scoreboard.Size.Width / 2 - width / 2;
 76 |             int top = ScoreboardContext.Navigation.Current.Scoreboard.Size.Height / 2 - 5;
 77 |             left = left < 0 ? 1 : left;
 78 |             top = top < 0 ? 1 : top;
 79 |             width = width > ScoreboardContext.Navigation.Current.Scoreboard.Size.Width ?
 80 |     ScoreboardContext.Navigation.Current.Scoreboard.Size.Width - 2 :
 81 |     width;
 82 |             height = direction == MessageBoxButtonsDirectionEnum.Horizontal ? 10 : buttonsList.Count() * 2 + 5;
 83 |             height = height > ScoreboardContext.Navigation.Current.Scoreboard.Size.Height ?
 84 |     ScoreboardContext.Navigation.Current.Scoreboard.Size.Height - 2 : height;
 85 |             mb = new MessageBox(message, resultAction, title, type, direction, buttonsList)
 86 |             {
 87 |                 BackgroundColor = GetBackgroundColor(type),
 88 |                 ForegroundColor = GetForegroundColor(type),
 89 |                 BorderForegroundColor = GetForegroundColor(type),
 90 |                 BorderBackgroundColor = GetBackgroundColor(type),
 91 |                 Size = new Size
 92 |                 {
 93 |                     Height = height,
 94 |                     Width = width
 95 |                 },
 96 |                 Location = new Point
 97 |                 {
 98 |                     Left = left,
 99 |                     Top = top
100 |                 }
101 |             };
102 |             ScoreboardContext.Navigation.Navigate(mb);
103 |             ScoreboardContext.RenderEngine.ConsoleAdapter.Beep();
104 |         }
105 | 
106 |         public static void Show(string message, Action<MessageBoxResultEnum, object> resultAction = null,
107 |             string title = "Message", MessageBoxTypeEnum type = MessageBoxTypeEnum.Info,
108 |             MessageBoxButtonsEnum buttons = MessageBoxButtonsEnum.Ok,
109 |             MessageBoxButtonsDirectionEnum direction = MessageBoxButtonsDirectionEnum.Horizontal)
110 |         {
111 | 
112 |             int width = 0;
113 |             ScoreboardContext.CurrentState.IsNavigating = true;
114 |             MessageBox mb;
115 |             int minWidth = ScoreboardContext.Navigation.Current.Scoreboard.Size.Width / 2;
116 |             width = message.Length > minWidth ? message.Length + 2 : minWidth;
117 |             int left = ScoreboardContext.Navigation.Current.Scoreboard.Size.Width / 2 - width / 2;
118 |             int top = ScoreboardContext.Navigation.Current.Scoreboard.Size.Height / 2 - 4;
119 |             left = left < 0 ? 1 : left;
120 |             top = top < 0 ? 1 : top;
121 |             width = width > ScoreboardContext.Navigation.Current.Scoreboard.Size.Width ?
122 |                 ScoreboardContext.Navigation.Current.Scoreboard.Size.Width - 2 :
123 |                 width;
124 |             mb = new MessageBox(message, resultAction, title, type, buttons, direction)
125 |             {
126 |                 BackgroundColor = GetBackgroundColor(type),
127 |                 ForegroundColor = GetForegroundColor(type),
128 |                 BorderForegroundColor = GetForegroundColor(type),
129 |                 BorderBackgroundColor = GetBackgroundColor(type),
130 |                 Size = new Size
131 |                 {
132 |                     Height = direction == MessageBoxButtonsDirectionEnum.Horizontal ? 10 : 20,
133 |                     Width = width
134 |                 },
135 |                 Location = new Point
136 |                 {
137 |                     Left = left,
138 |                     Top = top
139 |                 }
140 |             };
141 |             ScoreboardContext.Navigation.Navigate(mb);
142 |             ScoreboardContext.RenderEngine.ConsoleAdapter.Beep();
143 | 
144 |         }
145 | 
146 |         public static void Alert(string message, Action<MessageBoxResultEnum, object> resultAction, string title, MessageBoxTypeEnum type = MessageBoxTypeEnum.None)
147 |         {
148 |             Show(message, resultAction, title, type);
149 |         }
150 | 
151 |         public static string Prompt(string message, Action<MessageBoxResultEnum> resultAction, string title)
152 |         {
153 |             return "Ok";
154 |         }
155 | 
156 |         public static void Confirm(string message, Action<MessageBoxResultEnum, object> resultAction, string title)
157 |         {
158 |             Show(message, resultAction, string.Empty, MessageBoxTypeEnum.Info, MessageBoxButtonsEnum.YesNo);
159 |         }
160 | 
161 |         public override void Initialize()
162 |         {
163 |             base.Initialize();
164 |             var left = Size.Width / 2 - _message.Length / 2;
165 |             left = left < 5 ? 5 : left;
166 |             _labelMessage = new Label
167 |             {
168 |                 Text = _message,
169 |                 Location = new Point
170 |                 {
171 |                     Top = 2,
172 |                     Left = left
173 |                 },
174 |                 BackgroundColor = BackgroundColor,
175 |                 ForegroundColor = ForegroundColor
176 |             };
177 |             RootPanel.AddChild(_labelMessage);
178 |             InitializeButtons();
179 |             InitializeImage();
180 |         }
181 | 
182 |         protected override void OnEscapePressed(object data = null)
183 |         {
184 |             (MessageBoxResultEnum, object) escapeResult = (MessageBoxResultEnum.None, null);
185 |             base.OnEscapePressed(escapeResult);
186 |             PerfomMessageBoxResultAction(MessageBoxResultEnum.None, null);
187 |         }
188 | 
189 |         private void InitializeCustomButtons()
190 |         {
191 |             int buttonWidth = 10;
192 |             int buttonTopStep = 2;
193 |             int buttonStartTopPointer = 0;
194 | 
195 |             var largestTextLength = _buttonsList.Select(i => i.Text.Length).Max();
196 |             buttonWidth = largestTextLength > 10 ? (largestTextLength + 2) : buttonWidth;
197 | 
198 |             foreach (var context in _buttonsList)
199 |             {
200 |                 var button = new Button
201 |                 {
202 |                     Text = context.Text,
203 |                     Location = new Point
204 |                     {
205 |                         Left = this.Size.Width / 2 - (buttonWidth) / 2,
206 |                         Top = buttonStartTopPointer + 4
207 |                     },
208 |                     Width = buttonWidth,
209 |                     Tag = context.Data,
210 |                     IsEnabled = context.IsEnabled
211 |                 };
212 |                 Debug.WriteLine(this.Size.Width);
213 |                 Debug.WriteLine(largestTextLength);
214 |                 RootPanel.AddChild(button);
215 |                 button.Pressed += button_Pressed;
216 |                 buttonStartTopPointer += buttonTopStep;
217 |             }
218 |             return;
219 |         }
220 | 
221 |         private void InitializeStandardButtons()
222 |         {
223 |             int buttonWidth = 10;
224 |             int buttonTop = Size.Height - 2;
225 |             var resultButtonsDictionary = new Dictionary<MessageBoxResultEnum, string>
226 |             {
227 |                 {MessageBoxResultEnum.Ok, "Ok"},
228 |                 {MessageBoxResultEnum.Cancel, "Cancel"},
229 |                 {MessageBoxResultEnum.Yes, "Yes"},
230 |                 {MessageBoxResultEnum.No, "No"},
231 |             };
232 | 
233 |             var buttonTypeTextDisctionary = new Dictionary
234 |                 <MessageBoxButtonsEnum, List<Tuple<MessageBoxResultEnum, string>>>
235 |             {
236 |                 {
237 |                     MessageBoxButtonsEnum.Ok,
238 |                     new List<Tuple<MessageBoxResultEnum, string>>
239 |                     {
240 |                         new Tuple<MessageBoxResultEnum, string>(MessageBoxResultEnum.Ok,
241 |                             resultButtonsDictionary[MessageBoxResultEnum.Ok])
242 |                     }
243 |                 },
244 |                 {
245 |                     MessageBoxButtonsEnum.OkCancel,
246 |                     new List<Tuple<MessageBoxResultEnum, string>>
247 |                     {
248 |                         new Tuple<MessageBoxResultEnum, string>(MessageBoxResultEnum.Ok,
249 |                             resultButtonsDictionary[MessageBoxResultEnum.Ok]),
250 |                         new Tuple<MessageBoxResultEnum, string>(MessageBoxResultEnum.Cancel,
251 |                             resultButtonsDictionary[MessageBoxResultEnum.Cancel]),
252 |                     }
253 |                 },
254 |                 {
255 |                     MessageBoxButtonsEnum.YesNo,
256 |                     new List<Tuple<MessageBoxResultEnum, string>>
257 |                     {
258 |                         new Tuple<MessageBoxResultEnum, string>(MessageBoxResultEnum.Yes,
259 |                             resultButtonsDictionary[MessageBoxResultEnum.Yes]),
260 |                         new Tuple<MessageBoxResultEnum, string>(MessageBoxResultEnum.No,
261 |                             resultButtonsDictionary[MessageBoxResultEnum.No]),
262 |                     }
263 |                 },
264 |                 {
265 |                     MessageBoxButtonsEnum.YesNoCancel,
266 |                     new List<Tuple<MessageBoxResultEnum, string>>
267 |                     {
268 |                         new Tuple<MessageBoxResultEnum, string>(MessageBoxResultEnum.Yes,
269 |                             resultButtonsDictionary[MessageBoxResultEnum.Yes]),
270 |                         new Tuple<MessageBoxResultEnum, string>(MessageBoxResultEnum.No,
271 |                             resultButtonsDictionary[MessageBoxResultEnum.No]),
272 |                         new Tuple<MessageBoxResultEnum, string>(MessageBoxResultEnum.Cancel,
273 |                             resultButtonsDictionary[MessageBoxResultEnum.Cancel]),
274 |                     }
275 |                 }
276 |             };
277 | 
278 |             int buttonsCount = buttonTypeTextDisctionary[_buttonsType].Count;
279 |             int buttonAreaWidth = Size.Width / buttonsCount;
280 |             int buttonLeftStep = (buttonAreaWidth - buttonWidth) / 2;
281 |             int buttonStartLeftPointer = 0;
282 | 
283 |             foreach (var text in buttonTypeTextDisctionary[_buttonsType])
284 |             {
285 |                 var button = new Button
286 |                 {
287 |                     Text = text.Item2,
288 |                     Location = new Point
289 |                     {
290 |                         Left = buttonStartLeftPointer + buttonLeftStep,
291 |                         Top = buttonTop
292 |                     },
293 |                     Tag = text.Item1
294 |                 };
295 |                 RootPanel.AddChild(button);
296 |                 button.Pressed += button_Pressed;
297 |                 buttonStartLeftPointer += buttonAreaWidth;
298 |             }
299 |         }
300 | 
301 |         private void InitializeButtons()
302 |         {
303 |             if (_buttonsList != null)
304 |             {
305 |                 InitializeCustomButtons();
306 |             }
307 |             else
308 |             {
309 |                 InitializeStandardButtons();
310 |             }
311 |         }
312 | 
313 |         private void button_Pressed(object sender, EventArgs e)
314 |         {
315 |             var senderButton = (Button)sender;
316 |             var enumResult = senderButton.Tag is MessageBoxResultEnum @enum ? @enum : MessageBoxResultEnum.None;
317 |             GoBack((enumResult, senderButton.Tag));
318 |             PerfomMessageBoxResultAction(enumResult, senderButton.Tag);
319 |         }
320 | 
321 |         private void PerfomMessageBoxResultAction(MessageBoxResultEnum messageBoxResult, object data)
322 |         {
323 |             if (_result != null)
324 |             {
325 |                 _result(messageBoxResult, data);
326 |                 _result = null;
327 |             }
328 |         }
329 | 
330 |         private void InitializeImage()
331 |         {
332 |             char[,] imageArray;
333 |             switch (_messageBoxType)
334 |             {
335 |                 case MessageBoxTypeEnum.Error:
336 |                     imageArray = new[,]
337 |                     {
338 |                         {' ', ' ', ' '},
339 |                         {'█', ' ', '█'},
340 |                         {' ', '█', ' '},
341 |                         {' ', '█', ' '},
342 |                         {' ', ' ', ' '},
343 |                         {'█', ' ', '█'}
344 |                     };
345 |                     break;
346 |                 case MessageBoxTypeEnum.Warning:
347 |                     imageArray = new[,]
348 |                     {
349 |                         {' ', '█', ' '},
350 |                         {'░', '█', '░'},
351 |                         {' ', '█', ' '},
352 |                         {' ', '█', ' '},
353 |                         {' ', ' ', ' '},
354 |                         {' ', '█', ' '}
355 |                     };
356 |                     break;
357 |                 case MessageBoxTypeEnum.Info:
358 |                     imageArray = new[,]
359 |                     {
360 |                         {' ', '█', ' '},
361 |                         {' ', ' ', ' '},
362 |                         {' ', '█', ' '},
363 |                         {' ', '█', ' '},
364 |                         {' ', '█', ' '},
365 |                         {'█', '█', '█'}
366 |                     };
367 |                     break;
368 |                 case MessageBoxTypeEnum.Question:
369 |                     imageArray = new[,]
370 |                     {
371 |                         {'░', '█', '░'},
372 |                         {'█', ' ', '█'},
373 |                         {' ', ' ', '█'},
374 |                         {' ', '█', '░'},
375 |                         {' ', '█', ' '},
376 |                         {' ', '█', ' '}
377 |                     };
378 |                     break;
379 |                 default:
380 |                     imageArray = new char[0, 0];
381 |                     break;
382 |             }
383 |             _messageBoxImage = new Image(imageArray)
384 |             {
385 |                 Location = new Point
386 |                 {
387 |                     Left = 1,
388 |                     Top = 1
389 |                 },
390 |                 BackgroundColor = BackgroundColor,
391 |                 ForegroundColor = GetForegroundColor(_messageBoxType)
392 |             };
393 |             RootPanel.AddChild(_messageBoxImage);
394 |         }
395 | 
396 |         private static ConsoleColor GetBackgroundColor(MessageBoxTypeEnum type)
397 |         {
398 |             switch (type)
399 |             {
400 |                 case MessageBoxTypeEnum.Error:
401 |                     return ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.ErrorMessageBoxBackgroundColor;
402 |                 case MessageBoxTypeEnum.Warning:
403 |                     return ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.WarningMessageBoxBackgroundColor;
404 |                 case MessageBoxTypeEnum.Info:
405 |                 case MessageBoxTypeEnum.Question:
406 |                 case MessageBoxTypeEnum.None:
407 |                     return ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.MessageBoxBackgroundColor;
408 |                 default:
409 |                     throw new ArgumentOutOfRangeException(nameof(type), type, null);
410 |             }
411 |         }
412 | 
413 | 
414 |         private static ConsoleColor GetForegroundColor(MessageBoxTypeEnum type)
415 |         {
416 |             switch (type)
417 |             {
418 |                 case MessageBoxTypeEnum.Error:
419 |                     return ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.ErrorMessageBoxForegroundColor;
420 |                 case MessageBoxTypeEnum.Warning:
421 |                     return ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.WarningMessageBoxForegroundColor;
422 |                 case MessageBoxTypeEnum.Info:
423 |                 case MessageBoxTypeEnum.Question:
424 |                 case MessageBoxTypeEnum.None:
425 |                     return ScoreboardContext.RenderEngine.RenderOptions.ColorScheme.MessageBoxForegroundColor;
426 |                 default:
427 |                     throw new ArgumentOutOfRangeException(nameof(type), type, null);
428 |             }
429 |         }
430 |     }
431 | }


--------------------------------------------------------------------------------
/EntityFX.ScoreboardUI/EntityFX.ScoreboardUI/Render/DefaultRenderer.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Globalization;
  4 | using System.Linq;
  5 | using EntityFX.ScoreboardUI.Drawing;
  6 | using EntityFX.ScoreboardUI.Elements;
  7 | using EntityFX.ScoreboardUI.Elements.Controls;
  8 | using EntityFX.ScoreboardUI.Elements.Controls.Charts;
  9 | using EntityFX.ScoreboardUI.Elements.Controls.Menu;
 10 | using EntityFX.ScoreboardUI.Elements.Controls.StatusBar;
 11 | using EntityFX.ScoreboardUI.Elements.MessageBox;
 12 | using EntityFX.ScoreboardUI.Elements.Scoreboards;
 13 | 
 14 | namespace EntityFX.ScoreboardUI.Render
 15 | {
 16 |     internal class DefaultRenderer : IRenderer
 17 |     {
 18 |         public IConsoleAdapter ConsoleAdapter { get; set; }
 19 | 
 20 |         public DefaultRenderer(IConsoleAdapter consoleAdapter, IRenderOptions renderOptions)
 21 |         {
 22 |             ConsoleAdapter = consoleAdapter;
 23 |             RenderOptions = renderOptions;
 24 |         }
 25 | 
 26 |         public void Initialize()
 27 |         {
 28 |             //_consoleAdapter.WindowHeight = RenderOptions.WindowHeight;
 29 |             //_consoleAdapter.WindowWidth = RenderOptions.WindowWidth;
 30 |             ConsoleAdapter.CursorVisible = false;
 31 |             ConsoleAdapter.Size = new Size() {Width = RenderOptions.WindowWidth, Height = RenderOptions.WindowHeight};
 32 |         }
 33 | 
 34 |         public void Render(UiElement uiElement)
 35 |         {
 36 |             if (!uiElement.IsVisible)
 37 |             {
 38 |                 return;
 39 |             }
 40 | 
 41 |             if (uiElement is Scoreboard scoreboard)
 42 |             {
 43 |                 RenderBackgroundBox(scoreboard.Location, scoreboard.Size, scoreboard.BackgroundColor);
 44 |                 if (scoreboard.IsBorderVisible)
 45 |                 {
 46 |                     RenderBorder(scoreboard, scoreboard.Location, scoreboard.Size, new BorderCharType
 47 |                     {
 48 |                         TopLeftChar = '╔',
 49 |                         BottomLeftChar = '╚',
 50 |                         BottomRightChar = '╝',
 51 |                         TopRightChar = '╗',
 52 |                         HorizontalChar = '═',
 53 |                         VerticalChar = '║'
 54 |                     });
 55 |                 }
 56 |                 RenderTitle(scoreboard);
 57 | 
 58 | 
 59 |                 if (scoreboard is MessageBox messageBox)
 60 |                 {
 61 |                 }
 62 | 
 63 |                 if (scoreboard.Menu != null)
 64 |                 {
 65 |                     RenderMenu(scoreboard);
 66 |                 }
 67 | 
 68 |                 if (scoreboard.StatusStrip != null)
 69 |                     RenderStatusStrip(scoreboard);
 70 | 
 71 |                 Render(scoreboard.RootPanel);
 72 |             }
 73 | 
 74 | 
 75 |             if (uiElement is Panel panel)
 76 |             {
 77 |                 foreach (ControlBase control in panel.Controls)
 78 |                 {
 79 |                     Render(control);
 80 |                 }
 81 |                 RenderPanel(panel);
 82 |             }
 83 | 
 84 |             if (uiElement is ControlBase controlElement)
 85 |             {
 86 |                 RenderControl(controlElement);
 87 |             }
 88 |         }
 89 | 
 90 |         private void RenderStatusStrip(Scoreboard scoreboard)
 91 |         {
 92 |             var stripLocation = new Point
 93 |             {
 94 |                 Left = 1,
 95 |                 Top = scoreboard.Size.Height - 1
 96 |             };
 97 |             var statusStripWidth = scoreboard.Size.Width + (scoreboard.IsBorderVisible ? -2 : 0);
 98 | 
 99 |             RenderVerticalLine(
100 |                 stripLocation,
101 |                 statusStripWidth, '▒'
102 |             );
103 | 
104 |             foreach (var stripItem in scoreboard.StatusStrip.Controls)
105 |             {
106 |                 RenderStripItem(stripItem);
107 |             }
108 |         }
109 | 
110 |         private void RenderMenu(Scoreboard scoreboard)
111 |         {
112 |             var stripLocation = new Point
113 |             {
114 |                 Left = 1,
115 |                 Top = 1
116 |             };
117 |             var statusStripWidth = scoreboard.Size.Width + (scoreboard.IsBorderVisible ? -2 : 0);
118 | 
119 |             RenderVerticalLine(
120 |                 stripLocation,
121 |                 statusStripWidth, '▒'
122 |             );
123 | 
124 |             foreach (var menuItem in scoreboard.Menu.Controls)
125 |             {
126 |                 RenderMenuItem(menuItem);   
127 |             }   
128 |         }
129 | 
130 |         private void RenderStripItem(StatusStripItem stripItem)
131 |         {
132 |             RenderControl(stripItem.InternalControl);
133 |         }
134 |             
135 |         private void RenderMenuItem<TData>(MenuItem<TData> stripItem)
136 |         {
137 |             RenderControl(stripItem.InternalControl);
138 |         }
139 | 
140 |         public IRenderOptions RenderOptions { get; set; }
141 | 
142 |         private void RenderControl(ControlBase control)
143 |         {
144 |             if (!control.IsVisible)
145 |             {
146 |                 return;
147 |             }
148 | 
149 |             ConsoleColor previousForeground = ConsoleAdapter.ForegroundColor;
150 |             ConsoleColor previousBackground = ConsoleAdapter.BackgroundColor;
151 |             if (control.IsEnabled)
152 |             {
153 |                 ConsoleAdapter.BackgroundColor = control.IsFocused ? RenderOptions.ColorScheme.FocusedBackgroundColor : control.BackgroundColor;
154 |                 ConsoleAdapter.ForegroundColor = control.IsFocused ? RenderOptions.ColorScheme.FocusedForegroundColor : control.ForegroundColor;
155 |             }
156 |             else
157 |             {
158 |                 ConsoleAdapter.BackgroundColor = RenderOptions.ColorScheme.DisabledBackgroundColor;
159 |                 ConsoleAdapter.ForegroundColor = RenderOptions.ColorScheme.DisabledForegroundColor;
160 |             }
161 | 
162 |             var sizeable = control as ISizable;
163 |             if (control is IBorderable borderable && sizeable != null)
164 |             {
165 |                 RenderBorder(borderable, control.Location, sizeable.Size, new BorderCharType
166 |                 {
167 |                     TopLeftChar = '┌',
168 |                     BottomLeftChar = '└',
169 |                     BottomRightChar = '┘',
170 |                     TopRightChar = '┐',
171 |                     HorizontalChar = '─',
172 |                     VerticalChar = '│'
173 |                 });
174 |             }
175 | 
176 |             Point loc = control.AbsoluteLocation();
177 |             ConsoleAdapter.MoveCursor(loc.Left, loc.Top);
178 |             if (control is Checkbox checkbox)
179 |             {
180 |                 RenderCheckBox(checkbox);
181 |             }
182 | 
183 |             if (control is RadioButton radioButton)
184 |             {
185 |                 RenderRadioButton(radioButton);
186 |             }
187 | 
188 |             if (control is Label label)
189 |             {
190 |                 RenderLabel(label);
191 |             }
192 | 
193 |             if (control is PasswordBox passwordBox)
194 |             {
195 |                 RenderPasswordBox(passwordBox);
196 |             }
197 | 
198 |             if (control is TextBox text && !(control is PasswordBox))
199 |             {
200 |                 RenderTextBox(text);
201 |             }
202 | 
203 |             if (control is Button button)
204 |             {
205 |                 RenderButton(button);
206 |             }
207 | 
208 |             if (control is ProgressBar progressBar)
209 |             {
210 |                 RenderProgressBar(progressBar);
211 |             }
212 | 
213 |             if (control is Image image)
214 |             {
215 |                 RenderImage(image);
216 |             }
217 | 
218 |             if (control is PlotChart plotChart)
219 |             {
220 |                 RenderPlotChart(plotChart);
221 |             }
222 | 
223 |             if (control is Panel panel)
224 |             {
225 |                 RenderPanel(panel);
226 |             }
227 | 
228 |             if (control is StatusStripItem stripItem)
229 |             {
230 |                 RenderStripItem(stripItem);
231 |             }
232 | 
233 |             if (control is MenuItem<object> menuItem)
234 |             {
235 |                 RenderMenuItem(menuItem);
236 |             }
237 | 
238 |             if (control is ComboBox comboBox)
239 |             {
240 |                 RenderComboBox(comboBox);
241 |             }
242 | 
243 |             if (control is IListView listView)
244 |             {
245 |                 RenderListView(listView);
246 |             }
247 | 
248 |             ConsoleAdapter.ForegroundColor = previousForeground;
249 |             ConsoleAdapter.BackgroundColor = previousBackground;
250 |         }
251 | 
252 |         private void RenderPlotChart(PlotChart plotChart)
253 |         {
254 |             ConsoleColor previousForeground = ConsoleAdapter.ForegroundColor;
255 |             ConsoleAdapter.ForegroundColor = plotChart.PointColor;
256 |             foreach (var listViewItemsControl in plotChart.Controls.OfType<Image>())
257 |             {
258 |                 RenderImage(listViewItemsControl);
259 |             }
260 |             ConsoleAdapter.ForegroundColor = previousForeground;
261 |         }
262 | 
263 |         private void RenderListView(IListView listView)
264 |         {
265 |             if (listView.ItemsControls == null) {
266 |                 return;
267 |             }
268 |             foreach (var listViewItemsControl in listView.ItemsControls)
269 |             {
270 |                 RenderListViewItem(listViewItemsControl);
271 |             }
272 |         }
273 | 
274 |         private void RenderListViewItem(ListViewItem listView)
275 |         {
276 |             foreach (var listViewItemsControl in listView.Controls)
277 |             {
278 |                 Render(listViewItemsControl);
279 |             }
280 |         }
281 | 
282 |         private static IEnumerable<ControlBase> GetOverlappedControls(Point startPoint, Point endPoint)
283 |         {
284 |             return ScoreboardContext.CurrentState.ControlsList.Where(_ =>
285 |             {
286 |                 var controlStartPoint = _.AbsoluteLocation();
287 |                 var linerableControl = _ as ILinearable;
288 |                 Point controlEndPoint;
289 |                 if (_ is ISizable sizableControl)
290 |                 {
291 |                     controlEndPoint = new Point
292 |                     {
293 |                         Left = controlStartPoint.Left + sizableControl.Size.Width,
294 |                         Top = controlStartPoint.Top + sizableControl.Size.Height
295 |                     };
296 | 
297 |                 }
298 |                 else if (linerableControl != null)
299 |                 {
300 |                     controlEndPoint = new Point
301 |                     {
302 |                         Left = controlStartPoint.Left + linerableControl.Width,
303 |                         Top = controlStartPoint.Top + 1
304 |                     };
305 |                 }
306 |                 else
307 |                 {
308 |                     controlEndPoint = new Point()
309 |                     {
310 |                         Left = controlStartPoint.Left + _.VisibleText.Length,
311 |                         Top = controlStartPoint.Top + 1
312 |                     };
313 |                 }
314 |                 return controlEndPoint.Left >= startPoint.Left
315 |                        && controlStartPoint.Left <= endPoint.Left
316 |                        && controlEndPoint.Top >= startPoint.Top
317 |                        && controlEndPoint.Top <= endPoint.Top;
318 |             });
319 |         }
320 | 
321 |         private void RenderComboBox(ComboBox comboBox)
322 |         {
323 |             Point loc = comboBox.AbsoluteLocation();
324 |             ConsoleAdapter.Write(new string(' ', comboBox.Width));
325 |             ConsoleAdapter.MoveCursor(loc.Left, loc.Top);
326 |             ConsoleAdapter.Write(comboBox.VisibleText);
327 |             ConsoleAdapter.MoveCursor(loc.Left + comboBox.Width - 1, loc.Top);
328 |             ConsoleColor saveColor = ConsoleAdapter.BackgroundColor;
329 |             ConsoleAdapter.BackgroundColor = comboBox.ExpanderBackground;
330 | 
331 |             var expanded = comboBox.DroppedDown;
332 |             ConsoleAdapter.Write(expanded ? '▲' : '▼');
333 |             ConsoleAdapter.BackgroundColor = saveColor;
334 |             var initialCurosrTopPosition = loc.Top + 1;
335 |             var itemLinesToDraw = comboBox.Items.Count > comboBox.VisibleItemsCount
336 |                                                         ? comboBox.VisibleItemsCount
337 |                                                         : comboBox.Items.Count;
338 | 
339 |             var expanderLocation = new Point
340 |             {
341 |                 Left = loc.Left + 1,
342 |                 Top = initialCurosrTopPosition
343 |             };
344 | 
345 |             var expanderSize = new Size { Width = comboBox.Width - 1, Height = itemLinesToDraw };
346 | 
347 |             if (expanded)
348 |             {
349 |                 ConsoleAdapter.MoveCursor(loc.Left + comboBox.Width - 1, loc.Top);
350 | 
351 |                 RenderBackgroundBox(
352 |                     expanderLocation,
353 |                     expanderSize,
354 |                     comboBox.BackgroundColor
355 |                 );
356 |                 ConsoleAdapter.ForegroundColor = comboBox.ForegroundColor;
357 |                 ConsoleAdapter.BackgroundColor = comboBox.BackgroundColor;
358 | 
359 |                 var startItem = comboBox.SelectedIndex >= comboBox.VisibleItemsCount ? comboBox.SelectedIndex - comboBox.VisibleItemsCount + 1 : 0;
360 |                 for (int i = startItem; i < startItem + itemLinesToDraw; i++)
361 |                 {
362 |                     ConsoleAdapter.MoveCursor(loc.Left + 1, initialCurosrTopPosition);
363 |                     if (comboBox.Items[i] == comboBox.Items[comboBox.SelectedIndex])
364 |                     {
365 |                         ConsoleAdapter.BackgroundColor = RenderOptions.ColorScheme.FocusedBackgroundColor;
366 |                         ConsoleAdapter.ForegroundColor = comboBox.SelectedColor;
367 |                     }
368 |                     ConsoleAdapter.Write(comboBox.Items[i].Text);
369 |                     ConsoleAdapter.BackgroundColor = comboBox.BackgroundColor;
370 |                     ConsoleAdapter.ForegroundColor = comboBox.ForegroundColor;
371 |                     ++initialCurosrTopPosition;
372 |                 }
373 | 
374 |                 if (comboBox.Items.Count > comboBox.VisibleItemsCount)
375 |                 {
376 |                     var rollerSize = (int)((comboBox.VisibleItemsCount / (float)comboBox.Items.Count) * (comboBox.VisibleItemsCount - 2));
377 |                     var rollDiff = comboBox.Items.Count - comboBox.VisibleItemsCount;
378 |                     var rollerOffset = comboBox.SelectedIndex < comboBox.VisibleItemsCount ?
379 |                         0 :
380 |                         (int)(((comboBox.SelectedIndex - comboBox.VisibleItemsCount + 1) / (float)rollDiff) * (comboBox.VisibleItemsCount - 2 - rollerSize));
381 |                     RenderVerticalScroll(
382 |                         new Point() { Left = loc.Left + comboBox.Width - 1, Top = loc.Top + 1 },
383 |                         comboBox.VisibleItemsCount,
384 |                         rollerSize,
385 |                         rollerOffset
386 |                     );
387 |                 }
388 |             }
389 |             else
390 |             {
391 |                 RenderBackgroundBox(
392 |                     expanderLocation,
393 |                     expanderSize,
394 |                     ScoreboardContext.Navigation.Current.Scoreboard.BackgroundColor
395 |                 );
396 |                 var overlapped = GetOverlappedControls(expanderLocation, new Point
397 |                 {
398 |                     Left = expanderLocation.Left + expanderSize.Width,
399 |                     Top = expanderLocation.Top + expanderSize.Height
400 |                 }).Where(_ => _ != comboBox);
401 | 
402 |                 RenderOverridedExcept(overlapped, comboBox);
403 |             }
404 |         }
405 | 
406 |         private void RenderOverridedExcept(IEnumerable<ControlBase> controls, ControlBase controlToExclude)
407 |         {
408 |             var controlsArray = controls.ToArray();
409 |             foreach (var controlBase in controlsArray)
410 |             {
411 |                 if (controlBase is Control<ControlBase> containerControl)
412 |                 {
413 |                     RenderOverridedExcept(containerControl.Controls, controlToExclude);
414 |                     RenderControl(containerControl);
415 |                 }
416 |                 else
417 |                 {
418 |                     if (controlBase != controlToExclude)
419 |                     {
420 |                         RenderControl(controlBase);
421 |                     }
422 |                 }
423 |             }
424 |         }
425 | 
426 |         private void RenderVerticalScroll(Point point, int height, int rollerSize = 1, int rollerOffset = 0)
427 |         {
428 |             RenderHorizontalLine(new Point() { Left = point.Left, Top = point.Top + 1 }, height - 2, '░');
429 |             ConsoleAdapter.BackgroundColor = ConsoleColor.DarkGray;
430 |             ConsoleAdapter.MoveCursor(point.Left, point.Top);
431 |             ConsoleAdapter.Write('▲');
432 |             ConsoleAdapter.MoveCursor(point.Left, point.Top + height - 1);
433 |             ConsoleAdapter.Write('▼');
434 | 
435 |             RenderHorizontalLine(new Point() { Left = point.Left, Top = point.Top + 1 + rollerOffset }, rollerSize, '█');
436 |         }
437 | 
438 |         private void RenderPanel(Panel panel)
439 |         {
440 |             if (panel.DisplayText)
441 |             {
442 |                 var loc = panel.AbsoluteLocation();
443 |                 ConsoleAdapter.MoveCursor(loc.Left + 1, loc.Top);
444 |                 ConsoleAdapter.Write(panel.VisibleText);
445 |             }
446 |         }
447 | 
448 |         private void RenderImage(Image image)
449 |         {
450 |             Point loc = image.AbsoluteLocation();
451 |             RenderBackgroundBox(
452 |                 loc,
453 |                 image.Size,
454 |                 image.BackgroundColor
455 |             );
456 |             if (image.UseColors)
457 |             {
458 |                 ConsoleColor previousColor = image.UseInvertedColors ? ConsoleAdapter.BackgroundColor : ConsoleAdapter.BackgroundColor;
459 |                 for (int y = 0; y < image.Size.Height; ++y)
460 |                 {
461 |                     for (int x = 0; x < image.Size.Width; x++)
462 |                     {
463 |                         ConsoleAdapter.MoveCursor(x + loc.Left, y + loc.Top);
464 |                         if (image.UseInvertedColors)
465 |                         {
466 |                             ConsoleAdapter.BackgroundColor = image.ImageArray[y, x].Color;
467 |                             ConsoleAdapter.ForegroundColor = image.ForegroundColor;
468 |                         }
469 |                         else
470 |                         {
471 |                             ConsoleAdapter.ForegroundColor = image.ImageArray[y, x].Color;
472 |                         }
473 |                         ConsoleAdapter.Write(image.ImageArray[y, x].Char);
474 |                     }
475 |                 }
476 |                 ConsoleAdapter.ForegroundColor = previousColor;
477 |             }
478 |             else
479 |             {
480 |                 for (int y = 0; y < image.Size.Height; ++y)
481 |                 {
482 |                     for (int x = 0; x < image.Size.Width; x++)
483 |                     {
484 |                         ConsoleAdapter.MoveCursor(x + loc.Left, y + loc.Top);
485 |                         ConsoleAdapter.Write(image.ImageArray[y, x].Char);
486 |                     }
487 |                 }
488 |             }
489 | 
490 |         }
491 | 
492 |         private void RenderLabel(Label label)
493 |         {
494 |             Point loc = label.AbsoluteLocation();
495 |             ConsoleAdapter.MoveCursor(loc.Left, loc.Top);
496 |             if (label.Text.Contains('\n'))
497 |             {
498 |                 var textLines = label.Text.Split('\n').Select(t => t.Replace('\r', ' ')).ToArray();
499 | 
500 |                 if (textLines.Length > 6)
501 |                 {
502 |                     var textsList = textLines.Take(6).ToList();
503 |                     textsList.Add("...");
504 |                     textLines = textsList.ToArray();
505 |                 }
506 |                 else
507 |                 {
508 |                     textLines = textLines;
509 |                 }
510 | 
511 |                 var startTop = loc.Top;
512 |                 foreach (var text in textLines)
513 |                 {
514 |                     var currentText = text;
515 |                     if (label.ParentScoreboard != null)
516 |                     {
517 |                         var supposedTextLength = label.ParentScoreboard.Size.Width - label.Location.Left -
518 |                                                  (label.ParentScoreboard.IsBorderVisible ? 4 : 2);
519 |                         if (text.Length > supposedTextLength)
520 |                         {
521 |                             currentText = text.Substring(0, supposedTextLength) + "...";
522 |                         }
523 |                     }
524 | 
525 |                     ConsoleAdapter.MoveCursor(loc.Left, startTop);
526 |                     ConsoleAdapter.Write(currentText);
527 |                     startTop++;
528 |                 }
529 |             }
530 |             else
531 |             {
532 |                 ConsoleAdapter.MoveCursor(loc.Left, loc.Top);
533 |                 ConsoleAdapter.Write(label.Text);
534 |             }
535 |         }
536 | 
537 |         private void RenderCheckBox(Checkbox checkbox)
538 |         {
539 |             char marker = checkbox.IsChecked != null ? (bool)checkbox.IsChecked ? '■' : ' ' : '?';
540 |             string label = checkbox.DisplayText ? " " + checkbox.Text : string.Empty;
541 |             ConsoleAdapter.Write(string.Format("[{0}]{1}", marker, label));
542 |         }
543 | 
544 |         private void RenderTextBox(TextBox textBox)
545 |         {
546 |             Point loc = textBox.AbsoluteLocation();
547 |             ConsoleAdapter.Write(new string(' ', textBox.InputLength));
548 |             ConsoleAdapter.MoveCursor(loc.Left, loc.Top);
549 |             ConsoleAdapter.Write(textBox.VisibleText);
550 |         }
551 | 
552 | 
553 |         private void RenderPasswordBox(PasswordBox textBox)
554 |         {
555 |             ConsoleAdapter.Write(new string(' ', textBox.InputLength));
556 |             ConsoleAdapter.MoveCursor(textBox.Location.Left, textBox.Location.Top);
557 |             if (textBox.IsFocused && textBox.VisibleText.Length > 0)
558 |             {
559 |                 ConsoleAdapter.Write(new String('*', textBox.VisibleText.Length - 1) + textBox.VisibleText[textBox.VisibleText.Length - 1]);
560 |             }
561 |             else
562 |             {
563 |                 ConsoleAdapter.Write(new String('*', textBox.VisibleText.Length));
564 |             }
565 |         }
566 | 
567 |         private void RenderButton(Button button)
568 |         {
569 |             int lineLength = button.Width;
570 | 
571 |             var str = new string(' ', lineLength);
572 |             Point loc = button.AbsoluteLocation();
573 |             ConsoleAdapter.MoveCursor(loc.Left, loc.Top);
574 |             ConsoleAdapter.Write(str);
575 | 
576 |             if (button.DisplayText)
577 |             {
578 |                 int titleLength = button.VisibleText.Length;
579 |                 int left = 0;
580 |                 switch (button.TextAligment)
581 |                 {
582 |                     case TitleAligment.Left:
583 |                         left = button.Location.Left;
584 |                         ConsoleAdapter.MoveCursor(loc.Left, loc.Top);
585 |                         break;
586 |                     case TitleAligment.Center:
587 |                         left = (button.Width / 2) - (titleLength / 2) + loc.Left;
588 |                         break;
589 |                     case TitleAligment.Right:
590 |                         left = button.Width - titleLength + loc.Left;
591 |                         break;
592 |                     default:
593 |                         throw new ArgumentOutOfRangeException("aligment");
594 |                 }
595 |                 ConsoleAdapter.MoveCursor(left, loc.Top);
596 |                 ConsoleAdapter.Write(button.VisibleText);
597 |             }
598 |         }
599 | 
600 |         private void RenderRadioButton(RadioButton radioButton)
601 |         {
602 |             char marker = radioButton.IsChecked != null ? (bool)radioButton.IsChecked ? '∙' : ' ' : '?';
603 |             string label = radioButton.DisplayText ? " " + radioButton.Text : string.Empty;
604 |             ConsoleAdapter.Write(string.Format("({0}){1}", marker, label));
605 |         }
606 | 
607 |         private void RenderProgressBar(ProgressBar progressBar)
608 |         {
609 |             var location = progressBar.AbsoluteLocation();
610 |             ConsoleAdapter.MoveCursor(location.Left, location.Top);
611 |             ConsoleAdapter.Write(new string(' ', progressBar.Width));
612 | 
613 |             int normalMax = progressBar.Maximum - progressBar.Minimum;
614 |             int normalValue = progressBar.Value - progressBar.Minimum;
615 |             var size = (int)((normalValue / (normalMax * 1.0)) * progressBar.Width);
616 | 
617 |             ConsoleAdapter.MoveCursor(location.Left, location.Top);
618 |             ConsoleColor saveColor = ConsoleAdapter.BackgroundColor;
619 |             ConsoleAdapter.BackgroundColor = progressBar.StripeColor;
620 |             ConsoleAdapter.Write(new string(' ', size));
621 |             ConsoleAdapter.BackgroundColor = saveColor;
622 | 
623 |             if (progressBar.DisplayText)
624 |             {
625 |                 int titleLength = progressBar.VisibleText.Length;
626 |                 int left = 0;
627 |                 int offset = 0;
628 |                 switch (progressBar.TextAligment)
629 |                 {
630 |                     case TitleAligment.Left:
631 |                         left = location.Left;
632 |                         offset = 0;
633 |                         break;
634 |                     case TitleAligment.Center:
635 |                         offset = (progressBar.Width / 2) - (titleLength / 2);
636 |                         left = offset + location.Left;
637 |                         break;
638 |                     case TitleAligment.Right:
639 |                         offset = progressBar.Width - titleLength;
640 |                         left = offset + location.Left;
641 |                         break;
642 |                     default:
643 |                         throw new ArgumentOutOfRangeException("aligment");
644 |                 }
645 |                 ConsoleAdapter.MoveCursor(location.Left, location.Top);
646 |                 var intersection = size - offset < 0 ? 0 : size - offset;
647 |                 var filledString = progressBar.VisibleText.Substring(0, intersection > progressBar.VisibleText.Length ? progressBar.VisibleText.Length : intersection);
648 |                 var nonFilledString =
649 |                     progressBar.VisibleText.Substring(intersection > progressBar.VisibleText.Length ? progressBar.VisibleText.Length : intersection);
650 | 
651 |                 ConsoleAdapter.BackgroundColor = progressBar.StripeColor;
652 |                 ConsoleAdapter.ForegroundColor = progressBar.BackgroundColor;
653 |                 ConsoleAdapter.MoveCursor(left, location.Top);
654 |                 ConsoleAdapter.Write(filledString);
655 | 
656 |                 if (!string.IsNullOrEmpty(nonFilledString))
657 |                 {
658 |                     ConsoleAdapter.BackgroundColor = progressBar.BackgroundColor;
659 |                     ConsoleAdapter.ForegroundColor = progressBar.StripeColor;
660 |                     ConsoleAdapter.MoveCursor(left + filledString.Length, location.Top);
661 |                     ConsoleAdapter.Write(nonFilledString);
662 |                 }
663 |             }
664 |         }
665 | 
666 |         private void RenderBackgroundBox(Point point, Size size, ConsoleColor backgroundColor)
667 |         {
668 |             ConsoleColor previousBackground = ConsoleAdapter.BackgroundColor;
669 |             ConsoleAdapter.BackgroundColor = backgroundColor;
670 |             int lineLength = size.Width;
671 | 
672 |             var str = new string(' ', lineLength);
673 | 
674 |             for (int y = point.Top; y < point.Top + size.Height; y++)
675 |             {
676 |                 ConsoleAdapter.MoveCursor(point.Left, y);
677 |                 ConsoleAdapter.Write(str);
678 |             }
679 |             ConsoleAdapter.MoveCursor(point.Left, point.Top);
680 |             ConsoleAdapter.BackgroundColor = previousBackground;
681 |         }
682 | 
683 |         private void RenderBorder(IBorderable control, Point location, Size size, BorderCharType borderCharType)
684 |         {
685 |             ConsoleColor previousBackground = ConsoleAdapter.BackgroundColor;
686 |             ConsoleAdapter.BackgroundColor = control.BorderBackgroundColor;
687 | 
688 |             ConsoleColor previousForeground = ConsoleAdapter.ForegroundColor;
689 |             ConsoleAdapter.ForegroundColor = control.BorderForegroundColor;
690 |             RenderVerticalLine(
691 |                 new Point
692 |                 {
693 |                     Left = location.Left + 1,
694 |                     Top = location.Top
695 |                 },
696 |                 size.Width - 2, borderCharType.HorizontalChar);
697 |             RenderVerticalLine(
698 |                 new Point
699 |                 {
700 |                     Left = location.Left + 1,
701 |                     Top = location.Top + size.Height - 1
702 |                 },
703 |                 size.Width - 2, borderCharType.HorizontalChar);
704 |             RenderHorizontalLine(
705 |                 new Point
706 |                 {
707 |                     Left = location.Left,
708 |                     Top = location.Top + 1
709 |                 },
710 |                 size.Height - 2, borderCharType.VerticalChar);
711 |             RenderHorizontalLine(
712 |                 new Point
713 |                 {
714 |                     Left = location.Left + size.Width - 1,
715 |                     Top = location.Top + 1
716 |                 },
717 |                 size.Height - 2, borderCharType.VerticalChar);
718 | 
719 |             ConsoleAdapter.MoveCursor(location.Left + size.Width - 1, location.Top + size.Height - 1);
720 |             if (!(RenderOptions.WindowHeight == location.Left + size.Width && RenderOptions.WindowHeight == location.Top + size.Height))
721 |             {
722 |                 ConsoleAdapter.Write(borderCharType.BottomRightChar);
723 |             }
724 |             else
725 |             {
726 |                 ConsoleAdapter.MoveCursor(location.Left, location.Top);
727 |                 ConsoleAdapter.Write(borderCharType.BottomRightChar);
728 |                 ConsoleAdapter.MoveArea(location.Left, location.Top, 1, 1, location.Left + size.Width - 1, location.Top + size.Height - 1);
729 |             }
730 | 
731 |             ConsoleAdapter.MoveCursor(location.Left, location.Top);
732 |             ConsoleAdapter.Write(borderCharType.TopLeftChar);
733 | 
734 |             ConsoleAdapter.MoveCursor(location.Left, location.Top + size.Height - 1);
735 |             ConsoleAdapter.Write(borderCharType.BottomLeftChar);
736 | 
737 |             ConsoleAdapter.MoveCursor(location.Left + size.Width - 1, location.Top);
738 |             ConsoleAdapter.Write(borderCharType.TopRightChar);
739 |             ConsoleAdapter.BackgroundColor = previousBackground;
740 |             ConsoleAdapter.ForegroundColor = previousForeground;
741 |         }
742 | 
743 |         private void RenderVerticalLine(Point location, int width, char character = '-')
744 |         {
745 |             var str = new string(character, width);
746 |             ConsoleAdapter.MoveCursor(location.Left, location.Top);
747 |             ConsoleAdapter.Write(str);
748 |         }
749 | 
750 |         private void RenderHorizontalLine(Point location, int height, char character = '-')
751 |         {
752 |             for (int i = 0; i < height; i++)
753 |             {
754 |                 ConsoleAdapter.MoveCursor(location.Left, location.Top + i);
755 |                 ConsoleAdapter.Write(character);
756 |             }
757 |         }
758 | 
759 |         private void RenderTitle(Scoreboard scoreboard)
760 |         {
761 |             ConsoleColor previousForeground = ConsoleAdapter.ForegroundColor;
762 |             ConsoleColor previousBackground = ConsoleAdapter.BackgroundColor;
763 |             ConsoleAdapter.BackgroundColor = scoreboard.BackgroundColor;
764 |             ConsoleAdapter.ForegroundColor = scoreboard.ForegroundColor;
765 | 
766 |             int titleLength = scoreboard.Title.Length;
767 |             int left = 0;
768 |             switch (scoreboard.TitleAligment)
769 |             {
770 |                 case TitleAligment.Left:
771 |                     left = scoreboard.Location.Left;
772 |                     ConsoleAdapter.MoveCursor(scoreboard.Location.Left, scoreboard.Location.Top);
773 |                     break;
774 |                 case TitleAligment.Center:
775 |                     left = (scoreboard.Size.Width / 2) - (titleLength / 2) + scoreboard.Location.Left;
776 |                     break;
777 |                 case TitleAligment.Right:
778 |                     left = scoreboard.Size.Width - titleLength + scoreboard.Location.Left;
779 |                     break;
780 |                 default:
781 |                     throw new ArgumentOutOfRangeException("aligment");
782 |             }
783 |             ConsoleAdapter.MoveCursor(left, scoreboard.Location.Top);
784 |             ConsoleAdapter.Write(scoreboard.Title);
785 |             ConsoleAdapter.ForegroundColor = previousForeground;
786 |             ConsoleAdapter.BackgroundColor = previousBackground;
787 |         }
788 |     }
789 | }


--------------------------------------------------------------------------------