How to show another window on FSE(FullScreen Exclusive)

@Tong Xu - MSFT

Thanks for creating the sample program.

It looks the parent window is not FSE(fullscreen exclusive by SetFullscreenState) but just borderless normal fullscreen window.

And you set the style WS_CHILD| WS_OVERLAPPEDWINDOW for child window but seeing the style definition, WS_OVERLAPPED is not set actually.

WS_OVERLAPPED = 0x00000000L;
WS_CHILD = 0x40000000L;

WS_OVERLAPPEDWINDOW =
(WS_OVERLAPPED |WS_CAPTION |WS_SYSMENU |WS_THICKFRAME |WS_MINIMIZEBOX |WS_MAXIMIZEBOX);

I built your sample code in my local and I inspected the actual style for the child window using Spy++. Here is the result.

I do want to know how Windows OS handles window on FSE.

I found only some applications like game bar and volume controller can appear on FSE and I do want to know how they are implemented technically.

Today, I borrowed a device to test it, using raw code.

hWnd = CreateWindowEx(NULL,
        L"WindowClass",
        L"Our First Direct3D Program",
        NULL,
        10,
        10,
        1600,
        900,
        NULL,
        NULL,
        hInstance,
        NULL);
    if (hWnd == NULL)
    {
        return 0;
    }
    HWND hWnd1 = CreateWindowExW(NULL,
        L"WindowClass",
        L"Our First Direct3D Program",
        WS_OVERLAPPED|WS_SYSMENU|WS_MINIMIZEBOX|WS_CAPTION|WS_VSCROLL,
        400,
        400,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        hWnd,
        NULL,
        hInstance,
        NULL);
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);
    ShowWindow(hWnd1, nCmdShow);
    UpdateWindow(hWnd1);

It activates the full-screen exclusive mode and scales down to a resolution of 1600*1050 no matter having WS_CHILD and not.
Please check what has changed with my source code！I will keep an eye on this case to help you solve it.

@Tong Xu - MSFT

Thank you so much for kindly support.

Let me confirm 2 points.

Is your test application really fullscreen exclusive mode by SetFullscreenState?

Also could you check whether your test application is in FSE mode actually?

Here is the video about how to check FSE mode or not.
https://www.youtube.com/watch?v=G-vYP68nwkA

Yes, I confirmed. After ALT+TAB, father window still is borderless window.
HRESULT ree= swapchain->SetFullscreenState(TRUE, nullptr);
ree returns S_OK.

Maybe you should upload a video. Let's see what's going on.
The last of the last, we can open a ticket to have a remote meeting, but it is paid. We don't need to talk about it yet.

@Tong Xu - MSFT

Thanks for the confirmation.

I created test code based on your suggested code,
It works if the program doesn't render anything but it doesn't work once if render something.

(RenderFrame() is missing in your test code probably?)

With this test code, FSE can't be kept If something(alt tab switcher, other overlapped window) is overlayed on the target monitor.

// include the basic windows header files and the Direct3D header files
#include <windows.h>
#include <windowsx.h>
#include <d3d11.h>
//#include <d3dx11.h>
//#include <d3dx10.h>

// include the Direct3D Library file
#pragma comment (lib, "d3d11.lib")
//#pragma comment (lib, "d3dx11.lib")
//#pragma comment (lib, "d3dx10.lib")

// define the screen resolution
#define SCREEN_WIDTH  800
#define SCREEN_HEIGHT 600

// global declarations
IDXGISwapChain* swapchain;             // the pointer to the swap chain interface
ID3D11Device* dev;                     // the pointer to our Direct3D device interface
ID3D11DeviceContext* devcon;           // the pointer to our Direct3D device context
ID3D11RenderTargetView* backbuffer;    // the pointer to our back buffer

// function prototypes
void InitD3D(HWND hWnd);    // sets up and initializes Direct3D
void RenderFrame(void);     // renders a single frame
void CleanD3D(void);        // closes Direct3D and releases memory

// the WindowProc function prototype
LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);


// the entry point for any Windows program
int WINAPI WinMain(HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPSTR lpCmdLine,
    int nCmdShow)
{
    HWND hWnd;
    WNDCLASSEX wc;

    ZeroMemory(&wc, sizeof(WNDCLASSEX));

    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    //wc.hbrBackground = (HBRUSH)COLOR_WINDOW;    // no longer needed
    wc.lpszClassName = L"WindowClass";

    RegisterClassEx(&wc);

    RECT wr = { 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT };
    AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);

    hWnd = CreateWindowEx(NULL,
        L"WindowClass",
        L"Our First Direct3D Program",
        WS_OVERLAPPEDWINDOW,
        300,
        300,
        wr.right - wr.left,
        wr.bottom - wr.top,
        NULL,
        NULL,
        hInstance,
        NULL);
#if 0
    HWND hWnd1 = CreateWindowExW(NULL,
        L"WindowClass",
        L"Our Second Direct3D Program",
        //WS_OVERLAPPED | WS_SYSMENU | WS_MINIMIZEBOX | WS_CAPTION | WS_VSCROLL,
        WS_CHILD | WS_CLIPCHILDREN | /*WS_CLIPSIBLINGS |*/ WS_CAPTION | WS_SYSMENU | WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_VISIBLE,
        100,
        100,
        400,
        400,
        hWnd,
        NULL,
        hInstance,
        NULL);
    ShowWindow(hWnd1, SW_NORMAL);
#endif
    ShowWindow(hWnd, nCmdShow);


    // set up and initialize Direct3D
    InitD3D(hWnd);

    // Set FSE
    swapchain->SetFullscreenState(TRUE, NULL);    // switch to FSE

    // enter the main loop:

    MSG msg;

    while (TRUE)
    {
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);

            if (msg.message == WM_QUIT)
                break;
        }
        
        RenderFrame();
    }

    // clean up DirectX and COM
    CleanD3D();

    return msg.wParam;
}


// this is the main message handler for the program
LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_DESTROY:
    {
        PostQuitMessage(0);
        return 0;
    } break;
    }

    return DefWindowProc(hWnd, message, wParam, lParam);
}


// this function initializes and prepares Direct3D for use
void InitD3D(HWND hWnd)
{
    // create a struct to hold information about the swap chain
    DXGI_SWAP_CHAIN_DESC scd;

    // clear out the struct for use
    ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));

    // fill the swap chain description struct
    scd.BufferCount = 1;                                    // one back buffer
    scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;     // use 32-bit color
    scd.BufferDesc.Width = SCREEN_WIDTH;                    // set the back buffer width
    scd.BufferDesc.Height = SCREEN_HEIGHT;                  // set the back buffer height
    scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;      // how swap chain is to be used
    scd.OutputWindow = hWnd;                                // the window to be used
    scd.SampleDesc.Count = 4;                               // how many multisamples
    scd.Windowed = TRUE;                                    // windowed/full-screen mode
    scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;     // allow full-screen switching

    // create a device, device context and swap chain using the information in the scd struct
    D3D11CreateDeviceAndSwapChain(NULL,
        D3D_DRIVER_TYPE_HARDWARE,
        NULL,
        NULL,
        NULL,
        NULL,
        D3D11_SDK_VERSION,
        &scd,
        &swapchain,
        &dev,
        NULL,
        &devcon);


    // get the address of the back buffer
    ID3D11Texture2D* pBackBuffer;
    swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);

    // use the back buffer address to create the render target
    dev->CreateRenderTargetView(pBackBuffer, NULL, &backbuffer);
    pBackBuffer->Release();

    // set the render target as the back buffer
    devcon->OMSetRenderTargets(1, &backbuffer, NULL);


    // Set the viewport
    D3D11_VIEWPORT viewport;
    ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));

    viewport.TopLeftX = 0;
    viewport.TopLeftY = 0;
    viewport.Width = SCREEN_WIDTH;
    viewport.Height = SCREEN_HEIGHT;

    devcon->RSSetViewports(1, &viewport);
}


// this is the function used to render a single frame
void RenderFrame(void)
{
    float clearColor[4] = { 0.0f, 0.2f, 0.4f, 1.0f };
    // clear the back buffer to a deep blue
    devcon->ClearRenderTargetView(backbuffer, clearColor);

     // do 3D rendering on the back buffer here

    // switch the back buffer and the front buffer
    swapchain->Present(0, 0);
}


// this is the function that cleans up Direct3D and COM
void CleanD3D(void)
{
    swapchain->SetFullscreenState(FALSE, NULL);    // switch to windowed mode

    // close and release all existing COM objects
    swapchain->Release();
    backbuffer->Release();
    dev->Release();
    devcon->Release();
}