controls.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	HEADCOMBO

Macros
#define	HBMMENU_CALLBACK   ((HBITMAP) -1)
#define	HBMMENU_SYSTEM   ((HBITMAP) 1)
#define	HBMMENU_MBAR_RESTORE   ((HBITMAP) 2)
#define	HBMMENU_MBAR_MINIMIZE   ((HBITMAP) 3)
#define	HBMMENU_MBAR_CLOSE   ((HBITMAP) 5)
#define	HBMMENU_MBAR_CLOSE_D   ((HBITMAP) 6)
#define	HBMMENU_MBAR_MINIMIZE_D   ((HBITMAP) 7)
#define	HBMMENU_POPUP_CLOSE   ((HBITMAP) 8)
#define	HBMMENU_POPUP_RESTORE   ((HBITMAP) 9)
#define	HBMMENU_POPUP_MAXIMIZE   ((HBITMAP) 10)
#define	HBMMENU_POPUP_MINIMIZE   ((HBITMAP) 11)
#define	ID_CB_LISTBOX   1000
#define	ID_CB_EDIT   1001
#define	CB_OKAY   0
#define	CBF_DROPPED   0x0001
#define	CBF_BUTTONDOWN   0x0002
#define	CBF_NOROLLUP   0x0004
#define	CBF_MEASUREITEM   0x0008
#define	CBF_FOCUSED   0x0010
#define	CBF_CAPTURE   0x0020
#define	CBF_EDIT   0x0040
#define	CBF_NORESIZE   0x0080
#define	CBF_NOTIFY   0x0100
#define	CBF_NOREDRAW   0x0200
#define	CBF_SELCHANGE   0x0400
#define	CBF_NOEDITNOTIFY   0x1000
#define	CBF_NOLBSELECT   0x2000 /* do not change current selection */
#define	CBF_BEENFOCUSED   0x4000 /* has it ever had focus */
#define	CBF_EUI   0x8000
#define	CB_GETTYPE(lphc)   ((lphc)->dwStyle & (CBS_DROPDOWNLIST))
#define	LB_INSERTSTRING_UPPER   0x1AA
#define	LB_INSERTSTRING_LOWER   0x1AB
#define	LB_ADDSTRING_UPPER   0x1AC
#define	LB_ADDSTRING_LOWER   0x1AD

Typedefs
typedef struct HEADCOMBO *	LPHEADCOMBO

Functions
BOOL	COMBO_FlipListbox (LPHEADCOMBO, BOOL, BOOL)
HRGN	set_control_clipping (HDC hdc, const RECT *rect)
LRESULT WINAPI	DesktopWndProcA (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	DesktopWndProcW (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	User32DefWindowProc (HWND, UINT, WPARAM, LPARAM, BOOL)
BOOL WINAPI	RegisterClientPFN (VOID)
LRESULT WINAPI	IconTitleWndProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	ButtonWndProcA (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	ButtonWndProcW (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	ButtonWndProc_common (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL unicode)
LRESULT WINAPI	ComboWndProcA (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	ComboWndProcW (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	ComboWndProc_common (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam, BOOL unicode)
LRESULT WINAPI	EditWndProcA (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	EditWndProcW (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	EditWndProc_common (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode)
LRESULT WINAPI	GhostWndProcA (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	GhostWndProcW (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	GhostWndProc_common (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL unicode)
LRESULT WINAPI	ListBoxWndProcA (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	ListBoxWndProcW (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	ListBoxWndProc_common (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode)
LRESULT WINAPI	MDIClientWndProcA (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	MDIClientWndProcW (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	MDIClientWndProc_common (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam, BOOL unicode)
LRESULT WINAPI	PopupMenuWndProcA (HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	PopupMenuWndProcW (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	ScrollBarWndProcW (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	ScrollBarWndProcA (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	StaticWndProcA (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	StaticWndProcW (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	StaticWndProc_common (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL unicode)
LRESULT WINAPI	SwitchWndProcA (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	SwitchWndProcW (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

Macro Definition Documentation

CB_GETTYPE

#define CB_GETTYPE

(

lphc

)

((lphc)->dwStyle & (CBS_DROPDOWNLIST))

Definition at line 82 of file controls.h.

CB_OKAY

#define CB_OKAY   0

Definition at line 42 of file controls.h.

CBF_BEENFOCUSED

#define CBF_BEENFOCUSED   0x4000 /* has it ever had focus */

Definition at line 58 of file controls.h.

CBF_BUTTONDOWN

#define CBF_BUTTONDOWN   0x0002

Definition at line 46 of file controls.h.

CBF_CAPTURE

#define CBF_CAPTURE   0x0020

Definition at line 50 of file controls.h.

CBF_DROPPED

#define CBF_DROPPED   0x0001

Definition at line 45 of file controls.h.

CBF_EDIT

#define CBF_EDIT   0x0040

Definition at line 51 of file controls.h.

CBF_EUI

#define CBF_EUI   0x8000

Definition at line 59 of file controls.h.

CBF_FOCUSED

#define CBF_FOCUSED   0x0010

Definition at line 49 of file controls.h.

CBF_MEASUREITEM

#define CBF_MEASUREITEM   0x0008

Definition at line 48 of file controls.h.

CBF_NOEDITNOTIFY

#define CBF_NOEDITNOTIFY   0x1000

Definition at line 56 of file controls.h.

CBF_NOLBSELECT

#define CBF_NOLBSELECT   0x2000 /* do not change current selection */

Definition at line 57 of file controls.h.

CBF_NOREDRAW

#define CBF_NOREDRAW   0x0200

Definition at line 54 of file controls.h.

CBF_NORESIZE

#define CBF_NORESIZE   0x0080

Definition at line 52 of file controls.h.

CBF_NOROLLUP

#define CBF_NOROLLUP   0x0004

Definition at line 47 of file controls.h.

CBF_NOTIFY

#define CBF_NOTIFY   0x0100

Definition at line 53 of file controls.h.

CBF_SELCHANGE

#define CBF_SELCHANGE   0x0400

Definition at line 55 of file controls.h.

HBMMENU_CALLBACK

#define HBMMENU_CALLBACK   ((HBITMAP) -1)

Definition at line 4 of file controls.h.

HBMMENU_MBAR_CLOSE

#define HBMMENU_MBAR_CLOSE   ((HBITMAP) 5)

Definition at line 16 of file controls.h.

HBMMENU_MBAR_CLOSE_D

#define HBMMENU_MBAR_CLOSE_D   ((HBITMAP) 6)

Definition at line 19 of file controls.h.

HBMMENU_MBAR_MINIMIZE

#define HBMMENU_MBAR_MINIMIZE   ((HBITMAP) 3)

Definition at line 13 of file controls.h.

HBMMENU_MBAR_MINIMIZE_D

#define HBMMENU_MBAR_MINIMIZE_D   ((HBITMAP) 7)

Definition at line 22 of file controls.h.

HBMMENU_MBAR_RESTORE

#define HBMMENU_MBAR_RESTORE   ((HBITMAP) 2)

Definition at line 10 of file controls.h.

HBMMENU_POPUP_CLOSE

#define HBMMENU_POPUP_CLOSE   ((HBITMAP) 8)

Definition at line 25 of file controls.h.

HBMMENU_POPUP_MAXIMIZE

#define HBMMENU_POPUP_MAXIMIZE   ((HBITMAP) 10)

Definition at line 31 of file controls.h.

HBMMENU_POPUP_MINIMIZE

#define HBMMENU_POPUP_MINIMIZE   ((HBITMAP) 11)

Definition at line 34 of file controls.h.

HBMMENU_POPUP_RESTORE

#define HBMMENU_POPUP_RESTORE   ((HBITMAP) 9)

Definition at line 28 of file controls.h.

HBMMENU_SYSTEM

#define HBMMENU_SYSTEM   ((HBITMAP) 1)

Definition at line 7 of file controls.h.

ID_CB_EDIT

#define ID_CB_EDIT   1001

Definition at line 39 of file controls.h.

ID_CB_LISTBOX

#define ID_CB_LISTBOX   1000

Definition at line 38 of file controls.h.

LB_ADDSTRING_LOWER

#define LB_ADDSTRING_LOWER   0x1AD

Definition at line 89 of file controls.h.

LB_ADDSTRING_UPPER

#define LB_ADDSTRING_UPPER   0x1AC

Definition at line 88 of file controls.h.

LB_INSERTSTRING_LOWER

#define LB_INSERTSTRING_LOWER   0x1AB

Definition at line 87 of file controls.h.

LB_INSERTSTRING_UPPER

#define LB_INSERTSTRING_UPPER   0x1AA

Definition at line 86 of file controls.h.

Typedef Documentation

LPHEADCOMBO

typedef struct HEADCOMBO* LPHEADCOMBO

Function Documentation

ButtonWndProc_common()

LRESULT WINAPI ButtonWndProc_common	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL	unicode
	)

Definition at line 243 of file button.c.

{
    RECT rect;
    POINT pt;
    LONG style = GetWindowLongPtrW( hWnd, GWL_STYLE );
    UINT btn_type = get_button_type( style );
    LONG state;
    HANDLE oldHbitmap;
#ifdef __REACTOS__
    PWND pWnd;
 
    pWnd = ValidateHwnd(hWnd);
    if (pWnd)
    {
       if (!pWnd->fnid)
       {
          NtUserSetWindowFNID(hWnd, FNID_BUTTON);
       }
       else
       {
          if (pWnd->fnid != FNID_BUTTON)
          {
             ERR("Wrong window class for Button! fnId 0x%x\n",pWnd->fnid);
             return 0;
          }
       }
    }
    else
       return 0;
#else
    if (!IsWindow( hWnd )) return 0;
#endif
 
    pt.x = (short)LOWORD(lParam);
    pt.y = (short)HIWORD(lParam);
 
    switch (uMsg)
    {
    case WM_GETDLGCODE:
        switch(btn_type)
        {
        case BS_USERBUTTON:
        case BS_PUSHBUTTON:      return DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON;
        case BS_DEFPUSHBUTTON:   return DLGC_BUTTON | DLGC_DEFPUSHBUTTON;
        case BS_RADIOBUTTON:
        case BS_AUTORADIOBUTTON: return DLGC_BUTTON | DLGC_RADIOBUTTON;
        case BS_GROUPBOX:        return DLGC_STATIC;
        default:                 return DLGC_BUTTON;
        }
 
    case WM_ENABLE:
        paint_button( hWnd, btn_type, ODA_DRAWENTIRE );
        break;
 
    case WM_CREATE:
        if (btn_type >= MAX_BTN_TYPE)
            return -1; /* abort */
 
        /* XP turns a BS_USERBUTTON into BS_PUSHBUTTON */
        if (btn_type == BS_USERBUTTON )
        {
            style = (style & ~BS_TYPEMASK) | BS_PUSHBUTTON;
#ifdef __REACTOS__
            NtUserAlterWindowStyle(hWnd, GWL_STYLE, style );
#else
            WIN_SetStyle( hWnd, style, BS_TYPEMASK & ~style );
#endif
        }
        set_button_state( hWnd, BST_UNCHECKED );
#ifdef __REACTOS__
        button_update_uistate( hWnd, unicode );
#endif
        return 0;
 
#ifdef __REACTOS__
    case WM_NCDESTROY:
        NtUserSetWindowFNID(hWnd, FNID_DESTROY);
    case WM_DESTROY:
        break;
#endif
 
    case WM_ERASEBKGND:
        if (btn_type == BS_OWNERDRAW)
        {
            HDC hdc = (HDC)wParam;
            RECT rc;
            HBRUSH hBrush;
            HWND parent = GetParent(hWnd);
            if (!parent) parent = hWnd;
#ifdef __REACTOS__
            hBrush = GetControlColor( parent, hWnd, hdc, WM_CTLCOLORBTN);
#else
            hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORBTN, (WPARAM)hdc, (LPARAM)hWnd);
            if (!hBrush) /* did the app forget to call defwindowproc ? */
                hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORBTN,
                                                (WPARAM)hdc, (LPARAM)hWnd);
#endif
            GetClientRect(hWnd, &rc);
            FillRect(hdc, &rc, hBrush);
        }
        return 1;
 
    case WM_PRINTCLIENT:
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC hdc = wParam ? (HDC)wParam : BeginPaint( hWnd, &ps );
        if (btnPaintFunc[btn_type])
        {
            int nOldMode = SetBkMode( hdc, OPAQUE );
            (btnPaintFunc[btn_type])( hWnd, hdc, ODA_DRAWENTIRE );
            SetBkMode(hdc, nOldMode); /*  reset painting mode */
        }
        if ( !wParam ) EndPaint( hWnd, &ps );
        break;
    }
 
    case WM_KEYDOWN:
    if (wParam == VK_SPACE)
    {
        SendMessageW( hWnd, BM_SETSTATE, TRUE, 0 );
            set_button_state( hWnd, get_button_state( hWnd ) | BUTTON_BTNPRESSED );
            SetCapture( hWnd );
    }
    break;
 
    case WM_LBUTTONDBLCLK:
        if(style & BS_NOTIFY ||
           btn_type == BS_RADIOBUTTON ||
           btn_type == BS_USERBUTTON ||
           btn_type == BS_OWNERDRAW)
        {
            BUTTON_NOTIFY_PARENT(hWnd, BN_DOUBLECLICKED);
            break;
        }
        /* fall through */
    case WM_LBUTTONDOWN:
        SetCapture( hWnd );
        SetFocus( hWnd );
        set_button_state( hWnd, get_button_state( hWnd ) | BUTTON_BTNPRESSED );
        SendMessageW( hWnd, BM_SETSTATE, TRUE, 0 );
        break;
 
    case WM_KEYUP:
    if (wParam != VK_SPACE)
        break;
    /* fall through */
    case WM_LBUTTONUP:
#ifdef __REACTOS__
    {
        BOOL TellParent = FALSE; 
#endif
        state = get_button_state( hWnd );
        if (!(state & BUTTON_BTNPRESSED)) break;
        state &= BUTTON_NSTATES;
        set_button_state( hWnd, state );
        if (!(state & BST_PUSHED))
        {
            ReleaseCapture();
            break;
        }
        SendMessageW( hWnd, BM_SETSTATE, FALSE, 0 );
        GetClientRect( hWnd, &rect );
    if (uMsg == WM_KEYUP || PtInRect( &rect, pt ))
        {
            state = get_button_state( hWnd );
            switch(btn_type)
            {
            case BS_AUTOCHECKBOX:
                SendMessageW( hWnd, BM_SETCHECK, !(state & BST_CHECKED), 0 );
                break;
            case BS_AUTORADIOBUTTON:
                BUTTON_CheckAutoRadioButton( hWnd );
                break;
            case BS_AUTO3STATE:
                SendMessageW( hWnd, BM_SETCHECK,
                                (state & BST_INDETERMINATE) ? 0 : ((state & 3) + 1), 0 );
                break;
            }
#ifdef __REACTOS__
            TellParent = TRUE; // <---- Fix CORE-10194, Notify parent after capture is released.
#else
            ReleaseCapture();
            BUTTON_NOTIFY_PARENT(hWnd, BN_CLICKED);
#endif
        }
#ifndef __REACTOS__
        else
        {
            ReleaseCapture();
        }
#else
        ReleaseCapture();
        if (TellParent) BUTTON_NOTIFY_PARENT(hWnd, BN_CLICKED);
    }
#endif
        break;
 
    case WM_CAPTURECHANGED:
        TRACE("WM_CAPTURECHANGED %p\n", hWnd);
        if (hWnd == (HWND)lParam) break;
        state = get_button_state( hWnd );
        if (state & BUTTON_BTNPRESSED)
        {
            state &= BUTTON_NSTATES;
            set_button_state( hWnd, state );
            if (state & BST_PUSHED) SendMessageW( hWnd, BM_SETSTATE, FALSE, 0 );
        }
        break;
 
    case WM_MOUSEMOVE:
        if ((wParam & MK_LBUTTON) && GetCapture() == hWnd)
        {
            GetClientRect( hWnd, &rect );
            SendMessageW( hWnd, BM_SETSTATE, PtInRect(&rect, pt), 0 );
        }
        break;
 
    case WM_SETTEXT:
    {
        /* Clear an old text here as Windows does */
//
// ReactOS Note :
// wine Bug: http://bugs.winehq.org/show_bug.cgi?id=25790
// Patch: http://source.winehq.org/patches/data/70889
// By: Alexander LAW, Replicate Windows behavior of WM_SETTEXT handler regarding WM_CTLCOLOR*
//
#ifdef __REACTOS__
        if (style & WS_VISIBLE)
#else
        if (IsWindowVisible(hWnd))
#endif
        {
            HDC hdc = GetDC(hWnd);
            HBRUSH hbrush;
            RECT client, rc;
            HWND parent = GetParent(hWnd);
            UINT message = (btn_type == BS_PUSHBUTTON ||
                            btn_type == BS_DEFPUSHBUTTON ||
                            btn_type == BS_PUSHLIKE ||
                            btn_type == BS_USERBUTTON ||
                            btn_type == BS_OWNERDRAW) ?
                            WM_CTLCOLORBTN : WM_CTLCOLORSTATIC;
 
            if (!parent) parent = hWnd;
#ifdef __REACTOS__
            hbrush = GetControlColor(parent, hWnd, hdc, message);
#else
            hbrush = (HBRUSH)SendMessageW(parent, message,
                                          (WPARAM)hdc, (LPARAM)hWnd);
            if (!hbrush) /* did the app forget to call DefWindowProc ? */
                hbrush = (HBRUSH)DefWindowProcW(parent, message,
                                                (WPARAM)hdc, (LPARAM)hWnd);
#endif
 
            GetClientRect(hWnd, &client);
            rc = client;
            /* FIXME: check other BS_* handlers */
            if (btn_type == BS_GROUPBOX)
                InflateRect(&rc, -7, 1); /* GB_Paint does this */
            BUTTON_CalcLabelRect(hWnd, hdc, &rc);
            /* Clip by client rect bounds */
            if (rc.right > client.right) rc.right = client.right;
            if (rc.bottom > client.bottom) rc.bottom = client.bottom;
            FillRect(hdc, &rc, hbrush);
            ReleaseDC(hWnd, hdc);
        }
 
        if (unicode) DefWindowProcW( hWnd, WM_SETTEXT, wParam, lParam );
        else DefWindowProcA( hWnd, WM_SETTEXT, wParam, lParam );
        if (btn_type == BS_GROUPBOX) /* Yes, only for BS_GROUPBOX */
            InvalidateRect( hWnd, NULL, TRUE );
        else
            paint_button( hWnd, btn_type, ODA_DRAWENTIRE );
        return 1; /* success. FIXME: check text length */
    }
 
    case WM_SETFONT:
        set_button_font( hWnd, (HFONT)wParam );
        if (lParam) InvalidateRect(hWnd, NULL, TRUE);
        break;
 
    case WM_GETFONT:
        return (LRESULT)get_button_font( hWnd );
 
    case WM_SETFOCUS:
        TRACE("WM_SETFOCUS %p\n",hWnd);
        set_button_state( hWnd, get_button_state(hWnd) | BST_FOCUS );
        paint_button( hWnd, btn_type, ODA_FOCUS );
        if (style & BS_NOTIFY)
            BUTTON_NOTIFY_PARENT(hWnd, BN_SETFOCUS);
#ifdef __REACTOS__
        if (((btn_type == BS_RADIOBUTTON) || (btn_type == BS_AUTORADIOBUTTON)) &&
            !(get_button_state(hWnd) & BST_CHECKED))
        {
            BUTTON_NOTIFY_PARENT(hWnd, BN_CLICKED);
        }
#endif
        break;
 
    case WM_KILLFOCUS:
        TRACE("WM_KILLFOCUS %p\n",hWnd);
        state = get_button_state( hWnd );
        set_button_state( hWnd, state & ~BST_FOCUS );
    paint_button( hWnd, btn_type, ODA_FOCUS );
 
        if ((state & BUTTON_BTNPRESSED) && GetCapture() == hWnd)
            ReleaseCapture();
        if (style & BS_NOTIFY)
            BUTTON_NOTIFY_PARENT(hWnd, BN_KILLFOCUS);
 
        InvalidateRect( hWnd, NULL, FALSE );
        break;
 
    case WM_SYSCOLORCHANGE:
        InvalidateRect( hWnd, NULL, FALSE );
        break;
 
    case BM_SETSTYLE:
        btn_type = wParam & BS_TYPEMASK;
        style = (style & ~BS_TYPEMASK) | btn_type;
#ifdef __REACTOS__
        NtUserAlterWindowStyle(hWnd, GWL_STYLE, style);
#else
        WIN_SetStyle( hWnd, style, BS_TYPEMASK & ~style );
#endif
 
        /* Only redraw if lParam flag is set.*/
        if (lParam)
            InvalidateRect( hWnd, NULL, TRUE );
 
        break;
 
    case BM_CLICK:
#ifdef __REACTOS__
        state = get_button_state(hWnd);
        if (state & BUTTON_BMCLICK)
           break;
        set_button_state(hWnd, state | BUTTON_BMCLICK); // Tracked in STATE_GWL_OFFSET.
#endif
    SendMessageW( hWnd, WM_LBUTTONDOWN, 0, 0 );
    SendMessageW( hWnd, WM_LBUTTONUP, 0, 0 );
#ifdef __REACTOS__
        state = get_button_state(hWnd);
        if (!(state & BUTTON_BMCLICK)) break;
        state &= ~BUTTON_BMCLICK;
        set_button_state(hWnd, state);
#endif
    break;
 
    case BM_SETIMAGE:
        /* Check that image format matches button style */
        switch (style & (BS_BITMAP|BS_ICON))
        {
        case BS_BITMAP:
            if (wParam != IMAGE_BITMAP) return 0;
            break;
        case BS_ICON:
            if (wParam != IMAGE_ICON) return 0;
            break;
        default:
            return 0;
        }
        oldHbitmap = (HBITMAP)SetWindowLongPtrW( hWnd, HIMAGE_GWL_OFFSET, lParam );
    InvalidateRect( hWnd, NULL, FALSE );
    return (LRESULT)oldHbitmap;
 
    case BM_GETIMAGE:
        return GetWindowLongPtrW( hWnd, HIMAGE_GWL_OFFSET );
 
    case BM_GETCHECK:
        return get_button_state( hWnd ) & 3;
 
    case BM_SETCHECK:
        if (wParam > maxCheckState[btn_type]) wParam = maxCheckState[btn_type];
        state = get_button_state( hWnd );
        if ((btn_type == BS_RADIOBUTTON) || (btn_type == BS_AUTORADIOBUTTON))
        {
#ifdef __REACTOS__
            if (wParam) style |= WS_TABSTOP;
            else style &= ~WS_TABSTOP;
            NtUserAlterWindowStyle(hWnd, GWL_STYLE, style);
#else
            if (wParam) WIN_SetStyle( hWnd, WS_TABSTOP, 0 );
            else WIN_SetStyle( hWnd, 0, WS_TABSTOP );
#endif
        }
        if ((state & 3) != wParam)
        {
            set_button_state( hWnd, (state & ~3) | wParam );
            paint_button( hWnd, btn_type, ODA_SELECT );
        }
        break;
 
    case BM_GETSTATE:
        return get_button_state( hWnd );
 
    case BM_SETSTATE:
        state = get_button_state( hWnd );
        if (wParam)
            set_button_state( hWnd, state | BST_PUSHED );
        else
            set_button_state( hWnd, state & ~BST_PUSHED );
 
        paint_button( hWnd, btn_type, ODA_SELECT );
        break;
 
#ifdef __REACTOS__
    case WM_UPDATEUISTATE:
        if (unicode)
            DefWindowProcW(hWnd, uMsg, wParam, lParam);
        else
            DefWindowProcA(hWnd, uMsg, wParam, lParam);
 
        if (button_update_uistate(hWnd, unicode))
            paint_button( hWnd, btn_type, ODA_DRAWENTIRE );
        break;
#endif
 
    case WM_NCHITTEST:
        if(btn_type == BS_GROUPBOX) return HTTRANSPARENT;
        /* fall through */
    default:
        return unicode ? DefWindowProcW(hWnd, uMsg, wParam, lParam) :
                         DefWindowProcA(hWnd, uMsg, wParam, lParam);
    }
    return 0;
}

Referenced by RegisterClientPFN().

ButtonWndProcA()

LRESULT WINAPI ButtonWndProcA	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Referenced by RegisterClientPFN().

ButtonWndProcW()

LRESULT WINAPI ButtonWndProcW	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Referenced by RegisterClientPFN().

COMBO_FlipListbox()

BOOL COMBO_FlipListbox	(	LPHEADCOMBO	lphc,
		BOOL	ok,
		BOOL	bRedrawButton
	)

Definition at line 1116 of file combo.c.

{
   if( lphc->wState & CBF_DROPPED )
   {
       CBRollUp( lphc, ok, bRedrawButton );
       return FALSE;
   }
 
   CBDropDown( lphc );
   return TRUE;
}

Referenced by COMBO_WindowProc(), ComboWndProc_common(), LISTBOX_HandleLButtonDownCombo(), LISTBOX_WindowProc(), and ListBoxWndProc_common().

ComboWndProc_common()

LRESULT WINAPI ComboWndProc_common	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL	unicode
	)

Definition at line 1814 of file combo.c.

{
    LPHEADCOMBO lphc = (LPHEADCOMBO)GetWindowLongPtrW( hwnd, 0 );
#ifdef __REACTOS__
    PWND pWnd;
 
    pWnd = ValidateHwnd(hwnd);
    if (pWnd)
    {
        if (!pWnd->fnid)
        {
            NtUserSetWindowFNID(hwnd, FNID_COMBOBOX);
        }
        else
        {
            if (pWnd->fnid != FNID_COMBOBOX)
            {
                ERR("Wrong window class for ComboBox! fnId 0x%x\n",pWnd->fnid);
                return 0;
            }
         }
    }
#endif
 
    TRACE("[%p]: msg %s wp %08lx lp %08lx\n", hwnd, SPY_GetMsgName(message, hwnd), wParam, lParam);
 
#ifndef __REACTOS__
    if (!IsWindow(hwnd)) return 0;
#endif
 
    if (lphc || message == WM_NCCREATE)
    switch(message)
    {
    case WM_NCCREATE:
    {
        LONG style = unicode ? ((LPCREATESTRUCTW)lParam)->style : ((LPCREATESTRUCTA)lParam)->style;
        return COMBO_NCCreate(hwnd, style);
    }
    case WM_NCDESTROY:
        COMBO_NCDestroy(lphc);
#ifdef __REACTOS__
        NtUserSetWindowFNID(hwnd, FNID_DESTROY);
#endif
        break;/* -> DefWindowProc */
 
    case WM_CREATE:
    {
        HWND hwndParent;
        LONG style;
        if(unicode)
        {
            hwndParent = ((LPCREATESTRUCTW)lParam)->hwndParent;
            style = ((LPCREATESTRUCTW)lParam)->style;
        }
        else
        {
            hwndParent = ((LPCREATESTRUCTA)lParam)->hwndParent;
            style = ((LPCREATESTRUCTA)lParam)->style;
        }
        return COMBO_Create(hwnd, lphc, hwndParent, style, unicode);
    }
    case WM_PRINTCLIENT:
        /* Fallthrough */
    case WM_PAINT:
        /* wParam may contain a valid HDC! */
        return  COMBO_Paint(lphc, (HDC)wParam);
    case WM_ERASEBKGND:
        /* do all painting in WM_PAINT like Windows does */
        return 1;
 
    case WM_GETDLGCODE:
    {
        LRESULT result = DLGC_WANTARROWS | DLGC_WANTCHARS;
        if (lParam && (((LPMSG)lParam)->message == WM_KEYDOWN))
        {
            int vk = (int)((LPMSG)lParam)->wParam;
 
            if ((vk == VK_RETURN || vk == VK_ESCAPE) && (lphc->wState & CBF_DROPPED))
                result |= DLGC_WANTMESSAGE;
        }
        return  result;
    }
    case WM_SIZE:
        if (lphc->hWndLBox && !(lphc->wState & CBF_NORESIZE))
            COMBO_Size( lphc );
        return  TRUE;
    case WM_SETFONT:
        COMBO_Font( lphc, (HFONT)wParam, (BOOL)lParam );
        return TRUE;
    case WM_GETFONT:
        return (LRESULT)lphc->hFont;
    case WM_SETFOCUS:
        if (lphc->wState & CBF_EDIT)
        {
            SetFocus( lphc->hWndEdit );
            /* The first time focus is received, select all the text */
            if (!(lphc->wState & CBF_BEENFOCUSED))
            {
                SendMessageW(lphc->hWndEdit, EM_SETSEL, 0, -1);
                lphc->wState |= CBF_BEENFOCUSED;
            }
        }
        else
            COMBO_SetFocus( lphc );
        return  TRUE;
    case WM_KILLFOCUS:
    {
        HWND hwndFocus = WIN_GetFullHandle((HWND)wParam);
        if (!hwndFocus || (hwndFocus != lphc->hWndEdit && hwndFocus != lphc->hWndLBox))
            COMBO_KillFocus( lphc );
        return  TRUE;
    }
    case WM_COMMAND:
        return COMBO_Command( lphc, wParam, WIN_GetFullHandle((HWND)lParam) );
    case WM_GETTEXT:
        return unicode ? COMBO_GetTextW( lphc, wParam, (LPWSTR)lParam )
                       : COMBO_GetTextA( lphc, wParam, (LPSTR)lParam );
    case WM_SETTEXT:
    case WM_GETTEXTLENGTH:
    case WM_CLEAR:
        if ((message == WM_GETTEXTLENGTH) && !ISWIN31 && !(lphc->wState & CBF_EDIT))
        {
            int j = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
            if (j == -1) return 0;
            return unicode ? SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, j, 0) :
                             SendMessageA(lphc->hWndLBox, LB_GETTEXTLEN, j, 0);
        }
        else if ( lphc->wState & CBF_EDIT )
        {
            LRESULT ret;
            lphc->wState |= CBF_NOEDITNOTIFY;
            ret = unicode ? SendMessageW(lphc->hWndEdit, message, wParam, lParam) :
                            SendMessageA(lphc->hWndEdit, message, wParam, lParam);
            lphc->wState &= ~CBF_NOEDITNOTIFY;
            return ret;
        }
        else
            return CB_ERR;
    case WM_CUT:
    case WM_PASTE:
    case WM_COPY:
        if (lphc->wState & CBF_EDIT)
        {
            return unicode ? SendMessageW(lphc->hWndEdit, message, wParam, lParam) :
                             SendMessageA(lphc->hWndEdit, message, wParam, lParam);
        }
        else return  CB_ERR;
 
    case WM_DRAWITEM:
    case WM_DELETEITEM:
    case WM_COMPAREITEM:
    case WM_MEASUREITEM:
        return COMBO_ItemOp(lphc, message, lParam);
    case WM_ENABLE:
        if (lphc->wState & CBF_EDIT)
            EnableWindow( lphc->hWndEdit, (BOOL)wParam );
        EnableWindow( lphc->hWndLBox, (BOOL)wParam );
 
        /* Force the control to repaint when the enabled state changes. */
        InvalidateRect(lphc->self, NULL, TRUE);
        return  TRUE;
    case WM_SETREDRAW:
        if (wParam)
            lphc->wState &= ~CBF_NOREDRAW;
        else
            lphc->wState |= CBF_NOREDRAW;
 
        if ( lphc->wState & CBF_EDIT )
            SendMessageW(lphc->hWndEdit, message, wParam, lParam);
        SendMessageW(lphc->hWndLBox, message, wParam, lParam);
        return  0;
    case WM_SYSKEYDOWN:
#ifdef __REACTOS__
        if ( KF_ALTDOWN & HIWORD(lParam) )
#else
        if ( KEYDATA_ALT & HIWORD(lParam) )
#endif
            if( wParam == VK_UP || wParam == VK_DOWN )
#ifdef __REACTOS__
            {
#endif
                COMBO_FlipListbox( lphc, FALSE, FALSE );
        return  0;
#ifdef __REACTOS__
            }
        break;
#endif
 
    case WM_KEYDOWN:
        if ((wParam == VK_RETURN || wParam == VK_ESCAPE) &&
                (lphc->wState & CBF_DROPPED))
        {
            CBRollUp( lphc, wParam == VK_RETURN, FALSE );
            return TRUE;
        }
        else if ((wParam == VK_F4) && !(lphc->wState & CBF_EUI))
        {
            COMBO_FlipListbox( lphc, FALSE, FALSE );
            return TRUE;
        }
        /* fall through */
    case WM_CHAR:
    case WM_IME_CHAR:
        {
            HWND hwndTarget;
 
#ifdef __REACTOS__
            if (lphc->wState & CBF_DROPPED)
                lphc->wState |= CBF_NOROLLUP;
#endif
            if ( lphc->wState & CBF_EDIT )
                hwndTarget = lphc->hWndEdit;
            else
                hwndTarget = lphc->hWndLBox;
 
            return unicode ? SendMessageW(hwndTarget, message, wParam, lParam) :
                             SendMessageA(hwndTarget, message, wParam, lParam);
        }
    case WM_LBUTTONDOWN:
        if ( !(lphc->wState & CBF_FOCUSED) ) SetFocus( lphc->self );
        if ( lphc->wState & CBF_FOCUSED ) COMBO_LButtonDown( lphc, lParam );
        return  TRUE;
    case WM_LBUTTONUP:
        COMBO_LButtonUp( lphc );
        return  TRUE;
    case WM_MOUSEMOVE:
        if ( lphc->wState & CBF_CAPTURE )
            COMBO_MouseMove( lphc, wParam, lParam );
        return  TRUE;
 
    case WM_MOUSEWHEEL:
        if (wParam & (MK_SHIFT | MK_CONTROL))
            return unicode ? DefWindowProcW(hwnd, message, wParam, lParam) :
                             DefWindowProcA(hwnd, message, wParam, lParam);
 
        if (GET_WHEEL_DELTA_WPARAM(wParam) > 0) return SendMessageW(hwnd, WM_KEYDOWN, VK_UP, 0);
        if (GET_WHEEL_DELTA_WPARAM(wParam) < 0) return SendMessageW(hwnd, WM_KEYDOWN, VK_DOWN, 0);
        return TRUE;
 
    case WM_CTLCOLOR:
    case WM_CTLCOLORMSGBOX:
    case WM_CTLCOLOREDIT:
    case WM_CTLCOLORLISTBOX:
    case WM_CTLCOLORBTN:
    case WM_CTLCOLORDLG:
    case WM_CTLCOLORSCROLLBAR:
    case WM_CTLCOLORSTATIC:
#ifdef __REACTOS__
        if (pWnd && !(pWnd->state2 & WNDS2_WIN40COMPAT)) break; // Must be Win 4.0 and above.
#endif
        if (lphc->owner)
            return SendMessageW(lphc->owner, message, wParam, lParam);
        break;
 
    /* Combo messages */
    case CB_ADDSTRING:
        if (unicode)
        {
            if (lphc->dwStyle & CBS_LOWERCASE)
                CharLowerW((LPWSTR)lParam);
            else if (lphc->dwStyle & CBS_UPPERCASE)
                CharUpperW((LPWSTR)lParam);
            return SendMessageW(lphc->hWndLBox, LB_ADDSTRING, 0, lParam);
        }
        else /* unlike the unicode version, the ansi version does not overwrite
                the string if converting case */
        {
            char *string = NULL;
            LRESULT ret;
            if (lphc->dwStyle & CBS_LOWERCASE)
            {
                string = strdupA((LPSTR)lParam);
                CharLowerA(string);
            }
 
            else if (lphc->dwStyle & CBS_UPPERCASE)
            {
                string = strdupA((LPSTR)lParam);
                CharUpperA(string);
            }
 
            ret = SendMessageA(lphc->hWndLBox, LB_ADDSTRING, 0, string ? (LPARAM)string : lParam);
            HeapFree(GetProcessHeap(), 0, string);
            return ret;
        }
    case CB_INSERTSTRING:
        if (unicode)
        {
            if (lphc->dwStyle & CBS_LOWERCASE)
                CharLowerW((LPWSTR)lParam);
            else if (lphc->dwStyle & CBS_UPPERCASE)
                CharUpperW((LPWSTR)lParam);
            return SendMessageW(lphc->hWndLBox, LB_INSERTSTRING, wParam, lParam);
        }
        else
        {
            if (lphc->dwStyle & CBS_LOWERCASE)
                CharLowerA((LPSTR)lParam);
            else if (lphc->dwStyle & CBS_UPPERCASE)
                CharUpperA((LPSTR)lParam);
            return SendMessageA(lphc->hWndLBox, LB_INSERTSTRING, wParam, lParam);
        }
    case CB_DELETESTRING:
        return unicode ? SendMessageW(lphc->hWndLBox, LB_DELETESTRING, wParam, 0) :
                         SendMessageA(lphc->hWndLBox, LB_DELETESTRING, wParam, 0);
    case CB_SELECTSTRING:
        return COMBO_SelectString(lphc, (INT)wParam, lParam, unicode);
    case CB_FINDSTRING:
        return unicode ? SendMessageW(lphc->hWndLBox, LB_FINDSTRING, wParam, lParam) :
                         SendMessageA(lphc->hWndLBox, LB_FINDSTRING, wParam, lParam);
    case CB_FINDSTRINGEXACT:
        return unicode ? SendMessageW(lphc->hWndLBox, LB_FINDSTRINGEXACT, wParam, lParam) :
                         SendMessageA(lphc->hWndLBox, LB_FINDSTRINGEXACT, wParam, lParam);
    case CB_SETITEMHEIGHT:
        return  COMBO_SetItemHeight( lphc, (INT)wParam, (INT)lParam);
    case CB_GETITEMHEIGHT:
        if ((INT)wParam >= 0) /* listbox item */
            return SendMessageW(lphc->hWndLBox, LB_GETITEMHEIGHT, wParam, 0);
        return  CBGetTextAreaHeight(hwnd, lphc);
    case CB_RESETCONTENT:
        SendMessageW(lphc->hWndLBox, LB_RESETCONTENT, 0, 0);
        if ((lphc->wState & CBF_EDIT) && CB_HASSTRINGS(lphc))
        {
            static const WCHAR empty_stringW[] = { 0 };
            SendMessageW(lphc->hWndEdit, WM_SETTEXT, 0, (LPARAM)empty_stringW);
        }
        else
            InvalidateRect(lphc->self, NULL, TRUE);
        return  TRUE;
    case CB_INITSTORAGE:
        return SendMessageW(lphc->hWndLBox, LB_INITSTORAGE, wParam, lParam);
    case CB_GETHORIZONTALEXTENT:
        return SendMessageW(lphc->hWndLBox, LB_GETHORIZONTALEXTENT, 0, 0);
    case CB_SETHORIZONTALEXTENT:
        return SendMessageW(lphc->hWndLBox, LB_SETHORIZONTALEXTENT, wParam, 0);
    case CB_GETTOPINDEX:
        return SendMessageW(lphc->hWndLBox, LB_GETTOPINDEX, 0, 0);
    case CB_GETLOCALE:
        return SendMessageW(lphc->hWndLBox, LB_GETLOCALE, 0, 0);
    case CB_SETLOCALE:
        return SendMessageW(lphc->hWndLBox, LB_SETLOCALE, wParam, 0);
    case CB_SETDROPPEDWIDTH:
        if ((CB_GETTYPE(lphc) == CBS_SIMPLE) || (INT)wParam >= 32768)
            return CB_ERR;
        /* new value must be higher than combobox width */
        if ((INT)wParam >= lphc->droppedRect.right - lphc->droppedRect.left)
            lphc->droppedWidth = wParam;
        else if (wParam)
            lphc->droppedWidth = 0;
 
        /* recalculate the combobox area */
        CBCalcPlacement(hwnd, lphc, &lphc->textRect, &lphc->buttonRect, &lphc->droppedRect );
 
        /* fall through */
    case CB_GETDROPPEDWIDTH:
        if (lphc->droppedWidth)
            return lphc->droppedWidth;
        return  lphc->droppedRect.right - lphc->droppedRect.left;
    case CB_GETDROPPEDCONTROLRECT:
        if (lParam) CBGetDroppedControlRect(lphc, (LPRECT)lParam );
        return  CB_OKAY;
    case CB_GETDROPPEDSTATE:
        return (lphc->wState & CBF_DROPPED) != 0;
    case CB_DIR:
        return unicode ? SendMessageW(lphc->hWndLBox, LB_DIR, wParam, lParam) :
                         SendMessageA(lphc->hWndLBox, LB_DIR, wParam, lParam);
 
    case CB_SHOWDROPDOWN:
        if (CB_GETTYPE(lphc) != CBS_SIMPLE)
        {
            if (wParam)
            {
                if (!(lphc->wState & CBF_DROPPED))
                    CBDropDown( lphc );
            }
            else if (lphc->wState & CBF_DROPPED)
                CBRollUp( lphc, FALSE, TRUE );
        }
        return  TRUE;
    case CB_GETCOUNT:
        return SendMessageW(lphc->hWndLBox, LB_GETCOUNT, 0, 0);
    case CB_GETCURSEL:
        return SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
    case CB_SETCURSEL:
        lParam = SendMessageW(lphc->hWndLBox, LB_SETCURSEL, wParam, 0);
        if (lParam >= 0)
            SendMessageW(lphc->hWndLBox, LB_SETTOPINDEX, wParam, 0);
 
        /* no LBN_SELCHANGE in this case, update manually */
        CBPaintText(lphc, NULL);
        lphc->wState &= ~CBF_SELCHANGE;
        return lParam;
    case CB_GETLBTEXT:
        return unicode ? SendMessageW(lphc->hWndLBox, LB_GETTEXT, wParam, lParam) :
                         SendMessageA(lphc->hWndLBox, LB_GETTEXT, wParam, lParam);
    case CB_GETLBTEXTLEN:
        return unicode ? SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, wParam, 0) :
                         SendMessageA(lphc->hWndLBox, LB_GETTEXTLEN, wParam, 0);
    case CB_GETITEMDATA:
        return SendMessageW(lphc->hWndLBox, LB_GETITEMDATA, wParam, 0);
    case CB_SETITEMDATA:
        return SendMessageW(lphc->hWndLBox, LB_SETITEMDATA, wParam, lParam);
    case CB_GETEDITSEL:
        /* Edit checks passed parameters itself */
        if (lphc->wState & CBF_EDIT)
            return SendMessageW(lphc->hWndEdit, EM_GETSEL, wParam, lParam);
        return  CB_ERR;
    case CB_SETEDITSEL:
        if (lphc->wState & CBF_EDIT)
            return SendMessageW(lphc->hWndEdit, EM_SETSEL, (INT)(INT16)LOWORD(lParam), (INT)(INT16)HIWORD(lParam) );
        return  CB_ERR;
    case CB_SETEXTENDEDUI:
        if (CB_GETTYPE(lphc) == CBS_SIMPLE )
            return  CB_ERR;
        if (wParam)
            lphc->wState |= CBF_EUI;
        else lphc->wState &= ~CBF_EUI;
        return  CB_OKAY;
    case CB_GETEXTENDEDUI:
        return (lphc->wState & CBF_EUI) != 0;
    case CB_GETCOMBOBOXINFO:
        return COMBO_GetComboBoxInfo(lphc, (COMBOBOXINFO *)lParam);
    case CB_LIMITTEXT:
        if (lphc->wState & CBF_EDIT)
            return SendMessageW(lphc->hWndEdit, EM_LIMITTEXT, wParam, lParam);
        return  TRUE;
 
#ifdef __REACTOS__
    case WM_UPDATEUISTATE:
        if (unicode)
            DefWindowProcW(lphc->self, message, wParam, lParam);
        else
            DefWindowProcA(lphc->self, message, wParam, lParam);
 
        if (COMBO_update_uistate(lphc))
        {
           /* redraw text */
           if (!(lphc->wState & CBF_EDIT))
                NtUserInvalidateRect(lphc->self, &lphc->textRect, TRUE);
        }
        break;
 
    case WM_CBLOSTTEXTFOCUS: /* undocumented message - deselects the text when focus is lost */
        if (lphc->hWndEdit != NULL)
        {
            SendMessage(lphc->self, WM_LBUTTONUP, 0, 0xFFFFFFFF);
            SendMessage(lphc->hWndEdit, EM_SETSEL, 0, 0);
            lphc->wState &= ~(CBF_FOCUSED | CBF_BEENFOCUSED);
            CB_NOTIFY(lphc, CBN_KILLFOCUS);
        }
        return TRUE;
#endif
 
    default:
        if (message >= WM_USER)
            WARN("unknown msg WM_USER+%04x wp=%04lx lp=%08lx\n", message - WM_USER, wParam, lParam );
        break;
    }
    return unicode ? DefWindowProcW(hwnd, message, wParam, lParam) :
                     DefWindowProcA(hwnd, message, wParam, lParam);
}

Referenced by RegisterClientPFN().

ComboWndProcA()

LRESULT WINAPI ComboWndProcA	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Referenced by RegisterClientPFN().

ComboWndProcW()

LRESULT WINAPI ComboWndProcW	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Referenced by RegisterClientPFN().

DesktopWndProcA()

LRESULT WINAPI DesktopWndProcA	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1307 of file message.c.

{
  LRESULT Result;
  MSG AnsiMsg, UcMsg;
 
  TRACE("Desktop A Class Atom! hWnd 0x%x, Msg %d\n", hwnd, message);
 
  AnsiMsg.hwnd = hwnd;
  AnsiMsg.message = message;
  AnsiMsg.wParam = wParam;
  AnsiMsg.lParam = lParam;
  AnsiMsg.time = 0;
  AnsiMsg.pt.x = 0;
  AnsiMsg.pt.y = 0;
 
  // Desktop is always Unicode so convert Ansi here.
  if (!MsgiAnsiToUnicodeMessage(hwnd, &UcMsg, &AnsiMsg))
  {
     return FALSE;
  }
 
  Result = DesktopWndProcW(hwnd, message, UcMsg.wParam, UcMsg.lParam);
 
  MsgiAnsiToUnicodeCleanup(&UcMsg, &AnsiMsg);
 
  return Result;
 }

Referenced by RegisterClientPFN().

DesktopWndProcW()

LRESULT WINAPI DesktopWndProcW	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 33 of file desktop.c.

{
   TRACE("Desktop W Class Atom! hWnd 0x%x, Msg %d\n", Wnd, Msg);
 
   switch(Msg)
   {
      case WM_ERASEBKGND:
      case WM_NCCREATE:
      case WM_CREATE:
      case WM_CLOSE:
      case WM_DISPLAYCHANGE:
      case WM_PAINT:
      case WM_SYSCOLORCHANGE:
        {
          LRESULT lResult;
          NtUserMessageCall( Wnd, Msg, wParam, lParam, (ULONG_PTR)&lResult, FNID_DESKTOP, FALSE);
          TRACE("Desktop lResult %d\n", lResult);
          return lResult;
        }
 
      case WM_PALETTECHANGED:
          if (Wnd == (HWND)wParam) break;
      case WM_QUERYNEWPALETTE:
        {
          HDC hdc = GetWindowDC( Wnd );
          PaintDesktop(hdc);
          ReleaseDC( Wnd, hdc );
          break;
        }
 
      case WM_SETCURSOR:
          return (LRESULT)SetCursor(LoadCursorW(0, (LPCWSTR)IDC_ARROW));
 
      default:
          return DefWindowProcW(Wnd, Msg, wParam, lParam);
   }
   return 0;
}

Referenced by DesktopWndProcA(), and RegisterClientPFN().

EditWndProc_common()

LRESULT WINAPI EditWndProc_common	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL	unicode
	)

Definition at line 4854 of file edit.c.

{
    EDITSTATE *es = (EDITSTATE *)GetWindowLongPtrW( hwnd, 0 );
    LRESULT result = 0;
#ifdef __REACTOS__
    /* ReactOS r50219 */
    PWND pWnd;
 
    pWnd = ValidateHwnd(hwnd);
    if (pWnd)
    {
        if (!pWnd->fnid)
        {
            NtUserSetWindowFNID(hwnd, FNID_EDIT);
        }
        else
        {
            if (pWnd->fnid != FNID_EDIT)
            {
                ERR("Wrong window class for Edit! fnId 0x%x\n",pWnd->fnid);
                return 0;
            }
        }
    }
#endif
 
        TRACE("hwnd=%p msg=%x (%s) wparam=%lx lparam=%lx\n", hwnd, msg, SPY_GetMsgName(msg, hwnd), wParam, lParam);
 
    if (!es && msg != WM_NCCREATE)
        return DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
 
    if (es && (msg != WM_NCDESTROY)) EDIT_LockBuffer(es);
 
    switch (msg) {
    case EM_GETSEL:
        result = EDIT_EM_GetSel(es, (PUINT)wParam, (PUINT)lParam);
        break;
 
    case EM_SETSEL:
        EDIT_EM_SetSel(es, wParam, lParam, FALSE);
        EDIT_EM_ScrollCaret(es);
        result = 1;
        break;
 
    case EM_GETRECT:
        if (lParam)
            CopyRect((LPRECT)lParam, &es->format_rect);
        break;
 
    case EM_SETRECT:
        if ((es->style & ES_MULTILINE) && lParam) {
            EDIT_SetRectNP(es, (LPRECT)lParam);
            EDIT_UpdateText(es, NULL, TRUE);
        }
        break;
 
    case EM_SETRECTNP:
        if ((es->style & ES_MULTILINE) && lParam)
            EDIT_SetRectNP(es, (LPRECT)lParam);
        break;
 
    case EM_SCROLL:
        result = EDIT_EM_Scroll(es, (INT)wParam);
                break;
 
    case EM_LINESCROLL:
        result = (LRESULT)EDIT_EM_LineScroll(es, (INT)wParam, (INT)lParam);
        break;
 
    case EM_SCROLLCARET:
        EDIT_EM_ScrollCaret(es);
        result = 1;
        break;
 
    case EM_GETMODIFY:
        result = ((es->flags & EF_MODIFIED) != 0);
        break;
 
    case EM_SETMODIFY:
        if (wParam)
            es->flags |= EF_MODIFIED;
        else
                        es->flags &= ~(EF_MODIFIED | EF_UPDATE);  /* reset pending updates */
        break;
 
    case EM_GETLINECOUNT:
        result = (es->style & ES_MULTILINE) ? es->line_count : 1;
        break;
 
    case EM_LINEINDEX:
        result = (LRESULT)EDIT_EM_LineIndex(es, (INT)wParam);
        break;
 
    case EM_SETHANDLE:
        EDIT_EM_SetHandle(es, (HLOCAL)wParam);
        break;
 
    case EM_GETHANDLE:
        result = (LRESULT)EDIT_EM_GetHandle(es);
        break;
 
    case EM_GETTHUMB:
        result = EDIT_EM_GetThumb(es);
        break;
 
    /* these messages missing from specs */
    case 0x00bf:
    case 0x00c0:
    case 0x00c3:
    case 0x00ca:
        FIXME("undocumented message 0x%x, please report\n", msg);
        result = DefWindowProcW(hwnd, msg, wParam, lParam);
        break;
 
    case EM_LINELENGTH:
        result = (LRESULT)EDIT_EM_LineLength(es, (INT)wParam);
        break;
 
    case EM_REPLACESEL:
    {
        LPWSTR textW;
 
        if(unicode)
            textW = (LPWSTR)lParam;
        else
        {
            LPSTR textA = (LPSTR)lParam;
            INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
            if (!(textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR)))) break;
                    MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
        }
 
        EDIT_EM_ReplaceSel(es, (BOOL)wParam, textW, TRUE, TRUE);
        result = 1;
 
        if(!unicode)
            HeapFree(GetProcessHeap(), 0, textW);
        break;
    }
 
    case EM_GETLINE:
        result = (LRESULT)EDIT_EM_GetLine(es, (INT)wParam, (LPWSTR)lParam, unicode);
        break;
 
    case EM_SETLIMITTEXT:
        EDIT_EM_SetLimitText(es, wParam);
        break;
 
    case EM_CANUNDO:
        result = (LRESULT)EDIT_EM_CanUndo(es);
        break;
 
    case EM_UNDO:
    case WM_UNDO:
        result = (LRESULT)EDIT_EM_Undo(es);
        break;
 
    case EM_FMTLINES:
        result = (LRESULT)EDIT_EM_FmtLines(es, (BOOL)wParam);
        break;
 
    case EM_LINEFROMCHAR:
        result = (LRESULT)EDIT_EM_LineFromChar(es, (INT)wParam);
        break;
 
    case EM_SETTABSTOPS:
        result = (LRESULT)EDIT_EM_SetTabStops(es, (INT)wParam, (LPINT)lParam);
        break;
 
    case EM_SETPASSWORDCHAR:
    {
        WCHAR charW = 0;
 
        if(unicode)
            charW = (WCHAR)wParam;
        else
        {
            CHAR charA = wParam;
            MultiByteToWideChar(CP_ACP, 0, &charA, 1, &charW, 1);
        }
 
        EDIT_EM_SetPasswordChar(es, charW);
        break;
    }
 
    case EM_EMPTYUNDOBUFFER:
        EDIT_EM_EmptyUndoBuffer(es);
        break;
 
    case EM_GETFIRSTVISIBLELINE:
        result = (es->style & ES_MULTILINE) ? es->y_offset : es->x_offset;
        break;
 
    case EM_SETREADONLY:
    {
        DWORD old_style = es->style;
 
        if (wParam) {
                    SetWindowLongW( hwnd, GWL_STYLE,
                                    GetWindowLongW( hwnd, GWL_STYLE ) | ES_READONLY );
                    es->style |= ES_READONLY;
        } else {
                    SetWindowLongW( hwnd, GWL_STYLE,
                                    GetWindowLongW( hwnd, GWL_STYLE ) & ~ES_READONLY );
                    es->style &= ~ES_READONLY;
        }
 
        if (old_style ^ es->style)
            InvalidateRect(es->hwndSelf, NULL, TRUE);
 
        result = 1;
        break;
    }
 
    case EM_SETWORDBREAKPROC:
        EDIT_EM_SetWordBreakProc(es, (void *)lParam);
        break;
 
    case EM_GETWORDBREAKPROC:
        result = (LRESULT)es->word_break_proc;
        break;
 
    case EM_GETPASSWORDCHAR:
    {
        if(unicode)
            result = es->password_char;
        else
        {
            WCHAR charW = es->password_char;
            CHAR charA = 0;
            WideCharToMultiByte(CP_ACP, 0, &charW, 1, &charA, 1, NULL, NULL);
            result = charA;
        }
        break;
    }
 
    case EM_SETMARGINS:
        EDIT_EM_SetMargins(es, (INT)wParam, LOWORD(lParam), HIWORD(lParam), TRUE);
        break;
 
    case EM_GETMARGINS:
        result = MAKELONG(es->left_margin, es->right_margin);
        break;
 
    case EM_GETLIMITTEXT:
        result = es->buffer_limit;
        break;
 
    case EM_POSFROMCHAR:
        if ((INT)wParam >= get_text_length(es)) result = -1;
        else result = EDIT_EM_PosFromChar(es, (INT)wParam, FALSE);
        break;
 
    case EM_CHARFROMPOS:
        result = EDIT_EM_CharFromPos(es, (short)LOWORD(lParam), (short)HIWORD(lParam));
        break;
 
        /* End of the EM_ messages which were in numerical order; what order
         * are these in?  vaguely alphabetical?
         */
 
    case WM_NCCREATE:
        result = EDIT_WM_NCCreate(hwnd, (LPCREATESTRUCTW)lParam, unicode);
        break;
 
    case WM_NCDESTROY:
        result = EDIT_WM_NCDestroy(es);
#ifdef __REACTOS__
        NtUserSetWindowFNID(hwnd, FNID_DESTROY);
#endif
        es = NULL;
        break;
 
    case WM_GETDLGCODE:
        result = DLGC_HASSETSEL | DLGC_WANTCHARS | DLGC_WANTARROWS;
 
        if (es->style & ES_MULTILINE)
           result |= DLGC_WANTALLKEYS;
 
                if (lParam)
                {
                    es->flags|=EF_DIALOGMODE;
 
                    if (((LPMSG)lParam)->message == WM_KEYDOWN)
                    {
                        int vk = (int)((LPMSG)lParam)->wParam;
 
                        if (es->hwndListBox)
                        {
                            if (vk == VK_RETURN || vk == VK_ESCAPE)
                                if (SendMessageW(GetParent(hwnd), CB_GETDROPPEDSTATE, 0, 0))
                                    result |= DLGC_WANTMESSAGE;
                        }
                    }
                }
        break;
 
        case WM_IME_CHAR:
#ifdef __REACTOS__
            /* Rely on DefWindowProc */
            result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
            break;
#else
            if (!unicode)
            {
                WCHAR charW;
                CHAR  strng[2];
 
                strng[0] = wParam >> 8;
                strng[1] = wParam & 0xff;
                if (strng[0]) MultiByteToWideChar(CP_ACP, 0, strng, 2, &charW, 1);
                else MultiByteToWideChar(CP_ACP, 0, &strng[1], 1, &charW, 1);
        result = EDIT_WM_Char(es, charW);
        break;
            }
            /* fall through */
#endif
    case WM_CHAR:
    {
        WCHAR charW;
 
        if(unicode)
            charW = wParam;
        else
        {
            CHAR charA = wParam;
            MultiByteToWideChar(CP_ACP, 0, &charA, 1, &charW, 1);
        }
 
                if (es->hwndListBox)
                {
                    if (charW == VK_RETURN || charW == VK_ESCAPE)
                    {
                        if (SendMessageW(GetParent(hwnd), CB_GETDROPPEDSTATE, 0, 0))
                            SendMessageW(GetParent(hwnd), WM_KEYDOWN, charW, 0);
                        break;
                    }
                }
        result = EDIT_WM_Char(es, charW);
        break;
    }
 
        case WM_UNICHAR:
                if (unicode)
                {
                    if (wParam == UNICODE_NOCHAR) return TRUE;
                    if (wParam <= 0x000fffff)
                    {
                        if(wParam > 0xffff) /* convert to surrogates */
                        {
                            wParam -= 0x10000;
                            EDIT_WM_Char(es, (wParam >> 10) + 0xd800);
                            EDIT_WM_Char(es, (wParam & 0x03ff) + 0xdc00);
                        }
                        else EDIT_WM_Char(es, wParam);
                    }
                    return 0;
                }
                break;
 
    case WM_CLEAR:
        EDIT_WM_Clear(es);
        break;
 
        case WM_CONTEXTMENU:
        EDIT_WM_ContextMenu(es, (short)LOWORD(lParam), (short)HIWORD(lParam));
        break;
 
    case WM_COPY:
        EDIT_WM_Copy(es);
        break;
 
    case WM_CREATE:
        if(unicode)
            result = EDIT_WM_Create(es, ((LPCREATESTRUCTW)lParam)->lpszName);
        else
        {
            LPCSTR nameA = ((LPCREATESTRUCTA)lParam)->lpszName;
            LPWSTR nameW = NULL;
            if(nameA)
            {
            INT countW = MultiByteToWideChar(CP_ACP, 0, nameA, -1, NULL, 0);
            if((nameW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
                MultiByteToWideChar(CP_ACP, 0, nameA, -1, nameW, countW);
            }
            result = EDIT_WM_Create(es, nameW);
                    HeapFree(GetProcessHeap(), 0, nameW);
        }
        break;
 
    case WM_CUT:
        EDIT_WM_Cut(es);
        break;
 
    case WM_ENABLE:
                es->bEnableState = (BOOL) wParam;
        EDIT_UpdateText(es, NULL, TRUE);
        break;
 
    case WM_ERASEBKGND:
        /* we do the proper erase in EDIT_WM_Paint */
        result = 1;
        break;
 
    case WM_GETFONT:
        result = (LRESULT)es->font;
        break;
 
    case WM_GETTEXT:
        result = (LRESULT)EDIT_WM_GetText(es, (INT)wParam, (LPWSTR)lParam, unicode);
        break;
 
    case WM_GETTEXTLENGTH:
                if (unicode) result = get_text_length(es);
                else result = WideCharToMultiByte( CP_ACP, 0, es->text, get_text_length(es),
                                                   NULL, 0, NULL, NULL );
        break;
 
    case WM_HSCROLL:
        result = EDIT_WM_HScroll(es, LOWORD(wParam), (short)HIWORD(wParam));
        break;
 
    case WM_KEYDOWN:
        result = EDIT_WM_KeyDown(es, (INT)wParam);
        break;
 
    case WM_KILLFOCUS:
        result = EDIT_WM_KillFocus(es);
        break;
 
    case WM_LBUTTONDBLCLK:
        result = EDIT_WM_LButtonDblClk(es);
        break;
 
    case WM_LBUTTONDOWN:
        result = EDIT_WM_LButtonDown(es, wParam, (short)LOWORD(lParam), (short)HIWORD(lParam));
        break;
 
    case WM_LBUTTONUP:
        result = EDIT_WM_LButtonUp(es);
        break;
 
    case WM_MBUTTONDOWN:
        result = EDIT_WM_MButtonDown(es);
        break;
 
    case WM_MOUSEMOVE:
        result = EDIT_WM_MouseMove(es, (short)LOWORD(lParam), (short)HIWORD(lParam));
        break;
 
    case WM_PRINTCLIENT:
    case WM_PAINT:
            EDIT_WM_Paint(es, (HDC)wParam);
        break;
 
    case WM_PASTE:
        EDIT_WM_Paste(es);
        break;
 
    case WM_SETFOCUS:
        EDIT_WM_SetFocus(es);
        break;
 
    case WM_SETFONT:
        EDIT_WM_SetFont(es, (HFONT)wParam, LOWORD(lParam) != 0);
        break;
 
    case WM_SETREDRAW:
        /* FIXME: actually set an internal flag and behave accordingly */
        break;
 
    case WM_SETTEXT:
        EDIT_WM_SetText(es, (LPCWSTR)lParam, unicode);
        result = TRUE;
        break;
 
    case WM_SIZE:
        EDIT_WM_Size(es, (UINT)wParam);
        break;
 
        case WM_STYLECHANGED:
                result = EDIT_WM_StyleChanged(es, wParam, (const STYLESTRUCT *)lParam);
                break;
 
        case WM_STYLECHANGING:
                result = 0; /* See EDIT_WM_StyleChanged */
                break;
 
    case WM_SYSKEYDOWN:
        result = EDIT_WM_SysKeyDown(es, (INT)wParam, (DWORD)lParam);
        break;
 
    case WM_TIMER:
        EDIT_WM_Timer(es);
        break;
 
    case WM_VSCROLL:
        result = EDIT_WM_VScroll(es, LOWORD(wParam), (short)HIWORD(wParam));
        break;
 
        case WM_MOUSEWHEEL:
                {
                    int wheelDelta;
                    UINT pulScrollLines = 3;
                    SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0);
 
                    if (wParam & (MK_SHIFT | MK_CONTROL)) {
                        result = DefWindowProcW(hwnd, msg, wParam, lParam);
                        break;
                    }
                    wheelDelta = GET_WHEEL_DELTA_WPARAM(wParam);
                    /* if scrolling changes direction, ignore left overs */
                    if ((wheelDelta < 0 && es->wheelDeltaRemainder < 0) ||
                        (wheelDelta > 0 && es->wheelDeltaRemainder > 0))
                        es->wheelDeltaRemainder += wheelDelta;
                    else
                        es->wheelDeltaRemainder = wheelDelta;
                    if (es->wheelDeltaRemainder && pulScrollLines)
                    {
                        int cLineScroll;
                        pulScrollLines = (int) min((UINT) es->line_count, pulScrollLines);
                        cLineScroll = pulScrollLines * (float)es->wheelDeltaRemainder / WHEEL_DELTA;
                        es->wheelDeltaRemainder -= WHEEL_DELTA * cLineScroll / (int)pulScrollLines;
                        result = EDIT_EM_LineScroll(es, 0, -cLineScroll);
                    }
                }
                break;
 
 
    /* IME messages to make the edit control IME aware */
    case WM_IME_SETCONTEXT:
#ifdef __REACTOS__
        if (FALSE) /* FIXME: Condition */
            lParam &= ~ISC_SHOWUICOMPOSITIONWINDOW;
 
        if (wParam)
        {
            HIMC hIMC = ImmGetContext(hwnd);
            LPINPUTCONTEXTDX pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
            if (pIC)
            {
                pIC->dwUIFlags &= ~0x40000;
                ImmUnlockIMC(hIMC);
            }
            if (GetWin32ClientInfo()->CI_flags & CI_WOW)
                ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
            ImmReleaseContext(hwnd, hIMC);
        }
 
        result = DefWindowProcT(hwnd, WM_IME_SETCONTEXT, wParam, lParam, unicode);
#endif
        break;
 
    case WM_IME_STARTCOMPOSITION:
#ifdef __REACTOS__
        if (FALSE) /* FIXME: Condition */
            return TRUE;
        result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
#else
        es->composition_start = es->selection_end;
        es->composition_len = 0;
#endif
        break;
 
    case WM_IME_COMPOSITION:
                EDIT_ImeComposition(hwnd, lParam, es);
#ifdef __REACTOS__
        result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
#endif
        break;
 
    case WM_IME_ENDCOMPOSITION:
#ifdef __REACTOS__
        result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
#else
                if (es->composition_len > 0)
                {
                        EDIT_EM_ReplaceSel(es, TRUE, empty_stringW, TRUE, TRUE);
                        es->selection_end = es->selection_start;
                        es->composition_len= 0;
                }
#endif
        break;
 
    case WM_IME_COMPOSITIONFULL:
        break;
 
    case WM_IME_SELECT:
#ifdef __REACTOS__
        result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
#endif
        break;
 
    case WM_IME_CONTROL:
#ifdef __REACTOS__
        result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
#endif
        break;
 
    case WM_IME_REQUEST:
        switch (wParam)
        {
                    case IMR_QUERYCHARPOSITION:
                    {
                        LRESULT pos;
                        IMECHARPOSITION *chpos = (IMECHARPOSITION *)lParam;
 
                        pos = EDIT_EM_PosFromChar(es, es->selection_start + chpos->dwCharPos, FALSE);
                        chpos->pt.x = LOWORD(pos);
                        chpos->pt.y = HIWORD(pos);
                        chpos->cLineHeight = es->line_height;
                        chpos->rcDocument = es->format_rect;
                        MapWindowPoints(hwnd, 0, &chpos->pt, 1);
                        MapWindowPoints(hwnd, 0, (POINT*)&chpos->rcDocument, 2);
                        result = 1;
                        break;
                    }
        }
        break;
 
    default:
        result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
        break;
    }
 
#ifdef __REACTOS__
        /* ReactOS: check GetWindowLong in case es has been destroyed during processing */
        if (IsWindow(hwnd) && es && msg != EM_GETHANDLE && GetWindowLongPtrW(hwnd, 0))
#else
        if (IsWindow(hwnd) && es && msg != EM_GETHANDLE)
#endif
            EDIT_UnlockBuffer(es, FALSE);
 
        TRACE("hwnd=%p msg=%x (%s) -- 0x%08lx\n", hwnd, msg, SPY_GetMsgName(msg, hwnd), result);
 
    return result;

Referenced by RegisterClientPFN().

EditWndProcA()

LRESULT WINAPI EditWndProcA	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Referenced by RegisterClientPFN().

EditWndProcW()

LRESULT WINAPI EditWndProcW	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Referenced by RegisterClientPFN().

GhostWndProc_common()

LRESULT WINAPI GhostWndProc_common	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL	unicode
	)

Definition at line 515 of file ghost.c.

{
    switch (uMsg)
    {
        case WM_CREATE:
            if (!Ghost_OnCreate(hwnd, (CREATESTRUCTW *)lParam))
                return -1;
            break;
 
        case WM_NCPAINT:
            Ghost_OnNCPaint(hwnd, (HRGN)wParam, unicode);
            return 0;
 
        case WM_ERASEBKGND:
            Ghost_OnDraw(hwnd, (HDC)wParam);
            return TRUE;
 
        case WM_PAINT:
            Ghost_OnPaint(hwnd);
            break;
 
        case WM_MOVE:
            Ghost_OnMove(hwnd, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
            break;
 
        case WM_SIZE:
            break;
 
        case WM_SIZING:
            return TRUE;
 
        case WM_SYSCOMMAND:
            switch ((UINT)wParam)
            {
                case SC_MAXIMIZE:
                case SC_SIZE:
                    // sizing-related
                    return 0;
            }
            if (unicode)
                return DefWindowProcW(hwnd, uMsg, wParam, lParam);
            else
                return DefWindowProcA(hwnd, uMsg, wParam, lParam);
 
        case WM_CLOSE:
            Ghost_OnClose(hwnd);
            break;
 
        case WM_TIMER:
            Ghost_OnTimer(hwnd, (UINT)wParam);
            break;
 
        case WM_NCMOUSEMOVE:
            if (unicode)
                DefWindowProcW(hwnd, uMsg, wParam, lParam);
            else
                DefWindowProcA(hwnd, uMsg, wParam, lParam);
            SetCursor(LoadCursor(NULL, IDC_WAIT));
            return 0;
 
        case WM_GETICON:
            return (LRESULT)Ghost_GetIcon(hwnd, (INT)wParam);
 
        case WM_COMMAND:
            if (LOWORD(wParam) == 3333)
                Ghost_Unenchant(hwnd, FALSE);
            break;
 
        case WM_DESTROY:
            Ghost_OnDestroy(hwnd);
            break;
 
        case WM_NCDESTROY:
            Ghost_OnNCDestroy(hwnd);
            break;
 
        default:
        {
            if (unicode)
                return DefWindowProcW(hwnd, uMsg, wParam, lParam);
            else
                return DefWindowProcA(hwnd, uMsg, wParam, lParam);
        }
    }
    return 0;
}

Referenced by GhostWndProcA(), GhostWndProcW(), and RegisterClientPFN().

GhostWndProcA()

LRESULT WINAPI GhostWndProcA	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 604 of file ghost.c.

{
    return GhostWndProc_common(hwnd, uMsg, wParam, lParam, FALSE);
}

Referenced by RegisterClientPFN().

GhostWndProcW()

LRESULT WINAPI GhostWndProcW	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 610 of file ghost.c.

{
    return GhostWndProc_common(hwnd, uMsg, wParam, lParam, TRUE);
}

Referenced by RegisterClientPFN().

IconTitleWndProc()

LRESULT WINAPI IconTitleWndProc	(	HWND	hWnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 184 of file icontitle.c.

{
    HWND owner = GetWindow( hWnd, GW_OWNER );
 
    if (!IsWindow(hWnd)) return 0;
 
    switch( msg )
    {
        case WM_CREATE:
            if (!hIconTitleFont)
            {
                LOGFONTA logFont;
                SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0, &logFont, 0 );
                SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0, &bMultiLineTitle, 0 );
                hIconTitleFont = CreateFontIndirectA( &logFont );
            }
            return (hIconTitleFont ? 0 : -1);
    case WM_NCHITTEST:
         return HTCAPTION;
    case WM_NCMOUSEMOVE:
    case WM_NCLBUTTONDBLCLK:
         return SendMessageW( owner, msg, wParam, lParam );
    case WM_ACTIVATE:
         if( wParam ) SetActiveWindow( owner );
             return 0;
    case WM_CLOSE:
         return 0;
    case WM_SHOWWINDOW:
             if (wParam) ICONTITLE_SetTitlePos( hWnd, owner );
         return 0;
    case WM_ERASEBKGND:
            if( GetWindowLongPtrW( owner, GWL_STYLE ) & WS_CHILD )
                lParam = SendMessageW( owner, WM_ISACTIVEICON, 0, 0 );
            else
                lParam = (owner == GetActiveWindow());
            if( ICONTITLE_Paint( hWnd, owner, (HDC)wParam, (BOOL)lParam ) )
                ValidateRect( hWnd, NULL );
            return 1;
    }
    return DefWindowProcW( hWnd, msg, wParam, lParam );
}

Referenced by RegisterClientPFN().

ListBoxWndProc_common()

LRESULT WINAPI ListBoxWndProc_common	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL	unicode
	)

Definition at line 2614 of file listbox.c.

{
    LB_DESCR *descr = (LB_DESCR *)GetWindowLongPtrW( hwnd, 0 );
    LPHEADCOMBO lphc = 0;
    LRESULT ret;
#ifdef __REACTOS__
    PWND pWnd;
 
    pWnd = ValidateHwnd(hwnd);
    if (pWnd)
    {
       if (!pWnd->fnid)
       {
          NtUserSetWindowFNID(hwnd, FNID_LISTBOX); // Could be FNID_COMBOLBOX by class.
       }
       else
       {
          if (pWnd->fnid != FNID_LISTBOX)
          {
             ERR("Wrong window class for listbox! fnId 0x%x\n",pWnd->fnid);
             return 0;
          }
       }
    }    
#endif    
 
    if (!descr)
    {
        if (!IsWindow(hwnd)) return 0;
 
        if (msg == WM_CREATE)
        {
        CREATESTRUCTW *lpcs = (CREATESTRUCTW *)lParam;
            if (lpcs->style & LBS_COMBOBOX) lphc = lpcs->lpCreateParams;
            if (!LISTBOX_Create( hwnd, lphc )) return -1;
            TRACE("creating hwnd %p descr %p\n", hwnd, (void *)GetWindowLongPtrW( hwnd, 0 ) );
            return 0;
        }
        /* Ignore all other messages before we get a WM_CREATE */
        return unicode ? DefWindowProcW( hwnd, msg, wParam, lParam ) :
                         DefWindowProcA( hwnd, msg, wParam, lParam );
    }
    if (descr->style & LBS_COMBOBOX) lphc = descr->lphc;
 
    TRACE("[%p]: msg %s wp %08lx lp %08lx\n",
          descr->self, SPY_GetMsgName(msg, descr->self), wParam, lParam );
 
    switch(msg)
    {
    case LB_RESETCONTENT:
        LISTBOX_ResetContent( descr );
        LISTBOX_UpdateScroll( descr );
        InvalidateRect( descr->self, NULL, TRUE );
        return 0;
 
    case LB_ADDSTRING:
#ifdef __REACTOS__
    case LB_ADDSTRING_LOWER:
    case LB_ADDSTRING_UPPER:
#endif
    {
        INT ret;
        LPWSTR textW;
        if(unicode || !HAS_STRINGS(descr))
            textW = (LPWSTR)lParam;
        else
        {
            LPSTR textA = (LPSTR)lParam;
            INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
            if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
                MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
            else
                return LB_ERRSPACE;
        }
#ifdef __REACTOS__
        /* in the unicode the version, the string is really overwritten
           during the converting case */
        if (msg == LB_ADDSTRING_LOWER)
            strlwrW(textW);
        else if (msg == LB_ADDSTRING_UPPER)
            struprW(textW);
#endif
        wParam = LISTBOX_FindStringPos( descr, textW, FALSE );
        ret = LISTBOX_InsertString( descr, wParam, textW );
        if (!unicode && HAS_STRINGS(descr))
            HeapFree(GetProcessHeap(), 0, textW);
        return ret;
    }
 
    case LB_INSERTSTRING:
#ifdef __REACTOS__
    case LB_INSERTSTRING_UPPER:
    case LB_INSERTSTRING_LOWER:
#endif
    {
        INT ret;
        LPWSTR textW;
        if(unicode || !HAS_STRINGS(descr))
            textW = (LPWSTR)lParam;
        else
        {
            LPSTR textA = (LPSTR)lParam;
            INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
            if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
                MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
            else
                return LB_ERRSPACE;
        }
#ifdef __REACTOS__
        /* in the unicode the version, the string is really overwritten
           during the converting case */
        if (msg == LB_INSERTSTRING_LOWER)
            strlwrW(textW);
        else if (msg == LB_INSERTSTRING_UPPER)
            struprW(textW);
#endif
        ret = LISTBOX_InsertString( descr, wParam, textW );
        if(!unicode && HAS_STRINGS(descr))
            HeapFree(GetProcessHeap(), 0, textW);
        return ret;
    }
 
    case LB_ADDFILE:
    {
        INT ret;
        LPWSTR textW;
        if(unicode || !HAS_STRINGS(descr))
            textW = (LPWSTR)lParam;
        else
        {
            LPSTR textA = (LPSTR)lParam;
            INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
            if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
                MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
            else
                return LB_ERRSPACE;
        }
        wParam = LISTBOX_FindFileStrPos( descr, textW );
        ret = LISTBOX_InsertString( descr, wParam, textW );
        if(!unicode && HAS_STRINGS(descr))
            HeapFree(GetProcessHeap(), 0, textW);
        return ret;
    }
 
    case LB_DELETESTRING:
        if (LISTBOX_RemoveItem( descr, wParam) != LB_ERR)
            return descr->nb_items;
        else
        {
            SetLastError(ERROR_INVALID_INDEX);
            return LB_ERR;
        }
 
    case LB_GETITEMDATA:
        if (((INT)wParam < 0) || ((INT)wParam >= descr->nb_items))
        {
            SetLastError(ERROR_INVALID_INDEX);
            return LB_ERR;
        }
        return descr->items[wParam].data;
 
    case LB_SETITEMDATA:
        if (((INT)wParam < 0) || ((INT)wParam >= descr->nb_items))
        {
            SetLastError(ERROR_INVALID_INDEX);
            return LB_ERR;
        }
        descr->items[wParam].data = lParam;
        /* undocumented: returns TRUE, not LB_OKAY (0) */
        return TRUE;
 
    case LB_GETCOUNT:
        return descr->nb_items;
 
    case LB_GETTEXT:
        return LISTBOX_GetText( descr, wParam, (LPWSTR)lParam, unicode );
 
    case LB_GETTEXTLEN:
        if ((INT)wParam >= descr->nb_items || (INT)wParam < 0)
        {
            SetLastError(ERROR_INVALID_INDEX);
            return LB_ERR;
        }
        if (!HAS_STRINGS(descr)) return sizeof(DWORD);
        if (unicode) return strlenW( descr->items[wParam].str );
        return WideCharToMultiByte( CP_ACP, 0, descr->items[wParam].str,
                                    strlenW(descr->items[wParam].str), NULL, 0, NULL, NULL );
 
    case LB_GETCURSEL:
        if (descr->nb_items == 0)
            return LB_ERR;
        if (!IS_MULTISELECT(descr))
            return descr->selected_item;
        if (descr->selected_item != -1)
            return descr->selected_item;
        return descr->focus_item;
        /* otherwise, if the user tries to move the selection with the    */
        /* arrow keys, we will give the application something to choke on */
    case LB_GETTOPINDEX:
        return descr->top_item;
 
    case LB_GETITEMHEIGHT:
        return LISTBOX_GetItemHeight( descr, wParam );
 
    case LB_SETITEMHEIGHT:
        return LISTBOX_SetItemHeight( descr, wParam, lParam, TRUE );
 
    case LB_ITEMFROMPOINT:
        {
            POINT pt;
            RECT rect;
            int index;
            BOOL hit = TRUE;
 
            /* The hiword of the return value is not a client area
               hittest as suggested by MSDN, but rather a hittest on
               the returned listbox item. */
 
            if(descr->nb_items == 0)
                return 0x1ffff;      /* win9x returns 0x10000, we copy winnt */
 
            pt.x = (short)LOWORD(lParam);
            pt.y = (short)HIWORD(lParam);
 
            SetRect(&rect, 0, 0, descr->width, descr->height);
 
            if(!PtInRect(&rect, pt))
            {
                pt.x = min(pt.x, rect.right - 1);
                pt.x = max(pt.x, 0);
                pt.y = min(pt.y, rect.bottom - 1);
                pt.y = max(pt.y, 0);
                hit = FALSE;
            }
 
            index = LISTBOX_GetItemFromPoint(descr, pt.x, pt.y);
 
            if(index == -1)
            {
                index = descr->nb_items - 1;
                hit = FALSE;
            }
            return MAKELONG(index, hit ? 0 : 1);
        }
 
    case LB_SETCARETINDEX:
        if ((!IS_MULTISELECT(descr)) && (descr->selected_item != -1)) return LB_ERR;
        if (LISTBOX_SetCaretIndex( descr, wParam, !lParam ) == LB_ERR)
            return LB_ERR;
        else if (ISWIN31)
             return wParam;
        else
             return LB_OKAY;
 
    case LB_GETCARETINDEX:
        return descr->focus_item;
 
    case LB_SETTOPINDEX:
        return LISTBOX_SetTopItem( descr, wParam, TRUE );
 
    case LB_SETCOLUMNWIDTH:
        return LISTBOX_SetColumnWidth( descr, wParam );
 
    case LB_GETITEMRECT:
        return LISTBOX_GetItemRect( descr, wParam, (RECT *)lParam );
 
    case LB_FINDSTRING:
    {
        INT ret;
        LPWSTR textW;
        if(unicode || !HAS_STRINGS(descr))
            textW = (LPWSTR)lParam;
        else
        {
            LPSTR textA = (LPSTR)lParam;
            INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
            if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
                MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
        }
        ret = LISTBOX_FindString( descr, wParam, textW, FALSE );
        if(!unicode && HAS_STRINGS(descr))
            HeapFree(GetProcessHeap(), 0, textW);
        return ret;
    }
 
    case LB_FINDSTRINGEXACT:
    {
        INT ret;
        LPWSTR textW;
        if(unicode || !HAS_STRINGS(descr))
            textW = (LPWSTR)lParam;
        else
        {
            LPSTR textA = (LPSTR)lParam;
            INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
            if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
                MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
        }
        ret = LISTBOX_FindString( descr, wParam, textW, TRUE );
        if(!unicode && HAS_STRINGS(descr))
            HeapFree(GetProcessHeap(), 0, textW);
        return ret;
    }
 
    case LB_SELECTSTRING:
    {
        INT index;
        LPWSTR textW;
 
    if(HAS_STRINGS(descr))
        TRACE("LB_SELECTSTRING: %s\n", unicode ? debugstr_w((LPWSTR)lParam) :
                             debugstr_a((LPSTR)lParam));
        if(unicode || !HAS_STRINGS(descr))
            textW = (LPWSTR)lParam;
        else
        {
            LPSTR textA = (LPSTR)lParam;
            INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
            if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
                MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
        }
        index = LISTBOX_FindString( descr, wParam, textW, FALSE );
        if(!unicode && HAS_STRINGS(descr))
            HeapFree(GetProcessHeap(), 0, textW);
        if (index != LB_ERR)
    {
            LISTBOX_MoveCaret( descr, index, TRUE );
            LISTBOX_SetSelection( descr, index, TRUE, FALSE );
    }
        return index;
    }
 
    case LB_GETSEL:
        if (((INT)wParam < 0) || ((INT)wParam >= descr->nb_items))
            return LB_ERR;
        return descr->items[wParam].selected;
 
    case LB_SETSEL:
        return LISTBOX_SetSelection( descr, lParam, wParam, FALSE );
 
    case LB_SETCURSEL:
        if (IS_MULTISELECT(descr)) return LB_ERR;
        LISTBOX_SetCaretIndex( descr, wParam, TRUE );
        ret = LISTBOX_SetSelection( descr, wParam, TRUE, FALSE );
    if (ret != LB_ERR) ret = descr->selected_item;
    return ret;
 
    case LB_GETSELCOUNT:
        return LISTBOX_GetSelCount( descr );
 
    case LB_GETSELITEMS:
        return LISTBOX_GetSelItems( descr, wParam, (LPINT)lParam );
 
    case LB_SELITEMRANGE:
        if (LOWORD(lParam) <= HIWORD(lParam))
            return LISTBOX_SelectItemRange( descr, LOWORD(lParam),
                                            HIWORD(lParam), wParam );
        else
            return LISTBOX_SelectItemRange( descr, HIWORD(lParam),
                                            LOWORD(lParam), wParam );
 
    case LB_SELITEMRANGEEX:
        if ((INT)lParam >= (INT)wParam)
            return LISTBOX_SelectItemRange( descr, wParam, lParam, TRUE );
        else
            return LISTBOX_SelectItemRange( descr, lParam, wParam, FALSE);
 
    case LB_GETHORIZONTALEXTENT:
        return descr->horz_extent;
 
    case LB_SETHORIZONTALEXTENT:
        return LISTBOX_SetHorizontalExtent( descr, wParam );
 
    case LB_GETANCHORINDEX:
        return descr->anchor_item;
 
    case LB_SETANCHORINDEX:
        if (((INT)wParam < -1) || ((INT)wParam >= descr->nb_items))
        {
            SetLastError(ERROR_INVALID_INDEX);
            return LB_ERR;
        }
        descr->anchor_item = (INT)wParam;
        return LB_OKAY;
 
    case LB_DIR:
    {
        INT ret;
        LPWSTR textW;
        if(unicode)
            textW = (LPWSTR)lParam;
        else
        {
            LPSTR textA = (LPSTR)lParam;
            INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
            if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
                MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
        }
        ret = LISTBOX_Directory( descr, wParam, textW, msg == LB_DIR );
        if(!unicode)
            HeapFree(GetProcessHeap(), 0, textW);
        return ret;
    }
 
    case LB_GETLOCALE:
        return descr->locale;
 
    case LB_SETLOCALE:
    {
        LCID ret;
        if (!IsValidLocale((LCID)wParam, LCID_INSTALLED))
            return LB_ERR;
        ret = descr->locale;
        descr->locale = (LCID)wParam;
        return ret;
    }
 
    case LB_INITSTORAGE:
        return LISTBOX_InitStorage( descr, wParam );
 
    case LB_SETCOUNT:
        return LISTBOX_SetCount( descr, (INT)wParam );
 
    case LB_SETTABSTOPS:
        return LISTBOX_SetTabStops( descr, wParam, (LPINT)lParam );
 
    case LB_CARETON:
        if (descr->caret_on)
            return LB_OKAY;
        descr->caret_on = TRUE;
        if ((descr->focus_item != -1) && (descr->in_focus))
            LISTBOX_RepaintItem( descr, descr->focus_item, ODA_FOCUS );
        return LB_OKAY;
 
    case LB_CARETOFF:
        if (!descr->caret_on)
            return LB_OKAY;
        descr->caret_on = FALSE;
        if ((descr->focus_item != -1) && (descr->in_focus))
            LISTBOX_RepaintItem( descr, descr->focus_item, ODA_FOCUS );
        return LB_OKAY;
 
    case LB_GETLISTBOXINFO:
        return descr->page_size;
 
    case WM_DESTROY:
        return LISTBOX_Destroy( descr );
 
    case WM_ENABLE:
        InvalidateRect( descr->self, NULL, TRUE );
        return 0;
 
    case WM_SETREDRAW:
        LISTBOX_SetRedraw( descr, wParam != 0 );
        return 0;
 
    case WM_GETDLGCODE:
        return DLGC_WANTARROWS | DLGC_WANTCHARS;
 
    case WM_PRINTCLIENT:
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = ( wParam ) ? ((HDC)wParam) :  BeginPaint( descr->self, &ps );
            ret = LISTBOX_Paint( descr, hdc );
            if( !wParam ) EndPaint( descr->self, &ps );
        }
        return ret;
    case WM_SIZE:
        LISTBOX_UpdateSize( descr );
        return 0;
    case WM_GETFONT:
        return (LRESULT)descr->font;
    case WM_SETFONT:
        LISTBOX_SetFont( descr, (HFONT)wParam );
        if (lParam) InvalidateRect( descr->self, 0, TRUE );
        return 0;
    case WM_SETFOCUS:
        descr->in_focus = TRUE;
        descr->caret_on = TRUE;
        if (descr->focus_item != -1)
            LISTBOX_DrawFocusRect( descr, TRUE );
        SEND_NOTIFICATION( descr, LBN_SETFOCUS );
        return 0;
    case WM_KILLFOCUS:
        LISTBOX_HandleLButtonUp( descr ); /* Release capture if we have it */
        descr->in_focus = FALSE;
        descr->wheel_remain = 0;
        if ((descr->focus_item != -1) && descr->caret_on)
            LISTBOX_RepaintItem( descr, descr->focus_item, ODA_FOCUS );
        SEND_NOTIFICATION( descr, LBN_KILLFOCUS );
        return 0;
    case WM_HSCROLL:
        return LISTBOX_HandleHScroll( descr, LOWORD(wParam), HIWORD(wParam) );
    case WM_VSCROLL:
        return LISTBOX_HandleVScroll( descr, LOWORD(wParam), HIWORD(wParam) );
    case WM_MOUSEWHEEL:
        if (wParam & (MK_SHIFT | MK_CONTROL))
            return DefWindowProcW( descr->self, msg, wParam, lParam );
        return LISTBOX_HandleMouseWheel( descr, (SHORT)HIWORD(wParam) );
    case WM_LBUTTONDOWN:
    if (lphc)
            return LISTBOX_HandleLButtonDownCombo(descr, msg, wParam,
                                                  (INT16)LOWORD(lParam),
                                                  (INT16)HIWORD(lParam) );
        return LISTBOX_HandleLButtonDown( descr, wParam,
                                          (INT16)LOWORD(lParam),
                                          (INT16)HIWORD(lParam) );
    case WM_LBUTTONDBLCLK:
    if (lphc)
            return LISTBOX_HandleLButtonDownCombo(descr, msg, wParam,
                                                  (INT16)LOWORD(lParam),
                                                  (INT16)HIWORD(lParam) );
        if (descr->style & LBS_NOTIFY)
            SEND_NOTIFICATION( descr, LBN_DBLCLK );
        return 0;
    case WM_MOUSEMOVE:
        if ( lphc && ((lphc->dwStyle & CBS_DROPDOWNLIST) != CBS_SIMPLE) )
        {
            BOOL    captured = descr->captured;
            POINT   mousePos;
            RECT    clientRect;
 
            mousePos.x = (INT16)LOWORD(lParam);
            mousePos.y = (INT16)HIWORD(lParam);
 
            /*
             * If we are in a dropdown combobox, we simulate that
             * the mouse is captured to show the tracking of the item.
             */
            if (GetClientRect(descr->self, &clientRect) && PtInRect( &clientRect, mousePos ))
                descr->captured = TRUE;
 
            LISTBOX_HandleMouseMove( descr, mousePos.x, mousePos.y);
 
            descr->captured = captured;
        } 
        else if (GetCapture() == descr->self)
        {
            LISTBOX_HandleMouseMove( descr, (INT16)LOWORD(lParam),
                                     (INT16)HIWORD(lParam) );
        }
        return 0;
    case WM_LBUTTONUP:
    if (lphc)
    {
            POINT mousePos;
            RECT  clientRect;
 
            /*
             * If the mouse button "up" is not in the listbox,
             * we make sure there is no selection by re-selecting the
             * item that was selected when the listbox was made visible.
             */
            mousePos.x = (INT16)LOWORD(lParam);
            mousePos.y = (INT16)HIWORD(lParam);
 
            GetClientRect(descr->self, &clientRect);
 
            /*
             * When the user clicks outside the combobox and the focus
             * is lost, the owning combobox will send a fake buttonup with
             * 0xFFFFFFF as the mouse location, we must also revert the
             * selection to the original selection.
             */
            if ( (lParam == (LPARAM)-1) || (!PtInRect( &clientRect, mousePos )) )
                LISTBOX_MoveCaret( descr, lphc->droppedIndex, FALSE );
        }
        return LISTBOX_HandleLButtonUp( descr );
    case WM_KEYDOWN:
        if( lphc && (lphc->dwStyle & CBS_DROPDOWNLIST) != CBS_SIMPLE )
        {
            /* for some reason Windows makes it possible to
             * show/hide ComboLBox by sending it WM_KEYDOWNs */
 
            if( (!(lphc->wState & CBF_EUI) && wParam == VK_F4) ||
                ( (lphc->wState & CBF_EUI) && !(lphc->wState & CBF_DROPPED)
                  && (wParam == VK_DOWN || wParam == VK_UP)) )
            {
                COMBO_FlipListbox( lphc, FALSE, FALSE );
                return 0;
            }
        }
        return LISTBOX_HandleKeyDown( descr, wParam );
    case WM_CHAR:
    {
        WCHAR charW;
        if(unicode)
            charW = (WCHAR)wParam;
        else
        {
            CHAR charA = (CHAR)wParam;
            MultiByteToWideChar(CP_ACP, 0, &charA, 1, &charW, 1);
        }
        return LISTBOX_HandleChar( descr, charW );
    }
    case WM_SYSTIMER:
        return LISTBOX_HandleSystemTimer( descr );
    case WM_ERASEBKGND:
        if ((IS_OWNERDRAW(descr)) && !(descr->style & LBS_DISPLAYCHANGED))
        {
            RECT rect;
#ifdef __REACTOS__
            HBRUSH hbrush = GetControlColor( descr->owner, descr->self, (HDC)wParam, WM_CTLCOLORLISTBOX);
#else
            HBRUSH hbrush = (HBRUSH)SendMessageW( descr->owner, WM_CTLCOLORLISTBOX,
                                              wParam, (LPARAM)descr->self );
#endif
        TRACE("hbrush = %p\n", hbrush);
        if(!hbrush)
        hbrush = GetSysColorBrush(COLOR_WINDOW);
        if(hbrush)
        {
        GetClientRect(descr->self, &rect);
        FillRect((HDC)wParam, &rect, hbrush);
        }
        }
        return 1;
    case WM_DROPFILES:
        if( lphc ) return 0;
        return unicode ? SendMessageW( descr->owner, msg, wParam, lParam ) :
                         SendMessageA( descr->owner, msg, wParam, lParam );
 
    case WM_NCDESTROY:
        if( lphc && (lphc->dwStyle & CBS_DROPDOWNLIST) != CBS_SIMPLE )
            lphc->hWndLBox = 0;
#ifdef __REACTOS__
        NtUserSetWindowFNID(hwnd, FNID_DESTROY);
#endif
        break;
 
    case WM_NCACTIVATE:
        if (lphc) return 0;
    break;
// ReactOS
    case WM_UPDATEUISTATE:
        if (unicode)
            DefWindowProcW(descr->self, msg, wParam, lParam);
        else
            DefWindowProcA(descr->self, msg, wParam, lParam);
 
        if (LISTBOX_update_uistate(descr))
        {
           /* redraw text */
           if (descr->focus_item != -1)
               LISTBOX_DrawFocusRect( descr, descr->in_focus );
        }
        break;
//
    default:
        if ((msg >= WM_USER) && (msg < 0xc000))
            WARN("[%p]: unknown msg %04x wp %08lx lp %08lx\n",
                 hwnd, msg, wParam, lParam );
    }
 
    return unicode ? DefWindowProcW( hwnd, msg, wParam, lParam ) :
                     DefWindowProcA( hwnd, msg, wParam, lParam );
}

Referenced by ListBoxWndProcA(), ListBoxWndProcW(), and RegisterClientPFN().

ListBoxWndProcA()

LRESULT WINAPI ListBoxWndProcA	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 3277 of file listbox.c.

{
    return ListBoxWndProc_common( hwnd, msg, wParam, lParam, FALSE );
}

Referenced by RegisterClientPFN().

ListBoxWndProcW()

LRESULT WINAPI ListBoxWndProcW	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 3285 of file listbox.c.

{
    return ListBoxWndProc_common( hwnd, msg, wParam, lParam, TRUE );
}

Referenced by RegisterClientPFN().

MDIClientWndProc_common()

LRESULT WINAPI MDIClientWndProc_common	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL	unicode
	)

Definition at line 1097 of file mdi.c.

{
    MDICLIENTINFO *ci = NULL;
 
    TRACE("%p %04x (%s) %08lx %08lx\n", hwnd, message, SPY_GetMsgName(message, hwnd), wParam, lParam);
 
    if (!(ci = get_client_info( hwnd )))
    {
#ifdef __REACTOS__
        if (message == WM_NCCREATE)
        {
          if (!(ci = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ci))))
             return FALSE;
           SetWindowLongPtrW( hwnd, GWLP_MDIWND, (LONG_PTR)ci );
           ci->hBmpClose = 0;
           NtUserSetWindowFNID( hwnd, FNID_MDICLIENT); // wine uses WIN_ISMDICLIENT
        }
#else
        if (message == WM_NCCREATE) win_set_flags( hwnd, WIN_ISMDICLIENT, 0 );
#endif
        return unicode ? DefWindowProcW( hwnd, message, wParam, lParam ) :
                         DefWindowProcA( hwnd, message, wParam, lParam );
    }
 
    switch (message)
    {
      case WM_CREATE:
      {
          /* Since we are using only cs->lpCreateParams, we can safely
           * cast to LPCREATESTRUCTA here */
        LPCREATESTRUCTA cs = (LPCREATESTRUCTA)lParam;
        LPCLIENTCREATESTRUCT ccs = (LPCLIENTCREATESTRUCT)cs->lpCreateParams;
 
        ci->hWindowMenu     = ccs->hWindowMenu;
        ci->idFirstChild    = ccs->idFirstChild;
        ci->hwndChildMaximized  = 0;
        ci->child = NULL;
    ci->nActiveChildren = 0;
    ci->nTotalCreated   = 0;
    ci->frameTitle      = NULL;
    ci->mdiFlags        = 0;
        ci->hFrameMenu = GetMenu(cs->hwndParent);
 
    if (!ci->hBmpClose) ci->hBmpClose = CreateMDIMenuBitmap();
 
        TRACE("Client created: hwnd %p, Window menu %p, idFirst = %04x\n",
              hwnd, ci->hWindowMenu, ci->idFirstChild );
        return 0;
      }
 
      case WM_DESTROY:
      {
          if( ci->hwndChildMaximized )
              MDI_RestoreFrameMenu(GetParent(hwnd), ci->hwndChildMaximized, ci->hBmpClose);
 
          ci->nActiveChildren = 0;
          MDI_RefreshMenu(ci);
 
          HeapFree( GetProcessHeap(), 0, ci->child );
          HeapFree( GetProcessHeap(), 0, ci->frameTitle );
#ifdef __REACTOS__
          HeapFree( GetProcessHeap(), 0, ci );
          SetWindowLongPtrW( hwnd, GWLP_MDIWND, 0 );
#endif
          return 0;
      }
 
#ifdef __REACTOS__
      case WM_NCDESTROY:
      {
          NtUserSetWindowFNID(hwnd, FNID_DESTROY);
          return 0;
      }
#endif
 
      case WM_MDIACTIVATE:
      {
        if( ci->hwndActiveChild != (HWND)wParam )
        SetWindowPos((HWND)wParam, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE);
        return 0;
      }
 
      case WM_MDICASCADE:
        return MDICascade(hwnd, ci);
 
      case WM_MDICREATE:
        if (lParam)
        {
            HWND child;
 
            if (unicode)
            {
                MDICREATESTRUCTW *csW = (MDICREATESTRUCTW *)lParam;
                child = CreateWindowExW(WS_EX_MDICHILD, csW->szClass,
                                            csW->szTitle, csW->style,
                                            csW->x, csW->y, csW->cx, csW->cy,
                                            hwnd, 0, csW->hOwner,
                                            (LPVOID)csW->lParam);
            }
            else
            {
                MDICREATESTRUCTA *csA = (MDICREATESTRUCTA *)lParam;
                child = CreateWindowExA(WS_EX_MDICHILD, csA->szClass,
                                            csA->szTitle, csA->style,
                                            csA->x, csA->y, csA->cx, csA->cy,
                                            hwnd, 0, csA->hOwner,
                                            (LPVOID)csA->lParam);
            }
            return (LRESULT)child;
        }
        return 0;
 
      case WM_MDIDESTROY:
          return MDIDestroyChild( hwnd, ci, (HWND)wParam, TRUE );
 
      case WM_MDIGETACTIVE:
          if (lParam) *(BOOL *)lParam = IsZoomed(ci->hwndActiveChild);
          return (LRESULT)ci->hwndActiveChild;
 
      case WM_MDIICONARRANGE:
    ci->mdiFlags |= MDIF_NEEDUPDATE;
        ArrangeIconicWindows( hwnd );
    ci->sbRecalc = SB_BOTH+1;
#ifdef __REACTOS__
    PostMessageA( hwnd, WM_MDICALCCHILDSCROLL, 0, 0 ); 
#else
        SendMessageW( hwnd, WM_MDICALCCHILDSCROLL, 0, 0 );
#endif
        return 0;
 
      case WM_MDIMAXIMIZE:
    ShowWindow( (HWND)wParam, SW_MAXIMIZE );
        return 0;
 
      case WM_MDINEXT: /* lParam != 0 means previous window */
      {
        HWND hwnd = wParam ? WIN_GetFullHandle((HWND)wParam) : ci->hwndActiveChild;
        HWND next = MDI_GetWindow( ci, hwnd, !lParam, 0 );
        MDI_SwitchActiveChild( ci, next, TRUE );
        if(!lParam)
            SetWindowPos(hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
    break;
      }
 
      case WM_MDIRESTORE:
        ShowWindow( (HWND)wParam, SW_SHOWNORMAL );
        return 0;
 
      case WM_MDISETMENU:
          return MDISetMenu( hwnd, (HMENU)wParam, (HMENU)lParam );
 
      case WM_MDIREFRESHMENU:
          return MDI_RefreshMenu( ci );
 
      case WM_MDITILE:
    ci->mdiFlags |= MDIF_NEEDUPDATE;
        ShowScrollBar( hwnd, SB_BOTH, FALSE );
        MDITile( hwnd, ci, wParam );
        ci->mdiFlags &= ~MDIF_NEEDUPDATE;
        return 0;
 
      case WM_VSCROLL:
      case WM_HSCROLL:
    ci->mdiFlags |= MDIF_NEEDUPDATE;
        ScrollChildren( hwnd, message, wParam, lParam );
    ci->mdiFlags &= ~MDIF_NEEDUPDATE;
        return 0;
 
      case WM_SETFOCUS:
          if (ci->hwndActiveChild && !IsIconic( ci->hwndActiveChild ))
              SetFocus( ci->hwndActiveChild );
          return 0;
 
      case WM_NCACTIVATE:
        if( ci->hwndActiveChild )
            SendMessageW(ci->hwndActiveChild, message, wParam, lParam);
    break;
 
      case WM_PARENTNOTIFY:
        switch (LOWORD(wParam))
        {
        case WM_CREATE:
            if (GetWindowLongPtrW((HWND)lParam, GWL_EXSTYLE) & WS_EX_MDICHILD)
            {
                // ReactOS See rev 33503
                if (!ci->child)
                    ci->child = HeapAlloc(GetProcessHeap(), 0, sizeof(HWND));
                else
                    ci->child = HeapReAlloc(GetProcessHeap(), 0, ci->child, sizeof(HWND) * (ci->nActiveChildren + 1));
 
                TRACE("Adding MDI child %p, # of children %d\n",
                      (HWND)lParam, ci->nActiveChildren);
 
                if (ci->child != NULL)
                {
                    ci->child[ci->nActiveChildren] = (HWND)lParam;
                    ci->nTotalCreated++;
                    ci->nActiveChildren++;
                }
            }
            break;
 
        case WM_LBUTTONDOWN:
            {
            HWND child;
            POINT pt;
            pt.x = (short)LOWORD(lParam);
            pt.y = (short)HIWORD(lParam);
            child = ChildWindowFromPoint(hwnd, pt);
 
        TRACE("notification from %p (%li,%li)\n",child,pt.x,pt.y);
 
            if( child && child != hwnd && child != ci->hwndActiveChild )
                SetWindowPos(child, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
            break;
            }
 
        case WM_DESTROY:
            return MDIDestroyChild( hwnd, ci, WIN_GetFullHandle( (HWND)lParam ), FALSE );
        }
        return 0;
 
      case WM_SIZE:
        if( ci->hwndActiveChild && IsZoomed(ci->hwndActiveChild) )
    {
        RECT    rect;
 
        SetRect(&rect, 0, 0, LOWORD(lParam), HIWORD(lParam));
        AdjustWindowRectEx(&rect, GetWindowLongPtrA(ci->hwndActiveChild, GWL_STYLE),
                               0, GetWindowLongPtrA(ci->hwndActiveChild, GWL_EXSTYLE) );
        MoveWindow(ci->hwndActiveChild, rect.left, rect.top,
             rect.right - rect.left, rect.bottom - rect.top, 1);
    }
    else
            MDI_PostUpdate(hwnd, ci, SB_BOTH+1);
 
    break;
 
      case WM_MDICALCCHILDSCROLL:
    if( (ci->mdiFlags & MDIF_NEEDUPDATE) && ci->sbRecalc )
    {
            CalcChildScroll(hwnd, ci->sbRecalc-1);
        ci->sbRecalc = 0;
        ci->mdiFlags &= ~MDIF_NEEDUPDATE;
    }
        return 0;
    }
    return unicode ? DefWindowProcW( hwnd, message, wParam, lParam ) :
                     DefWindowProcA( hwnd, message, wParam, lParam );

Referenced by MDIClientWndProcA(), MDIClientWndProcW(), and RegisterClientPFN().

MDIClientWndProcA()

LRESULT WINAPI MDIClientWndProcA	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1351 of file mdi.c.

{
    if (!IsWindow(hwnd)) return 0;
    return MDIClientWndProc_common( hwnd, message, wParam, lParam, FALSE );

Referenced by RegisterClientPFN().

MDIClientWndProcW()

LRESULT WINAPI MDIClientWndProcW	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1360 of file mdi.c.

{
    if (!IsWindow(hwnd)) return 0;
    return MDIClientWndProc_common( hwnd, message, wParam, lParam, TRUE );

Referenced by RegisterClientPFN().

PopupMenuWndProcA()

LRESULT WINAPI PopupMenuWndProcA	(	HWND	hWnd,
		UINT	Message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 368 of file menu.c.

{
  PWND pWnd;
 
  pWnd = ValidateHwnd(Wnd);
  if (pWnd && !pWnd->fnid && Message != WM_NCCREATE)
  {
     return DefWindowProcA(Wnd, Message, wParam, lParam);
  }    
  TRACE("YES! hwnd=%x msg=0x%04x wp=0x%04lx lp=0x%08lx\n", Wnd, Message, wParam, lParam);
 
  switch(Message)
    {
    case WM_NCCREATE:
    case WM_CREATE:
    case WM_MOUSEACTIVATE:
    case WM_PAINT:
    case WM_PRINTCLIENT:
    case WM_ERASEBKGND:
    case WM_DESTROY:
    case WM_NCDESTROY:
    case WM_SHOWWINDOW:
    case MM_SETMENUHANDLE:
    case MM_GETMENUHANDLE:
    case MN_SETHMENU:
    case MN_GETHMENU: 
      return PopupMenuWndProcW(Wnd, Message, wParam, lParam);
 
    default:
      return DefWindowProcA(Wnd, Message, wParam, lParam);
    }
  return 0;
}

Referenced by MenuWindowProcA(), and RegisterClientPFN().

PopupMenuWndProcW()

LRESULT WINAPI PopupMenuWndProcW	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 297 of file menu.c.

{
  LRESULT lResult;
  PWND pWnd;
 
  TRACE("PMWPW : hwnd=%x msg=0x%04x wp=0x%04lx lp=0x%08lx\n", Wnd, Message, wParam, lParam);
 
  pWnd = ValidateHwnd(Wnd);
  if (pWnd)
  {
     if (!pWnd->fnid)
     {
        if (Message != WM_NCCREATE)
        {
           return DefWindowProcW(Wnd, Message, wParam, lParam);
        }
     }
     else
     {
        if (pWnd->fnid != FNID_MENU)
        {
           ERR("Wrong window class for Menu!\n");
           return 0;
        }
     }
  }
 
  switch(Message)
    {
    case WM_DESTROY:
    case WM_NCDESTROY:
    case WM_NCCREATE:
    case WM_CREATE:
    case MM_SETMENUHANDLE:
    case MM_GETMENUHANDLE:
    case MN_SETHMENU:
    case MN_GETHMENU:
    case WM_PAINT:
    case WM_PRINTCLIENT:
      {
        TRACE("Menu Class ProcW\n");
        NtUserMessageCall( Wnd, Message, wParam, lParam, (ULONG_PTR)&lResult, FNID_MENU, FALSE);
        return lResult;
      }
    case WM_MOUSEACTIVATE:  /* We don't want to be activated */
      return MA_NOACTIVATE;
 
    case WM_ERASEBKGND:
      return 1;
 
    case WM_SHOWWINDOW: // Not sure what this does....
      if (0 != wParam)
        {
          if (0 == GetWindowLongPtrW(Wnd, 0))
            {
              OutputDebugStringA("no menu to display\n");
            }
        }
      else
        {
          //SetWindowLongPtrW(Wnd, 0, 0);
        }
      break;
 
    default:
      return DefWindowProcW(Wnd, Message, wParam, lParam);
    }
 
  return 0;
}

Referenced by MenuWindowProcW(), PopupMenuWndProcA(), and RegisterClientPFN().

RegisterClientPFN()

BOOL WINAPI RegisterClientPFN

(

VOID

)

Definition at line 143 of file regcontrol.c.

{
  NTSTATUS Status;
 
  pfnClientA.pfnScrollBarWndProc      = ScrollBarWndProcA;
  pfnClientW.pfnScrollBarWndProc      = ScrollBarWndProcW;
  pfnClientA.pfnTitleWndProc          = IconTitleWndProc;
  pfnClientW.pfnTitleWndProc          = IconTitleWndProc;
  pfnClientA.pfnMenuWndProc           = PopupMenuWndProcA;
  pfnClientW.pfnMenuWndProc           = PopupMenuWndProcW;
  pfnClientA.pfnDesktopWndProc        = DesktopWndProcA;
  pfnClientW.pfnDesktopWndProc        = DesktopWndProcW;
  pfnClientA.pfnDefWindowProc         = DefWindowProcA;
  pfnClientW.pfnDefWindowProc         = DefWindowProcW;
  pfnClientA.pfnMessageWindowProc     = MsgWindowProc;
  pfnClientW.pfnMessageWindowProc     = MsgWindowProc;
  pfnClientA.pfnSwitchWindowProc      = SwitchWndProcA;
  pfnClientW.pfnSwitchWindowProc      = SwitchWndProcW;
  pfnClientA.pfnButtonWndProc         = ButtonWndProcA;
  pfnClientW.pfnButtonWndProc         = ButtonWndProcW;
  pfnClientA.pfnComboBoxWndProc       = ComboWndProcA;
  pfnClientW.pfnComboBoxWndProc       = ComboWndProcW;
  pfnClientA.pfnComboListBoxProc      = ListBoxWndProcA;
  pfnClientW.pfnComboListBoxProc      = ListBoxWndProcW;
  pfnClientA.pfnDialogWndProc         = DefDlgProcA;
  pfnClientW.pfnDialogWndProc         = DefDlgProcW;
  pfnClientA.pfnEditWndProc           = EditWndProcA;
  pfnClientW.pfnEditWndProc           = EditWndProcW;
  pfnClientA.pfnListBoxWndProc        = ListBoxWndProcA;
  pfnClientW.pfnListBoxWndProc        = ListBoxWndProcW;
  pfnClientA.pfnMDIClientWndProc      = MDIClientWndProcA;
  pfnClientW.pfnMDIClientWndProc      = MDIClientWndProcW;
  pfnClientA.pfnStaticWndProc         = StaticWndProcA;
  pfnClientW.pfnStaticWndProc         = StaticWndProcW;
  pfnClientA.pfnImeWndProc            = ImeWndProcA;
  pfnClientW.pfnImeWndProc            = ImeWndProcW;
  pfnClientA.pfnGhostWndProc          = GhostWndProcA;
  pfnClientW.pfnGhostWndProc          = GhostWndProcW;
  pfnClientA.pfnHkINLPCWPSTRUCT       = DefWindowProcA;
  pfnClientW.pfnHkINLPCWPSTRUCT       = DefWindowProcW;
  pfnClientA.pfnHkINLPCWPRETSTRUCT    = DefWindowProcA;
  pfnClientW.pfnHkINLPCWPRETSTRUCT    = DefWindowProcW;
  pfnClientA.pfnDispatchHook          = DefWindowProcA;
  pfnClientW.pfnDispatchHook          = DefWindowProcW;
  pfnClientA.pfnDispatchDefWindowProc = DefWindowProcA;
  pfnClientW.pfnDispatchDefWindowProc = DefWindowProcW;
  pfnClientA.pfnDispatchMessage       = DefWindowProcA;
  pfnClientW.pfnDispatchMessage       = DefWindowProcW;
  pfnClientA.pfnMDIActivateDlgProc    = DefWindowProcA;
  pfnClientW.pfnMDIActivateDlgProc    = DefWindowProcW;
 
  pfnClientWorker.pfnButtonWndProc    = ButtonWndProc_common;
  pfnClientWorker.pfnComboBoxWndProc  = ComboWndProc_common;
  pfnClientWorker.pfnComboListBoxProc = ListBoxWndProc_common;
  pfnClientWorker.pfnDialogWndProc    = DialogWndProc_common;
  pfnClientWorker.pfnEditWndProc      = EditWndProc_common;
  pfnClientWorker.pfnListBoxWndProc   = ListBoxWndProc_common;
  pfnClientWorker.pfnMDIClientWndProc = MDIClientWndProc_common;
  pfnClientWorker.pfnStaticWndProc    = StaticWndProc_common;
  pfnClientWorker.pfnImeWndProc       = ImeWndProc_common;
  pfnClientWorker.pfnGhostWndProc     = GhostWndProc_common;
  pfnClientWorker.pfnCtfHookProc      = User32DefWindowProc;
 
  Status = NtUserInitializeClientPfnArrays( &pfnClientA,
                                            &pfnClientW,
                                            &pfnClientWorker,
                                            User32Instance);
  
  return NT_SUCCESS(Status) ? TRUE : FALSE;
}

Referenced by ClientThreadSetupHelper().

ScrollBarWndProcA()

LRESULT WINAPI ScrollBarWndProcA	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1466 of file scrollbar.c.

{
  return ScrollBarWndProc_common(DefWindowProcA, Wnd, Msg, wParam, lParam, FALSE);

Referenced by RegisterClientPFN().

ScrollBarWndProcW()

LRESULT WINAPI ScrollBarWndProcW	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1460 of file scrollbar.c.

{
  return ScrollBarWndProc_common(DefWindowProcW, Wnd, Msg, wParam, lParam, TRUE);

Referenced by RegisterClientPFN().

set_control_clipping()

HRGN set_control_clipping	(	HDC	hdc,
		const RECT *	rect
	)

Definition at line 239 of file button.c.

{
    RECT rc = *rect;
    HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
 
    if (GetClipRgn( hdc, hrgn ) != 1)
    {
        DeleteObject( hrgn );
        hrgn = 0;
    }
    DPtoLP( hdc, (POINT *)&rc, 2 );
    if (GetLayout( hdc ) & LAYOUT_RTL)  /* compensate for the shifting done by IntersectClipRect */
    {
        rc.left++;
        rc.right++;
    }
    IntersectClipRect( hdc, rc.left, rc.top, rc.right, rc.bottom );
    return hrgn;
}

Referenced by CB_Paint(), CBPaintText(), GB_Paint(), LISTBOX_PaintItem(), OB_Paint(), PB_Paint(), STATIC_TryPaintFcn(), STATIC_WindowProc(), and StaticWndProc_common().

StaticWndProc_common()

LRESULT WINAPI StaticWndProc_common	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL	unicode
	)

Definition at line 337 of file static.c.

{
    LRESULT lResult = 0;
    LONG full_style = GetWindowLongW( hwnd, GWL_STYLE );
    LONG style = full_style & SS_TYPEMASK;
#ifdef __REACTOS__
    PWND pWnd;
 
    pWnd = ValidateHwnd(hwnd);
    if (pWnd)
    {
       if (!pWnd->fnid)
       {
          NtUserSetWindowFNID(hwnd, FNID_STATIC);
       }
       else
       {
          if (pWnd->fnid != FNID_STATIC)
          {
             ERR("Wrong window class for Static! fnId 0x%x\n",pWnd->fnid);
             return 0;
          }
       }
    }
#endif
 
    if (!IsWindow( hwnd )) return 0;
 
    switch (uMsg)
    {
    case WM_CREATE:
        if (style < 0L || style > SS_TYPEMASK)
        {
            ERR("Unknown style 0x%02lx\n", style );
            return -1;
        }
        STATIC_update_uistate(hwnd, unicode); // ReactOS r30727
        STATIC_InitColours();
        break;
 
    case WM_NCDESTROY:
#ifdef __REACTOS__
        NtUserSetWindowFNID(hwnd, FNID_DESTROY);
#endif
        if (style == SS_ICON) {
/*
 * FIXME
 *           DestroyIcon32( STATIC_SetIcon( wndPtr, 0 ) );
 *
 * We don't want to do this yet because DestroyIcon32 is broken. If the icon
 * had already been loaded by the application the last thing we want to do is
 * GlobalFree16 the handle.
 */
            break;
        }
        else return unicode ? DefWindowProcW(hwnd, uMsg, wParam, lParam) :
                              DefWindowProcA(hwnd, uMsg, wParam, lParam);
 
    case WM_ERASEBKGND:
        /* do all painting in WM_PAINT like Windows does */
        return 1;
 
    case WM_PRINTCLIENT:
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            RECT rect;
            HDC hdc = wParam ? (HDC)wParam : BeginPaint(hwnd, &ps);
            GetClientRect( hwnd, &rect );
            if (staticPaintFunc[style])
            {
                HRGN hrgn = set_control_clipping( hdc, &rect );
                (staticPaintFunc[style])( hwnd, hdc, full_style );
                SelectClipRgn( hdc, hrgn );
                if (hrgn) DeleteObject( hrgn );
            }
            if (!wParam) EndPaint(hwnd, &ps);
        }
        break;
 
    case WM_ENABLE:
        STATIC_TryPaintFcn( hwnd, full_style );
        if (full_style & SS_NOTIFY) {
            if (wParam) {
                SendMessageW( GetParent(hwnd), WM_COMMAND,
                              MAKEWPARAM( GetWindowLongPtrW(hwnd,GWLP_ID), STN_ENABLE ), (LPARAM)hwnd);
            }
            else {
                SendMessageW( GetParent(hwnd), WM_COMMAND,
                              MAKEWPARAM( GetWindowLongPtrW(hwnd,GWLP_ID), STN_DISABLE ), (LPARAM)hwnd);
            }
        }
        break;
 
    case WM_SYSCOLORCHANGE:
        STATIC_InitColours();
        STATIC_TryPaintFcn( hwnd, full_style );
        break;
 
    case WM_NCCREATE:
        {
            CREATESTRUCTW *cs = (CREATESTRUCTW *)lParam;
 
            if (full_style & SS_SUNKEN)
                SetWindowLongW( hwnd, GWL_EXSTYLE,
                                GetWindowLongW( hwnd, GWL_EXSTYLE ) | WS_EX_STATICEDGE );
 
            switch (style) {
            case SS_ICON:
                {
                    HICON hIcon;
                    if (unicode || IS_INTRESOURCE(cs->lpszName))
                       hIcon = STATIC_LoadIconW(cs->hInstance, cs->lpszName, full_style);
                    else
                       hIcon = STATIC_LoadIconA(cs->hInstance, (LPCSTR)cs->lpszName, full_style);
                    STATIC_SetIcon(hwnd, hIcon, full_style);
                }
                break;
            case SS_BITMAP:
                if ((ULONG_PTR)cs->hInstance >> 16)
                {
                    HBITMAP hBitmap;
                    if (unicode || IS_INTRESOURCE(cs->lpszName))
                        hBitmap = LoadBitmapW(cs->hInstance, cs->lpszName);
                    else
                        hBitmap = LoadBitmapA(cs->hInstance, (LPCSTR)cs->lpszName);
                    STATIC_SetBitmap(hwnd, hBitmap, full_style);
                }
                break;
            }
            /* SS_ENHMETAFILE: Despite what MSDN says, Windows does not load
               the enhanced metafile that was specified as the window text. */
        }
        return unicode ? DefWindowProcW(hwnd, uMsg, wParam, lParam) :
                         DefWindowProcA(hwnd, uMsg, wParam, lParam);
 
    case WM_SETTEXT:
        if (hasTextStyle( full_style ))
        {
            if (unicode)
                lResult = DefWindowProcW( hwnd, uMsg, wParam, lParam );
            else
                lResult = DefWindowProcA( hwnd, uMsg, wParam, lParam );
            STATIC_TryPaintFcn( hwnd, full_style );
        }
        break;
 
    case WM_SETFONT:
        if (hasTextStyle( full_style ))
        {
            SetWindowLongPtrW( hwnd, HFONT_GWL_OFFSET, wParam );
            if (LOWORD(lParam))
                RedrawWindow( hwnd, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_ALLCHILDREN );
        }
        break;
 
    case WM_GETFONT:
        return GetWindowLongPtrW( hwnd, HFONT_GWL_OFFSET );
 
    case WM_NCHITTEST:
        if (full_style & SS_NOTIFY)
           return HTCLIENT;
        else
           return HTTRANSPARENT;
 
    case WM_GETDLGCODE:
        return DLGC_STATIC;
 
    case WM_LBUTTONDOWN:
    case WM_NCLBUTTONDOWN:
        if (full_style & SS_NOTIFY)
            SendMessageW( GetParent(hwnd), WM_COMMAND,
                          MAKEWPARAM( GetWindowLongPtrW(hwnd,GWLP_ID), STN_CLICKED ), (LPARAM)hwnd);
        return 0;
 
    case WM_LBUTTONDBLCLK:
    case WM_NCLBUTTONDBLCLK:
        if (full_style & SS_NOTIFY)
            SendMessageW( GetParent(hwnd), WM_COMMAND,
                          MAKEWPARAM( GetWindowLongPtrW(hwnd,GWLP_ID), STN_DBLCLK ), (LPARAM)hwnd);
        return 0;
 
    case STM_GETIMAGE:
        return (LRESULT)STATIC_GetImage( hwnd, wParam, full_style );
 
    case STM_GETICON:
        return (LRESULT)STATIC_GetImage( hwnd, IMAGE_ICON, full_style );
 
    case STM_SETIMAGE:
        switch(wParam) {
    case IMAGE_BITMAP:
        if (style != SS_BITMAP) return 0; // ReactOS r43158
        lResult = (LRESULT)STATIC_SetBitmap( hwnd, (HBITMAP)lParam, full_style );
        break;
    case IMAGE_ENHMETAFILE:
        if (style != SS_ENHMETAFILE) return 0; // ReactOS r43158
        lResult = (LRESULT)STATIC_SetEnhMetaFile( hwnd, (HENHMETAFILE)lParam, full_style );
        break;
    case IMAGE_ICON:
    case IMAGE_CURSOR:
        if (style != SS_ICON) return 0; // ReactOS r43158
        lResult = (LRESULT)STATIC_SetIcon( hwnd, (HICON)lParam, full_style );
        break;
    default:
        FIXME("STM_SETIMAGE: Unhandled type %lx\n", wParam);
        break;
    }
        STATIC_TryPaintFcn( hwnd, full_style );
    break;
 
    case STM_SETICON:
        lResult = (LRESULT)STATIC_SetIcon( hwnd, (HICON)wParam, full_style );
        STATIC_TryPaintFcn( hwnd, full_style );
        break;
 
#ifdef __REACTOS__
    case WM_UPDATEUISTATE:
        if (unicode)
            DefWindowProcW(hwnd, uMsg, wParam, lParam);
        else
            DefWindowProcA(hwnd, uMsg, wParam, lParam);
 
        if (STATIC_update_uistate(hwnd, unicode) && hasTextStyle( full_style ))
        {
            RedrawWindow( hwnd, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_ALLCHILDREN );
        }
        break;
#endif
 
    default:
        return unicode ? DefWindowProcW(hwnd, uMsg, wParam, lParam) :
                         DefWindowProcA(hwnd, uMsg, wParam, lParam);
    }
    return lResult;
}

Referenced by RegisterClientPFN(), StaticWndProcA(), and StaticWndProcW().

StaticWndProcA()

LRESULT WINAPI StaticWndProcA	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 576 of file static.c.

{
    if (!IsWindow( hWnd )) return 0;
    return StaticWndProc_common(hWnd, uMsg, wParam, lParam, FALSE);
}

Referenced by RegisterClientPFN().

StaticWndProcW()

LRESULT WINAPI StaticWndProcW	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 585 of file static.c.

{
    if (!IsWindow( hWnd )) return 0;
    return StaticWndProc_common(hWnd, uMsg, wParam, lParam, TRUE);
}

Referenced by RegisterClientPFN().

SwitchWndProcA()

LRESULT WINAPI SwitchWndProcA	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 820 of file appswitch.c.

{
   return SwitchWndProc_common(hWnd, uMsg, wParam, lParam, FALSE);
}

Referenced by RegisterClientPFN().

SwitchWndProcW()

LRESULT WINAPI SwitchWndProcW	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 825 of file appswitch.c.

{
   return SwitchWndProc_common(hWnd, uMsg, wParam, lParam, TRUE);
}

Referenced by RegisterClientPFN().

User32DefWindowProc()

LRESULT WINAPI User32DefWindowProc	(	HWND	hWnd,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL	bUnicode
	)

Definition at line 317 of file defwnd.c.

{
    PWND pWnd = NULL;
    if (hWnd)
    {
       pWnd = ValidateHwnd(hWnd);
       if (!pWnd) return 0;
    }
 
    switch (Msg)
    {
        case WM_DEVICECHANGE:
            return TRUE;
 
        case WM_POPUPSYSTEMMENU:
        {
            /* This is an undocumented message used by the windows taskbar to
               display the system menu of windows that belong to other processes. */
            HMENU menu = GetSystemMenu(hWnd, FALSE);
            ERR("WM_POPUPSYSTEMMENU\n");
            if (menu)
            {
                SetForegroundWindow(hWnd);
                TrackPopupMenu(menu, TPM_LEFTBUTTON|TPM_RIGHTBUTTON|TPM_SYSTEM_MENU,
                               LOWORD(lParam), HIWORD(lParam), 0, hWnd, NULL);
            }
            return 0;
        }
 
        case WM_RBUTTONUP:
        {
            POINT Pt;
            Pt.x = GET_X_LPARAM(lParam);
            Pt.y = GET_Y_LPARAM(lParam);
            ClientToScreen(hWnd, &Pt);
            lParam = MAKELPARAM(Pt.x, Pt.y);
            if (bUnicode)
            {
                SendMessageW(hWnd, WM_CONTEXTMENU, (WPARAM)hWnd, lParam);
            }
            else
            {
                SendMessageA(hWnd, WM_CONTEXTMENU, (WPARAM)hWnd, lParam);
            }
            break;
        }
 
        case WM_NCRBUTTONUP:
          /*
           * FIXME : we must NOT send WM_CONTEXTMENU on a WM_NCRBUTTONUP (checked
           * in Windows), but what _should_ we do? According to MSDN :
           * "If it is appropriate to do so, the system sends the WM_SYSCOMMAND
           * message to the window". When is it appropriate?
           */
           ERR("WM_NCRBUTTONUP\n");
            break;
 
        case WM_XBUTTONUP:
        case WM_NCXBUTTONUP:
            if (HIWORD(wParam) == XBUTTON1 || HIWORD(wParam) == XBUTTON2)
            {
               SendMessageW(hWnd, WM_APPCOMMAND, (WPARAM)hWnd,
                         MAKELPARAM(LOWORD(wParam), FAPPCOMMAND_MOUSE | HIWORD(wParam)));
            }
            break;
 
        case WM_CONTEXTMENU:
        {
            if (GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_CHILD)
            {
                if (bUnicode)
                {
                    SendMessageW(GetParent(hWnd), Msg, (WPARAM)hWnd, lParam);
                }
                else
                {
                    SendMessageA(GetParent(hWnd), Msg, (WPARAM)hWnd, lParam);
                }
            }
            else
            {
               goto GoSS;
            }
            break;
        }
 
        case WM_CLOSE:
            DestroyWindow(hWnd);
            return (0);
 
        case WM_MOUSEACTIVATE:
            if (GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_CHILD)
            {
                LONG Ret = SendMessageW(GetParent(hWnd), WM_MOUSEACTIVATE, wParam, lParam);
                if (Ret) return (Ret);
            }
            return ( (HIWORD(lParam) == WM_LBUTTONDOWN && LOWORD(lParam) == HTCAPTION) ? MA_NOACTIVATE : MA_ACTIVATE );
 
        case WM_ACTIVATE:
            /* The default action in Windows is to set the keyboard focus to
             * the window, if it's being activated and not minimized */
            if (LOWORD(wParam) != WA_INACTIVE &&
                !(GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_MINIMIZE))
            {
                //ERR("WM_ACTIVATE %p\n",hWnd);
                SetFocus(hWnd);
            }
            break;
 
        case WM_MOUSEWHEEL:
            if (GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_CHILD)
                return SendMessageW( GetParent(hWnd), WM_MOUSEWHEEL, wParam, lParam);
            break;
 
        case WM_ERASEBKGND:
        case WM_ICONERASEBKGND:
        {
            RECT Rect;
            HBRUSH hBrush = (HBRUSH)GetClassLongPtrW(hWnd, GCL_HBRBACKGROUND);
 
            if (NULL == hBrush)
            {
                return 0;
            }
            if (GetClassLongPtrW(hWnd, GCL_STYLE) & CS_PARENTDC)
            {
                /* can't use GetClipBox with a parent DC or we fill the whole parent */
                GetClientRect(hWnd, &Rect);
                DPtoLP((HDC)wParam, (LPPOINT)&Rect, 2);
            }
            else
            {
                GetClipBox((HDC)wParam, &Rect);
            }
            FillRect((HDC)wParam, &Rect, hBrush);
            return (1);
        }
 
        case WM_CTLCOLORMSGBOX:
        case WM_CTLCOLOREDIT:
        case WM_CTLCOLORLISTBOX:
        case WM_CTLCOLORBTN:
        case WM_CTLCOLORDLG:
        case WM_CTLCOLORSTATIC:
        case WM_CTLCOLORSCROLLBAR:
            return (LRESULT) DefWndControlColor((HDC)wParam, Msg - WM_CTLCOLORMSGBOX);
 
        case WM_CTLCOLOR:
            return (LRESULT) DefWndControlColor((HDC)wParam, HIWORD(lParam));
 
        case WM_SYSCOMMAND:
            return (DefWndHandleSysCommand(hWnd, wParam, lParam));
 
        case WM_VKEYTOITEM:
        case WM_CHARTOITEM:
            return (-1);
/*
        case WM_DROPOBJECT:
            return DRAG_FILE;
*/
        case WM_QUERYDROPOBJECT:
        {
            if (GetWindowLongPtrW(hWnd, GWL_EXSTYLE) & WS_EX_ACCEPTFILES)
            {
                return(1);
            }
            break;
        }
 
        case WM_QUERYDRAGICON:
        {
            UINT Len;
            HICON hIcon;
 
            hIcon = (HICON)GetClassLongPtrW(hWnd, GCL_HICON);
            if (hIcon)
            {
                return ((LRESULT)hIcon);
            }
            for (Len = 1; Len < 64; Len++)
            {
                if ((hIcon = LoadIconW(NULL, MAKEINTRESOURCEW(Len))) != NULL)
                {
                    return((LRESULT)hIcon);
                }
            }
            return ((LRESULT)LoadIconW(0, IDI_APPLICATION));
        }
 
        case WM_ISACTIVEICON:
        {
           BOOL isai;
           isai = (pWnd->state & WNDS_ACTIVEFRAME) != 0;
           return isai;
        }
 
        case WM_NOTIFYFORMAT:
        {
            if (lParam == NF_QUERY)
                return IsWindowUnicode(hWnd) ? NFR_UNICODE : NFR_ANSI;
            break;
        }
 
        case WM_GETICON:
        {
           return DefWndGetIcon(pWnd, wParam, lParam);
        }
 
        case WM_HELP:
        {
            if (bUnicode)
            {
                SendMessageW(GetParent(hWnd), Msg, wParam, lParam);
            }
            else
            {
                SendMessageA(GetParent(hWnd), Msg, wParam, lParam);
            }
            break;
        }
 
        case WM_QUERYOPEN:
        case WM_QUERYENDSESSION:
        {
            return (1);
        }
 
        case WM_INPUTLANGCHANGEREQUEST:
        {
            HKL hNewKL;
            HWND hwndFocus;
 
            if ((wParam & INPUTLANGCHANGE_BACKWARD) && (wParam & INPUTLANGCHANGE_FORWARD))
                return FALSE;
 
            hwndFocus = GetFocus();
            if (hwndFocus && hwndFocus != hWnd &&
                GetClassLongPtrW(hWnd, GCW_ATOM) != (ULONG_PTR)WC_DIALOG)
            {
                return SendMessageW(hwndFocus, Msg, wParam, lParam);
            }
 
            if (wParam & INPUTLANGCHANGE_FORWARD)
                hNewKL = (HKL)UlongToHandle(HKL_NEXT);
            else if (wParam & INPUTLANGCHANGE_BACKWARD)
                hNewKL = (HKL)UlongToHandle(HKL_PREV);
            else
                hNewKL = (HKL)lParam;
 
            NtUserActivateKeyboardLayout(hNewKL, KLF_SETFORPROCESS);
            return TRUE;
        }
 
        case WM_INPUTLANGCHANGE:
        {
            int count = 0;
            HWND *win_array = WIN_ListChildren( hWnd );
 
            if (!win_array)
                break;
            while (win_array[count])
                SendMessageW( win_array[count++], WM_INPUTLANGCHANGE, wParam, lParam);
            HeapFree(GetProcessHeap(),0,win_array);
            break;
        }
 
        case WM_QUERYUISTATE:
        {
            LRESULT Ret = 0;
            PWND Wnd = ValidateHwnd(hWnd);
            if (Wnd != NULL)
            {
                if (Wnd->HideFocus)
                    Ret |= UISF_HIDEFOCUS;
                if (Wnd->HideAccel)
                    Ret |= UISF_HIDEACCEL;
            }
            return Ret;
        }
 
        case WM_CHANGEUISTATE:
        {
            BOOL AlwaysShowCues = FALSE;
            WORD Action = LOWORD(wParam);
            WORD Flags = HIWORD(wParam);
            PWND Wnd;
 
            SystemParametersInfoW(SPI_GETKEYBOARDCUES, 0, &AlwaysShowCues, 0);
            if (AlwaysShowCues)
                break;
 
            Wnd= ValidateHwnd(hWnd);
            if (!Wnd || lParam != 0)
                break;
 
            if (Flags & ~(UISF_HIDEFOCUS | UISF_HIDEACCEL | UISF_ACTIVE))
                break;
 
            if (Flags & UISF_ACTIVE)
            {
                WARN("WM_CHANGEUISTATE does not yet support UISF_ACTIVE!\n");
            }
 
            if (Action == UIS_INITIALIZE)
            {
                PDESKTOPINFO Desk = GetThreadDesktopInfo();
                if (Desk == NULL)
                    break;
 
                Action = Desk->LastInputWasKbd ? UIS_CLEAR : UIS_SET;
                Flags = UISF_HIDEFOCUS | UISF_HIDEACCEL;
 
                /* We need to update wParam in case we need to send out messages */
                wParam = MAKEWPARAM(Action, Flags);
            }
 
            switch (Action)
            {
                case UIS_SET:
                    /* See if we actually need to change something */
                    if ((Flags & UISF_HIDEFOCUS) && !Wnd->HideFocus)
                        break;
                    if ((Flags & UISF_HIDEACCEL) && !Wnd->HideAccel)
                        break;
 
                    /* Don't need to do anything... */
                    return 0;
 
                case UIS_CLEAR:
                    /* See if we actually need to change something */
                    if ((Flags & UISF_HIDEFOCUS) && Wnd->HideFocus)
                        break;
                    if ((Flags & UISF_HIDEACCEL) && Wnd->HideAccel)
                        break;
 
                    /* Don't need to do anything... */
                    return 0;
 
                default:
                    WARN("WM_CHANGEUISTATE: Unsupported Action 0x%x\n", Action);
                    break;
            }
 
            if ((Wnd->style & WS_CHILD) && Wnd->spwndParent != NULL)
            {
                /* We're a child window and we need to pass this message down until
                   we reach the root */
                hWnd = UserHMGetHandle((PWND)DesktopPtrToUser(Wnd->spwndParent));
            }
            else
            {
                /* We're a top level window, we need to change the UI state */
                Msg = WM_UPDATEUISTATE;
            }
 
            if (bUnicode)
                return SendMessageW(hWnd, Msg, wParam, lParam);
            else
                return SendMessageA(hWnd, Msg, wParam, lParam);
        }
 
        case WM_UPDATEUISTATE:
        {
            BOOL Change = TRUE;
            BOOL AlwaysShowCues = FALSE;
            WORD Action = LOWORD(wParam);
            WORD Flags = HIWORD(wParam);
            PWND Wnd;
 
            SystemParametersInfoW(SPI_GETKEYBOARDCUES, 0, &AlwaysShowCues, 0);
            if (AlwaysShowCues)
                break;
 
            Wnd = ValidateHwnd(hWnd);
            if (!Wnd || lParam != 0)
                break;
 
            if (Flags & ~(UISF_HIDEFOCUS | UISF_HIDEACCEL | UISF_ACTIVE))
                break;
 
            if (Flags & UISF_ACTIVE)
            {
                WARN("WM_UPDATEUISTATE does not yet support UISF_ACTIVE!\n");
            }
 
            if (Action == UIS_INITIALIZE)
            {
                PDESKTOPINFO Desk = GetThreadDesktopInfo();
                if (Desk == NULL)
                    break;
 
                Action = Desk->LastInputWasKbd ? UIS_CLEAR : UIS_SET;
                Flags = UISF_HIDEFOCUS | UISF_HIDEACCEL;
 
                /* We need to update wParam for broadcasting the update */
                wParam = MAKEWPARAM(Action, Flags);
            }
 
            switch (Action)
            {
                case UIS_SET:
                    /* See if we actually need to change something */
                    if ((Flags & UISF_HIDEFOCUS) && !Wnd->HideFocus)
                        break;
                    if ((Flags & UISF_HIDEACCEL) && !Wnd->HideAccel)
                        break;
 
                    /* Don't need to do anything... */
                    Change = FALSE;
                    break;
 
                case UIS_CLEAR:
                    /* See if we actually need to change something */
                    if ((Flags & UISF_HIDEFOCUS) && Wnd->HideFocus)
                        break;
                    if ((Flags & UISF_HIDEACCEL) && Wnd->HideAccel)
                        break;
 
                    /* Don't need to do anything... */
                    Change = FALSE;
                    break;
 
                default:
                    WARN("WM_UPDATEUISTATE: Unsupported Action 0x%x\n", Action);
                    return 0;
            }
 
            /* Pack the information and call win32k */
            if (Change)
            {
                if (!NtUserxUpdateUiState(hWnd, Flags | ((DWORD)Action << 3)))
                    break;
            }
 
            /* Always broadcast the update to all children */
            EnumChildWindows(hWnd,
                             UserSendUiUpdateMsg,
                             (LPARAM)wParam);
 
            break;
        }
 
        case WM_COPYGLOBALDATA:
        {
            TRACE("WM_COPYGLOBALDATA hGlobal %p Size %d Flags 0x%x\n",lParam,wParam,GlobalFlags((HGLOBAL)lParam));
            return lParam;
        }
 
/* Move to Win32k !*/
        case WM_SHOWWINDOW:
            if (!lParam) break; // Call when it is necessary.
        case WM_LBUTTONDOWN:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONDOWN:
        case WM_NCLBUTTONDOWN:
        case WM_NCRBUTTONDOWN:
        case WM_LBUTTONDBLCLK:
        case WM_NCLBUTTONDBLCLK:
        case WM_KEYF1:
        case WM_KEYUP:
        case WM_SYSKEYUP:
        case WM_KEYDOWN:
        case WM_SYSKEYDOWN:
        case WM_SYSCHAR:
        case WM_CANCELMODE:
        case WM_PAINTICON:
        case WM_PAINT:
        case WM_PRINT:
        case WM_SETICON:
        case WM_SYSCOLORCHANGE:
        case WM_NCUAHDRAWCAPTION:
        case WM_NCUAHDRAWFRAME:
        case WM_NCPAINT:
        case WM_NCACTIVATE:
        case WM_NCCALCSIZE:
        case WM_NCHITTEST:
        case WM_SYNCPAINT:
        case WM_SETREDRAW:
        case WM_CLIENTSHUTDOWN:
        case WM_GETHOTKEY:
        case WM_SETHOTKEY:
        case WM_WINDOWPOSCHANGING:
        case WM_WINDOWPOSCHANGED:
        case WM_APPCOMMAND:
        case WM_SETCURSOR:
GoSS:
        {
            LRESULT lResult;
            NtUserMessageCall( hWnd, Msg, wParam, lParam, (ULONG_PTR)&lResult, FNID_DEFWINDOWPROC, !bUnicode);
            return lResult;
        }
    }
    return 0;
}

Referenced by RealDefWindowProcA(), RealDefWindowProcW(), and RegisterClientPFN().