tenho seguinte código c++

// DataIntegrityTools.cpp : Define o ponto de entrada para o aplicativo.
//
#include "framework.h"
#include "DataIntegrityTools.h"
#include <shlobj.h>
#include <string>

#define MAX_LOADSTRING 100

// Definição do tamanho fixo
const int WINDOW_WIDTH = 1024;
const int WINDOW_HEIGHT = 768;

// Variáveis Globais:
HINSTANCE hInst;                                // instância atual
WCHAR szTitle[MAX_LOADSTRING];                  // O texto da barra de título
WCHAR szWindowClass[MAX_LOADSTRING];            // o nome da classe da janela principal
HWND hStaticPath;                               // Controle estático para exibir o caminho da pasta

// Declarações de encaminhamento de funções incluídas nesse módulo de código:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

// Função para atualizar o texto do controle estático
void UpdateStaticPath(const std::wstring& path) {
    std::wstring displayText = L"Pasta Selecionada: " + path;
    SetWindowTextW(hStaticPath, displayText.c_str());
}

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ LPWSTR    lpCmdLine,
    _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // Inicialização das strings
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_DATAINTEGRITYTOOLS, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    if (!InitInstance(hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_DATAINTEGRITYTOOLS));

    MSG msg;

    // Loop de mensagem principal:
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int)msg.wParam;
}

//
//  FUNÇÃO: MyRegisterClass()
//
//  FINALIDADE: Registra a classe de janela.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc = WndProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_DATAINTEGRITYTOOLS));
    wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_DATAINTEGRITYTOOLS);
    wcex.lpszClassName = szWindowClass;
    wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

//
//   FUNÇÃO: InitInstance(HINSTANCE, int)
//
//   FINALIDADE: Salva o identificador de instância e cria a janela principal
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    hInst = hInstance; // Armazenar o identificador de instância em nossa variável global

    // Calcular o tamanho total da janela com base no tamanho desejado do cliente
    RECT rect = { 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT };
    AdjustWindowRect(&rect, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX, FALSE); // Inclui WS_MINIMIZEBOX

    HWND hWnd = CreateWindowW(szWindowClass, szTitle,
        WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,  // Inclui WS_MINIMIZEBOX
        CW_USEDEFAULT, 0, rect.right - rect.left, rect.bottom - rect.top,
        nullptr, nullptr, hInstance, nullptr);

    if (!hWnd)
    {
        return FALSE;
    }

    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);

    return TRUE;
}

//
//  FUNÇÃO: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  FINALIDADE: Processa as mensagens para a janela principal.
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_CREATE:
    {
        // Criar o controle estático para exibir o caminho da pasta
        hStaticPath = CreateWindowW(L"STATIC", L"Pasta Selecionada: Nenhuma",
            WS_CHILD | WS_VISIBLE | SS_LEFT,
            10, 10, WINDOW_WIDTH - 20, 25, // Posição e tamanho
            hWnd, (HMENU)1, hInst, nullptr);

        // Remover a opção de maximizar do menu do sistema
        HMENU hMenu = GetSystemMenu(hWnd, FALSE);
        if (hMenu)
        {
            // Desabilitar o item de maximizar
            EnableMenuItem(hMenu, SC_MAXIMIZE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);

            // Opcionalmente, remover o item de maximizar completamente
            // RemoveMenu(hMenu, SC_MAXIMIZE, MF_BYCOMMAND);
        }
    }
    break;
    case WM_COMMAND:
    {
        int wmId = LOWORD(wParam);
        // Analisar as seleções do menu:
        switch (wmId)
        {
        case IDM_ABOUT:
            DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
            break;
        case IDM_EXIT:
            DestroyWindow(hWnd);
            break;
        case IDM_SELECT_FOLDER:
        {
            BROWSEINFO bi = { 0 };
            bi.lpszTitle = L"Selecione uma pasta";
            bi.ulFlags = BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS;

            LPITEMIDLIST pidl = SHBrowseForFolder(&bi);

            if (pidl != NULL)
            {
                WCHAR path[MAX_PATH];
                if (SHGetPathFromIDListW(pidl, path))
                {
                    // Atualizar o controle estático com o caminho da pasta
                    UpdateStaticPath(path);
                }
                CoTaskMemFree(pidl);  // Liberar memória alocada
            }
            break;
        }
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
    }
    break;
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);
        // Adicione qualquer desenho adicional aqui, se necessário
        EndPaint(hWnd, &ps);
    }
    break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    case WM_GETMINMAXINFO:
    {
        // Definir o tamanho mínimo e máximo para impedir redimensionamento
        MINMAXINFO* mmi = (MINMAXINFO*)lParam;
        mmi->ptMinTrackSize.x = WINDOW_WIDTH;
        mmi->ptMinTrackSize.y = WINDOW_HEIGHT;
        mmi->ptMaxTrackSize.x = WINDOW_WIDTH;
        mmi->ptMaxTrackSize.y = WINDOW_HEIGHT;
    }
    break;
    case WM_SYSCOMMAND:
    {
        if ((wParam & 0xFFF0) == SC_MAXIMIZE)
        {
            // Ignorar o comando de maximizar
            return 0;
        }
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

Como posso adicionar abaixo de Pasta Selecionada

uma listbox com tamanho de 90% height centralizado, que mostra os arquivos de extensão dll, exe, asi e m3d a list box deve ter como primeiro parametro uma checkbox, segundo nome do arquivo, terceiro hash e quarto tamanho, mostrando B, KB, MB e GB