mirror of
https://github.com/gui-cs/Terminal.Gui.git
synced 2025-12-26 15:57:56 +01:00
a6258ed398
* Add comprehensive unit tests for WindowsKeyConverter - Implement 118 parallelizable unit tests for WindowsKeyConverter - Cover ToKey and ToKeyInfo methods with full bidirectional testing - Test basic characters, modifiers, special keys, function keys - Test VK_PACKET Unicode/IME input - Test OEM keys, NumPad keys, and lock states - Include round-trip conversion tests - All tests passing successfully Fixes #4389 * Rename `start` parameter to `viewportXOffset` for clarity The `start` parameter in several methods and interfaces has been renamed to `viewportXOffset` to better reflect its purpose as the horizontal offset of the viewport during string rendering. - Updated method signatures in `ListViewWithSelection` to use `viewportXOffset` instead of `start`, including default values. - Modified the `RenderUstr` method in `ListViewWithSelection` to use `viewportXOffset` for calculating the starting index. - Renamed the `start` parameter to `viewportXOffset` in the `IListDataSource` interface and updated its documentation. - Replaced all occurrences of `start` with `viewportXOffset` in the `ListWrapper<T>` class, including method calls and logic. - Updated the `RenderUstr` method in `ListWrapper<T>` to use `viewportXOffset` for substring calculations. - Adjusted the test method in `ListViewTests.cs` to reflect the parameter name change. These changes improve code readability and make the parameter's role in rendering logic more explicit. * Remove WindowsKeyConverterTests class that was added by mistake * Modernized ListView and IListDataSource - Tons of new unit tests Refactored `ListView` and `IListDataSource` to improve readability, maintainability, and functionality. Introduced `ListWrapper<T>` as a default implementation of `IListDataSource` for easier integration with standard collections. Enhanced `ListView` with better handling of marking, selection, and scrolling. Replaced `viewportXOffset` with `viewportX` for horizontal scrolling. Added `EnsureSelectedItemVisible` to maintain visibility of the selected item. Updated `IListDataSource` with detailed XML documentation and added `SuspendCollectionChangedEvent` for bulk updates. Improved null safety with nullable reference types. Added comprehensive unit tests for `ListWrapper<T>` and `IListDataSource` to ensure robustness. Modernized the codebase with C# features like expression-bodied members and pattern matching. Fixed bugs related to `SelectedItem` validation and rendering artifacts. * Improve index validation in ComboBox and ListView Enhance robustness by adding stricter checks for valid indices in ComboBox and ListView. Updated conditions in the `_listview.SelectedItemChanged` event handler to ensure `e.Item` is non-negative before accessing `_searchSet`. Modified the `SetValue` method to use `e.Item` instead of `_listview.SelectedItem`. In ListView, updated the `OnSelectedChanged` method to validate that `SelectedItem` is non-negative (`>= 0`) before accessing the `Source` list. These changes prevent potential out-of-range errors and improve code safety. * Refactor and enhance test coverage across modules Refactored and added new tests to improve coverage, readability, and consistency across multiple test files. Key changes include: - **ShortcutTests.cs**: Added tests for `BindKeyToApplication` and removed redundant tests. - **SourcesManagerTests.cs**: Renamed `Update_*` tests to `Load_*` for clarity. - **ArrangementTests.cs**: Reintroduced `MouseGrabHandler` tests, added `ViewArrangement` flag tests, and improved structure. - **NeedsDrawTests.cs**: Replaced `Application.Screen.Size` with fixed dimensions for better isolation. - **DimAutoTests.cs**: Updated layout tests to use fixed dimensions. - **FrameTests.cs**: Standardized object initialization and validated frame behavior. - **SubViewTests.cs**: Improved formatting and modernized event handling. - **NumericUpDownTests.cs**: Decoupled layout tests from screen size. General improvements: - Enhanced formatting and removed redundant tests. - Added comments for clarity. - Introduced `ITestOutputHelper` for better debugging in `ArrangementTests`. * Refactor to use nullable types for better null safety Enabled nullable reference types across the codebase to improve null safety and prevent potential null reference issues. Refactored `SelectedItem` and related properties from `int` to `int?` to represent no selection with `null` instead of `-1`. Updated logic, event arguments, and method signatures to handle nullable values consistently. Simplified object initialization using modern C# syntax and improved code readability with interpolated strings. Added null checks and early returns to prevent runtime errors. Enhanced error handling by throwing `ArgumentOutOfRangeException` for invalid values. Updated tests to reflect the changes, replacing assertions for `-1` with `null` and ensuring proper handling of nullable values. Cleaned up redundant code and improved formatting for better maintainability. * on` functionality has been deprecated, refactored, or removed from the `Shortcut` class. * Refactor: Transition to instance-based architecture Updated `Run-LocalCoverage.ps1` to increase `--blame-hang-timeout` from 10s to 60s. Improved null safety in `GuiTestContext` by adding null-conditional operators. Commented out problematic code in `SetupFakeApplicationAttribute.cs` to prevent test hangs. Excluded `ViewBase` files from `UnitTests.Parallelizable.csproj` and removed redundant folder declarations. Simplified event handling in `IListDataSourceTests.cs` and updated `ListViewTests.cs` to use nullable reference types. Enhanced documentation to emphasize the transition to an instance-based application architecture. Updated examples in `application.md`, `multitasking.md`, and `navigation.md` to reflect the use of `Application.Create()` and `View.App`. Clarified the obsolescence of the static `Application` class. Revised table of contents in `toc.yml` to include new sections like "Application Deep Dive" and "Scheme Deep Dive." Added `dotnet-tools.json` for tool configuration. These changes improve maintainability, testability, and alignment with modern C# practices. * Refactor ListViewTests to use Terminal.Gui framework The `ListViewTests` class has been refactored to replace the `AutoInitShutdown` attribute with explicit application lifecycle management using `IApplication` and `app.Init()` from the `Terminal.Gui` framework. Key changes include: - Rewriting tests to use `Terminal.Gui`'s application lifecycle. - Adding a private `_output` field for logging test output via `ITestOutputHelper`. - Updating `DriverAssert.AssertDriverContentsWithFrameAre` to include `app.Driver` for UI verification. - Rewriting tests like `Clicking_On_Border_Is_Ignored`, `EnsureSelectedItemVisible_SelectedItem`, and others to align with the new framework. - Adding explicit calls to `app.Shutdown()` for proper cleanup. - Enabling nullable reference types with `#nullable enable`. - Updating `using` directives and `namespace` to reflect the new structure. These changes improve test maintainability, compatibility, and diagnostics. * Update Terminal.Gui/Views/CollectionNavigation/CollectionNavigatorBase.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update Terminal.Gui/Views/CollectionNavigation/CollectionNavigatorBase.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update Examples/UICatalog/UICatalogTop.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update Terminal.Gui/Views/ListWrapper.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update Terminal.Gui/Views/ListWrapper.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Updated the `SetMark` method to return `Source.IsMarked(SelectedItem.Value)` for consistency and removed an outdated comment questioning its correctness. Enhanced the exception message in the `SelectedItem` property setter to provide clearer guidance when the value is out of range. * Add comprehensive ListView behavior test coverage Added multiple test methods to validate `ListView` behavior: - `Vertical_ScrollBar_Hides_And_Shows_As_Needed`: Ensures the vertical scrollbar auto-hides/shows based on content height. - `Mouse_Wheel_Scrolls`: Verifies vertical scrolling with the mouse wheel updates `TopItem`. - `SelectedItem_With_Source_Null_Does_Nothing`: Confirms no exceptions occur when setting `SelectedItem` with a `null` source. - `Horizontal_Scroll`: Tests horizontal scrolling, including programmatic and mouse wheel interactions, ensuring `LeftItem` updates correctly. - `SetSourceAsync_SetsSource`: Validates the asynchronous `SetSourceAsync` method updates the source and item count. - `AllowsMultipleSelection_Set_To_False_Unmarks_All_But_Selected`: Ensures disabling multiple selection unmarks all but the selected item. - `Source_CollectionChanged_Remove`: Confirms `SelectedItem` and source count update correctly when items are removed from the source collection. --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
1414 lines
59 KiB
C#
1414 lines
59 KiB
C#
using System.Collections.ObjectModel;
|
|
using System.ComponentModel;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Text;
|
|
|
|
#pragma warning disable CS0618 // Type or member is obsolete
|
|
|
|
namespace UICatalog.Scenarios;
|
|
|
|
[ScenarioMetadata ("Dynamic MenuBar", "Demonstrates how to change a MenuBar dynamically.")]
|
|
[ScenarioCategory ("Arrangement")]
|
|
[ScenarioCategory ("Menus")]
|
|
public class DynamicMenuBar : Scenario
|
|
{
|
|
public override void Main ()
|
|
{
|
|
// Init
|
|
Application.Init ();
|
|
|
|
// Setup - Create a top-level application window and configure it.
|
|
DynamicMenuBarSample appWindow = new ()
|
|
{
|
|
Title = GetQuitKeyAndName ()
|
|
};
|
|
|
|
// Run - Start the application.
|
|
Application.Run (appWindow);
|
|
appWindow.Dispose ();
|
|
|
|
// Shutdown - Calling Application.Shutdown is required.
|
|
Application.Shutdown ();
|
|
}
|
|
|
|
public class Binding
|
|
{
|
|
private readonly PropertyInfo _sourceBindingProperty;
|
|
private readonly object _sourceDataContext;
|
|
private readonly IValueConverter _valueConverter;
|
|
|
|
public Binding (
|
|
View source,
|
|
string sourcePropertyName,
|
|
View target,
|
|
string targetPropertyName,
|
|
IValueConverter valueConverter = null
|
|
)
|
|
{
|
|
Target = target;
|
|
Source = source;
|
|
SourcePropertyName = sourcePropertyName;
|
|
TargetPropertyName = targetPropertyName;
|
|
_sourceDataContext = Source.GetType ().GetProperty ("DataContext").GetValue (Source);
|
|
_sourceBindingProperty = _sourceDataContext.GetType ().GetProperty (SourcePropertyName);
|
|
_valueConverter = valueConverter;
|
|
UpdateTarget ();
|
|
|
|
var notifier = (INotifyPropertyChanged)_sourceDataContext;
|
|
|
|
if (notifier != null)
|
|
{
|
|
notifier.PropertyChanged += (s, e) =>
|
|
{
|
|
if (e.PropertyName == SourcePropertyName)
|
|
{
|
|
UpdateTarget ();
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
public View Source { get; }
|
|
public string SourcePropertyName { get; }
|
|
public View Target { get; }
|
|
public string TargetPropertyName { get; }
|
|
|
|
private void UpdateTarget ()
|
|
{
|
|
try
|
|
{
|
|
object sourceValue = _sourceBindingProperty.GetValue (_sourceDataContext);
|
|
|
|
if (sourceValue == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
object finalValue = _valueConverter?.Convert (sourceValue) ?? sourceValue;
|
|
|
|
PropertyInfo targetProperty = Target.GetType ().GetProperty (TargetPropertyName);
|
|
targetProperty.SetValue (Target, finalValue);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.ErrorQuery ("Binding Error", $"Binding failed: {ex}.", "Ok");
|
|
}
|
|
}
|
|
}
|
|
|
|
public class DynamicMenuBarDetails : FrameView
|
|
{
|
|
private bool _hasParent;
|
|
private MenuItem _menuItem;
|
|
|
|
public DynamicMenuBarDetails (MenuItem menuItem = null, bool hasParent = false) : this ()
|
|
{
|
|
_menuItem = menuItem;
|
|
_hasParent = hasParent;
|
|
Title = menuItem == null ? "Adding New Menu." : "Editing Menu.";
|
|
}
|
|
|
|
public DynamicMenuBarDetails ()
|
|
{
|
|
var lblTitle = new Label { Y = 1, Text = "Title:" };
|
|
Add (lblTitle);
|
|
|
|
TextTitle = new () { X = Pos.Right (lblTitle) + 2, Y = Pos.Top (lblTitle), Width = Dim.Fill () };
|
|
Add (TextTitle);
|
|
|
|
var lblHelp = new Label { X = Pos.Left (lblTitle), Y = Pos.Bottom (lblTitle) + 1, Text = "Help:" };
|
|
Add (lblHelp);
|
|
|
|
TextHelp = new () { X = Pos.Left (TextTitle), Y = Pos.Top (lblHelp), Width = Dim.Fill () };
|
|
Add (TextHelp);
|
|
|
|
var lblAction = new Label { X = Pos.Left (lblTitle), Y = Pos.Bottom (lblHelp) + 1, Text = "Action:" };
|
|
Add (lblAction);
|
|
|
|
TextAction = new ()
|
|
{
|
|
X = Pos.Left (TextTitle), Y = Pos.Top (lblAction), Width = Dim.Fill (), Height = 5
|
|
};
|
|
Add (TextAction);
|
|
|
|
var lblHotKey = new Label { X = Pos.Left (lblTitle), Y = Pos.Bottom (lblAction) + 5, Text = "HotKey:" };
|
|
Add (lblHotKey);
|
|
|
|
TextHotKey = new ()
|
|
{
|
|
X = Pos.Left (TextTitle), Y = Pos.Bottom (lblAction) + 5, Width = 2, ReadOnly = true
|
|
};
|
|
|
|
TextHotKey.TextChanging += (s, e) =>
|
|
{
|
|
if (!string.IsNullOrEmpty (e.Result) && char.IsLower (e.Result [0]))
|
|
{
|
|
e.Result = e.Result.ToUpper ();
|
|
}
|
|
};
|
|
TextHotKey.TextChanged += (s, _) => TextHotKey.SelectAll ();
|
|
TextHotKey.SelectAll ();
|
|
Add (TextHotKey);
|
|
|
|
CkbIsTopLevel = new ()
|
|
{
|
|
X = Pos.Left (lblTitle), Y = Pos.Bottom (lblHotKey) + 1, Text = "IsTopLevel"
|
|
};
|
|
Add (CkbIsTopLevel);
|
|
|
|
CkbSubMenu = new ()
|
|
{
|
|
X = Pos.Left (lblTitle),
|
|
Y = Pos.Bottom (CkbIsTopLevel),
|
|
CheckedState = (_menuItem == null ? !_hasParent : HasSubMenus (_menuItem)) ? CheckState.Checked : CheckState.UnChecked,
|
|
Text = "Has sub-menus"
|
|
};
|
|
Add (CkbSubMenu);
|
|
|
|
CkbNullCheck = new ()
|
|
{
|
|
X = Pos.Left (lblTitle), Y = Pos.Bottom (CkbSubMenu), Text = "Allow null checked"
|
|
};
|
|
Add (CkbNullCheck);
|
|
|
|
var rChkLabels = new [] { "NoCheck", "Checked", "Radio" };
|
|
|
|
OsChkStyle = new ()
|
|
{
|
|
X = Pos.Left (lblTitle), Y = Pos.Bottom (CkbSubMenu) + 1, Labels = rChkLabels
|
|
};
|
|
Add (OsChkStyle);
|
|
|
|
var lblShortcut = new Label
|
|
{
|
|
X = Pos.Right (CkbSubMenu) + 10, Y = Pos.Top (CkbSubMenu), Text = "Shortcut:"
|
|
};
|
|
Add (lblShortcut);
|
|
|
|
TextShortcutKey = new ()
|
|
{
|
|
X = Pos.X (lblShortcut), Y = Pos.Bottom (lblShortcut), Width = Dim.Fill (), ReadOnly = true
|
|
};
|
|
|
|
TextShortcutKey.KeyDown += (s, e) =>
|
|
{
|
|
TextShortcutKey.Text = e.ToString ();
|
|
|
|
};
|
|
|
|
Add (TextShortcutKey);
|
|
|
|
var btnShortcut = new Button
|
|
{
|
|
X = Pos.X (lblShortcut), Y = Pos.Bottom (TextShortcutKey) + 1, Text = "Clear Shortcut"
|
|
};
|
|
btnShortcut.Accepting += (s, e) => { TextShortcutKey.Text = ""; };
|
|
Add (btnShortcut);
|
|
|
|
CkbIsTopLevel.CheckedStateChanging += (s, e) =>
|
|
{
|
|
if ((_menuItem != null && _menuItem.Parent != null && e.Result == CheckState.Checked)
|
|
|| (_menuItem == null && _hasParent && e.Result == CheckState.Checked))
|
|
{
|
|
MessageBox.ErrorQuery (
|
|
"Invalid IsTopLevel",
|
|
"Only menu bar can have top level menu item!",
|
|
"Ok"
|
|
);
|
|
e.Handled = true;
|
|
|
|
return;
|
|
}
|
|
|
|
if (e.Result == CheckState.Checked)
|
|
{
|
|
CkbSubMenu.CheckedState = CheckState.UnChecked;
|
|
CkbSubMenu.SetNeedsDraw ();
|
|
TextHelp.Enabled = true;
|
|
TextAction.Enabled = true;
|
|
TextShortcutKey.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
if ((_menuItem == null && !_hasParent) || _menuItem.Parent == null)
|
|
{
|
|
CkbSubMenu.CheckedState = CheckState.Checked;
|
|
CkbSubMenu.SetNeedsDraw ();
|
|
TextShortcutKey.Enabled = false;
|
|
}
|
|
|
|
TextHelp.Text = "";
|
|
TextHelp.Enabled = false;
|
|
TextAction.Text = "";
|
|
|
|
TextShortcutKey.Enabled =
|
|
e.Result == CheckState.Checked && CkbSubMenu.CheckedState == CheckState.UnChecked;
|
|
}
|
|
};
|
|
|
|
CkbSubMenu.CheckedStateChanged += (s, e) =>
|
|
{
|
|
if (e.Value == CheckState.Checked)
|
|
{
|
|
CkbIsTopLevel.CheckedState = CheckState.UnChecked;
|
|
CkbIsTopLevel.SetNeedsDraw ();
|
|
TextHelp.Text = "";
|
|
TextHelp.Enabled = false;
|
|
TextAction.Text = "";
|
|
TextAction.Enabled = false;
|
|
TextShortcutKey.Text = "";
|
|
TextShortcutKey.Enabled = false;
|
|
}
|
|
else
|
|
{
|
|
if (!_hasParent)
|
|
{
|
|
CkbIsTopLevel.CheckedState = CheckState.Checked;
|
|
CkbIsTopLevel.SetNeedsDraw ();
|
|
TextShortcutKey.Enabled = true;
|
|
}
|
|
|
|
TextHelp.Enabled = true;
|
|
TextAction.Enabled = true;
|
|
|
|
if (_hasParent)
|
|
{
|
|
TextShortcutKey.Enabled = CkbIsTopLevel.CheckedState == CheckState.UnChecked
|
|
&& e.Value == CheckState.UnChecked;
|
|
}
|
|
}
|
|
};
|
|
|
|
CkbNullCheck.CheckedStateChanged += (s, e) =>
|
|
{
|
|
if (_menuItem != null)
|
|
{
|
|
_menuItem.AllowNullChecked = e.Value == CheckState.Checked;
|
|
}
|
|
};
|
|
|
|
//Add (_frmMenuDetails);
|
|
}
|
|
|
|
public CheckBox CkbIsTopLevel { get; }
|
|
public CheckBox CkbNullCheck { get; }
|
|
public CheckBox CkbSubMenu { get; }
|
|
public OptionSelector OsChkStyle { get; }
|
|
public TextView TextAction { get; }
|
|
public TextField TextHelp { get; }
|
|
public TextField TextHotKey { get; }
|
|
public TextField TextShortcutKey { get; }
|
|
public TextField TextTitle { get; }
|
|
|
|
public Action CreateAction (MenuItem menuItem, DynamicMenuItem item)
|
|
{
|
|
switch (menuItem.CheckType)
|
|
{
|
|
case MenuItemCheckStyle.NoCheck:
|
|
return () => MessageBox.ErrorQuery (item.Title, item.Action, "Ok");
|
|
case MenuItemCheckStyle.Checked:
|
|
return menuItem.ToggleChecked;
|
|
case MenuItemCheckStyle.Radio:
|
|
break;
|
|
}
|
|
|
|
return () =>
|
|
{
|
|
menuItem.Checked = true;
|
|
var parent = menuItem?.Parent as MenuBarItem;
|
|
|
|
if (parent != null)
|
|
{
|
|
MenuItem [] childrens = parent.Children;
|
|
|
|
for (var i = 0; i < childrens.Length; i++)
|
|
{
|
|
MenuItem child = childrens [i];
|
|
|
|
if (child != menuItem)
|
|
{
|
|
child.Checked = false;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
public void EditMenuBarItem (MenuItem menuItem)
|
|
{
|
|
if (menuItem == null)
|
|
{
|
|
_hasParent = false;
|
|
Enabled = false;
|
|
CleanEditMenuBarItem ();
|
|
|
|
return;
|
|
}
|
|
|
|
_hasParent = menuItem.Parent != null;
|
|
Enabled = true;
|
|
_menuItem = menuItem;
|
|
TextTitle.Text = menuItem?.Title ?? "";
|
|
TextHelp.Text = menuItem?.Help ?? "";
|
|
|
|
TextAction.Text = menuItem.Action != null
|
|
? GetTargetAction (menuItem.Action)
|
|
: string.Empty;
|
|
TextHotKey.Text = menuItem?.HotKey != Key.Empty ? menuItem.HotKey.ToString () : "";
|
|
CkbIsTopLevel.CheckedState = IsTopLevel (menuItem) ? CheckState.Checked : CheckState.UnChecked;
|
|
CkbSubMenu.CheckedState = HasSubMenus (menuItem) ? CheckState.Checked : CheckState.UnChecked;
|
|
CkbNullCheck.CheckedState = menuItem.AllowNullChecked ? CheckState.Checked : CheckState.UnChecked;
|
|
TextHelp.Enabled = CkbSubMenu.CheckedState == CheckState.UnChecked;
|
|
TextAction.Enabled = CkbSubMenu.CheckedState == CheckState.UnChecked;
|
|
OsChkStyle.Value = (int)(menuItem?.CheckType ?? MenuItemCheckStyle.NoCheck);
|
|
TextShortcutKey.Text = menuItem?.ShortcutTag ?? "";
|
|
|
|
TextShortcutKey.Enabled = CkbIsTopLevel.CheckedState == CheckState.Checked && CkbSubMenu.CheckedState == CheckState.UnChecked
|
|
|| CkbIsTopLevel.CheckedState == CheckState.UnChecked && CkbSubMenu.CheckedState == CheckState.UnChecked;
|
|
}
|
|
|
|
public DynamicMenuItem EnterMenuItem ()
|
|
{
|
|
var valid = false;
|
|
|
|
if (_menuItem == null)
|
|
{
|
|
var m = new DynamicMenuItem ();
|
|
TextTitle.Text = m.Title;
|
|
TextHelp.Text = m.Help;
|
|
TextAction.Text = m.Action;
|
|
TextHotKey.Text = m.HotKey ?? string.Empty;
|
|
CkbIsTopLevel.CheckedState = CheckState.UnChecked;
|
|
CkbSubMenu.CheckedState = !_hasParent ? CheckState.Checked : CheckState.UnChecked;
|
|
CkbNullCheck.CheckedState = CheckState.UnChecked;
|
|
TextHelp.Enabled = _hasParent;
|
|
TextAction.Enabled = _hasParent;
|
|
TextShortcutKey.Enabled = _hasParent;
|
|
}
|
|
else
|
|
{
|
|
EditMenuBarItem (_menuItem);
|
|
}
|
|
|
|
var btnOk = new Button { IsDefault = true, Text = "Ok" };
|
|
|
|
btnOk.Accepting += (s, e) =>
|
|
{
|
|
if (string.IsNullOrEmpty (TextTitle.Text))
|
|
{
|
|
MessageBox.ErrorQuery ("Invalid title", "Must enter a valid title!.", "Ok");
|
|
}
|
|
else
|
|
{
|
|
valid = true;
|
|
Application.RequestStop ();
|
|
}
|
|
};
|
|
var btnCancel = new Button { Text = "Cancel" };
|
|
|
|
btnCancel.Accepting += (s, e) =>
|
|
{
|
|
TextTitle.Text = string.Empty;
|
|
Application.RequestStop ();
|
|
};
|
|
|
|
var dialog = new Dialog
|
|
{ Title = "Enter the menu details.", Buttons = [btnOk, btnCancel], Height = Dim.Auto (DimAutoStyle.Content, 23, Application.Screen.Height) };
|
|
|
|
Width = Dim.Fill ();
|
|
Height = Dim.Fill () - 2;
|
|
dialog.Add (this);
|
|
TextTitle.SetFocus ();
|
|
TextTitle.CursorPosition = TextTitle.Text.Length;
|
|
Application.Run (dialog);
|
|
dialog.Dispose ();
|
|
|
|
if (valid)
|
|
{
|
|
return new ()
|
|
{
|
|
Title = TextTitle.Text,
|
|
Help = TextHelp.Text,
|
|
Action = TextAction.Text,
|
|
HotKey = TextHotKey.Text,
|
|
IsTopLevel = CkbIsTopLevel?.CheckedState == CheckState.Checked,
|
|
HasSubMenu = CkbSubMenu?.CheckedState == CheckState.Checked,
|
|
CheckStyle = OsChkStyle.Value == 0 ? MenuItemCheckStyle.NoCheck :
|
|
OsChkStyle.Value == 1 ? MenuItemCheckStyle.Checked :
|
|
MenuItemCheckStyle.Radio,
|
|
ShortcutKey = TextShortcutKey.Text,
|
|
AllowNullChecked = CkbNullCheck?.CheckedState == CheckState.Checked,
|
|
};
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public void UpdateParent (ref MenuItem menuItem)
|
|
{
|
|
var parent = menuItem.Parent as MenuBarItem;
|
|
int idx = parent.GetChildrenIndex (menuItem);
|
|
|
|
if (!(menuItem is MenuBarItem))
|
|
{
|
|
menuItem = new MenuBarItem (menuItem.Title, new MenuItem [] { }, menuItem.Parent);
|
|
|
|
if (idx > -1)
|
|
{
|
|
parent.Children [idx] = menuItem;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
menuItem = new (
|
|
menuItem.Title,
|
|
menuItem.Help,
|
|
CreateAction (menuItem, new ()),
|
|
null,
|
|
menuItem.Parent
|
|
);
|
|
|
|
if (idx > -1)
|
|
{
|
|
parent.Children [idx] = menuItem;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CleanEditMenuBarItem ()
|
|
{
|
|
TextTitle.Text = "";
|
|
TextHelp.Text = "";
|
|
TextAction.Text = "";
|
|
TextHotKey.Text = "";
|
|
CkbIsTopLevel.CheckedState = CheckState.UnChecked;
|
|
CkbSubMenu.CheckedState = CheckState.UnChecked;
|
|
OsChkStyle.Value = (int)MenuItemCheckStyle.NoCheck;
|
|
TextShortcutKey.Text = "";
|
|
}
|
|
|
|
private string GetTargetAction (Action action)
|
|
{
|
|
object me = action.Target;
|
|
|
|
if (me == null)
|
|
{
|
|
throw new ArgumentException ();
|
|
}
|
|
|
|
var v = new object ();
|
|
|
|
foreach (FieldInfo field in me.GetType ().GetFields ())
|
|
{
|
|
if (field.Name == "item")
|
|
{
|
|
v = field.GetValue (me);
|
|
}
|
|
}
|
|
|
|
return v == null || !(v is DynamicMenuItem item) ? string.Empty : item.Action;
|
|
}
|
|
|
|
private bool HasSubMenus (MenuItem menuItem)
|
|
{
|
|
var menuBarItem = menuItem as MenuBarItem;
|
|
|
|
if (menuBarItem != null && menuBarItem.Children != null && (menuBarItem.Children.Length > 0 || menuBarItem.Action == null))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool IsTopLevel (MenuItem menuItem)
|
|
{
|
|
var topLevel = menuItem as MenuBarItem;
|
|
|
|
if (topLevel != null && topLevel.Parent == null && (topLevel.Children == null || topLevel.Children.Length == 0) && topLevel.Action != null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public class DynamicMenuBarSample : Window
|
|
{
|
|
private readonly ListView _lstMenus;
|
|
private MenuItem _currentEditMenuBarItem;
|
|
private MenuItem _currentMenuBarItem;
|
|
private int _currentSelectedMenuBar;
|
|
private MenuBar _menuBar;
|
|
|
|
public DynamicMenuBarSample ()
|
|
{
|
|
DataContext = new ();
|
|
|
|
var frmDelimiter = new FrameView
|
|
{
|
|
X = Pos.Center (),
|
|
Y = 3,
|
|
Width = 25,
|
|
Height = 4,
|
|
Title = "Shortcut Delimiter:"
|
|
};
|
|
|
|
var txtDelimiter = new TextField
|
|
{
|
|
X = Pos.Center (), Width = 2, Text = Key.Separator.ToString ()
|
|
};
|
|
|
|
|
|
var frmMenu = new FrameView { Y = 7, Width = Dim.Percent (50), Height = Dim.Fill (), Title = "Menus:" };
|
|
|
|
var btnAddMenuBar = new Button { Y = 1, Text = "Add a MenuBar" };
|
|
frmMenu.Add (btnAddMenuBar);
|
|
|
|
var btnMenuBarUp = new Button { X = Pos.Center (), Text = Glyphs.UpArrow.ToString () };
|
|
frmMenu.Add (btnMenuBarUp);
|
|
|
|
var btnMenuBarDown = new Button { X = Pos.Center (), Y = Pos.Bottom (btnMenuBarUp), Text = Glyphs.DownArrow.ToString () };
|
|
frmMenu.Add (btnMenuBarDown);
|
|
|
|
var btnRemoveMenuBar = new Button { Y = 1, Text = "Remove a MenuBar" };
|
|
|
|
btnRemoveMenuBar.X = Pos.AnchorEnd (0) - (Pos.Right (btnRemoveMenuBar) - Pos.Left (btnRemoveMenuBar));
|
|
frmMenu.Add (btnRemoveMenuBar);
|
|
|
|
var btnPrevious = new Button
|
|
{
|
|
X = Pos.Left (btnAddMenuBar), Y = Pos.Top (btnAddMenuBar) + 2, Text = Glyphs.LeftArrow.ToString ()
|
|
};
|
|
frmMenu.Add (btnPrevious);
|
|
|
|
var btnAdd = new Button { Y = Pos.Top (btnPrevious) + 2, Text = " Add " };
|
|
btnAdd.X = Pos.AnchorEnd ();
|
|
frmMenu.Add (btnAdd);
|
|
|
|
var btnNext = new Button { X = Pos.X (btnAdd), Y = Pos.Top (btnPrevious), Text = Glyphs.RightArrow.ToString () };
|
|
frmMenu.Add (btnNext);
|
|
|
|
var lblMenuBar = new Label
|
|
{
|
|
SchemeName = "Dialog",
|
|
TextAlignment = Alignment.Center,
|
|
X = Pos.Right (btnPrevious) + 1,
|
|
Y = Pos.Top (btnPrevious),
|
|
|
|
Width = Dim.Fill () - Dim.Func (_ => btnAdd.Frame.Width + 1),
|
|
Height = 1
|
|
};
|
|
|
|
lblMenuBar.TextChanged += (s, e) =>
|
|
{
|
|
if (lblMenuBar.Text.Contains ("_"))
|
|
{
|
|
lblMenuBar.Text = lblMenuBar.Text.Replace ("_", "");
|
|
}
|
|
};
|
|
frmMenu.Add (lblMenuBar);
|
|
lblMenuBar.WantMousePositionReports = true;
|
|
lblMenuBar.CanFocus = true;
|
|
|
|
var lblParent = new Label
|
|
{
|
|
TextAlignment = Alignment.Center,
|
|
X = Pos.Right (btnPrevious) + 1,
|
|
Y = Pos.Top (btnPrevious) + 1,
|
|
|
|
Width = Dim.Fill () - Dim.Width (btnAdd) - 1
|
|
};
|
|
frmMenu.Add (lblParent);
|
|
|
|
var btnPreviowsParent = new Button
|
|
{
|
|
X = Pos.Left (btnAddMenuBar), Y = Pos.Top (btnPrevious) + 1, Text = ".."
|
|
};
|
|
frmMenu.Add (btnPreviowsParent);
|
|
|
|
_lstMenus = new ()
|
|
{
|
|
SchemeName = "Dialog",
|
|
X = Pos.Right (btnPrevious) + 1,
|
|
Y = Pos.Top (btnPrevious) + 2,
|
|
Width = lblMenuBar.Width,
|
|
Height = Dim.Fill (),
|
|
Source = new ListWrapper<DynamicMenuItemList> ([])
|
|
};
|
|
frmMenu.Add (_lstMenus);
|
|
|
|
//lblMenuBar.TabIndex = btnPrevious.TabIndex + 1;
|
|
//_lstMenus.TabIndex = lblMenuBar.TabIndex + 1;
|
|
//btnNext.TabIndex = _lstMenus.TabIndex + 1;
|
|
//btnAdd.TabIndex = btnNext.TabIndex + 1;
|
|
|
|
var btnRemove = new Button { X = Pos.Left (btnAdd), Y = Pos.Top (btnAdd) + 1, Text = "Remove" };
|
|
frmMenu.Add (btnRemove);
|
|
|
|
var btnUp = new Button { X = Pos.Right (_lstMenus) + 2, Y = Pos.Top (btnRemove) + 2, Text = Glyphs.UpArrow.ToString () };
|
|
frmMenu.Add (btnUp);
|
|
|
|
var btnDown = new Button { X = Pos.Right (_lstMenus) + 2, Y = Pos.Top (btnUp) + 1, Text = Glyphs.DownArrow.ToString () };
|
|
frmMenu.Add (btnDown);
|
|
|
|
Add (frmMenu);
|
|
|
|
var frmMenuDetails = new DynamicMenuBarDetails
|
|
{
|
|
X = Pos.Right (frmMenu),
|
|
Y = Pos.Top (frmMenu),
|
|
Width = Dim.Fill (),
|
|
Height = Dim.Fill (2),
|
|
Title = "Menu Details:"
|
|
};
|
|
Add (frmMenuDetails);
|
|
|
|
btnMenuBarUp.Accepting += (s, e) =>
|
|
{
|
|
int i = _currentSelectedMenuBar;
|
|
|
|
MenuBarItem menuItem = _menuBar != null && _menuBar.Menus.Length > 0
|
|
? _menuBar.Menus [i]
|
|
: null;
|
|
|
|
if (menuItem != null)
|
|
{
|
|
MenuBarItem [] menus = _menuBar.Menus;
|
|
|
|
if (i > 0)
|
|
{
|
|
menus [i] = menus [i - 1];
|
|
menus [i - 1] = menuItem;
|
|
_currentSelectedMenuBar = i - 1;
|
|
_menuBar.SetNeedsDraw ();
|
|
}
|
|
}
|
|
};
|
|
|
|
btnMenuBarDown.Accepting += (s, e) =>
|
|
{
|
|
int i = _currentSelectedMenuBar;
|
|
|
|
MenuBarItem menuItem = _menuBar != null && _menuBar.Menus.Length > 0
|
|
? _menuBar.Menus [i]
|
|
: null;
|
|
|
|
if (menuItem != null)
|
|
{
|
|
MenuBarItem [] menus = _menuBar.Menus;
|
|
|
|
if (i < menus.Length - 1)
|
|
{
|
|
menus [i] = menus [i + 1];
|
|
menus [i + 1] = menuItem;
|
|
_currentSelectedMenuBar = i + 1;
|
|
_menuBar.SetNeedsDraw ();
|
|
}
|
|
}
|
|
};
|
|
|
|
btnUp.Accepting += (s, e) =>
|
|
{
|
|
int i = _lstMenus.SelectedItem.Value;
|
|
MenuItem menuItem = DataContext.Menus.Count > 0 ? DataContext.Menus [i].MenuItem : null;
|
|
|
|
if (menuItem != null)
|
|
{
|
|
MenuItem [] childrens = ((MenuBarItem)_currentMenuBarItem).Children;
|
|
|
|
if (i > 0)
|
|
{
|
|
childrens [i] = childrens [i - 1];
|
|
childrens [i - 1] = menuItem;
|
|
DataContext.Menus [i] = DataContext.Menus [i - 1];
|
|
|
|
DataContext.Menus [i - 1] =
|
|
new () { Title = menuItem.Title, MenuItem = menuItem };
|
|
_lstMenus.SelectedItem = i - 1;
|
|
}
|
|
}
|
|
};
|
|
|
|
btnDown.Accepting += (s, e) =>
|
|
{
|
|
int i = _lstMenus.SelectedItem.Value;
|
|
MenuItem menuItem = DataContext.Menus.Count > 0 ? DataContext.Menus [i].MenuItem : null;
|
|
|
|
if (menuItem != null)
|
|
{
|
|
MenuItem [] childrens = ((MenuBarItem)_currentMenuBarItem).Children;
|
|
|
|
if (i < childrens.Length - 1)
|
|
{
|
|
childrens [i] = childrens [i + 1];
|
|
childrens [i + 1] = menuItem;
|
|
DataContext.Menus [i] = DataContext.Menus [i + 1];
|
|
|
|
DataContext.Menus [i + 1] =
|
|
new () { Title = menuItem.Title, MenuItem = menuItem };
|
|
_lstMenus.SelectedItem = i + 1;
|
|
}
|
|
}
|
|
};
|
|
|
|
btnPreviowsParent.Accepting += (s, e) =>
|
|
{
|
|
if (_currentMenuBarItem != null && _currentMenuBarItem.Parent != null)
|
|
{
|
|
MenuItem mi = _currentMenuBarItem;
|
|
_currentMenuBarItem = _currentMenuBarItem.Parent as MenuBarItem;
|
|
SetListViewSource (_currentMenuBarItem, true);
|
|
int i = ((MenuBarItem)_currentMenuBarItem).GetChildrenIndex (mi);
|
|
|
|
if (i > -1)
|
|
{
|
|
_lstMenus.SelectedItem = i;
|
|
}
|
|
|
|
if (_currentMenuBarItem.Parent != null)
|
|
{
|
|
DataContext.Parent = _currentMenuBarItem.Title;
|
|
}
|
|
else
|
|
{
|
|
DataContext.Parent = string.Empty;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DataContext.Parent = string.Empty;
|
|
}
|
|
};
|
|
|
|
var btnOk = new Button { X = Pos.Right (frmMenu) + 20, Y = Pos.Bottom (frmMenuDetails), Text = "Ok" };
|
|
Add (btnOk);
|
|
|
|
var btnCancel = new Button { X = Pos.Right (btnOk) + 3, Y = Pos.Top (btnOk), Text = "Cancel" };
|
|
btnCancel.Accepting += (s, e) => { SetFrameDetails (_currentEditMenuBarItem); };
|
|
Add (btnCancel);
|
|
|
|
txtDelimiter.TextChanging += (s, e) =>
|
|
{
|
|
if (!string.IsNullOrEmpty (e.Result))
|
|
{
|
|
Key.Separator = e.Result.ToRunes () [0];
|
|
}
|
|
else
|
|
{
|
|
e.Handled = true;
|
|
txtDelimiter.SelectAll ();
|
|
}
|
|
};
|
|
txtDelimiter.TextChanged += (s, _) =>
|
|
{
|
|
txtDelimiter.SelectAll ();
|
|
SetFrameDetails ();
|
|
};
|
|
frmDelimiter.Add (txtDelimiter);
|
|
txtDelimiter.SelectAll ();
|
|
Add (frmDelimiter);
|
|
|
|
_lstMenus.SelectedItemChanged += (s, e) => { SetFrameDetails (); };
|
|
|
|
btnOk.Accepting += (s, e) =>
|
|
{
|
|
if (string.IsNullOrEmpty (frmMenuDetails.TextTitle.Text) && _currentEditMenuBarItem != null)
|
|
{
|
|
MessageBox.ErrorQuery ("Invalid title", "Must enter a valid title!.", "Ok");
|
|
}
|
|
else if (_currentEditMenuBarItem != null)
|
|
{
|
|
var menuItem = new DynamicMenuItem
|
|
{
|
|
Title = frmMenuDetails.TextTitle.Text,
|
|
Help = frmMenuDetails.TextHelp.Text,
|
|
Action = frmMenuDetails.TextAction.Text,
|
|
HotKey = frmMenuDetails.TextHotKey.Text,
|
|
IsTopLevel = frmMenuDetails.CkbIsTopLevel?.CheckedState == CheckState.Checked,
|
|
HasSubMenu = frmMenuDetails.CkbSubMenu?.CheckedState == CheckState.Checked,
|
|
CheckStyle = frmMenuDetails.OsChkStyle.Value == 0
|
|
? MenuItemCheckStyle.NoCheck
|
|
: frmMenuDetails.OsChkStyle.Value == 1
|
|
? MenuItemCheckStyle.Checked
|
|
: MenuItemCheckStyle.Radio,
|
|
ShortcutKey = frmMenuDetails.TextShortcutKey.Text
|
|
};
|
|
UpdateMenuItem (_currentEditMenuBarItem, menuItem, _lstMenus.SelectedItem.Value);
|
|
}
|
|
};
|
|
|
|
btnAdd.Accepting += (s, e) =>
|
|
{
|
|
if (MenuBar == null)
|
|
{
|
|
MessageBox.ErrorQuery ("Menu Bar Error", "Must add a MenuBar first!", "Ok");
|
|
btnAddMenuBar.SetFocus ();
|
|
|
|
return;
|
|
}
|
|
|
|
var frameDetails = new DynamicMenuBarDetails (null, _currentMenuBarItem != null);
|
|
DynamicMenuItem item = frameDetails.EnterMenuItem ();
|
|
|
|
if (item == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (_currentMenuBarItem is not MenuBarItem)
|
|
{
|
|
var parent = _currentMenuBarItem.Parent as MenuBarItem;
|
|
int idx = parent.GetChildrenIndex (_currentMenuBarItem);
|
|
|
|
_currentMenuBarItem = new MenuBarItem (
|
|
_currentMenuBarItem.Title,
|
|
new MenuItem [] { },
|
|
_currentMenuBarItem.Parent
|
|
);
|
|
_currentMenuBarItem.CheckType = item.CheckStyle;
|
|
parent.Children [idx] = _currentMenuBarItem;
|
|
}
|
|
else
|
|
{
|
|
MenuItem newMenu = CreateNewMenu (item, _currentMenuBarItem);
|
|
var menuBarItem = _currentMenuBarItem as MenuBarItem;
|
|
menuBarItem.AddMenuBarItem (MenuBar, newMenu);
|
|
|
|
|
|
DataContext.Menus.Add (new () { Title = newMenu.Title, MenuItem = newMenu });
|
|
_lstMenus.MoveDown ();
|
|
}
|
|
};
|
|
|
|
btnRemove.Accepting += (s, e) =>
|
|
{
|
|
MenuItem menuItem = (DataContext.Menus.Count > 0 && _lstMenus.SelectedItem is {} selectedItem
|
|
? DataContext.Menus [selectedItem].MenuItem
|
|
: _currentEditMenuBarItem);
|
|
|
|
if (menuItem != null)
|
|
{
|
|
menuItem.RemoveMenuItem ();
|
|
|
|
if (_currentEditMenuBarItem == menuItem)
|
|
{
|
|
_currentEditMenuBarItem = null;
|
|
|
|
if (menuItem.Parent is null)
|
|
{
|
|
_currentSelectedMenuBar = Math.Max (Math.Min (_currentSelectedMenuBar, _menuBar.Menus.Length - 1), 0);
|
|
}
|
|
|
|
SelectCurrentMenuBarItem ();
|
|
}
|
|
|
|
if (_lstMenus.SelectedItem is {} selected)
|
|
{
|
|
DataContext.Menus?.RemoveAt (selected);
|
|
}
|
|
|
|
if (_lstMenus.Source.Count > 0 && _lstMenus.SelectedItem > _lstMenus.Source.Count - 1)
|
|
{
|
|
_lstMenus.SelectedItem = _lstMenus.Source.Count - 1;
|
|
}
|
|
|
|
if (_menuBar.Menus.Length == 0)
|
|
{
|
|
RemoveMenuBar ();
|
|
}
|
|
|
|
_lstMenus.SetNeedsDraw ();
|
|
SetFrameDetails ();
|
|
}
|
|
};
|
|
|
|
_lstMenus.OpenSelectedItem += (s, e) =>
|
|
{
|
|
_currentMenuBarItem = DataContext.Menus [e.Item.Value].MenuItem;
|
|
|
|
if (!(_currentMenuBarItem is MenuBarItem))
|
|
{
|
|
MessageBox.ErrorQuery ("Menu Open Error", "Must allows sub menus first!", "Ok");
|
|
|
|
return;
|
|
}
|
|
|
|
DataContext.Parent = _currentMenuBarItem.Title;
|
|
DataContext.Menus = new ();
|
|
SetListViewSource (_currentMenuBarItem, true);
|
|
MenuItem menuBarItem = DataContext.Menus.Count > 0 ? DataContext.Menus [0].MenuItem : null;
|
|
SetFrameDetails (menuBarItem);
|
|
};
|
|
|
|
_lstMenus.HasFocusChanging += (s, e) =>
|
|
{
|
|
MenuItem menuBarItem = _lstMenus.SelectedItem is {} selectedItem && DataContext.Menus.Count > 0
|
|
? DataContext.Menus [selectedItem].MenuItem
|
|
: null;
|
|
SetFrameDetails (menuBarItem);
|
|
};
|
|
|
|
btnNext.Accepting += (s, e) =>
|
|
{
|
|
if (_menuBar != null && _currentSelectedMenuBar + 1 < _menuBar.Menus.Length)
|
|
{
|
|
_currentSelectedMenuBar++;
|
|
}
|
|
|
|
SelectCurrentMenuBarItem ();
|
|
};
|
|
|
|
btnPrevious.Accepting += (s, e) =>
|
|
{
|
|
if (_currentSelectedMenuBar - 1 > -1)
|
|
{
|
|
_currentSelectedMenuBar--;
|
|
}
|
|
|
|
SelectCurrentMenuBarItem ();
|
|
};
|
|
|
|
lblMenuBar.HasFocusChanging += (s, e) =>
|
|
{
|
|
if (_menuBar?.Menus != null)
|
|
{
|
|
_currentMenuBarItem = _menuBar.Menus [_currentSelectedMenuBar];
|
|
SetFrameDetails (_menuBar.Menus [_currentSelectedMenuBar]);
|
|
}
|
|
};
|
|
|
|
btnAddMenuBar.Accepting += (s, e) =>
|
|
{
|
|
var frameDetails = new DynamicMenuBarDetails (null);
|
|
DynamicMenuItem item = frameDetails.EnterMenuItem ();
|
|
|
|
if (item == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (MenuBar == null)
|
|
{
|
|
_menuBar = new ();
|
|
Add (_menuBar);
|
|
}
|
|
|
|
var newMenu = CreateNewMenu (item) as MenuBarItem;
|
|
newMenu.AddMenuBarItem (MenuBar);
|
|
|
|
_currentMenuBarItem = newMenu;
|
|
_currentMenuBarItem.CheckType = item.CheckStyle;
|
|
|
|
if (Key.TryParse (item.ShortcutKey, out Key key))
|
|
{
|
|
_currentMenuBarItem.ShortcutKey = key;
|
|
}
|
|
|
|
_currentSelectedMenuBar = _menuBar.Menus.Length - 1;
|
|
_menuBar.Menus [_currentSelectedMenuBar] = newMenu;
|
|
lblMenuBar.Text = newMenu.Title;
|
|
SetListViewSource (_currentMenuBarItem, true);
|
|
SetFrameDetails (_menuBar.Menus [_currentSelectedMenuBar]);
|
|
_menuBar.SetNeedsDraw ();
|
|
};
|
|
|
|
btnRemoveMenuBar.Accepting += (s, e) =>
|
|
{
|
|
if (_menuBar == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (_menuBar != null && _menuBar.Menus.Length > 0)
|
|
{
|
|
_currentMenuBarItem.RemoveMenuItem ();
|
|
|
|
|
|
|
|
if (_currentSelectedMenuBar - 1 >= 0 && _menuBar.Menus.Length > 0)
|
|
{
|
|
_currentSelectedMenuBar--;
|
|
}
|
|
|
|
_currentMenuBarItem = _menuBar.Menus?.Length > 0
|
|
? _menuBar.Menus [_currentSelectedMenuBar]
|
|
: null;
|
|
}
|
|
|
|
RemoveMenuBar ();
|
|
|
|
SetListViewSource (_currentMenuBarItem, true);
|
|
SetFrameDetails ();
|
|
};
|
|
|
|
void RemoveMenuBar ()
|
|
{
|
|
if (MenuBar != null && _currentMenuBarItem == null && _menuBar.Menus.Length == 0)
|
|
{
|
|
Remove (_menuBar);
|
|
_menuBar.Dispose ();
|
|
_menuBar = null;
|
|
DataContext.Menus = new ();
|
|
_currentMenuBarItem = null;
|
|
_currentSelectedMenuBar = -1;
|
|
lblMenuBar.Text = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
lblMenuBar.Text = _menuBar.Menus [_currentSelectedMenuBar].Title;
|
|
}
|
|
}
|
|
|
|
SetFrameDetails ();
|
|
|
|
var ustringConverter = new UStringValueConverter ();
|
|
ListWrapperConverter<DynamicMenuItemList> listWrapperConverter = new ListWrapperConverter<DynamicMenuItemList> ();
|
|
|
|
var bdgMenuBar = new Binding (this, "MenuBar", lblMenuBar, "Text", ustringConverter);
|
|
var bdgParent = new Binding (this, "Parent", lblParent, "Text", ustringConverter);
|
|
var bdgMenus = new Binding (this, "Menus", _lstMenus, "Source", listWrapperConverter);
|
|
|
|
void SetFrameDetails (MenuItem menuBarItem = null)
|
|
{
|
|
MenuItem menuItem;
|
|
|
|
if (menuBarItem == null)
|
|
{
|
|
menuItem = _lstMenus.SelectedItem is {} selectedItem && DataContext.Menus.Count > 0
|
|
? DataContext.Menus [selectedItem].MenuItem
|
|
: _currentEditMenuBarItem;
|
|
}
|
|
else
|
|
{
|
|
menuItem = menuBarItem;
|
|
}
|
|
|
|
_currentEditMenuBarItem = menuItem;
|
|
frmMenuDetails.EditMenuBarItem (menuItem);
|
|
bool f = btnOk.Enabled == frmMenuDetails.Enabled;
|
|
|
|
if (!f)
|
|
{
|
|
btnOk.Enabled = frmMenuDetails.Enabled;
|
|
btnCancel.Enabled = frmMenuDetails.Enabled;
|
|
}
|
|
}
|
|
|
|
void SelectCurrentMenuBarItem ()
|
|
{
|
|
MenuBarItem menuBarItem = null;
|
|
|
|
if (_menuBar?.Menus is { Length: > 0 })
|
|
{
|
|
menuBarItem = _menuBar.Menus [_currentSelectedMenuBar];
|
|
lblMenuBar.Text = menuBarItem.Title;
|
|
}
|
|
|
|
SetFrameDetails (menuBarItem);
|
|
_currentMenuBarItem = menuBarItem;
|
|
DataContext.Menus = new ();
|
|
SetListViewSource (_currentMenuBarItem, true);
|
|
lblParent.Text = string.Empty;
|
|
|
|
if (_currentMenuBarItem is null)
|
|
{
|
|
lblMenuBar.Text = string.Empty;
|
|
}
|
|
}
|
|
|
|
void SetListViewSource (MenuItem currentMenuBarItem, bool fill = false)
|
|
{
|
|
DataContext.Menus = [];
|
|
var menuBarItem = currentMenuBarItem as MenuBarItem;
|
|
|
|
if (menuBarItem != null && menuBarItem?.Children == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!fill)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (menuBarItem != null)
|
|
{
|
|
foreach (MenuItem child in menuBarItem?.Children)
|
|
{
|
|
var m = new DynamicMenuItemList { Title = child.Title, MenuItem = child };
|
|
DataContext.Menus.Add (m);
|
|
}
|
|
}
|
|
}
|
|
|
|
MenuItem CreateNewMenu (DynamicMenuItem item, MenuItem parent = null)
|
|
{
|
|
MenuItem newMenu;
|
|
|
|
if (item.HasSubMenu)
|
|
{
|
|
newMenu = new MenuBarItem (item.Title, new MenuItem [] { }, parent);
|
|
}
|
|
else if (parent != null)
|
|
{
|
|
newMenu = new (item.Title, item.Help, null, null, parent);
|
|
newMenu.CheckType = item.CheckStyle;
|
|
newMenu.Action = frmMenuDetails.CreateAction (newMenu, item);
|
|
|
|
if (Key.TryParse (item.ShortcutKey, out Key key))
|
|
{
|
|
newMenu.ShortcutKey = key;
|
|
}
|
|
newMenu.AllowNullChecked = item.AllowNullChecked;
|
|
}
|
|
else if (item.IsTopLevel)
|
|
{
|
|
newMenu = new MenuBarItem (item.Title, item.Help, null);
|
|
newMenu.Action = frmMenuDetails.CreateAction (newMenu, item);
|
|
|
|
if (Key.TryParse (item.ShortcutKey, out Key key))
|
|
{
|
|
newMenu.ShortcutKey = key;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
newMenu = new MenuBarItem (item.Title, item.Help, null);
|
|
|
|
((MenuBarItem)newMenu).Children [0].Action =
|
|
frmMenuDetails.CreateAction (newMenu, item);
|
|
|
|
if (Key.TryParse (item.ShortcutKey, out Key key))
|
|
{
|
|
((MenuBarItem)newMenu).Children [0].ShortcutKey = key;
|
|
}
|
|
}
|
|
|
|
return newMenu;
|
|
}
|
|
|
|
void UpdateMenuItem (MenuItem currentEditMenuBarItem, DynamicMenuItem menuItem, int index)
|
|
{
|
|
currentEditMenuBarItem.Title = menuItem.Title;
|
|
currentEditMenuBarItem.Help = menuItem.Help;
|
|
currentEditMenuBarItem.CheckType = menuItem.CheckStyle;
|
|
|
|
if (currentEditMenuBarItem.Parent is MenuBarItem parent
|
|
&& parent.Children.Length == 1
|
|
&& currentEditMenuBarItem.CheckType == MenuItemCheckStyle.Radio)
|
|
{
|
|
currentEditMenuBarItem.Checked = true;
|
|
}
|
|
|
|
if (menuItem.IsTopLevel && currentEditMenuBarItem is MenuBarItem)
|
|
{
|
|
((MenuBarItem)currentEditMenuBarItem).Children = null;
|
|
|
|
currentEditMenuBarItem.Action =
|
|
frmMenuDetails.CreateAction (currentEditMenuBarItem, menuItem);
|
|
|
|
if (Key.TryParse (menuItem.ShortcutKey, out Key key))
|
|
{
|
|
currentEditMenuBarItem.ShortcutKey = key;
|
|
}
|
|
|
|
SetListViewSource (currentEditMenuBarItem, true);
|
|
}
|
|
else if (menuItem.HasSubMenu)
|
|
{
|
|
currentEditMenuBarItem.Action = null;
|
|
|
|
if (currentEditMenuBarItem is MenuBarItem && ((MenuBarItem)currentEditMenuBarItem).Children == null)
|
|
{
|
|
((MenuBarItem)currentEditMenuBarItem).Children = new MenuItem [] { };
|
|
}
|
|
else if (currentEditMenuBarItem.Parent != null)
|
|
{
|
|
frmMenuDetails.UpdateParent (ref currentEditMenuBarItem);
|
|
}
|
|
else
|
|
{
|
|
currentEditMenuBarItem =
|
|
new MenuBarItem (
|
|
currentEditMenuBarItem.Title,
|
|
new MenuItem [] { },
|
|
currentEditMenuBarItem.Parent
|
|
);
|
|
}
|
|
|
|
SetListViewSource (currentEditMenuBarItem, true);
|
|
}
|
|
else if (currentEditMenuBarItem is MenuBarItem && currentEditMenuBarItem.Parent != null)
|
|
{
|
|
frmMenuDetails.UpdateParent (ref currentEditMenuBarItem);
|
|
|
|
currentEditMenuBarItem = new (
|
|
menuItem.Title,
|
|
menuItem.Help,
|
|
frmMenuDetails.CreateAction (currentEditMenuBarItem, menuItem),
|
|
null,
|
|
currentEditMenuBarItem.Parent
|
|
);
|
|
}
|
|
else
|
|
{
|
|
if (currentEditMenuBarItem is MenuBarItem)
|
|
{
|
|
((MenuBarItem)currentEditMenuBarItem).Children = null;
|
|
DataContext.Menus = new ();
|
|
}
|
|
|
|
currentEditMenuBarItem.Action =
|
|
frmMenuDetails.CreateAction (currentEditMenuBarItem, menuItem);
|
|
|
|
if (Key.TryParse (menuItem.ShortcutKey, out Key key))
|
|
{
|
|
currentEditMenuBarItem.ShortcutKey = key;
|
|
}
|
|
}
|
|
|
|
if (currentEditMenuBarItem.Parent == null)
|
|
{
|
|
DataContext.MenuBar = currentEditMenuBarItem.Title;
|
|
}
|
|
else
|
|
{
|
|
if (DataContext.Menus.Count == 0)
|
|
{
|
|
DataContext.Menus.Add (
|
|
new ()
|
|
{
|
|
Title = currentEditMenuBarItem.Title, MenuItem = currentEditMenuBarItem
|
|
}
|
|
);
|
|
}
|
|
|
|
DataContext.Menus [index] =
|
|
new ()
|
|
{
|
|
Title = currentEditMenuBarItem.Title, MenuItem = currentEditMenuBarItem
|
|
};
|
|
}
|
|
|
|
currentEditMenuBarItem.CheckType = menuItem.CheckStyle;
|
|
SetFrameDetails (currentEditMenuBarItem);
|
|
}
|
|
|
|
//_frmMenuDetails.Initialized += (s, e) => _frmMenuDetails.Enabled = false;
|
|
}
|
|
|
|
public DynamicMenuItemModel DataContext { get; set; }
|
|
}
|
|
|
|
public class DynamicMenuItem
|
|
{
|
|
public string Action { get; set; } = string.Empty;
|
|
public bool AllowNullChecked { get; set; }
|
|
public MenuItemCheckStyle CheckStyle { get; set; }
|
|
public bool HasSubMenu { get; set; }
|
|
public string Help { get; set; } = string.Empty;
|
|
public bool IsTopLevel { get; set; }
|
|
public string HotKey { get; set; }
|
|
public string ShortcutKey { get; set; }
|
|
public string Title { get; set; } = "_New";
|
|
}
|
|
|
|
public class DynamicMenuItemList
|
|
{
|
|
public MenuItem MenuItem { get; set; }
|
|
public string Title { get; set; }
|
|
public override string ToString () { return $"{Title}, {MenuItem.HotKey}, {MenuItem.ShortcutKey} "; }
|
|
}
|
|
|
|
public class DynamicMenuItemModel : INotifyPropertyChanged
|
|
{
|
|
private string _menuBar;
|
|
private ObservableCollection<DynamicMenuItemList> _menus;
|
|
private string _parent;
|
|
public DynamicMenuItemModel () { Menus = []; }
|
|
|
|
public string MenuBar
|
|
{
|
|
get => _menuBar;
|
|
set
|
|
{
|
|
if (value == _menuBar)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_menuBar = value;
|
|
|
|
PropertyChanged?.Invoke (
|
|
this,
|
|
new (GetPropertyName ())
|
|
);
|
|
}
|
|
}
|
|
|
|
public ObservableCollection<DynamicMenuItemList> Menus
|
|
{
|
|
get => _menus;
|
|
set
|
|
{
|
|
if (value == _menus)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_menus = value;
|
|
|
|
PropertyChanged?.Invoke (
|
|
this,
|
|
new (GetPropertyName ())
|
|
);
|
|
}
|
|
}
|
|
|
|
public string Parent
|
|
{
|
|
get => _parent;
|
|
set
|
|
{
|
|
if (value == _parent)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_parent = value;
|
|
|
|
PropertyChanged?.Invoke (
|
|
this,
|
|
new (GetPropertyName ())
|
|
);
|
|
}
|
|
}
|
|
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
public string GetPropertyName ([CallerMemberName] string propertyName = null) { return propertyName; }
|
|
}
|
|
|
|
public interface IValueConverter
|
|
{
|
|
object Convert (object value, object parameter = null);
|
|
}
|
|
|
|
public class ListWrapperConverter<T> : IValueConverter
|
|
{
|
|
public object Convert (object value, object parameter = null) { return new ListWrapper<T> ((ObservableCollection<T>)value); }
|
|
}
|
|
|
|
public class UStringValueConverter : IValueConverter
|
|
{
|
|
public object Convert (object value, object parameter = null)
|
|
{
|
|
byte [] data = Encoding.ASCII.GetBytes (value.ToString () ?? string.Empty);
|
|
|
|
return StringExtensions.ToString (data);
|
|
}
|
|
}
|
|
}
|