Customizing Window Close Behavior in Stride?

[EsatMan]

I'm looking to customize the window behavior of my application. Specifically, I want to:
1.Intercept the window close operation to perform some custom logic before the application actually closes. I'm not sure how to properly hook into this event in Stride. I've found Game.Window.Closing but not sure how to make use of it.
2.Hide or disable the default close button (X) in the top-right corner of the window when running in windowed mode. I believe this might involve modifying the non-client area of the window, but I'm not certain about the approach or best practices in Stride. Have I must implemente this by Win32api?
Thank you in advance for your help!

[NicusorN5]

Have you considered inheriting the Game class and writing your own destructor/Dispose logic?

[EsatMan]

Thanks for reply.
I've solved question 1, I found the type of EventArgs from Game.Window.Closeing is System.Windows.Forms.FormClosingEventArgs, and the closing operation can be stoped by set e.Cancel to false. Not sure how to deal with question 2 but it would work.
Inheriting the Game class sounds a little complicated for me.

[FloccinaucinihilifilipicatesLongNames]

So I've looked into this and below are my findings after some testing.

1. Great stuff that you already found the solution for question 1.
   If it helps any, the way I found it most comfortable for me is that you open the MyGameApp.cs (your app's name and usually with the name ending in .Windows or .Linux or whatever platform you're building for) then you modify it with something along the lines:

using var game = new Game();
game.WindowCreated += Game_WindowCreated; // Perform logic only once after the window is created
game.Run();

void Game_WindowCreated(object sender, EventArgs e)
{
    game.Exiting += Game_Exiting; // Implement another method with the logic required. I haven't tested this one enough to know when this runs, though.
    game.Window.Closing += Window_Closing; // Implement another method with the logic required. This runs when doing Alt+F4 but not sure if elsewhere.
    game.UnhandledException += Game_UnhandledException; // Implement another method with the logic required. This runs when a crash occurs.
}

void Window_Closing(object sender, EventArgs e)
{
     // Your logic here, below is an example
     System.Windows.Forms.MessageBox.Show("You're seeing this text when the window is forcibly shutdown.");
}

I haven't tested all of the event handlers in the engine but generally creating a void method and subscribing to the event that points to your method with += MyMethodHere or += delegate { /* Custom logic here */ } should be good enough to run the logic that you give it when the engine detects that part happening. (Make sure to avoid subscribing an event in a method that runs every frame like Update() because your memory will skyrocket to high heavens if you do, speaking from experience)

2. Removing the X button from the window is actually kind of complicated. Since I'm not an expert at Win32Api or whatever, I had to ask ChatGPT for this one.
   I found it possible to remove the system menu as you can see below:
   

For a (mostly) painless approach, you can copy the sorcery below and paste it somewhere in your code:

public static class WindowHelper
{
    // Inside GameHelper.cs
    // P/Invoke constants
    private const int GWL_STYLE = -16;
    private const int WS_SYSMENU = 0x00080000;
    private const uint SWP_NOSIZE = 0x0001;
    private const uint SWP_NOMOVE = 0x0002;
    private const uint SWP_NOZORDER = 0x0004;
    private const uint SWP_FRAMECHANGED = 0x0020;

    // P/Invoke functions
    [DllImport("user32.dll", SetLastError = true)]
    private static extern int GetWindowLong(IntPtr hWnd, int nIndex);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);

    public static void RemoveCloseButton(IntPtr windowHandle, bool ShowSystemMenu)
    {
        // Get the current window style
        int style = GetWindowLong(windowHandle, GWL_STYLE);

        // Modify the style based on the boolean
        if (ShowSystemMenu)
        {
            // Add the system menu (show the X button, minimize/maximize)
            SetWindowLong(windowHandle, GWL_STYLE, style | WS_SYSMENU);
        }
        else
        {
            // Remove the system menu (hide the X button, minimize/maximize)
            SetWindowLong(windowHandle, GWL_STYLE, style & ~WS_SYSMENU);
        }

        // Force the window to redraw and apply the changes
        SetWindowPos(windowHandle, IntPtr.Zero, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED);
    }
}

Then add the following delegate event once to Game.Window.ClientSizeChanged after the window is created. Preferably before the game runs and during the window creation event.

game.Window.ClientSizeChanged += delegate
{
    // Defer the RemoveCloseButton call until the window is fully initialized
    game.Script.AddTask(async () =>
    {
        await game.Script.NextFrame(); // Wait until the next frame
        WindowHelper.RemoveCloseButton(game.Window.NativeWindow.Handle, false); // Set to false to hide, true to show
    });
};

If you need to dissect the logic of the WindowHelper class to customize the window further, i'd recommend asking ChatGPT (or a similar coding bot) for it because the native window API is outside of my scope of knowledge and I'm currently not aware of a more "natively supported" solution to this question.
Otherwise, using the code above as outlined should suffice when you do size changes through Game.Window.SetSize(Int2Size) as the logic to readjust the window accordingly will run every time you resize the window.

Let me know if this helps or if you have any more questions.