When is this part of code declared?

Daniel Shepherd 246 Reputation points
2021-07-15T14:27:31.227+00:00

I am following the tutorial on modeless_dialogs.html about dialog boxes. In an example, when it shows the code CreateDialog(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_TOOLBAR), hwnd, ToolDlgProc);, at the end it shows ToolDlgProc. And I have one question. When is this defined? How can I implement this? What do I have to add to define something like that?

Visual Studio
Visual Studio
A family of Microsoft suites of integrated development tools for building applications for Windows, the web and mobile devices.
4,514 questions
Windows API - Win32
Windows API - Win32
A core set of Windows application programming interfaces (APIs) for desktop and server applications. Previously known as Win32 API.
2,387 questions
C++
C++
A high-level, general-purpose programming language, created as an extension of the C programming language, that has object-oriented, generic, and functional features in addition to facilities for low-level memory manipulation.
3,482 questions
{count} votes

8 answers

Sort by: Most helpful
  1. Castorix31 81,061 Reputation points
    2021-07-15T14:34:00.43+00:00

    Declare it at beginning :

    BOOL CALLBACK ToolDlgProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam);
    

  2. Daniel Shepherd 246 Reputation points
    2021-07-16T13:22:21.223+00:00

    Here is my code:

    include "framework.h"

    include "my windows app.h"

    include "d2d1.h"

    include <d2d1helper.h>

    include <dwrite.h>

    include <wincodec.h>

    include "winuser.h"

    include <iostream>

    include "Header.h"

    include "Resource.h"

    BOOL CALLBACK mydialog(HWND hwnd, UINT Dialog1, WPARAM, LPARAM lParam);

    define MAX_LOADSTRING 100

    // Global Variables:
    HINSTANCE hInst; // current instance
    WCHAR szTitle[MAX_LOADSTRING]; // The title bar text
    WCHAR szWindowClass[MAX_LOADSTRING]; // the main window class name

    // Forward declarations of functions included in this code module:
    ATOM MyRegisterClass(HINSTANCE hInstance);
    BOOL InitInstance(HINSTANCE, int);
    LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
    INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);

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

    // TODO: Place code here.  
    
    // Initialize global strings  
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);  
    LoadStringW(hInstance, IDC_MYWINDOWSAPP, szWindowClass, MAX_LOADSTRING);  
    MyRegisterClass(hInstance);  
    
    // Perform application initialization:  
    if (!InitInstance (hInstance, nCmdShow))  
    {  
        return FALSE;  
    }  
    
    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_MYWINDOWSAPP));  
    
    MSG msg;  
    
    // Main message loop:  
    while (GetMessage(&msg, nullptr, 0, 0))  
    {  
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))  
        {  
            TranslateMessage(&msg);  
            DispatchMessage(&msg);  
        }  
    }  
    
    return (int) msg.wParam;  
    

    }

    //
    // FUNCTION: MyRegisterClass()
    //
    // PURPOSE: Registers the window class.
    //
    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_MYWINDOWSAPP));  
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);  
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);  
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_MYWINDOWSAPP);  
    wcex.lpszClassName  = szWindowClass;  
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));  
    
    return RegisterClassExW(&wcex);  
    

    }

    //
    // FUNCTION: InitInstance(HINSTANCE, int)
    //
    // PURPOSE: Saves instance handle and creates main window
    //
    // COMMENTS:
    //
    // In this function, we save the instance handle in a global variable and
    // create and display the main program window.
    //
    BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
    {
    hInst = hInstance; // Store instance handle in our global variable

    HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
    CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

    if (!hWnd)
    {
    return FALSE;
    }

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

    return TRUE;
    }

    //
    // FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
    //
    // PURPOSE: Processes messages for the main window.
    //
    // WM_COMMAND - process the application menu
    // WM_PAINT - Paint the main window
    // WM_DESTROY - post a quit message and return
    //
    //
    LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    {
    TCHAR test[] = _T("welcome to my app :D");
    TCHAR testagain[] = _T("try clicking about :D");
    switch (message)
    {
    case WM_COMMAND:
    {
    int wmId = LOWORD(wParam);
    // Parse the menu selections:
    switch (wmId)
    {
    case ID_OPENDIALOG_OPENDIALOGBOXTHATIMADE:
    DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG1), hWnd, About);
    case IDM_ABOUT:
    {
    DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, mydialog);
    break;
    return 0;
    }
    case IDM_EXIT:
    MessageBox(hWnd, L"bye", L"bye!", MB_OK | MB_ICONHAND);
    DestroyWindow(hWnd);
    break;
    case ID_CLOSEWINDOWFORSOMETREASON_YESCLOSEIT:
    DestroyWindow(hWnd);
    break;
    case ID_MAKESOMETEXT:
    {
    case WM_PAINT:
    {
    TCHAR outtext[] = _T("ok here it is mr magic man");
    PAINTSTRUCT ps;
    HDC hdc = BeginPaint(hWnd, &ps);
    TextOut(hdc,
    10,30,
    outtext, _tcslen(outtext));
    EndPaint(hWnd, &ps);
    }
    break;
    }
    case ID_OTHERS_DESTROYWINDOW:
    {
    DestroyWindow(hWnd);
    break;
    return 0;
    }
    case ID_OTHERS_CLOSEWINDOW:
    {
    std::cout << "test \n";
    CloseWindow(hWnd);
    break;
    return 0;
    }
    default:
    return DefWindowProc(hWnd, message, wParam, lParam);
    }
    }
    break;
    case WM_MDIMAXIMIZE:
    {
    if (MessageBox(hWnd, L"you have maximized the window.", L"thx", MB_OK) == IDOK){
    SC_MAXIMIZE;
    }
    }
    case WM_LBUTTONDOWN:
    {
    MessageBox(hWnd, L"test", L"test", MB_OKCANCEL | MB_ICONINFORMATION);
    testheaderfunc();
    object.integer = 1;

        break;  
        return 0;  
    }  
    case WM_RBUTTONDOWN:  
    {  
        MessageBox(hWnd, L"you have right clicked the window", L"right click", MB_OK | MB_ICONASTERISK);  
        break;  
        return 0;  
    }  
    case WM_KEYDOWN:  
    {  
        MessageBox(hWnd, L"", L"", MB_YESNOCANCEL | MB_USERICON);  
        break;  
        return 0;  
    }  
    case WM_CLOSE:  
    {  
        if (MessageBox(hWnd, L"you have called WM_CLOSE. goodbye!", L"WM_CLOSE called", MB_OK | MB_ICONWARNING) == IDOK) {  
            DestroyWindow(hWnd);  
            return 0;  
        }  
    }  
    case WM_PAINT:  
        {  
            PAINTSTRUCT ps;  
            HDC hdc = BeginPaint(hWnd, &ps);  
            TextOut(hdc,  
                5, 5,  
                test, _tcslen(test));  
            TextOut(hdc,  
                10, 20,  
                testagain, _tcslen(testagain));  
            EndPaint(hWnd, &ps);  
        }  
        break;  
    case WM_DESTROY:  
        PostQuitMessage(0);  
        break;  
    default:  
        return DefWindowProc(hWnd, message, wParam, lParam);  
    }  
    return 0;  
    

    }

    // Message handler for about box.
    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;  
    

    }
    it returns two errors:
    115416-screenshot-2021-07-16-082133.png


  3. RLWA32 39,451 Reputation points
    2021-07-16T13:38:43.757+00:00

    Now that you have declared your dialog procedure function at the top of your source file you must include the body of your function, the function definition, in the source file also. For convenience, just place it in it's entirety at the very bottom of your source file.

    0 comments No comments

  4. Daniel Shepherd 246 Reputation points
    2021-07-16T14:34:55.827+00:00

    okay. These examples work, but it says hWnd is undefined.


  5. Daniel Shepherd 246 Reputation points
    2021-07-17T16:56:27.297+00:00

    Ok, this is one of my first windows apps. I am making a dialog function. it is returning an error no matter what. I am using visual studio 2019. Using c++ desktop wizard.