自学教程：C++ DefWindowProcA函数代码示例

internal LRESULT CALLBACK Win32MainWindowCallback(HWND Window, UINT Message, WPARAM WParam, LPARAM LParam) {	LRESULT Result = 0;	switch (Message) {	case WM_DESTROY: {		// TODO: handle this as an error - recreate window?		GlobalRunning = false;	} break;	case WM_CLOSE: {		// TODO: handle this with a message to the user?		GlobalRunning = false;	} break;	case WM_SETCURSOR: {		if (DEBUGGlobalShowCursor) {			Result = DefWindowProcA(Window, Message, WParam, LParam);		}		else {			SetCursor(0);		}	} break;	case WM_ACTIVATEAPP: {#if 0		if (WParam) {			SetLayeredWindowAttributes(Window, RGB(0, 0, 0), 255, LWA_ALPHA);		}		else {			SetLayeredWindowAttributes(Window, RGB(0, 0, 0), 64, LWA_ALPHA);		}#endif	} break;	case WM_PAINT: {		PAINTSTRUCT Paint;		HDC DeviceContext = BeginPaint(Window, &Paint);		win32_window_dimension Dimension = Win32GetWindowDimension(Window);		Win32DisplayBufferInWindow(&GlobalBackbuffer, DeviceContext, Dimension.Width, Dimension.Height);		EndPaint(Window, &Paint);	} break;	case WM_SYSKEYDOWN:	case WM_SYSKEYUP:	case WM_KEYDOWN:	case WM_KEYUP: {		Assert(!"Keyboard input came in through a non-dispatch message!");	} break;	default: {		// OutputDebugStringA("default/n");		Result = DefWindowProcA(Window, Message, WParam, LParam);	} break;	}	return(Result);}

LRESULT WINAPI ImeWndProc_common( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode ) // ReactOS{    PWND pWnd;    PIMEUI pimeui;    pWnd = ValidateHwnd(hwnd);    if (pWnd)    {       if (!pWnd->fnid)       {          if (msg != WM_NCCREATE)          {             if (unicode)                return DefWindowProcW(hwnd, msg, wParam, lParam);             return DefWindowProcA(hwnd, msg, wParam, lParam);          }          NtUserSetWindowFNID(hwnd, FNID_IME);          pimeui = HeapAlloc( GetProcessHeap(), 0, sizeof(IMEUI) );          SetWindowLongPtrW(hwnd, 0, (LONG_PTR)pimeui);       }       else       {          if (pWnd->fnid != FNID_IME)          {             ERR("Wrong window class for Ime! fnId 0x%x/n",pWnd->fnid);             return 0;          }          pimeui = ((PIMEWND)pWnd)->pimeui;          if (pimeui == NULL)          {             ERR("Window is not set to IME!/n");             return 0;          }       }    }    if (msg==WM_CREATE || msg==WM_NCCREATE)        return TRUE;    if (msg==WM_NCDESTROY)    {        HeapFree( GetProcessHeap(), 0, pimeui );        SetWindowLongPtrW(hwnd, 0, 0);        NtUserSetWindowFNID(hwnd, FNID_DESTROY);    }    if (unicode)       return DefWindowProcW(hwnd, msg, wParam, lParam);    return DefWindowProcA(hwnd, msg, wParam, lParam);}

/////////////////////////////////////////////////////////////// Function called whenever one of our windows receives a message////////////////////////////////////////////////////////////static LRESULT CALLBACK GlobalOnEvent(HWND Handle, UINT Message, WPARAM WParam, LPARAM LParam){    // Associate handle and Window instance when the creation message is received    if (Message == WM_CREATE)    {        // Get instance (it was passed as the last argument of CreateWindow)        LONG Instance = (LONG)((CREATESTRUCT *)LParam)->lpCreateParams;        // Set as the "user data" parameter of the window        SetWindowLongPtr(Handle, GWLP_USERDATA, Instance);    }    // Forward the event to the appropriate function	if (WindowhWnd)	{		ProcessEvent(Message, WParam, LParam);				if (WindowCallback)			return CallWindowProc((WNDPROC)(WindowCallback), Handle, Message, WParam, LParam);	}    // We don't forward the WM_CLOSE message to prevent the OS from automatically destroying the window    if (Message == WM_CLOSE)        return 0;    return HasUnicodeSupport() ? DefWindowProcW(Handle, Message, WParam, LParam) :								 DefWindowProcA(Handle, Message, WParam, LParam);}

static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){    static LONG defwndproc_counter = 0;    LRESULT ret;    struct message msg;    /* log system messages, except for painting */    if (message < WM_USER &&        message != WM_PAINT &&        message != WM_ERASEBKGND &&        message != WM_NCPAINT &&        message != WM_NCHITTEST &&        message != WM_GETTEXT &&        message != WM_GETICON &&        message != WM_DEVICECHANGE)    {        trace("parent: %p, %04x, %08lx, %08lx/n", hwnd, message, wParam, lParam);        msg.message = message;        msg.flags = sent|wparam|lparam;        if (defwndproc_counter) msg.flags |= defwinproc;        msg.wParam = wParam;        msg.lParam = lParam;        msg.id = 0;        add_message(sequences, PARENT_SEQ_INDEX, &msg);    }    defwndproc_counter++;    ret = DefWindowProcA(hwnd, message, wParam, lParam);    defwndproc_counter--;    return ret;}

static LRESULT WINAPI child_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){    static LONG defwndproc_counter;    struct message msg = { 0 };    LRESULT ret;    msg.message = message;    msg.flags = sent | wparam | lparam;    if (defwndproc_counter)        msg.flags |= defwinproc;    msg.wParam = wParam;    msg.lParam = lParam;    if (hwnd == child1_wnd)        msg.id = CHILD1_ID;    else if (hwnd == child2_wnd)        msg.id = CHILD2_ID;    else        msg.id = 0;    add_message(sequences, PAGER_SEQ_INDEX, &msg);    defwndproc_counter++;    ret = DefWindowProcA(hwnd, message, wParam, lParam);    defwndproc_counter--;    return ret;}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {	if (message == WM_CLOSE) {		mAppRunning = false;	}		return DefWindowProcA(hWnd, message, wParam, lParam);}

/////////////////////////////////////////////////////////////// Function called whenever one of our windows receives a message////////////////////////////////////////////////////////////LRESULT CALLBACK WindowImplWin32::GlobalOnEvent(HWND Handle, UINT Message, WPARAM WParam, LPARAM LParam){    // Associate handle and Window instance when the creation message is received    if (Message == WM_CREATE)    {        // Get WindowImplWin32 instance (it was passed as the last argument of CreateWindow)        long This = reinterpret_cast<long>(reinterpret_cast<CREATESTRUCT*>(LParam)->lpCreateParams);        // Set as the "user data" parameter of the window        SetWindowLongPtr(Handle, GWLP_USERDATA, This);    }    // Get the WindowImpl instance corresponding to the window handle    WindowImplWin32* Window = reinterpret_cast<WindowImplWin32*>(GetWindowLongPtr(Handle, GWLP_USERDATA));    // Forward the event to the appropriate function    if (Window)    {        Window->ProcessEvent(Message, WParam, LParam);        if (Window->myCallback)            return CallWindowProc(reinterpret_cast<WNDPROC>(Window->myCallback), Handle, Message, WParam, LParam);    }    // We don't forward the WM_CLOSE message to prevent the OS from automatically destroying the window    if (Message == WM_CLOSE)        return 0;    static const bool HasUnicode = HasUnicodeSupport();    return HasUnicode ? DefWindowProcW(Handle, Message, WParam, LParam) :                        DefWindowProcA(Handle, Message, WParam, LParam);}

static LRESULT WINAPI	MCIWndProc(HWND hWnd, UINT wMsg, WPARAM lParam1, LPARAM lParam2){   MCIWndInfo*	mwi = (MCIWndInfo*)GetWindowLongA(hWnd, 0);   if (mwi || wMsg == WM_CREATE) {      switch (wMsg) {      case WM_CREATE:	 MCIWND_Create(hWnd, (CREATESTRUCTA*)lParam2);	 return 0;      case WM_DESTROY:	 MCIWND_Close(mwi);	 HeapFree(GetProcessHeap(), 0, mwi->lpName);	 HeapFree(GetProcessHeap(), 0, mwi);	 break;      case WM_PAINT:	 MCIWND_Paint(mwi, lParam1);	 break;      case WM_COMMAND:	 return MCIWND_Command(mwi, lParam1, lParam2);      case WM_TIMER:	 MCIWND_Timer(mwi, lParam1, lParam2);	 return TRUE;      }   }   return DefWindowProcA(hWnd, wMsg, lParam1, lParam2);}

static LRESULT WINAPI parentWindowProcess(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){    static LONG defwndproc_counter = 0;    LRESULT ret;    struct message msg;    /* do not log painting messages */    if (message != WM_PAINT &&        message != WM_ERASEBKGND &&        message != WM_NCPAINT &&        message != WM_NCHITTEST &&        message != WM_GETTEXT &&        message != WM_GETICON &&        message != WM_DEVICECHANGE)    {        trace("parent: %p, %04x, %08lx, %08lx/n", hwnd, message, wParam, lParam);        msg.message = message;        msg.flags = sent|wparam|lparam;        if (defwndproc_counter) msg.flags |= defwinproc;        msg.wParam = wParam;        msg.lParam = lParam;        add_message(sequences, PARENT_SEQ_INDEX, &msg);    }    /* dump sent structure data */    if (message == WM_DRAWITEM)        g_drawitem = *(DRAWITEMSTRUCT*)lParam;    defwndproc_counter++;    ret = DefWindowProcA(hwnd, message, wParam, lParam);    defwndproc_counter--;    return ret;}

internal LRESULT CALLBACKMainWindowCallback(HWND Window,                   UINT Message,                   WPARAM wParam,                   LPARAM lParam){    LRESULT Result = 0;    switch(Message)    {    case WM_CLOSE:    case WM_DESTROY:    {        GlobalRunning = false;    }    break;    default:    {        Result = DefWindowProcA(Window, Message, wParam, lParam);    }    break;    }    return Result;}

static LRESULT CALLBACK WndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam ){    if(msg == WM_MOUSEMOVE)        results[test_no].mouse_move_called++;    return DefWindowProcA( hWnd, msg, wParam, lParam );}

static LRESULT CALLBACKwin32_window_callback(HWND window, UINT message, WPARAM wp, LPARAM lp){    switch (message) {        case WM_KEYDOWN: {            CORE->key_modifiers = win32_app_key_mods();            if (wp < KEYS_MAX) {                CORE->key_states[wp] = 1;                CORE->key_deltas[wp] = 1;                // printf("key pressed: %d/n", wp);            }            return 0;        }            break;        case WM_KEYUP: {            CORE->key_modifiers = win32_app_key_mods();            if (wp < KEYS_MAX) {                CORE->key_states[wp] = 0;                CORE->key_deltas[wp] = 1;                // printf("key released: %d/n", wp);            }            return 0;        }            break;        case WM_CLOSE: {            PostQuitMessage(0);            CORE->running = 0;        }            break;    }    return DefWindowProcA(window, message, wp, lp);}

static LRESULT WINAPI test_notify_parent_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam){   switch(msg)   {       case WM_NOTIFY:       {           NMHDR *hdr = ((LPNMHDR)lParam);           switch(hdr->code)           {               case NM_DBLCLK: g_got_dblclk = TRUE; break;               case NM_CLICK: g_got_click = TRUE; break;               case NM_RDBLCLK: g_got_rdblclk = TRUE; break;               case NM_RCLICK: g_got_rclick = TRUE; break;           }           /* Return zero to indicate default processing */           return 0;       }       case WM_CONTEXTMENU: g_got_contextmenu = TRUE; return 0;       default:            return( DefWindowProcA(hwnd, msg, wParam, lParam));   }   return 0;}

static LRESULT CALLBACK OwnerWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam){    if(msg == ID_FINDMSGSTRING) {        return handle_findmsg((FINDREPLACEA*)lParam);    }    return DefWindowProcA(hwnd, msg, wParam, lParam);}

static LRESULT CALLBACK main_window_procA (HWND hwnd, UINT uiMsg, WPARAM wParam,        LPARAM lParam){    switch (uiMsg)    {        /* Add blank case statements for these to ensure we don't use them         * by mistake.         */        case DM_GETDEFID: break;        case DM_SETDEFID: break;        case WM_CREATE:            return (OnMainWindowCreate (hwnd,                    (LPCREATESTRUCTA) lParam) ? 0 : (LRESULT) -1);        case WM_COMMAND:            if (wParam == IDCANCEL)            {                g_terminated = TRUE;                return 0;            }            break;    }    return DefWindowProcA (hwnd, uiMsg, wParam, lParam);}

static LRESULT CALLBACK winraw_callback(HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar){   static uint8_t data[1024];   UINT r;   unsigned i;   RAWINPUT *ri = (RAWINPUT*)data;   UINT size    = sizeof(data);   if (msg != WM_INPUT)      return DefWindowProcA(wnd, msg, wpar, lpar);   /* app is in the background */   if (GET_RAWINPUT_CODE_WPARAM(wpar) != RIM_INPUT)      goto end;   r = GetRawInputData((HRAWINPUT)lpar, RID_INPUT,         data, &size, sizeof(RAWINPUTHEADER));   if (r == (UINT)-1)   {      RARCH_WARN("[WINRAW]: GetRawInputData failed with error %lu./n",            GetLastError());      goto end;   }   if (ri->header.dwType == RIM_TYPEKEYBOARD)   {      if (ri->data.keyboard.Message == WM_KEYDOWN)         g_keyboard->keys[ri->data.keyboard.VKey] = 1;      else if (ri->data.keyboard.Message == WM_KEYUP)         g_keyboard->keys[ri->data.keyboard.VKey] = 0;   }   else if (ri->header.dwType == RIM_TYPEMOUSE)   {      for (i = 0; i < g_mouse_cnt; ++i)      {         if (g_mice[i].hnd == ri->header.hDevice)         {            winraw_update_mouse_state(&g_mice[i], &ri->data.mouse);            break;         }      }   }end:   DefWindowProcA(wnd, msg, wpar, lpar);   return 0;}

LRESULT CALLBACKWin32MainWindowCallback( HWND Window,                         UINT Message,                         WPARAM WParam,                         LPARAM LParam){    LRESULT Result = 0;        switch(Message)    {        case WM_SIZE:        {            RECT ClientRect;            GetClientRect(Window, &ClientRect);            int Width = ClientRect.right - ClientRect.left;            int Height = ClientRect.bottom - ClientRect.top;            Win32ResizeDIBSection(Width, Height);        } break;        case WM_DESTROY:        {            Running = false;        }break;        case WM_CLOSE:        {            PostQuitMessage(0);            Running = false;        }break;        case WM_ACTIVATEAPP:        {            OutputDebugStringA("");        }break;        case WM_PAINT:        {            PAINTSTRUCT Paint;            HDC DeviceContext = BeginPaint(Window, &Paint);            int X = Paint.rcPaint.left;            int Y = Paint.rcPaint.top;            int Width = Paint.rcPaint.right - Paint.rcPaint.left;            int Height = Paint.rcPaint.bottom - Paint.rcPaint.top;            RECT ClientRect;            GetClientRect(Window, &ClientRect);                        Win32UpdateWindow(DeviceContext, &ClientRect, X, Y, Width, Height);            EndPaint(Window, &Paint);        }break;                default:        {            OutputDebugStringA("");            Result = DefWindowProcA(Window, Message, WParam, LParam);        }break;                 }    return (Result);}

static LRESULT WINAPIVCP_UI_FileCopyWndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam){    if (uMsg != WM_CREATE)        return DefWindowProcA (hwnd, uMsg, wParam, lParam);    return 0;}

static LRESULT CALLBACK WndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam ){    if(msg == WM_SYSKEYDOWN)	{	    ok(wParam == VK_MENU, "Got wrong wParam in WM_SYSKEYDOWN (%d instead of %d)/n", wParam, VK_MENU );	}    return DefWindowProcA( hWnd, msg, wParam, lParam );}

static LRESULT CALLBACK MyWindowWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){	switch (message)	{		case WM_ACTIVATE:			if ( wParam == WA_INACTIVE && bEmbedBrowserObject )			{				ShowWindow(hwndHTMLParent, SW_HIDE);				UnEmbedBrowserObject(hwndHTMLParent);				bEmbedBrowserObject = FALSE;				bTooltipShow = FALSE;			}			break;		default:			return DefWindowProcA(hwnd, message, wParam, lParam);	}	return DefWindowProcA(hwnd, message, wParam, lParam);}

void CStaticMemDC::OnPaint(){	CPaintDC dc(this);	CRect clip;    GetWindowRect(&clip);		// get rect of the control    ScreenToClient(&clip);    CMemDC2 memDC(&dc,&clip);	DefWindowProcA(WM_PAINT, (WPARAM)memDC->m_hDC, (LPARAM)0);}

		LRESULT Window::wndproc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )		{			Window* window = reinterpret_cast<Window*>( GetWindowLongPtrA( hWnd, GWLP_USERDATA ) );			if( window )			{				return window->msgproc( hWnd, msg, wParam, lParam );			}			return DefWindowProcA( hWnd, msg, wParam, lParam );		}

static LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam){    if (msg == WM_DESTROY)    {        trace("destroying hwnd %p/n", hWnd);        PostQuitMessage(0);        return 0;    }    return DefWindowProcA( hWnd, msg, wParam, lParam );}

LRESULT CALLBACK StaticHookProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {	switch (uMsg) {		case WM_NCHITTEST:			return HTCLIENT;	}	WNDPROC pOldProc=(WNDPROC)GetPropA(hwnd,"OriginalStaticProc");	if (pOldProc)		CallWindowProcA(pOldProc,hwnd,uMsg,wParam,lParam);	return DefWindowProcA(hwnd,uMsg,wParam,lParam);}

LRESULT CTargetWnd::WindowProc(UINT msg,WPARAM wParam,LPARAM lParam){#ifdef _DEBUG	void DebugCommandsProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam);	DebugCommandsProc(*this,msg,wParam,lParam);#endif	if (IsUnicodeSystem())		return DefWindowProcW(m_hWnd,msg,wParam,lParam);	else		return DefWindowProcA(m_hWnd,msg,wParam,lParam);}

LRESULT CALLBACK ContainerWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {	switch (uMsg) {		case WM_CREATE:			return 0;	}	ContainerNode *pNode=(ContainerNode *)GetPropA(hwnd,"ContainerNode");	LRESULT retval=0;	if (pNode && pNode->OnMessage(hwnd,uMsg,wParam,lParam,&retval))		return retval;	return DefWindowProcA(hwnd,uMsg,wParam,lParam);}

static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){    static LONG defwndproc_counter = 0;    LRESULT ret;    struct message msg;    /* log system messages, except for painting */    if (message < WM_USER &&        message != WM_PAINT &&        message != WM_ERASEBKGND &&        message != WM_NCPAINT &&        message != WM_NCHITTEST &&        message != WM_GETTEXT &&        message != WM_GETICON &&        message != WM_DEVICECHANGE)    {        msg.message = message;        msg.flags = sent|wparam|lparam|parent;        if (defwndproc_counter) msg.flags |= defwinproc;        msg.wParam = wParam;        msg.lParam = lParam;        if (message == WM_NOTIFY && lParam) msg.id = ((NMHDR*)lParam)->code;        add_message(sequences, PAGER_SEQ_INDEX, &msg);    }    if (message == WM_NOTIFY)    {        NMHDR *nmhdr = (NMHDR *)lParam;        switch (nmhdr->code)        {            case PGN_CALCSIZE:            {                NMPGCALCSIZE *nmpgcs = (NMPGCALCSIZE *)lParam;                DWORD style = GetWindowLongA(nmpgcs->hdr.hwndFrom, GWL_STYLE);                if (style & PGS_HORZ)                    ok(nmpgcs->dwFlag == PGF_CALCWIDTH, "Unexpected flags %#x./n", nmpgcs->dwFlag);                else                    ok(nmpgcs->dwFlag == PGF_CALCHEIGHT, "Unexpected flags %#x./n", nmpgcs->dwFlag);                break;            }            default:                ;        }    }    defwndproc_counter++;    ret = DefWindowProcA(hwnd, message, wParam, lParam);    defwndproc_counter--;    return ret;}

static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){    if (message == WM_NOTIFY && lParam)    {        NMTTDISPINFOA *ttnmdi = (NMTTDISPINFOA*)lParam;        if (ttnmdi->hdr.code == TTN_GETDISPINFOA)            lstrcpyA(ttnmdi->lpszText, testcallbackA);    }    return DefWindowProcA(hwnd, message, wParam, lParam);}

static LRESULT WINAPI wndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam){    switch (msg)    {        case WM_IME_SETCONTEXT:        case WM_NCCREATE:        case WM_CREATE:            return TRUE;    }    return DefWindowProcA(hwnd,msg,wParam,lParam);}

static LRESULT CALLBACK info_wnd_proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam){    switch(msg) {    case WM_DESTROY:        PostQuitMessage(0);        break;    default:        return DefWindowProcA(hWnd, msg, wParam, lParam);    }    return 0;}