Unsure of the correct way to make multi-window application

[beeradmoore]

Hey,
I am wanting to make an application where a single window is visible at a time and each window can have its own menu. Navigating between windows would be a push/pop style navigation similar to Xamarin.Forms (and others) PushModal, PopModal. So the idea is you start at a main window, push a second window, from that window push a third. Then you choose to go back so you pop and you go back to the second window as it was.

I was a little confused by Window having a MenuBar but setting it doesn't make it appear as you need to add it. I can see in the code that adding a MenuBar via Add( will assign it to the MenuBar property, but doing so causes the menu bar to be below the window title. Setting the Window Y=1` just pushes both down and leaves a black line up the top.

Playing around with some things I got something to work, but unsure if this is making a mess of things and isn't how it's meant to work.

The general idea is I have a window MainWindow and it defines its own menu. Then a seperate TopLevel controls adding that menu to the visible stack itself. In final app I'd have SecondWindow, ThirdWindow but for this example is just MainWindow, and I seperate what window is what with a static in counter.

public class MainWindow : Window
{
	public MenuBar? CustomMenuBar { get; private set; } = null;
	
	public MainWindow(string title) : base(title)
	{
		CustomMenuBar = new MenuBar (new MenuBarItem [] {
			new MenuBarItem ("_File", new MenuItem [] {
				new MenuItem($"Window {MainTopLevel.windowCount}", "", () => { }),
				new MenuItem ("_Close Window", "", () => { 
					Application.RequestStop(); 
				}),
				new MenuItem ("_Quit", "", () => { 
					// This does not do what I wanted
					Application.RequestStop(Application.Top); 
				})
			}),
		});
		
		// Create login button
		var pushWindowButton = new Button () {
			Text = "P_ush Window",
			Y = Pos.Center() - 1,
			X = Pos.Center (),
		};
		pushWindowButton.Clicked += () =>
		{
			Application.Run<MainTopLevel>();
		};
		
		var popWindowButton = new Button () {
			Text = "P_op Window",
			Y = Pos.Center() + 1,
			X = Pos.Center (),
		};
		popWindowButton.Clicked += () =>
		{
			RequestStop();
		};
		
		Add(pushWindowButton, popWindowButton);
	}
}

The main top level looks like this (again, in future I'd abstract it out, or pass window to it)

public class MainTopLevel : Toplevel
{
	public static int windowCount = 0;
	public MainTopLevel()
	{
		var window = new MainWindow($"Window - {windowCount}")
		{
			X = 0,
			Y = 1,
			Width = Dim.Fill(),
			Height = Dim.Fill(),
		};
		if (window.CustomMenuBar != null)
		{
			Add(window.CustomMenuBar);
		}
		else
		{
			// make window take up full screen.
			window.Y = 0;
		}
		Add(window);
	
		
		++windowCount;
	}
}

and then to start the application I just call this,

Application.Run<MainTopLevel>();
Application.Shutdown();

Is the way I am pushing/poping ideal? Is there a better way? Is what I am doing here the reason why I can't access the menu via the F key?

[BDisp]

If you really want to use different menus on each toplevel and on each modal window then the MainTopLevel must contain the code to open the first window with the custom menu and code to open the second with the custom menu and code to open the third window and so on.
The trick to have the menu above the window is creating on the MainWindow a new toplevel with the same size as Application.Top and add the menu on it.
See the SingleBackgroundWorker.cs to see how this work. I'm not meaning about the thread but only how the menu is add to a new toplevel and the window is added to that toplevel and then call Application.Run(top);

It also doesn't make sense to me the fact you are creating the menu on the MainWindow class and add it in the MainTopLevel class. If you always want to use the same menu on all the windows you open, then you can create and add it only on the MainTopLevel class.
See bellow:

	public class MainTopLevel : Toplevel
	{
		public static int windowCount = 0;
		public static bool quitApp;

		public MainTopLevel()
		{
			var customMenuBar = new MenuBar (new MenuBarItem [] {
				new MenuBarItem ("_File", new MenuItem [] {
					new MenuItem($"Window {windowCount}", "", () => { }),
					new MenuItem ("_Close Window", "", () => {
						windowCount--;
						Application.RequestStop();
					}),
					new MenuItem ("_Quit", "", () => { 
						// Now does what I wanted
						quitApp = true;
						Application.RequestStop ();
					})
				}),
			});
			Add(customMenuBar);

			var window = new MainWindow($"Window - {windowCount}");
			Add(window);

			++windowCount;
		}
	}

	public class MainWindow : Window
	{
		public MainWindow(string title) : base(title)
		{

			// Create login button
			var pushWindowButton = new Button () {
				Text = "P_ush Window",
				Y = Pos.Center() - 1,
				X = Pos.Center (),
			};
			pushWindowButton.Clicked += () =>
			{
				Application.Run<MainTopLevel>();
				if (MainTopLevel.quitApp) {
					Application.RequestStop();
				}
			};

			var popWindowButton = new Button () {
				Text = "P_op Window",
				Y = Pos.Center() + 1,
				X = Pos.Center (),
			};
			popWindowButton.Clicked += RequestStop;

			Add(pushWindowButton, popWindowButton);
		}
	}

[beeradmoore]

Thinking back about what I wrote and what you wrote, I think the idea of what I was after in my head is more clear. The intent is (and if I use an example of a fruit and veg shop) is there to be a MainWindow which would have options the user can select such as todays specials, browse fruits, browse vegetables, browse seasonal items. So there would also be a TodaysSpecialsWindow, BrowseFruitsWindow, BrowseVegetablesWindow and BrowseSeasonaltemsWindow. In this situation MainTopLevel would be more of a generic (not generic as in T, but maybe it takes a Window in its constructor) type item who's purpose is to put the menu above the window (at least I assume that is how menu is intended to be used, but I can also see maybe it isn't).

This would then mean BrowseFruitsWindows could have a menu item of

File
  -> Back to main menu
Tips
  -> Avoiding fruit fly

but BrowseSeasonaltemsWindow may have a menu that is

File
  -> Back to main menu
Select Season
  -> Summer (current)
  -> Autumn
  -> Winter
  -> Spring

That's why the code for developing a menu for that window I had put inside itself.

I'll checkout what SingleBackgroundWorker.cs is doing to handle its menu and pages. Running it I am having issues where the menu is not intractable, but also I am noticing the same thing for the base UICatelog as well.

[tznind]

If I have understood you correctly you want a menu bar per window and the ability to pop modals over one another.

This is well supported, here is how.

• Create 2 windows in the designer
• Add MenuBars to each
• Update code as described below

using Terminal.Gui;
using YourNamespace;

Application.Init();
Application.Run(new Window1());
Application.Shutdown();

Program.cs

public Window1() {
    InitializeComponent();
    showWindow2MenuItem.Action = () =>
    {
        Application.Run(new Window2() { 
            X = Pos.Percent(25),
            Y = Pos.Percent(25),
            Width = Dim.Percent(50),
            Height = Dim.Percent(50),
        });
    };
}

Window1.cs

public Window2() {
    InitializeComponent();
    showWindow3MenuItem.Action = () =>
    {
        MessageBox.Query("This window 3", "Window 3", "Ok");
    };
    closeWindow2MenuItem.Action = () =>
    {
        Application.RequestStop();
    };
}

Window2.cs

When run it will look as follows:

[beeradmoore]

Not just over as a smaller window, but as a full window. I wrote up an example in this comment. Essentially a menu navigation that would take me to/from different windows.

In your above examples the menus were in the window boarder itself. My plan was to have the menu above the window boarder+title, but now I am unsure what is the standard placement of a window.