mirror of
https://github.com/gui-cs/Terminal.Gui.git
synced 2025-12-26 15:57:56 +01:00
e7a4df492d
* Initial plan
* Rename Command.Select to Command.Activate and Selecting to Activating
Co-authored-by: tig <585482+tig@users.noreply.github.com>
* Add Activating event propagation to SuperView
Co-authored-by: tig <585482+tig@users.noreply.github.com>
* Update all comments and docs referencing Select to Activate
Co-authored-by: tig <585482+tig@users.noreply.github.com>
* Fix event log messages in examples to use Activating/Activate
Co-authored-by: tig <585482+tig@users.noreply.github.com>
* Revert automatic Activating event propagation that broke tests
Co-authored-by: tig <585482+tig@users.noreply.github.com>
* Update docfx documentation to use Activate/Activating terminology
Co-authored-by: tig <585482+tig@users.noreply.github.com>
* renames
* Revert "Add Activating event propagation to SuperView"
This reverts commit 6d82bee9ad.
* added command diagrams
* mermaid
* updated level 3
* again
* Select->Activate in MouseTests.cs
* Update Terminal.Gui/Views/Selectors/FlagSelector.cs
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
* Refactor: Rename Selecting to Activating in View APIs
Renamed the `Selecting` event and `OnSelecting` method to
`Activating` and `OnActivating` to better reflect their purpose.
Updated all related comments, test method names, variables,
and assertions in `View` and `ViewCommandTests` to align with
the new terminology.
Improved code clarity by using `_` for unused parameters in
lambda expressions. Renamed properties like `HandleSelecting`
to `HandleActivating` and adjusted naming conventions for
consistency (e.g., `OnactivatingCount` to `OnActivatingCount`).
These changes enhance readability, maintainability, and
terminology consistency across the codebase.
* Update Terminal.Gui/Views/Selectors/OptionSelector.cs
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
* Typos
---------
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: tig <585482+tig@users.noreply.github.com>
Co-authored-by: Tig <tig@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
1554 lines
53 KiB
C#
1554 lines
53 KiB
C#
#nullable enable
|
|
using System.Data;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
|
|
namespace UICatalog.Scenarios;
|
|
|
|
[ScenarioMetadata ("TableEditor", "Implements data table editor using the TableView control.")]
|
|
[ScenarioCategory ("TableView")]
|
|
[ScenarioCategory ("Controls")]
|
|
[ScenarioCategory ("Dialogs")]
|
|
[ScenarioCategory ("Text and Formatting")]
|
|
public class TableEditor : Scenario
|
|
{
|
|
private readonly HashSet<FileSystemInfo>? _checkedFileSystemInfos = [];
|
|
private readonly List<IDisposable>? _toDispose = [];
|
|
|
|
private readonly List<UnicodeRange>? _ranges =
|
|
[
|
|
new (
|
|
0x0000,
|
|
0x001F,
|
|
"ASCII Control Characters"
|
|
),
|
|
|
|
new (0x0080, 0x009F, "C0 Control Characters"),
|
|
|
|
new (
|
|
0x1100,
|
|
0x11ff,
|
|
"Hangul Jamo"
|
|
), // This is where wide chars tend to start
|
|
|
|
new (0x20A0, 0x20CF, "Currency Symbols"),
|
|
|
|
new (0x2100, 0x214F, "Letterlike Symbols"),
|
|
|
|
new (0x2190, 0x21ff, "Arrows"),
|
|
|
|
new (0x2200, 0x22ff, "Mathematical symbols"),
|
|
|
|
new (
|
|
0x2300,
|
|
0x23ff,
|
|
"Miscellaneous Technical"
|
|
),
|
|
|
|
new (
|
|
0x2500,
|
|
0x25ff,
|
|
"Box Drawing & Geometric Shapes"
|
|
),
|
|
|
|
new (0x2600, 0x26ff, "Miscellaneous Symbols"),
|
|
|
|
new (0x2700, 0x27ff, "Dingbats"),
|
|
|
|
new (0x2800, 0x28ff, "Braille"),
|
|
|
|
new (
|
|
0x2b00,
|
|
0x2bff,
|
|
"Miscellaneous Symbols and Arrows"
|
|
),
|
|
|
|
new (
|
|
0xFB00,
|
|
0xFb4f,
|
|
"Alphabetic Presentation Forms"
|
|
),
|
|
|
|
new (
|
|
0x12400,
|
|
0x1240f,
|
|
"Cuneiform Numbers and Punctuation"
|
|
),
|
|
|
|
new (
|
|
(uint)(Terminal.Gui.Views.UnicodeRange.Ranges.Max (r => r.End) - 16),
|
|
(uint)Terminal.Gui.Views.UnicodeRange.Ranges.Max (r => r.End),
|
|
"End"
|
|
),
|
|
|
|
new (0x0020, 0x007F, "Basic Latin"),
|
|
|
|
new (0x00A0, 0x00FF, "Latin-1 Supplement"),
|
|
|
|
new (0x0100, 0x017F, "Latin Extended-A"),
|
|
|
|
new (0x0180, 0x024F, "Latin Extended-B"),
|
|
|
|
new (0x0250, 0x02AF, "IPA Extensions"),
|
|
|
|
new (
|
|
0x02B0,
|
|
0x02FF,
|
|
"Spacing Modifier Letters"
|
|
),
|
|
|
|
new (
|
|
0x0300,
|
|
0x036F,
|
|
"Combining Diacritical Marks"
|
|
),
|
|
|
|
new (0x0370, 0x03FF, "Greek and Coptic"),
|
|
|
|
new (0x0400, 0x04FF, "Cyrillic"),
|
|
|
|
new (0x0500, 0x052F, "Cyrillic Supplementary"),
|
|
|
|
new (0x0530, 0x058F, "Armenian"),
|
|
|
|
new (0x0590, 0x05FF, "Hebrew"),
|
|
|
|
new (0x0600, 0x06FF, "Arabic"),
|
|
|
|
new (0x0700, 0x074F, "Syriac"),
|
|
|
|
new (0x0780, 0x07BF, "Thaana"),
|
|
|
|
new (0x0900, 0x097F, "Devanagari"),
|
|
|
|
new (0x0980, 0x09FF, "Bengali"),
|
|
|
|
new (0x0A00, 0x0A7F, "Gurmukhi"),
|
|
|
|
new (0x0A80, 0x0AFF, "Gujarati"),
|
|
|
|
new (0x0B00, 0x0B7F, "Oriya"),
|
|
|
|
new (0x0B80, 0x0BFF, "Tamil"),
|
|
|
|
new (0x0C00, 0x0C7F, "Telugu"),
|
|
|
|
new (0x0C80, 0x0CFF, "Kannada"),
|
|
|
|
new (0x0D00, 0x0D7F, "Malayalam"),
|
|
|
|
new (0x0D80, 0x0DFF, "Sinhala"),
|
|
|
|
new (0x0E00, 0x0E7F, "Thai"),
|
|
|
|
new (0x0E80, 0x0EFF, "Lao"),
|
|
|
|
new (0x0F00, 0x0FFF, "Tibetan"),
|
|
|
|
new (0x1000, 0x109F, "Myanmar"),
|
|
|
|
new (0x10A0, 0x10FF, "Georgian"),
|
|
|
|
new (0x1100, 0x11FF, "Hangul Jamo"),
|
|
|
|
new (0x1200, 0x137F, "Ethiopic"),
|
|
|
|
new (0x13A0, 0x13FF, "Cherokee"),
|
|
|
|
new (
|
|
0x1400,
|
|
0x167F,
|
|
"Unified Canadian Aboriginal Syllabics"
|
|
),
|
|
|
|
new (0x1680, 0x169F, "Ogham"),
|
|
|
|
new (0x16A0, 0x16FF, "Runic"),
|
|
|
|
new (0x1700, 0x171F, "Tagalog"),
|
|
|
|
new (0x1720, 0x173F, "Hanunoo"),
|
|
|
|
new (0x1740, 0x175F, "Buhid"),
|
|
|
|
new (0x1760, 0x177F, "Tagbanwa"),
|
|
|
|
new (0x1780, 0x17FF, "Khmer"),
|
|
|
|
new (0x1800, 0x18AF, "Mongolian"),
|
|
|
|
new (0x1900, 0x194F, "Limbu"),
|
|
|
|
new (0x1950, 0x197F, "Tai Le"),
|
|
|
|
new (0x19E0, 0x19FF, "Khmer Symbols"),
|
|
|
|
new (0x1D00, 0x1D7F, "Phonetic Extensions"),
|
|
|
|
new (
|
|
0x1E00,
|
|
0x1EFF,
|
|
"Latin Extended Additional"
|
|
),
|
|
|
|
new (0x1F00, 0x1FFF, "Greek Extended"),
|
|
|
|
new (0x2000, 0x206F, "General Punctuation"),
|
|
|
|
new (
|
|
0x2070,
|
|
0x209F,
|
|
"Superscripts and Subscripts"
|
|
),
|
|
|
|
new (0x20A0, 0x20CF, "Currency Symbols"),
|
|
|
|
new (
|
|
0x20D0,
|
|
0x20FF,
|
|
"Combining Diacritical Marks for Symbols"
|
|
),
|
|
|
|
new (0x2100, 0x214F, "Letterlike Symbols"),
|
|
|
|
new (0x2150, 0x218F, "Number Forms"),
|
|
|
|
new (0x2190, 0x21FF, "Arrows"),
|
|
|
|
new (0x2200, 0x22FF, "Mathematical Operators"),
|
|
|
|
new (
|
|
0x2300,
|
|
0x23FF,
|
|
"Miscellaneous Technical"
|
|
),
|
|
|
|
new (0x2400, 0x243F, "Control Pictures"),
|
|
|
|
new (
|
|
0x2440,
|
|
0x245F,
|
|
"Optical Character Recognition"
|
|
),
|
|
|
|
new (0x2460, 0x24FF, "Enclosed Alphanumerics"),
|
|
|
|
new (0x2500, 0x257F, "Box Drawing"),
|
|
|
|
new (0x2580, 0x259F, "Block Elements"),
|
|
|
|
new (0x25A0, 0x25FF, "Geometric Shapes"),
|
|
|
|
new (0x2600, 0x26FF, "Miscellaneous Symbols"),
|
|
|
|
new (0x2700, 0x27BF, "Dingbats"),
|
|
|
|
new (
|
|
0x27C0,
|
|
0x27EF,
|
|
"Miscellaneous Mathematical Symbols-A"
|
|
),
|
|
|
|
new (0x27F0, 0x27FF, "Supplemental Arrows-A"),
|
|
|
|
new (0x2800, 0x28FF, "Braille Patterns"),
|
|
|
|
new (0x2900, 0x297F, "Supplemental Arrows-B"),
|
|
|
|
new (
|
|
0x2980,
|
|
0x29FF,
|
|
"Miscellaneous Mathematical Symbols-B"
|
|
),
|
|
|
|
new (
|
|
0x2A00,
|
|
0x2AFF,
|
|
"Supplemental Mathematical Operators"
|
|
),
|
|
|
|
new (
|
|
0x2B00,
|
|
0x2BFF,
|
|
"Miscellaneous Symbols and Arrows"
|
|
),
|
|
|
|
new (
|
|
0x2E80,
|
|
0x2EFF,
|
|
"CJK Radicals Supplement"
|
|
),
|
|
|
|
new (0x2F00, 0x2FDF, "Kangxi Radicals"),
|
|
|
|
new (
|
|
0x2FF0,
|
|
0x2FFF,
|
|
"Ideographic Description Characters"
|
|
),
|
|
|
|
new (
|
|
0x3000,
|
|
0x303F,
|
|
"CJK Symbols and Punctuation"
|
|
),
|
|
|
|
new (0x3040, 0x309F, "Hiragana"),
|
|
|
|
new (0x30A0, 0x30FF, "Katakana"),
|
|
|
|
new (0x3100, 0x312F, "Bopomofo"),
|
|
|
|
new (
|
|
0x3130,
|
|
0x318F,
|
|
"Hangul Compatibility Jamo"
|
|
),
|
|
|
|
new (0x3190, 0x319F, "Kanbun"),
|
|
|
|
new (0x31A0, 0x31BF, "Bopomofo Extended"),
|
|
|
|
new (
|
|
0x31F0,
|
|
0x31FF,
|
|
"Katakana Phonetic Extensions"
|
|
),
|
|
|
|
new (
|
|
0x3200,
|
|
0x32FF,
|
|
"Enclosed CJK Letters and Months"
|
|
),
|
|
|
|
new (0x3300, 0x33FF, "CJK Compatibility"),
|
|
|
|
new (
|
|
0x3400,
|
|
0x4DBF,
|
|
"CJK Unified Ideographs Extension A"
|
|
),
|
|
|
|
new (
|
|
0x4DC0,
|
|
0x4DFF,
|
|
"Yijing Hexagram Symbols"
|
|
),
|
|
|
|
new (0x4E00, 0x9FFF, "CJK Unified Ideographs"),
|
|
|
|
new (0xA000, 0xA48F, "Yi Syllables"),
|
|
|
|
new (0xA490, 0xA4CF, "Yi Radicals"),
|
|
|
|
new (0xAC00, 0xD7AF, "Hangul Syllables"),
|
|
|
|
new (0xD800, 0xDB7F, "High Surrogates"),
|
|
|
|
new (
|
|
0xDB80,
|
|
0xDBFF,
|
|
"High Private Use Surrogates"
|
|
),
|
|
|
|
new (0xDC00, 0xDFFF, "Low Surrogates"),
|
|
|
|
new (0xE000, 0xF8FF, "Private Use Area"),
|
|
|
|
new (
|
|
0xF900,
|
|
0xFAFF,
|
|
"CJK Compatibility Ideographs"
|
|
),
|
|
|
|
new (
|
|
0xFB00,
|
|
0xFB4F,
|
|
"Alphabetic Presentation Forms"
|
|
),
|
|
|
|
new (
|
|
0xFB50,
|
|
0xFDFF,
|
|
"Arabic Presentation Forms-A"
|
|
),
|
|
|
|
new (0xFE00, 0xFE0F, "Variation Selectors"),
|
|
|
|
new (0xFE20, 0xFE2F, "Combining Half Marks"),
|
|
|
|
new (
|
|
0xFE30,
|
|
0xFE4F,
|
|
"CJK Compatibility Forms"
|
|
),
|
|
|
|
new (0xFE50, 0xFE6F, "Small Form Variants"),
|
|
|
|
new (
|
|
0xFE70,
|
|
0xFEFF,
|
|
"Arabic Presentation Forms-B"
|
|
),
|
|
|
|
new (
|
|
0xFF00,
|
|
0xFFEF,
|
|
"Halfwidth and Fullwidth Forms"
|
|
),
|
|
|
|
new (0xFFF0, 0xFFFF, "Specials"),
|
|
|
|
new (0x10000, 0x1007F, "Linear B Syllabary"),
|
|
|
|
new (0x10080, 0x100FF, "Linear B Ideograms"),
|
|
|
|
new (0x10100, 0x1013F, "Aegean Numbers"),
|
|
|
|
new (0x10300, 0x1032F, "Old Italic"),
|
|
|
|
new (0x10330, 0x1034F, "Gothic"),
|
|
|
|
new (0x10380, 0x1039F, "Ugaritic"),
|
|
|
|
new (0x10400, 0x1044F, "Deseret"),
|
|
|
|
new (0x10450, 0x1047F, "Shavian"),
|
|
|
|
new (0x10480, 0x104AF, "Osmanya"),
|
|
|
|
new (0x10800, 0x1083F, "Cypriot Syllabary"),
|
|
|
|
new (
|
|
0x1D000,
|
|
0x1D0FF,
|
|
"Byzantine Musical Symbols"
|
|
),
|
|
|
|
new (0x1D100, 0x1D1FF, "Musical Symbols"),
|
|
|
|
new (
|
|
0x1D300,
|
|
0x1D35F,
|
|
"Tai Xuan Jing Symbols"
|
|
),
|
|
|
|
new (
|
|
0x1D400,
|
|
0x1D7FF,
|
|
"Mathematical Alphanumeric Symbols"
|
|
),
|
|
|
|
new (0x1F600, 0x1F532, "Emojis Symbols"),
|
|
|
|
new (
|
|
0x20000,
|
|
0x2A6DF,
|
|
"CJK Unified Ideographs Extension B"
|
|
),
|
|
|
|
new (
|
|
0x2F800,
|
|
0x2FA1F,
|
|
"CJK Compatibility Ideographs Supplement"
|
|
),
|
|
|
|
new (0xE0000, 0xE007F, "Tags")
|
|
];
|
|
|
|
private Scheme? _alternatingScheme;
|
|
private DataTable? _currentTable;
|
|
private Scheme? _redScheme;
|
|
private Scheme? _redSchemeAlt;
|
|
private TableView? _tableView;
|
|
|
|
/// <summary>
|
|
/// Builds a simple table in which cell values contents are the index of the cell. This helps testing that
|
|
/// scrolling etc is working correctly and not skipping out any rows/columns when paging
|
|
/// </summary>
|
|
/// <param name="cols"></param>
|
|
/// <param name="rows"></param>
|
|
/// <returns></returns>
|
|
public static DataTable BuildSimpleDataTable (int cols, int rows)
|
|
{
|
|
var dt = new DataTable ();
|
|
|
|
for (var c = 0; c < cols; c++)
|
|
{
|
|
dt.Columns.Add ("Col" + c);
|
|
}
|
|
|
|
for (var r = 0; r < rows; r++)
|
|
{
|
|
DataRow newRow = dt.NewRow ();
|
|
|
|
for (var c = 0; c < cols; c++)
|
|
{
|
|
newRow [c] = $"R{r}C{c}";
|
|
}
|
|
|
|
dt.Rows.Add (newRow);
|
|
}
|
|
|
|
return dt;
|
|
}
|
|
|
|
public override void Main ()
|
|
{
|
|
// Init
|
|
Application.Init ();
|
|
|
|
// Setup - Create a top-level application window and configure it.
|
|
Runnable appWindow = new ();
|
|
|
|
_tableView = new () { X = 0, Y = 1, Width = Dim.Fill (), Height = Dim.Fill (1) };
|
|
|
|
var menu = new MenuBar ();
|
|
|
|
// File menu
|
|
menu.Add (
|
|
new MenuBarItem (
|
|
"_File",
|
|
[
|
|
new MenuItem { Title = "_OpenBigExample", Action = () => OpenExample (true) },
|
|
new MenuItem { Title = "_OpenSmallExample", Action = () => OpenExample (false) },
|
|
new MenuItem { Title = "OpenCharacter_Map", Action = OpenUnicodeMap },
|
|
new MenuItem { Title = "OpenTreeExample", Action = OpenTreeExample },
|
|
new MenuItem { Title = "_CloseExample", Action = CloseExample },
|
|
new MenuItem { Title = "_Quit", Action = Quit }
|
|
]
|
|
)
|
|
);
|
|
|
|
// View menu - created with helper method due to complexity
|
|
menu.Add (CreateViewMenu ());
|
|
|
|
// Column menu
|
|
menu.Add (
|
|
new MenuBarItem (
|
|
"_Column",
|
|
[
|
|
new MenuItem { Title = "_Set Max Width", Action = SetMaxWidth },
|
|
new MenuItem { Title = "_Set Min Width", Action = SetMinWidth },
|
|
new MenuItem { Title = "_Set MinAcceptableWidth", Action = SetMinAcceptableWidth },
|
|
new MenuItem { Title = "_Set All MinAcceptableWidth=1", Action = SetMinAcceptableWidthToOne }
|
|
]
|
|
)
|
|
);
|
|
|
|
appWindow.Add (menu);
|
|
|
|
var selectedCellLabel = new Label
|
|
{
|
|
Text = "0,0"
|
|
};
|
|
|
|
var statusBar = new StatusBar (
|
|
[
|
|
new (
|
|
Application.QuitKey,
|
|
"Quit",
|
|
Quit
|
|
),
|
|
new (
|
|
Key.F2,
|
|
"OpenExample",
|
|
() => OpenExample (true)
|
|
),
|
|
new (
|
|
Key.F3,
|
|
"CloseExample",
|
|
CloseExample
|
|
),
|
|
new (
|
|
Key.F4,
|
|
"OpenSimple",
|
|
() => OpenSimple (true)
|
|
),
|
|
new ()
|
|
{
|
|
HelpText = "Cell:",
|
|
CommandView = selectedCellLabel
|
|
}
|
|
]
|
|
)
|
|
{
|
|
AlignmentModes = AlignmentModes.IgnoreFirstOrLast
|
|
};
|
|
appWindow.Add (statusBar);
|
|
|
|
appWindow.Add (_tableView);
|
|
|
|
_tableView!.SelectedCellChanged += (s, e) => { selectedCellLabel.Text = $"{_tableView!.SelectedRow},{_tableView!.SelectedColumn}"; };
|
|
_tableView!.CellActivated += EditCurrentCell;
|
|
_tableView!.KeyDown += TableViewKeyPress;
|
|
|
|
//SetupScrollBar ();
|
|
|
|
_redScheme = new ()
|
|
{
|
|
Disabled = appWindow.GetAttributeForRole (VisualRole.Disabled),
|
|
HotFocus = appWindow.GetAttributeForRole (VisualRole.HotFocus),
|
|
Focus = appWindow.GetAttributeForRole (VisualRole.Focus),
|
|
Normal = new (Color.Red, appWindow.GetAttributeForRole (VisualRole.Normal).Background)
|
|
};
|
|
|
|
_alternatingScheme = new ()
|
|
{
|
|
Disabled = appWindow.GetAttributeForRole (VisualRole.Disabled),
|
|
HotFocus = appWindow.GetAttributeForRole (VisualRole.HotFocus),
|
|
Focus = appWindow.GetAttributeForRole (VisualRole.Focus),
|
|
Normal = new (Color.White, Color.BrightBlue)
|
|
};
|
|
|
|
_redSchemeAlt = new ()
|
|
{
|
|
Disabled = appWindow.GetAttributeForRole (VisualRole.Disabled),
|
|
HotFocus = appWindow.GetAttributeForRole (VisualRole.HotFocus),
|
|
Focus = appWindow.GetAttributeForRole (VisualRole.Focus),
|
|
Normal = new (Color.Red, Color.BrightBlue)
|
|
};
|
|
|
|
// if user clicks the mouse in TableView
|
|
_tableView!.Activating += (s, e) =>
|
|
{
|
|
if (_currentTable == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Only handle mouse clicks
|
|
if (e.Context is not CommandContext<MouseBinding> { Binding.MouseEventArgs: { } mouseArgs })
|
|
{
|
|
return;
|
|
}
|
|
|
|
_tableView!.ScreenToCell (mouseArgs.Position, out int? clickedCol);
|
|
|
|
if (clickedCol != null)
|
|
{
|
|
if (mouseArgs.Flags.HasFlag (MouseFlags.Button1Clicked))
|
|
{
|
|
// left click in a header
|
|
SortColumn (clickedCol.Value);
|
|
}
|
|
else if (mouseArgs.Flags.HasFlag (MouseFlags.Button3Clicked))
|
|
{
|
|
// right click in a header
|
|
ShowHeaderContextMenu (clickedCol.Value, mouseArgs);
|
|
}
|
|
}
|
|
};
|
|
|
|
_tableView!.KeyBindings.ReplaceCommands (Key.Space, Command.Accept);
|
|
|
|
// Run - Start the application.
|
|
Application.Run (appWindow);
|
|
appWindow.Dispose ();
|
|
|
|
// Shutdown - Calling Application.Shutdown is required.
|
|
Application.Shutdown ();
|
|
}
|
|
|
|
private MenuBarItem CreateViewMenu ()
|
|
{
|
|
// Store checkbox references for the toggle methods to access
|
|
Dictionary<string, CheckBox> checkboxes = new ();
|
|
|
|
MenuItem CreateCheckBoxMenuItem (string key, string title, bool initialState, Action<bool> onToggle)
|
|
{
|
|
CheckBox checkBox = new ()
|
|
{
|
|
Title = title,
|
|
CheckedState = initialState ? CheckState.Checked : CheckState.UnChecked
|
|
};
|
|
|
|
checkBox.CheckedStateChanged += (s, e) => onToggle (checkBox.CheckedState == CheckState.Checked);
|
|
|
|
MenuItem item = new () { CommandView = checkBox };
|
|
|
|
item.Accepting += (s, e) =>
|
|
{
|
|
checkBox.AdvanceCheckState ();
|
|
e.Handled = true;
|
|
};
|
|
|
|
checkboxes [key] = checkBox;
|
|
|
|
return item;
|
|
}
|
|
|
|
return new (
|
|
"_View",
|
|
[
|
|
CreateCheckBoxMenuItem (
|
|
"ShowHeaders",
|
|
"_ShowHeaders",
|
|
_tableView!.Style.ShowHeaders,
|
|
state =>
|
|
{
|
|
_tableView!.Style.ShowHeaders = state;
|
|
_tableView!.Update ();
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"AlwaysShowHeaders",
|
|
"_AlwaysShowHeaders",
|
|
_tableView!.Style.AlwaysShowHeaders,
|
|
state =>
|
|
{
|
|
_tableView!.Style.AlwaysShowHeaders = state;
|
|
_tableView!.Update ();
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"HeaderOverline",
|
|
"_HeaderOverLine",
|
|
_tableView!.Style.ShowHorizontalHeaderOverline,
|
|
state =>
|
|
{
|
|
_tableView!.Style.ShowHorizontalHeaderOverline = state;
|
|
_tableView!.Update ();
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"HeaderMidline",
|
|
"_HeaderMidLine",
|
|
_tableView!.Style.ShowVerticalHeaderLines,
|
|
state =>
|
|
{
|
|
_tableView!.Style.ShowVerticalHeaderLines = state;
|
|
_tableView!.Update ();
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"HeaderUnderline",
|
|
"_HeaderUnderLine",
|
|
_tableView!.Style.ShowHorizontalHeaderUnderline,
|
|
state =>
|
|
{
|
|
_tableView!.Style.ShowHorizontalHeaderUnderline = state;
|
|
_tableView!.Update ();
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"Bottomline",
|
|
"_BottomLine",
|
|
_tableView!.Style.ShowHorizontalBottomline,
|
|
state =>
|
|
{
|
|
_tableView!.Style.ShowHorizontalBottomline = state;
|
|
_tableView!.Update ();
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"HorizontalScrollIndicators",
|
|
"_HorizontalScrollIndicators",
|
|
_tableView!.Style.ShowHorizontalScrollIndicators,
|
|
state =>
|
|
{
|
|
_tableView!.Style.ShowHorizontalScrollIndicators = state;
|
|
_tableView!.Update ();
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"FullRowSelect",
|
|
"_FullRowSelect",
|
|
_tableView!.FullRowSelect,
|
|
state =>
|
|
{
|
|
_tableView!.FullRowSelect = state;
|
|
_tableView!.Update ();
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"CellLines",
|
|
"_CellLines",
|
|
_tableView!.Style.ShowVerticalCellLines,
|
|
state =>
|
|
{
|
|
_tableView!.Style.ShowVerticalCellLines = state;
|
|
_tableView!.Update ();
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"ExpandLastColumn",
|
|
"_ExpandLastColumn",
|
|
_tableView!.Style.ExpandLastColumn,
|
|
state =>
|
|
{
|
|
_tableView!.Style.ExpandLastColumn = state;
|
|
_tableView!.Update ();
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"AlwaysUseNormalColorForVerticalCellLines",
|
|
"_AlwaysUseNormalColorForVerticalCellLines",
|
|
_tableView!.Style.AlwaysUseNormalColorForVerticalCellLines,
|
|
state =>
|
|
{
|
|
_tableView!.Style.AlwaysUseNormalColorForVerticalCellLines = state;
|
|
_tableView!.Update ();
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"SmoothScrolling",
|
|
"_SmoothHorizontalScrolling",
|
|
_tableView!.Style.SmoothHorizontalScrolling,
|
|
state =>
|
|
{
|
|
_tableView!.Style.SmoothHorizontalScrolling = state;
|
|
_tableView!.Update ();
|
|
}
|
|
),
|
|
new MenuItem
|
|
{
|
|
Title = "_AllLines",
|
|
Action = () =>
|
|
{
|
|
_tableView!.Style.ShowHorizontalHeaderOverline = true;
|
|
_tableView!.Style.ShowVerticalHeaderLines = true;
|
|
_tableView!.Style.ShowHorizontalHeaderUnderline = true;
|
|
_tableView!.Style.ShowVerticalCellLines = true;
|
|
|
|
checkboxes ["HeaderOverline"].CheckedState = CheckState.Checked;
|
|
checkboxes ["HeaderMidline"].CheckedState = CheckState.Checked;
|
|
checkboxes ["HeaderUnderline"].CheckedState = CheckState.Checked;
|
|
checkboxes ["CellLines"].CheckedState = CheckState.Checked;
|
|
|
|
_tableView!.Update ();
|
|
}
|
|
},
|
|
new MenuItem
|
|
{
|
|
Title = "_NoLines",
|
|
Action = () =>
|
|
{
|
|
_tableView!.Style.ShowHorizontalHeaderOverline = false;
|
|
_tableView!.Style.ShowVerticalHeaderLines = false;
|
|
_tableView!.Style.ShowHorizontalHeaderUnderline = false;
|
|
_tableView!.Style.ShowVerticalCellLines = false;
|
|
|
|
checkboxes ["HeaderOverline"].CheckedState = CheckState.UnChecked;
|
|
checkboxes ["HeaderMidline"].CheckedState = CheckState.UnChecked;
|
|
checkboxes ["HeaderUnderline"].CheckedState = CheckState.UnChecked;
|
|
checkboxes ["CellLines"].CheckedState = CheckState.UnChecked;
|
|
|
|
_tableView!.Update ();
|
|
}
|
|
},
|
|
CreateCheckBoxMenuItem (
|
|
"Checkboxes",
|
|
"_Checkboxes",
|
|
false,
|
|
state =>
|
|
{
|
|
if (state)
|
|
{
|
|
ToggleCheckboxes (false);
|
|
checkboxes ["Radioboxes"].CheckedState = CheckState.UnChecked;
|
|
}
|
|
else if (HasCheckboxes ())
|
|
{
|
|
ToggleCheckboxes (false);
|
|
}
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"Radioboxes",
|
|
"_Radioboxes",
|
|
false,
|
|
state =>
|
|
{
|
|
if (state)
|
|
{
|
|
ToggleCheckboxes (true);
|
|
checkboxes ["Checkboxes"].CheckedState = CheckState.UnChecked;
|
|
}
|
|
else if (HasCheckboxes ())
|
|
{
|
|
ToggleCheckboxes (true);
|
|
}
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"AlternatingColors",
|
|
"Alternating Colors",
|
|
false,
|
|
state =>
|
|
{
|
|
if (state)
|
|
{
|
|
_tableView!.Style.RowColorGetter = a => { return a.RowIndex % 2 == 0 ? _alternatingScheme : null; };
|
|
}
|
|
else
|
|
{
|
|
_tableView!.Style.RowColorGetter = null;
|
|
}
|
|
|
|
_tableView!.SetNeedsDraw ();
|
|
}
|
|
),
|
|
CreateCheckBoxMenuItem (
|
|
"Cursor",
|
|
"Invert Selected Cell First Character",
|
|
_tableView!.Style.InvertSelectedCellFirstCharacter,
|
|
state =>
|
|
{
|
|
_tableView!.Style.InvertSelectedCellFirstCharacter = state;
|
|
_tableView!.SetNeedsDraw ();
|
|
}
|
|
),
|
|
new MenuItem { Title = "_ClearColumnStyles", Action = ClearColumnStyles },
|
|
new MenuItem { Title = "Sho_w All Columns", Action = ShowAllColumns }
|
|
]
|
|
);
|
|
}
|
|
|
|
protected override void Dispose (bool disposing)
|
|
{
|
|
base.Dispose (disposing);
|
|
|
|
foreach (IDisposable d in _toDispose!)
|
|
{
|
|
d.Dispose ();
|
|
}
|
|
}
|
|
|
|
private DataTable BuildUnicodeMap ()
|
|
{
|
|
var dt = new DataTable ();
|
|
|
|
// add cols called 0 to 9
|
|
for (var i = 0; i < 10; i++)
|
|
{
|
|
DataColumn col = dt.Columns.Add (i.ToString (), typeof (uint));
|
|
ColumnStyle style = _tableView!.Style.GetOrCreateColumnStyle (col.Ordinal);
|
|
style.RepresentationGetter = o => new Rune ((uint)o).ToString ();
|
|
}
|
|
|
|
// add cols called a to z
|
|
for (int i = 'a'; i < 'a' + 26; i++)
|
|
{
|
|
DataColumn col = dt.Columns.Add (((char)i).ToString (), typeof (uint));
|
|
ColumnStyle style = _tableView!.Style.GetOrCreateColumnStyle (col.Ordinal);
|
|
style.RepresentationGetter = o => new Rune ((uint)o).ToString ();
|
|
}
|
|
|
|
// now add table contents
|
|
List<uint> runes = new ();
|
|
|
|
foreach (UnicodeRange range in _ranges!)
|
|
{
|
|
for (uint i = range.Start; i <= range.End; i++)
|
|
{
|
|
runes.Add (i);
|
|
}
|
|
}
|
|
|
|
DataRow? dr = null;
|
|
|
|
for (var i = 0; i < runes.Count; i++)
|
|
{
|
|
if (dr == null || i % dt.Columns.Count == 0)
|
|
{
|
|
dr = dt.Rows.Add ();
|
|
}
|
|
|
|
dr [i % dt.Columns.Count] = runes [i].ToString ();
|
|
}
|
|
|
|
return dt;
|
|
}
|
|
|
|
private void CheckOrUncheckFile (FileSystemInfo info, bool check)
|
|
{
|
|
if (check)
|
|
{
|
|
_checkedFileSystemInfos!.Add (info);
|
|
}
|
|
else
|
|
{
|
|
_checkedFileSystemInfos!.Remove (info);
|
|
}
|
|
}
|
|
|
|
private void ClearColumnStyles ()
|
|
{
|
|
_tableView!.Style.ColumnStyles.Clear ();
|
|
_tableView!.Update ();
|
|
}
|
|
|
|
private void CloseExample () { _tableView!.Table = null; }
|
|
|
|
private void EditCurrentCell (object? sender, CellActivatedEventArgs e)
|
|
{
|
|
if (e.Table is not DataTableSource || _currentTable == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int tableCol = ToTableCol (e.Col);
|
|
|
|
if (tableCol < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
object o = _currentTable.Rows [e.Row] [tableCol];
|
|
|
|
string title = o is uint u ? GetUnicodeCategory (u) + $"(0x{o:X4})" : "Enter new value";
|
|
|
|
var oldValue = _currentTable.Rows [e.Row] [tableCol].ToString ();
|
|
var okPressed = false;
|
|
|
|
var ok = new Button { Text = "Ok", IsDefault = true };
|
|
|
|
ok.Accepting += (s, e) =>
|
|
{
|
|
okPressed = true;
|
|
Application.RequestStop ();
|
|
};
|
|
var cancel = new Button { Text = "Cancel" };
|
|
cancel.Accepting += (s, e) => { Application.RequestStop (); };
|
|
var d = new Dialog { Title = title, Buttons = [ok, cancel] };
|
|
|
|
var lbl = new Label { X = 0, Y = 1, Text = _tableView!.Table.ColumnNames [e.Col] };
|
|
|
|
var tf = new TextField { Text = oldValue, X = 0, Y = 2, Width = Dim.Fill () };
|
|
|
|
d.Add (lbl, tf);
|
|
tf.SetFocus ();
|
|
|
|
Application.Run (d);
|
|
d.Dispose ();
|
|
|
|
if (okPressed)
|
|
{
|
|
try
|
|
{
|
|
_currentTable.Rows [e.Row] [tableCol] =
|
|
string.IsNullOrWhiteSpace (tf.Text) ? DBNull.Value : tf.Text;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.ErrorQuery ((sender as View)?.App, 60, 20, "Failed to set text", ex.Message, "Ok");
|
|
}
|
|
|
|
_tableView!.Update ();
|
|
}
|
|
}
|
|
|
|
private IEnumerable<FileSystemInfo> GetChildren (FileSystemInfo arg)
|
|
{
|
|
try
|
|
{
|
|
return arg is DirectoryInfo d ? d.GetFileSystemInfos () : Enumerable.Empty<FileSystemInfo> ();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// Permission denied etc
|
|
return [];
|
|
}
|
|
}
|
|
|
|
private int? GetColumn ()
|
|
{
|
|
if (_tableView!.Table == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (_tableView!.SelectedColumn < 0 || _tableView!.SelectedColumn > _tableView!.Table.Columns)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return _tableView!.SelectedColumn;
|
|
}
|
|
|
|
private string GetHumanReadableFileSize (FileSystemInfo fsi)
|
|
{
|
|
if (fsi is not FileInfo fi)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
long value = fi.Length;
|
|
CultureInfo culture = CultureInfo.CurrentUICulture;
|
|
|
|
return GetHumanReadableFileSize (value, culture);
|
|
}
|
|
|
|
private string GetHumanReadableFileSize (long value, CultureInfo culture)
|
|
{
|
|
const long ByteConversion = 1024;
|
|
string [] SizeSuffixes = { "bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };
|
|
|
|
if (value < 0)
|
|
{
|
|
return "-" + GetHumanReadableFileSize (-value, culture);
|
|
}
|
|
|
|
if (value == 0)
|
|
{
|
|
return "0.0 bytes";
|
|
}
|
|
|
|
var mag = (int)Math.Log (value, ByteConversion);
|
|
double adjustedSize = value / Math.Pow (1000, mag);
|
|
|
|
return string.Format (culture.NumberFormat, "{0:n2} {1}", adjustedSize, SizeSuffixes [mag]);
|
|
}
|
|
|
|
private string GetProposedNewSortOrder (int clickedCol, out bool isAsc)
|
|
{
|
|
// work out new sort order
|
|
string sort = _currentTable!.DefaultView.Sort;
|
|
string colName = _tableView!.Table.ColumnNames [clickedCol];
|
|
|
|
if (sort?.EndsWith ("ASC") ?? false)
|
|
{
|
|
sort = $"{colName} DESC";
|
|
isAsc = false;
|
|
}
|
|
else
|
|
{
|
|
sort = $"{colName} ASC";
|
|
isAsc = true;
|
|
}
|
|
|
|
return sort;
|
|
}
|
|
|
|
private string GetUnicodeCategory (uint u) { return _ranges!.FirstOrDefault (r => u >= r.Start && u <= r.End)?.Category ?? "Unknown"; }
|
|
private bool HasCheckboxes () => _tableView!.Table is CheckBoxTableSourceWrapperBase;
|
|
|
|
private void HideColumn (int clickedCol)
|
|
{
|
|
ColumnStyle style = _tableView!.Style.GetOrCreateColumnStyle (clickedCol);
|
|
style.Visible = false;
|
|
_tableView!.Update ();
|
|
}
|
|
|
|
private void OpenExample (bool big)
|
|
{
|
|
SetTable (TableView.BuildDemoDataTable (big ? 30 : 5, big ? 1000 : 5));
|
|
SetDemoTableStyles ();
|
|
}
|
|
|
|
private void OpenSimple (bool big) { SetTable (BuildSimpleDataTable (big ? 30 : 5, big ? 1000 : 5)); }
|
|
|
|
private void OpenTreeExample ()
|
|
{
|
|
_tableView!.Style.ColumnStyles.Clear ();
|
|
|
|
TreeView<FileSystemInfo> tree = new ()
|
|
{
|
|
AspectGetter = f => f.Name, TreeBuilder = new DelegateTreeBuilder<FileSystemInfo> (GetChildren)
|
|
};
|
|
|
|
TreeTableSource<FileSystemInfo> source = new (
|
|
_tableView,
|
|
"Name",
|
|
tree,
|
|
new ()
|
|
{
|
|
{ "Extension", f => f.Extension },
|
|
{ "CreationTime", f => f.CreationTime },
|
|
{ "FileSize", GetHumanReadableFileSize }
|
|
}
|
|
);
|
|
|
|
HashSet<string> seen = new ();
|
|
|
|
try
|
|
{
|
|
foreach (string path in Environment.GetLogicalDrives ())
|
|
{
|
|
tree.AddObject (new DirectoryInfo (path));
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.ErrorQuery (_tableView?.App, "Could not find local drives", e.Message, "Ok");
|
|
}
|
|
|
|
_tableView!.Table = source;
|
|
|
|
_toDispose?.Add (tree);
|
|
}
|
|
|
|
private void OpenUnicodeMap ()
|
|
{
|
|
SetTable (BuildUnicodeMap ());
|
|
_tableView?.Update ();
|
|
}
|
|
|
|
private void Quit () { Application.RequestStop (); }
|
|
|
|
private void RunColumnWidthDialog (
|
|
int? col,
|
|
string prompt,
|
|
Action<ColumnStyle, int> setter,
|
|
Func<ColumnStyle, int> getter
|
|
)
|
|
{
|
|
if (col == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var accepted = false;
|
|
var ok = new Button { Text = "Ok", IsDefault = true };
|
|
|
|
ok.Accepting += (s, e) =>
|
|
{
|
|
accepted = true;
|
|
(s as View)?.App?.RequestStop ();
|
|
};
|
|
var cancel = new Button { Text = "Cancel" };
|
|
cancel.Accepting += (s, e) => { (s as View)?.App?.RequestStop (); };
|
|
|
|
var d = new Dialog
|
|
{
|
|
Title = prompt,
|
|
Buttons = [ok, cancel]
|
|
};
|
|
|
|
ColumnStyle style = _tableView!.Style.GetOrCreateColumnStyle (col.Value);
|
|
|
|
var lbl = new Label { X = 0, Y = 0, Text = $"{_tableView!.Table.ColumnNames [col.Value]}: " };
|
|
var tf = new TextField { Text = getter (style).ToString (), X = Pos.Right (lbl), Y = 0, Width = 20 };
|
|
|
|
d.Add (lbl, tf);
|
|
tf.SetFocus ();
|
|
|
|
_tableView.App?.Run (d);
|
|
d.Dispose ();
|
|
|
|
if (accepted)
|
|
{
|
|
try
|
|
{
|
|
setter (style, int.Parse (tf.Text));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.ErrorQuery (_tableView.App, 60, 20, "Failed to set", ex.Message, "Ok");
|
|
}
|
|
|
|
_tableView!.Update ();
|
|
}
|
|
}
|
|
|
|
private void SetDemoTableStyles ()
|
|
{
|
|
_tableView!.Style.ColumnStyles.Clear ();
|
|
|
|
var alignMid = new ColumnStyle { Alignment = Alignment.Center };
|
|
var alignRight = new ColumnStyle { Alignment = Alignment.End };
|
|
|
|
var dateFormatStyle = new ColumnStyle
|
|
{
|
|
Alignment = Alignment.End,
|
|
RepresentationGetter = v =>
|
|
v is DateTime d ? d.ToString ("yyyy-MM-dd") : v.ToString ()
|
|
};
|
|
|
|
var negativeRight = new ColumnStyle
|
|
{
|
|
Format = "0.##",
|
|
MinWidth = 10,
|
|
AlignmentGetter = v => v is double d
|
|
?
|
|
|
|
// align negative values right
|
|
d < 0
|
|
? Alignment.End
|
|
:
|
|
|
|
// align positive values left
|
|
Alignment.Start
|
|
:
|
|
|
|
// not a double
|
|
Alignment.Start,
|
|
ColorGetter = a => a.CellValue is double d
|
|
?
|
|
|
|
// color 0 and negative values red
|
|
d <= 0.0000001
|
|
? a.RowIndex % 2 == 0
|
|
? _redSchemeAlt
|
|
: _redScheme
|
|
:
|
|
|
|
// use normal scheme for positive values
|
|
null
|
|
:
|
|
|
|
// not a double
|
|
null
|
|
};
|
|
|
|
_tableView!.Style.ColumnStyles.Add (_currentTable!.Columns ["DateCol"]!.Ordinal, dateFormatStyle);
|
|
_tableView!.Style.ColumnStyles.Add (_currentTable!.Columns ["DoubleCol"]!.Ordinal, negativeRight);
|
|
_tableView!.Style.ColumnStyles.Add (_currentTable!.Columns ["NullsCol"]!.Ordinal, alignMid);
|
|
_tableView!.Style.ColumnStyles.Add (_currentTable!.Columns ["IntCol"]!.Ordinal, alignRight);
|
|
|
|
_tableView!.Update ();
|
|
}
|
|
|
|
private void SetMaxWidth ()
|
|
{
|
|
int? col = GetColumn ();
|
|
RunColumnWidthDialog (col, "MaxWidth", (s, v) => s.MaxWidth = v, s => s.MaxWidth);
|
|
}
|
|
|
|
private void SetMinAcceptableWidth ()
|
|
{
|
|
int? col = GetColumn ();
|
|
|
|
RunColumnWidthDialog (
|
|
col,
|
|
"MinAcceptableWidth",
|
|
(s, v) => s.MinAcceptableWidth = v,
|
|
s => s.MinAcceptableWidth
|
|
);
|
|
}
|
|
|
|
private void SetMinAcceptableWidthToOne ()
|
|
{
|
|
for (var i = 0; i < _tableView!.Table.Columns; i++)
|
|
{
|
|
ColumnStyle style = _tableView!.Style.GetOrCreateColumnStyle (i);
|
|
style.MinAcceptableWidth = 1;
|
|
}
|
|
}
|
|
|
|
private void SetMinWidth ()
|
|
{
|
|
int? col = GetColumn ();
|
|
RunColumnWidthDialog (col, "MinWidth", (s, v) => s.MinWidth = v, s => s.MinWidth);
|
|
}
|
|
|
|
private void SetTable (DataTable dataTable) { _tableView!.Table = new DataTableSource (_currentTable = dataTable); }
|
|
|
|
//private void SetupScrollBar ()
|
|
//{
|
|
// var scrollBar = new ScrollBarView (_tableView, true);
|
|
|
|
// scrollBar.ChangedPosition += (s, e) =>
|
|
// {
|
|
// _tableView!.RowOffset = scrollBar.Position;
|
|
|
|
// if (_tableView!.RowOffset != scrollBar.Position)
|
|
// {
|
|
// scrollBar.Position = _tableView!.RowOffset;
|
|
// }
|
|
|
|
// _tableView!.SetNeedsDraw ();
|
|
// };
|
|
// /*
|
|
// scrollBar.OtherScrollBarView.ChangedPosition += (s,e) => {
|
|
// tableView.LeftItem = scrollBar.OtherScrollBarView.Position;
|
|
// if (tableView.LeftItem != scrollBar.OtherScrollBarView.Position) {
|
|
// scrollBar.OtherScrollBarView.Position = tableView.LeftItem;
|
|
// }
|
|
// tableView.SetNeedsDraw ();
|
|
// };*/
|
|
|
|
// _tableView!.DrawingContent += (s, e) =>
|
|
// {
|
|
// scrollBar.Size = _tableView!.Table?.Rows ?? 0;
|
|
// scrollBar.Position = _tableView!.RowOffset;
|
|
|
|
// //scrollBar.OtherScrollBarView.Size = tableView.Maxlength - 1;
|
|
// //scrollBar.OtherScrollBarView.Position = tableView.LeftItem;
|
|
// scrollBar.Refresh ();
|
|
// };
|
|
//}
|
|
|
|
private void ShowAllColumns ()
|
|
{
|
|
foreach (KeyValuePair<int, ColumnStyle> colStyle in _tableView!.Style.ColumnStyles)
|
|
{
|
|
colStyle.Value.Visible = true;
|
|
}
|
|
|
|
_tableView!.Update ();
|
|
}
|
|
|
|
private void ShowHeaderContextMenu (int clickedCol, MouseEventArgs e)
|
|
{
|
|
if (HasCheckboxes () && clickedCol == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
string sort = GetProposedNewSortOrder (clickedCol, out bool isAsc);
|
|
string colName = _tableView!.Table.ColumnNames [clickedCol];
|
|
|
|
PopoverMenu? contextMenu = new (
|
|
[
|
|
new (
|
|
$"Hide {TrimArrows (colName)}",
|
|
"",
|
|
() => HideColumn (clickedCol)
|
|
),
|
|
new (
|
|
$"Sort {StripArrows (sort)}",
|
|
"",
|
|
() => SortColumn (clickedCol, sort, isAsc)
|
|
)
|
|
]);
|
|
|
|
// Registering with the PopoverManager will ensure that the context menu is closed when the view is no longer focused
|
|
// and the context menu is disposed when it is closed.
|
|
e.View?.App!.Popover?.Register (contextMenu);
|
|
contextMenu?.MakeVisible (new (e.ScreenPosition.X + 1, e.ScreenPosition.Y + 1));
|
|
}
|
|
|
|
private void SortColumn (int clickedCol)
|
|
{
|
|
string sort = GetProposedNewSortOrder (clickedCol, out bool isAsc);
|
|
|
|
// don't try to sort on the toggled column
|
|
if (HasCheckboxes () && clickedCol == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SortColumn (clickedCol, sort, isAsc);
|
|
}
|
|
|
|
private void SortColumn (int clickedCol, string sort, bool isAsc)
|
|
{
|
|
if (_currentTable == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// set a sort order
|
|
_currentTable.DefaultView.Sort = sort;
|
|
|
|
// copy the rows from the view
|
|
DataTable sortedCopy = _currentTable.DefaultView.ToTable ();
|
|
_currentTable.Rows.Clear ();
|
|
|
|
foreach (DataRow r in sortedCopy.Rows)
|
|
{
|
|
_currentTable.ImportRow (r);
|
|
}
|
|
|
|
foreach (DataColumn col in _currentTable.Columns)
|
|
{
|
|
// remove any lingering sort indicator
|
|
col.ColumnName = TrimArrows (col.ColumnName);
|
|
|
|
// add a new one if this the one that is being sorted
|
|
if (col.Ordinal == clickedCol)
|
|
{
|
|
col.ColumnName += isAsc ? Glyphs.UpArrow : Glyphs.DownArrow;
|
|
}
|
|
}
|
|
|
|
_tableView!.Update ();
|
|
}
|
|
|
|
private string StripArrows (string columnName) => columnName.Replace ($"{Glyphs.DownArrow}", "").Replace ($"{Glyphs.UpArrow}", "");
|
|
|
|
private void TableViewKeyPress (object? sender, Key e)
|
|
{
|
|
if (_currentTable == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (e.KeyCode == KeyCode.Delete)
|
|
{
|
|
if (_tableView!.FullRowSelect)
|
|
{
|
|
// Delete button deletes all rows when in full row mode
|
|
foreach (int toRemove in _tableView!.GetAllSelectedCells ()
|
|
.Select (p => p.Y)
|
|
.Distinct ()
|
|
.OrderByDescending (i => i))
|
|
{
|
|
_currentTable.Rows.RemoveAt (toRemove);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// otherwise set all selected cells to null
|
|
foreach (Point pt in _tableView!.GetAllSelectedCells ())
|
|
{
|
|
_currentTable.Rows [pt.Y] [pt.X] = DBNull.Value;
|
|
}
|
|
}
|
|
|
|
_tableView!.Update ();
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
private void ToggleCheckboxes (bool radio)
|
|
{
|
|
if (_tableView!.Table is CheckBoxTableSourceWrapperBase wrapper)
|
|
{
|
|
// unwrap it to remove check boxes
|
|
_tableView!.Table = wrapper.Wrapping;
|
|
|
|
// if toggling off checkboxes/radio
|
|
if (wrapper.UseRadioButtons == radio)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
ITableSource source;
|
|
|
|
// Either toggling on checkboxes/radio or switching from radio to checkboxes (or vice versa)
|
|
if (_tableView!.Table is TreeTableSource<FileSystemInfo> treeSource)
|
|
{
|
|
source = new CheckBoxTableSourceWrapperByObject<FileSystemInfo> (
|
|
_tableView,
|
|
treeSource,
|
|
_checkedFileSystemInfos!.Contains,
|
|
CheckOrUncheckFile
|
|
)
|
|
{ UseRadioButtons = radio };
|
|
}
|
|
else
|
|
{
|
|
source = new CheckBoxTableSourceWrapperByIndex (_tableView, _tableView!.Table) { UseRadioButtons = radio };
|
|
}
|
|
|
|
_tableView!.Table = source;
|
|
}
|
|
|
|
private int ToTableCol (int col)
|
|
{
|
|
if (HasCheckboxes ())
|
|
{
|
|
return col - 1;
|
|
}
|
|
|
|
return col;
|
|
}
|
|
|
|
private string TrimArrows (string columnName) =>
|
|
columnName.TrimEnd (
|
|
(char)Glyphs.UpArrow.Value,
|
|
(char)Glyphs.DownArrow.Value
|
|
);
|
|
|
|
public class UnicodeRange (uint start, uint end, string category)
|
|
{
|
|
public readonly string Category = category;
|
|
public readonly uint End = end;
|
|
public readonly uint Start = start;
|
|
}
|
|
}
|