defwnd.c File Reference

#include <win32k.h>
#include <windowsx.h>

Include dependency graph for defwnd.c:

Go to the source code of this file.

Macros
#define	ID_NEXTLAYOUT   10003

Functions
	DBG_DEFAULT_CHANNEL (UserDefwnd)
INT WINAPI	DrawTextExWorker (HDC hdc, LPWSTR str, INT i_count, LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp)
INT WINAPI	DrawTextW (HDC hdc, LPCWSTR str, INT count, LPRECT rect, UINT flags)
HBRUSH FASTCALL	DefWndControlColor (HDC hDC, UINT ctlType)
LRESULT FASTCALL	DefWndHandleWindowPosChanging (PWND pWnd, WINDOWPOS *Pos)
LRESULT FASTCALL	DefWndHandleWindowPosChanged (PWND pWnd, WINDOWPOS *Pos)
LRESULT FASTCALL	DefWndHandleSysCommand (PWND pWnd, WPARAM wParam, LPARAM lParam)
PWND FASTCALL	co_IntFindChildWindowToOwner (PWND Root, PWND Owner)
LRESULT	DefWndHandleSetCursor (PWND pWnd, WPARAM wParam, LPARAM lParam)
VOID FASTCALL	DefWndPrint (PWND pwnd, HDC hdc, ULONG uFlags)
BOOL	UserPaintCaption (PWND pWnd, INT Flags)
LRESULT FASTCALL	DefWndSetIcon (PWND pWnd, WPARAM wParam, LPARAM lParam)
LRESULT FASTCALL	DefWndGetIcon (PWND pWnd, WPARAM wParam, LPARAM lParam)
VOID FASTCALL	DefWndScreenshot (PWND pWnd)
LRESULT FASTCALL	IntDefWindowProc (PWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL Ansi)

Macro Definition Documentation

ID_NEXTLAYOUT

#define ID_NEXTLAYOUT   10003

Function Documentation

co_IntFindChildWindowToOwner()

PWND FASTCALL co_IntFindChildWindowToOwner	(	PWND	Root,
		PWND	Owner
	)

Definition at line 217 of file defwnd.c.

{
   PWND Ret;
   PWND Child, OwnerWnd;
 
   for(Child = Root->spwndChild; Child; Child = Child->spwndNext)
   {
      OwnerWnd = Child->spwndOwner;
      if(!OwnerWnd)
         continue;
 
      if (!(Child->style & WS_POPUP) ||
          !(Child->style & WS_VISIBLE) ||
          /* Fixes CMD pop up properties window from having foreground. */
           Owner->head.pti->MessageQueue != Child->head.pti->MessageQueue)
         continue;
 
      if(OwnerWnd == Owner)
      {
         Ret = Child;
         return Ret;
      }
   }
   return NULL;
}

Referenced by DefWndHandleSetCursor().

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

UserDefwnd

)

DefWndControlColor()

HBRUSH FASTCALL DefWndControlColor	(	HDC	hDC,
		UINT	ctlType
	)

Definition at line 33 of file defwnd.c.

{
  if (ctlType == CTLCOLOR_SCROLLBAR)
  {
      HBRUSH hb = IntGetSysColorBrush(COLOR_SCROLLBAR);
      COLORREF bk = IntGetSysColor(COLOR_3DHILIGHT);
      IntGdiSetTextColor(hDC, IntGetSysColor(COLOR_3DFACE));
      IntGdiSetBkColor(hDC, bk);
 
      /* if COLOR_WINDOW happens to be the same as COLOR_3DHILIGHT
       * we better use 0x55aa bitmap brush to make scrollbar's background
       * look different from the window background.
       */
      if ( bk == IntGetSysColor(COLOR_WINDOW))
          return gpsi->hbrGray;
 
      NtGdiUnrealizeObject( hb );
      return hb;
  }
 
  IntGdiSetTextColor(hDC, IntGetSysColor(COLOR_WINDOWTEXT));
 
  if ((ctlType == CTLCOLOR_EDIT) || (ctlType == CTLCOLOR_LISTBOX))
  {
      IntGdiSetBkColor(hDC, IntGetSysColor(COLOR_WINDOW));
  }
  else
  {
      IntGdiSetBkColor(hDC, IntGetSysColor(COLOR_3DFACE));
      return IntGetSysColorBrush(COLOR_3DFACE);
  }
 
  return IntGetSysColorBrush(COLOR_WINDOW);
}

Referenced by IntDefWindowProc(), IntDrawScrollInterior(), and User32DefWindowProc().

DefWndGetIcon()

LRESULT FASTCALL DefWndGetIcon	(	PWND	pWnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 477 of file defwnd.c.

{
    HICON hIconRet;
    if ( wParam > ICON_SMALL2 )
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
    switch(wParam)
    {
        case ICON_BIG:
            hIconRet = UserGetProp(pWnd, gpsi->atomIconProp, TRUE);
            break;
        case ICON_SMALL:
        case ICON_SMALL2:
            hIconRet = UserGetProp(pWnd, gpsi->atomIconSmProp, TRUE);
            break;
        DEFAULT_UNREACHABLE;
    }
    return (LRESULT)hIconRet;
}

Referenced by IntDefWindowProc(), and User32DefWindowProc().

DefWndHandleSetCursor()

LRESULT DefWndHandleSetCursor	(	PWND	pWnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 244 of file defwnd.c.

{
   PWND pwndPopUP = NULL;
   WORD Msg = HIWORD(lParam);
 
   /* Not for child windows. */
   if (UserHMGetHandle(pWnd) != (HWND)wParam)
   {
      return FALSE;
   }
 
   switch((short)LOWORD(lParam))
   {
      case HTERROR:
      {
         USER_REFERENCE_ENTRY Ref;
 
         if (Msg == WM_LBUTTONDOWN)
         {
            // Find a pop up window to bring active.
            pwndPopUP = co_IntFindChildWindowToOwner(UserGetDesktopWindow(), pWnd);
            if (pwndPopUP)
            {
               // Not a child pop up from desktop.
               if ( pwndPopUP != UserGetDesktopWindow()->spwndChild )
               {
                  // Get original active window.
                  PWND pwndOrigActive = gpqForeground->spwndActive;
 
                  co_WinPosSetWindowPos(pWnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 
                  UserRefObjectCo(pwndPopUP, &Ref);
                  //UserSetActiveWindow(pwndPopUP);
                  co_IntSetForegroundWindow(pwndPopUP); // HACK
                  UserDerefObjectCo(pwndPopUP);
 
                  // If the change was made, break out.
                  if (pwndOrigActive != gpqForeground->spwndActive)
                     break;
               }
            }
         }
     if (Msg == WM_LBUTTONDOWN || Msg == WM_MBUTTONDOWN ||
         Msg == WM_RBUTTONDOWN || Msg == WM_XBUTTONDOWN)
     {
             if (pwndPopUP)
             {
                 FLASHWINFO fwi =
                    {sizeof(FLASHWINFO),
                     UserHMGetHandle(pwndPopUP),
                     FLASHW_ALL,
                     gspv.dwForegroundFlashCount,
                     (gpsi->dtCaretBlink >> 3)};
 
                 // Now shake that window!
                 IntFlashWindowEx(pwndPopUP, &fwi);
             }
         UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0);
     }
     break;
      }
 
      case HTCLIENT:
      {
         if (pWnd->pcls->spcur)
         {
            IntSystemSetCursor(pWnd->pcls->spcur);
     }
     return FALSE;
      }
 
      case HTLEFT:
      case HTRIGHT:
      {
         if (pWnd->style & WS_MAXIMIZE)
         {
            break;
         }
         IntSystemSetCursor(SYSTEMCUR(SIZEWE));
         return TRUE;
      }
 
      case HTTOP:
      case HTBOTTOM:
      {
         if (pWnd->style & WS_MAXIMIZE)
         {
            break;
         }
         IntSystemSetCursor(SYSTEMCUR(SIZENS));
         return TRUE;
       }
 
       case HTTOPLEFT:
       case HTBOTTOMRIGHT:
       {
         if (pWnd->style & WS_MAXIMIZE)
         {
            break;
         }
         IntSystemSetCursor(SYSTEMCUR(SIZENWSE));
         return TRUE;
       }
 
       case HTBOTTOMLEFT:
       case HTTOPRIGHT:
       {
         if (pWnd->style & WS_MAXIMIZE)
         {
            break;
         }
         IntSystemSetCursor(SYSTEMCUR(SIZENESW));
         return TRUE;
       }
   }
   IntSystemSetCursor(SYSTEMCUR(ARROW));
   return FALSE;
}

Referenced by IntDefWindowProc().

DefWndHandleSysCommand()

LRESULT FASTCALL DefWndHandleSysCommand	(	PWND	pWnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 126 of file defwnd.c.

{
   LRESULT lResult = 0;
   BOOL Hook = FALSE;
 
   if (ISITHOOKED(WH_CBT) || (pWnd->head.rpdesk->pDeskInfo->fsHooks & HOOKID_TO_FLAG(WH_CBT)))
   {
      Hook = TRUE;
      lResult = co_HOOK_CallHooks(WH_CBT, HCBT_SYSCOMMAND, wParam, lParam);
 
      if (lResult) return lResult;
   }
 
   switch (wParam & 0xfff0)
   {
      case SC_MOVE:
      case SC_SIZE:
        DefWndDoSizeMove(pWnd, wParam);
        break;
 
      case SC_MINIMIZE:
        if (UserHMGetHandle(pWnd) == UserGetActiveWindow())
            IntShowOwnedPopups(pWnd,FALSE); // This is done in ShowWindow! Need to retest!
        co_WinPosShowWindow( pWnd, SW_MINIMIZE );
        break;
 
      case SC_MAXIMIZE:
        if (((pWnd->style & WS_MINIMIZE) != 0) && UserHMGetHandle(pWnd) == UserGetActiveWindow())
            IntShowOwnedPopups(pWnd,TRUE);
        co_WinPosShowWindow( pWnd, SW_MAXIMIZE );
        break;
 
      case SC_RESTORE:
        if (((pWnd->style & WS_MINIMIZE) != 0) && UserHMGetHandle(pWnd) == UserGetActiveWindow())
            IntShowOwnedPopups(pWnd,TRUE);
        co_WinPosShowWindow( pWnd, SW_RESTORE );
        break;
 
      case SC_CLOSE:
        return co_IntSendMessage(UserHMGetHandle(pWnd), WM_CLOSE, 0, 0);
 
      case SC_SCREENSAVE:
        ERR("Screensaver Called!\n");
        UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_START_SCREENSAVE, 0); // always lParam 0 == not Secure
        break;
 
      case SC_HOTKEY:
        {
           USER_REFERENCE_ENTRY Ref;
 
           pWnd = ValidateHwndNoErr((HWND)lParam);
           if (pWnd)
           {
              if (pWnd->spwndLastActive)
              {
                 pWnd = pWnd->spwndLastActive;
              }
              UserRefObjectCo(pWnd, &Ref);
              co_IntSetForegroundWindow(pWnd);
              UserDerefObjectCo(pWnd);
              if (pWnd->style & WS_MINIMIZE)
              {
                 UserPostMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_RESTORE, 0);
              }
           }
        }
        break;
//      case SC_DEFAULT:
      case SC_MOUSEMENU:
        {
          POINT Pt;
          Pt.x = (short)LOWORD(lParam);
          Pt.y = (short)HIWORD(lParam);
          MENU_TrackMouseMenuBar(pWnd, wParam & 0x000f, Pt);
        }
    break;
 
      case SC_KEYMENU:
        MENU_TrackKbdMenuBar(pWnd, wParam, (WCHAR)lParam);
    break;
 
 
      default:
   // We do not support anything else here so we should return normal even when sending a hook.
        return 0;
   }
 
   return(Hook ? 1 : 0); // Don't call us again from user space.
}

Referenced by IntDefWindowProc(), and User32DefWindowProc().

DefWndHandleWindowPosChanged()

LRESULT FASTCALL DefWndHandleWindowPosChanged	(	PWND	pWnd,
		WINDOWPOS *	Pos
	)

Definition at line 96 of file defwnd.c.

{
   RECT Rect;
   LONG style = pWnd->style;
 
   IntGetClientRect(pWnd, &Rect);
   IntMapWindowPoints(pWnd, (style & WS_CHILD ? IntGetParent(pWnd) : NULL), (LPPOINT) &Rect, 2);
 
   if (!(Pos->flags & SWP_NOCLIENTMOVE))
   {
      co_IntSendMessage(UserHMGetHandle(pWnd), WM_MOVE, 0, MAKELONG(Rect.left, Rect.top));
   }
 
   if (!(Pos->flags & SWP_NOCLIENTSIZE) || (Pos->flags & SWP_STATECHANGED))
   {
      if (style & WS_MINIMIZE) co_IntSendMessage(UserHMGetHandle(pWnd), WM_SIZE, SIZE_MINIMIZED, 0 );
      else
      {
         WPARAM wp = (style & WS_MAXIMIZE) ? SIZE_MAXIMIZED : SIZE_RESTORED;
         co_IntSendMessage(UserHMGetHandle(pWnd), WM_SIZE, wp, MAKELONG(Rect.right - Rect.left, Rect.bottom - Rect.top));
      }
   }
   return 0;
}

Referenced by IntDefWindowProc().

DefWndHandleWindowPosChanging()

LRESULT FASTCALL DefWndHandleWindowPosChanging	(	PWND	pWnd,
		WINDOWPOS *	Pos
	)

Definition at line 69 of file defwnd.c.

{
    POINT maxTrack, minTrack;
    LONG style = pWnd->style;
 
    if (Pos->flags & SWP_NOSIZE) return 0;
    if ((style & WS_THICKFRAME) || ((style & (WS_POPUP | WS_CHILD)) == 0))
    {
        co_WinPosGetMinMaxInfo(pWnd, NULL, NULL, &minTrack, &maxTrack);
        Pos->cx = min(Pos->cx, maxTrack.x);
        Pos->cy = min(Pos->cy, maxTrack.y);
        if (!(style & WS_MINIMIZE))
        {
            if (Pos->cx < minTrack.x) Pos->cx = minTrack.x;
            if (Pos->cy < minTrack.y) Pos->cy = minTrack.y;
        }
    }
    else
    {
        Pos->cx = max(Pos->cx, 0);
        Pos->cy = max(Pos->cy, 0);
    }
    return 0;
}

Referenced by IntDefWindowProc().

DefWndPrint()

VOID FASTCALL DefWndPrint	(	PWND	pwnd,
		HDC	hdc,
		ULONG	uFlags
	)

Definition at line 366 of file defwnd.c.

{
  /*
   * Visibility flag.
   */
  if ( (uFlags & PRF_CHECKVISIBLE) &&
       !IntIsWindowVisible(pwnd) )
      return;
 
  /*
   * Unimplemented flags.
   */
  if ( (uFlags & PRF_CHILDREN) ||
       (uFlags & PRF_OWNED)    ||
       (uFlags & PRF_NONCLIENT) )
  {
    FIXME("WM_PRINT message with unsupported flags\n");
  }
 
  /*
   * Background
   */
  if ( uFlags & PRF_ERASEBKGND)
    co_IntSendMessage(UserHMGetHandle(pwnd), WM_ERASEBKGND, (WPARAM)hdc, 0);
 
  /*
   * Client area
   */
  if ( uFlags & PRF_CLIENT)
    co_IntSendMessage(UserHMGetHandle(pwnd), WM_PRINTCLIENT, (WPARAM)hdc, uFlags);
}

Referenced by IntDefWindowProc().

DefWndScreenshot()

VOID FASTCALL DefWndScreenshot

(

PWND

pWnd

)

Definition at line 500 of file defwnd.c.

{
    RECT rect;
    HDC hdc;
    INT w;
    INT h;
    HBITMAP hbitmap;
    HDC hdc2;
    SETCLIPBDATA scd = {FALSE, FALSE};
 
    UserOpenClipboard(UserHMGetHandle(pWnd));
    UserEmptyClipboard();
 
    hdc = UserGetWindowDC(pWnd);
    IntGetWindowRect(pWnd, &rect);
    w = rect.right - rect.left;
    h = rect.bottom - rect.top;
 
    hbitmap = NtGdiCreateCompatibleBitmap(hdc, w, h);
    hdc2 = NtGdiCreateCompatibleDC(hdc);
    NtGdiSelectBitmap(hdc2, hbitmap);
 
    NtGdiBitBlt(hdc2, 0, 0, w, h, hdc, 0, 0, SRCCOPY, 0, 0);
 
    UserSetClipboardData(CF_BITMAP, hbitmap, &scd);
 
    UserReleaseDC(pWnd, hdc, FALSE);
    UserReleaseDC(pWnd, hdc2, FALSE);
 
    UserCloseClipboard();
}

Referenced by IntDefWindowProc().

DefWndSetIcon()

LRESULT FASTCALL DefWndSetIcon	(	PWND	pWnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 438 of file defwnd.c.

{
    HICON hIcon, hIconSmall, hIconOld;
 
    if ( wParam > ICON_SMALL2 )
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
    hIconSmall = UserGetProp(pWnd, gpsi->atomIconSmProp, TRUE);
    hIcon      = UserGetProp(pWnd, gpsi->atomIconProp, TRUE);
 
    hIconOld = wParam == ICON_BIG ? hIcon : hIconSmall;
 
    switch(wParam)
    {
        case ICON_BIG:
            hIcon = (HICON)lParam;
            break;
        case ICON_SMALL:
            hIconSmall = (HICON)lParam;
            break;
        case ICON_SMALL2:
            ERR("FIXME: Set ICON_SMALL2 support!\n");
        default:
            break;
    }
 
    UserSetProp(pWnd, gpsi->atomIconProp, hIcon, TRUE);
    UserSetProp(pWnd, gpsi->atomIconSmProp, hIconSmall, TRUE);
 
    if ((pWnd->style & WS_CAPTION ) == WS_CAPTION)
       UserPaintCaption(pWnd, DC_ICON);
 
    return (LRESULT)hIconOld;
}

Referenced by IntDefWindowProc().

DrawTextExWorker()

INT WINAPI DrawTextExWorker	(	HDC	hdc,
		LPWSTR	str,
		INT	i_count,
		LPRECT	rect,
		UINT	flags,
		LPDRAWTEXTPARAMS	dtp
	)

Definition at line 1071 of file text.c.

{
    SIZE size;
    const WCHAR *strPtr;
    WCHAR *retstr, *p_retstr;
    size_t size_retstr;
    WCHAR line[MAX_BUFFER];
    int len, lh, count=i_count;
    TEXTMETRICW tm;
    int lmargin = 0, rmargin = 0;
    int x = rect->left, y = rect->top;
    int width = rect->right - rect->left;
    int max_width = 0;
    int last_line;
    int tabwidth /* to keep gcc happy */ = 0;
    int prefix_offset;
    ellipsis_data ellip;
    BOOL invert_y=FALSE;
 
    HRGN    hrgn = 0;
 
#ifdef _WIN32K_
    TRACE("%S, %d, %08x\n", str, count, flags);
#else
    TRACE("%s, %d, [%s] %08x\n", debugstr_wn (str, count), count,
        wine_dbgstr_rect(rect), flags);
#endif
    if (dtp) TRACE("Params: iTabLength=%d, iLeftMargin=%d, iRightMargin=%d\n",
          dtp->iTabLength, dtp->iLeftMargin, dtp->iRightMargin);
 
    if (!str) return 0;
 
    strPtr = str;
 
    if (flags & DT_SINGLELINE)
        flags &= ~DT_WORDBREAK;
#ifdef _WIN32K_
    GreGetTextMetricsW(hdc, &tm);
#else
    GetTextMetricsW(hdc, &tm);
#endif
    if (flags & DT_EXTERNALLEADING)
    lh = tm.tmHeight + tm.tmExternalLeading;
    else
    lh = tm.tmHeight;
 
    if (str[0] && count == 0)
        return lh;
 
    if (dtp && dtp->cbSize != sizeof(DRAWTEXTPARAMS))
        return 0;
#ifdef _WIN32K_
    if (GreGetGraphicsMode(hdc) == GM_COMPATIBLE)
    {
        SIZE window_ext, viewport_ext;
        GreGetWindowExtEx(hdc, &window_ext);
        GreGetViewportExtEx(hdc, &viewport_ext);
        if ((window_ext.cy > 0) != (viewport_ext.cy > 0))
            invert_y = TRUE;
    }
#else
    if (GetGraphicsMode(hdc) == GM_COMPATIBLE)
    {
        SIZE window_ext, viewport_ext;
        GetWindowExtEx(hdc, &window_ext);
        GetViewportExtEx(hdc, &viewport_ext);
        if ((window_ext.cy > 0) != (viewport_ext.cy > 0))
            invert_y = TRUE;
    }
#endif
    if (count == -1)
    {
#ifdef _WIN32K_
        count = wcslen(str);
#else
        count = strlenW(str);
#endif
        if (count == 0)
        {
            if( flags & DT_CALCRECT)
            {
                rect->right = rect->left;
                if( flags & DT_SINGLELINE)
                    rect->bottom = rect->top + (invert_y ? -lh : lh);
                else
                    rect->bottom = rect->top;
            }
            return lh;
        }
    }
 
    if (dtp)
    {
        lmargin = dtp->iLeftMargin;
        rmargin = dtp->iRightMargin;
        if (!(flags & (DT_CENTER | DT_RIGHT)))
            x += lmargin;
        dtp->uiLengthDrawn = 0;     /* This param RECEIVES number of chars processed */
    }
 
    if (flags & DT_EXPANDTABS)
    {
        int tabstop = ((flags & DT_TABSTOP) && dtp && dtp->iTabLength) ? dtp->iTabLength : 8;
    tabwidth = tm.tmAveCharWidth * tabstop;
    }
 
    if (flags & DT_CALCRECT) flags |= DT_NOCLIP;
#ifndef _WIN32K_ 
    if (!(flags & DT_NOCLIP) )
    {
       int hasClip;
       hrgn = CreateRectRgn(0,0,0,0);
       if (hrgn)
       {
          hasClip = GetClipRgn(hdc, hrgn);
          // If the region to be retrieved is NULL, the return value is 0.
          if (hasClip != 1)
          {
             DeleteObject(hrgn);
             hrgn = NULL;
          }
          IntersectClipRect(hdc, rect->left, rect->top, rect->right, rect->bottom);
       }
    }
#else
    if (!(flags & DT_NOCLIP) )
    {
       int hasClip;
       hrgn = NtGdiCreateRectRgn(0,0,0,0);
       if (hrgn)
       {
          hasClip = NtGdiGetRandomRgn(hdc, hrgn, CLIPRGN);
          if (hasClip != 1)
          {
             GreDeleteObject(hrgn);
             hrgn = NULL;
          }
          NtGdiIntersectClipRect(hdc, rect->left, rect->top, rect->right, rect->bottom);
       }
    }
#endif 
    if (flags & DT_MODIFYSTRING)
    {
        size_retstr = (count + 4) * sizeof (WCHAR);
#ifdef _WIN32K_
        retstr = ExAllocatePoolWithTag(PagedPool, size_retstr, USERTAG_RTL);
#else
        retstr = HeapAlloc(GetProcessHeap(), 0, size_retstr);
#endif
        if (!retstr) return 0;
        memcpy (retstr, str, size_retstr);
    }
    else
    {
        size_retstr = 0;
        retstr = NULL;
    }
    p_retstr = retstr;
 
    do
    {
    len = sizeof(line)/sizeof(line[0]);
    if (invert_y)
            last_line = !(flags & DT_NOCLIP) && y - ((flags & DT_EDITCONTROL) ? 2*lh-1 : lh) < rect->bottom;
    else
            last_line = !(flags & DT_NOCLIP) && y + ((flags & DT_EDITCONTROL) ? 2*lh-1 : lh) > rect->bottom;
    strPtr = TEXT_NextLineW(hdc, strPtr, &count, line, &len, width, flags, &size, last_line, &p_retstr, tabwidth, &prefix_offset, &ellip);
 
#ifdef __REACTOS__
    if (flags & DT_CENTER)
    {
        if (((rect->right - rect->left) < size.cx) && (flags & DT_CALCRECT))
        {
            x = rect->left + size.cx;
        }
        else
        {
            x = (rect->left + rect->right - size.cx) / 2;
        }
    }
#else
    if (flags & DT_CENTER) x = (rect->left + rect->right -
                    size.cx) / 2;
#endif
    else if (flags & DT_RIGHT) x = rect->right - size.cx;
 
    if (flags & DT_SINGLELINE)
    {
#ifdef __REACTOS__
        if (flags & DT_VCENTER) y = rect->top +
            (rect->bottom - rect->top + (invert_y ? size.cy : -size.cy)) / 2;
        else if (flags & DT_BOTTOM)
            y = rect->bottom + (invert_y ? size.cy : -size.cy);
#else
        if (flags & DT_VCENTER) y = rect->top +
            (rect->bottom - rect->top) / 2 - size.cy / 2;
        else if (flags & DT_BOTTOM) y = rect->bottom - size.cy;
#endif
    }
 
    if (!(flags & DT_CALCRECT))
    {
            const WCHAR *str = line;
            int xseg = x;
            while (len)
            {
                int len_seg;
                SIZE size;
                if ((flags & DT_EXPANDTABS))
                {
                    const WCHAR *p;
                    p = str; while (p < str+len && *p != TAB) p++;
                    len_seg = p - str;
                    if (len_seg != len &&
#ifdef _WIN32K_
                        !GreGetTextExtentW(hdc, str, len_seg, &size, 0))
#else
                        !GetTextExtentPointW(hdc, str, len_seg, &size))
#endif
                    {
#ifdef _WIN32K_
                        ExFreePoolWithTag(retstr, USERTAG_RTL);
#else
                        HeapFree (GetProcessHeap(), 0, retstr);
#endif
                        return 0;
                    }
                }
                else
                    len_seg = len;
#ifdef _WIN32K_
                if (!UserExtTextOutW( hdc, xseg, y,
                                     ((flags & DT_NOCLIP) ? 0 : ETO_CLIPPED) |
                                     ((flags & DT_RTLREADING) ? ETO_RTLREADING : 0),
                                     rect, str, len_seg))
#else
                if (!ExtTextOutW( hdc, xseg, y,
                                 ((flags & DT_NOCLIP) ? 0 : ETO_CLIPPED) |
                                 ((flags & DT_RTLREADING) ? ETO_RTLREADING : 0),
                                 rect, str, len_seg, NULL ))
#endif
                {
#ifdef _WIN32K_
                    ExFreePoolWithTag(retstr, USERTAG_RTL);
#else
                    HeapFree (GetProcessHeap(), 0, retstr);
#endif
                    return 0;
                }
                if (prefix_offset != -1 && prefix_offset < len_seg)
                {
                    TEXT_DrawUnderscore (hdc, xseg, y + tm.tmAscent + 1, str, prefix_offset, (flags & DT_NOCLIP) ? NULL : rect);
                }
                len -= len_seg;
                str += len_seg;
                if (len)
                {
                    assert ((flags & DT_EXPANDTABS) && *str == TAB);
                    len--; str++;
                    xseg += ((size.cx/tabwidth)+1)*tabwidth;
                    if (prefix_offset != -1)
                    {
                        if (prefix_offset < len_seg)
                        {
                            /* We have just drawn an underscore; we ought to
                             * figure out where the next one is.  I am going
                             * to leave it for now until I have a better model
                             * for the line, which will make reprefixing easier.
                             * This is where ellip would be used.
                             */
                            prefix_offset = -1;
                        }
                        else
                            prefix_offset -= len_seg;
                    }
                }
            }
    }
    else if (size.cx > max_width)
        max_width = size.cx;
 
        y += invert_y ? -lh : lh;
        if (dtp)
            dtp->uiLengthDrawn += len;
    }
    while (strPtr && !last_line);
 
#ifndef _WIN32K_
    if (!(flags & DT_NOCLIP) )
    {
       SelectClipRgn(hdc, hrgn); // This should be NtGdiExtSelectClipRgn, but due to ReactOS build rules this option is next:
       GdiFlush();               // Flush the batch and level up! See CORE-16498.
       if (hrgn)
       {
          DeleteObject(hrgn);
       }
    }
#else
    if (!(flags & DT_NOCLIP) )
    {
       NtGdiExtSelectClipRgn(hdc, hrgn, RGN_COPY);
       if (hrgn)
       {
          GreDeleteObject(hrgn);
       }
    }
#endif
 
    if (flags & DT_CALCRECT)
    {
    rect->right = rect->left + max_width;
    rect->bottom = y;
        if (dtp)
            rect->right += lmargin + rmargin;
    }
    if (retstr)
    {
        memcpy (str, retstr, size_retstr);
#ifdef _WIN32K_
        ExFreePoolWithTag(retstr, USERTAG_RTL);
#else
        HeapFree (GetProcessHeap(), 0, retstr);
#endif
    }
    return y - rect->top;
}

Referenced by DrawTextW().

DrawTextW()

INT WINAPI DrawTextW	(	HDC	hdc,
		LPCWSTR	str,
		INT	count,
		LPRECT	rect,
		UINT	flags
	)

Definition at line 17 of file defwnd.c.

{
    DRAWTEXTPARAMS dtp;
 
    memset (&dtp, 0, sizeof(dtp));
    dtp.cbSize = sizeof(dtp);
    if (flags & DT_TABSTOP)
    {
        dtp.iTabLength = (flags >> 8) & 0xff;
        flags &= 0xffff00ff;
    }
    return DrawTextExWorker(hdc, (LPWSTR)str, count, rect, flags, &dtp);
}

Referenced by _check_txgetnaturalsize(), BUTTON_CalcLabelRect(), BUTTON_DrawTextCallback(), ProgressDlg::CalcTextRect(), CB_ThemedPaint(), CFn_WMPaint(), ConfirmMsgBox_Init(), ConfirmMsgBox_Paint(), SEALED_::ControlWindowProc(), CreateLayoutIcon(), DATETIME_Refresh(), DECLARE_INTERFACE_(), default_page_paint_hook(), DlgProc(), DoTestEntry(), DrawProc(), DrawShadowText(), DrawStatusTextW(), DrawTextFromResource(), DrawThemeText(), EditTypeDlg_OnDrawItem(), FillGrid(), GetThemeTextExtent(), Graph_DrawCpuUsageGraph(), Graph_DrawMemUsageGraph(), HEADER_DrawItem(), ICONTITLE_Paint(), ICONTITLE_SetTitlePos(), ImageView_DrawImage(), IPADDRESS_Draw(), LISTVIEW_DrawItemPart(), LISTVIEW_GetItemMetrics(), LrgCellWndProc(), MainWnd_OnDrawItem(), MENU_CalcItemSize(), MENU_DrawMenuItem(), MONTHCAL_PaintCalendar(), MONTHCAL_PaintTitle(), MONTHCAL_PaintTodayTitle(), MonthCalPaint(), MyDrawCaptionTemp(), MyDrawMenuBarTemp(), NT5_DrawLogoffCaptionText(), CAutoComplete::OnDrawItem(), CCell::OnPaint(), OnPaint(), OSK_Paint(), PAINTING_DrawStateJam(), PaintText(), ProgressDlg::ProcessWindowMessage(), PROPSHEET_Paint(), REBAR_DrawBand(), ScrollProc(), SoftModalMessageBox(), STATIC_PaintTextfn(), TAB_DrawItemInterior(), taskdialog_get_text_extent(), test_DrawTextCalcRect(), TOOLBAR_CustomizeDialogProc(), TOOLBAR_DrawString(), TOOLBAR_MeasureString(), TOOLTIPS_CalcTipSize(), TOOLTIPS_Refresh(), TREEVIEW_CreateDragImage(), UserDrawCaptionText(), and WndProc().

IntDefWindowProc()

LRESULT FASTCALL IntDefWindowProc	(	PWND	Wnd,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL	Ansi
	)

Definition at line 537 of file defwnd.c.

{
   PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
   LRESULT lResult = 0;
   USER_REFERENCE_ENTRY Ref;
 
   if (Msg > WM_USER) return 0;
 
   switch (Msg)
   {
      case WM_DEVICECHANGE:
            return TRUE;
 
      case WM_GETTEXTLENGTH:
      {
            PWSTR buf;
            ULONG len;
 
            if (Wnd != NULL && Wnd->strName.Length != 0)
            {
                buf = Wnd->strName.Buffer;
                if (buf != NULL &&
                    NT_SUCCESS(RtlUnicodeToMultiByteSize(&len,
                                                         buf,
                                                         Wnd->strName.Length)))
                {
                    lResult = (LRESULT) (Wnd->strName.Length / sizeof(WCHAR));
                }
            }
            else lResult = 0L;
 
            break;
      }
 
      case WM_GETTEXT: // FIXME: Handle Ansi
      {
            PWSTR buf = NULL;
            PWSTR outbuf = (PWSTR)lParam;
 
            if (Wnd != NULL && wParam != 0)
            {
                if (Wnd->strName.Buffer != NULL)
                    buf = Wnd->strName.Buffer;
                else
                    outbuf[0] = L'\0';
 
                if (buf != NULL)
                {
                    if (Wnd->strName.Length != 0)
                    {
                        lResult = min(Wnd->strName.Length / sizeof(WCHAR), wParam - 1);
                        RtlCopyMemory(outbuf,
                                      buf,
                                      lResult * sizeof(WCHAR));
                        outbuf[lResult] = L'\0';
                    }
                    else
                        outbuf[0] = L'\0';
                }
            }
            break;
      }
 
      case WM_SETTEXT: // FIXME: Handle Ansi
      {
            DefSetText(Wnd, (PCWSTR)lParam);
 
            if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
                UserPaintCaption(Wnd, DC_TEXT);
            IntNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, Wnd, OBJID_WINDOW, CHILDID_SELF, 0);
            lResult = 1;
            break;
      }
 
      case WM_SYSCOMMAND:
      {
         TRACE("hwnd %p WM_SYSCOMMAND %lx %lx\n", Wnd->head.h, wParam, lParam );
         lResult = DefWndHandleSysCommand(Wnd, wParam, lParam);
         break;
      }
 
      case WM_SHOWWINDOW:
      {
         if ((Wnd->style & WS_VISIBLE) && wParam) break;
         if (!(Wnd->style & WS_VISIBLE) && !wParam) break;
         if (!Wnd->spwndOwner) break;
         if (LOWORD(lParam))
         {
            co_WinPosShowWindow(Wnd, wParam ? SW_SHOWNOACTIVATE : SW_HIDE);
         }
         break;
      }
 
      case WM_CLIENTSHUTDOWN:
         return IntClientShutdown(Wnd, wParam, lParam);
 
      case WM_APPCOMMAND:
         if ( (Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
               Wnd != co_GetDesktopWindow(Wnd) )
         {
            if (!co_HOOK_CallHooks(WH_SHELL, HSHELL_APPCOMMAND, wParam, lParam))
               co_IntShellHookNotify(HSHELL_APPCOMMAND, wParam, lParam);
            break;
         }
         UserRefObjectCo(Wnd->spwndParent, &Ref);
         lResult = co_IntSendMessage(UserHMGetHandle(Wnd->spwndParent), WM_APPCOMMAND, wParam, lParam);
         UserDerefObjectCo(Wnd->spwndParent);
         break;
 
      case WM_KEYF1:
      {
         HELPINFO hi;
         HMENU hMenu = UlongToHandle(Wnd->IDMenu);
         PWND pwndActive = MENU_IsMenuActive();
         hi.cbSize = sizeof(HELPINFO);
         hi.MousePos = gpsi->ptCursor;
         hi.iContextType = HELPINFO_MENUITEM;
         hi.hItemHandle = pwndActive ? UserHMGetHandle(pwndActive) : UserHMGetHandle(Wnd);
         hi.iCtrlId = (Wnd->style & (WS_POPUP|WS_CHILD)) == WS_CHILD ? IntMenuItemFromPoint(Wnd, hMenu, hi.MousePos) : 0;
         hi.dwContextId = IntGetWindowContextHelpId(Wnd);
 
         co_IntSendMessage( UserHMGetHandle(Wnd), WM_HELP, 0, (LPARAM)&hi );
         break;
      }
 
      case WM_SETICON:
      {
         return DefWndSetIcon(Wnd, wParam, lParam);
      }
 
      case WM_GETICON:
      {
         return DefWndGetIcon(Wnd, wParam, lParam);
      }
 
      case WM_HELP:
      {
         PWND Parent = IntGetParent(Wnd);
         co_IntSendMessage(UserHMGetHandle(Parent), Msg, wParam, lParam);
         break;
      }
 
      case WM_LBUTTONDOWN:
      case WM_RBUTTONDOWN:
      case WM_MBUTTONDOWN:
          pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK);
          break;
 
      case WM_NCLBUTTONDOWN:
          return NC_HandleNCLButtonDown(Wnd, wParam, lParam);
 
      case WM_NCRBUTTONDOWN:
          return NC_HandleNCRButtonDown(Wnd, wParam, lParam);
 
      case WM_LBUTTONDBLCLK:
          return NC_HandleNCLButtonDblClk(Wnd, HTCLIENT, lParam);
 
      case WM_NCLBUTTONDBLCLK:
          return NC_HandleNCLButtonDblClk(Wnd, wParam, lParam);
 
      case WM_RBUTTONUP:
      {
            POINT Pt;
 
            Pt.x = GET_X_LPARAM(lParam);
            Pt.y = GET_Y_LPARAM(lParam);
            IntClientToScreen(Wnd, &Pt);
            lParam = MAKELPARAM(Pt.x, Pt.y);
            co_IntSendMessage(UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), 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)
          {
              co_IntSendMessage(UserHMGetHandle(Wnd), WM_APPCOMMAND, (WPARAM)UserHMGetHandle(Wnd),
                                MAKELPARAM(LOWORD(wParam), FAPPCOMMAND_MOUSE | HIWORD(wParam)));
          }
          break;
 
 
      case WM_CONTEXTMENU:
      {
            if (Wnd->style & WS_CHILD)
            {
                co_IntSendMessage(UserHMGetHandle(IntGetParent(Wnd)), Msg, (WPARAM)UserHMGetHandle(Wnd), lParam);
            }
            else
            {
                POINT Pt;
                LONG_PTR Style;
                LONG HitCode;
 
                Style = Wnd->style;
 
                Pt.x = GET_X_LPARAM(lParam);
                Pt.y = GET_Y_LPARAM(lParam);
                if (Style & WS_CHILD)
                {
                    IntScreenToClient(IntGetParent(Wnd), &Pt);
                }
 
                HitCode = GetNCHitEx(Wnd, Pt);
 
                if (HitCode == HTCAPTION || HitCode == HTSYSMENU)
                {
                    PMENU SystemMenu;
                    UINT Flags;
 
                    if((SystemMenu = IntGetSystemMenu(Wnd, FALSE)))
                    {
                      MENU_InitSysMenuPopup(SystemMenu, Wnd->style, Wnd->pcls->style, HitCode);
 
                      if(HitCode == HTCAPTION)
                        Flags = TPM_LEFTBUTTON | TPM_RIGHTBUTTON;
                      else
                        Flags = TPM_LEFTBUTTON;
 
                      IntTrackPopupMenuEx(SystemMenu, Flags|TPM_SYSTEM_MENU, Pt.x, Pt.y, Wnd, NULL);
                    }
                }
                if (HitCode == HTHSCROLL || HitCode == HTVSCROLL)
                {
                   WARN("Scroll Menu Not Supported\n");
                }
        }
            break;
      }
 
      case WM_KEYDOWN:
         if (wParam == VK_F10)
         {
            pti->MessageQueue->QF_flags |= QF_FF10STATUS;
 
            if (UserGetKeyState(VK_SHIFT) & 0x8000)
            {
               co_IntSendMessage(UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), MAKELPARAM(-1, -1));
            }
         }
         if (g_bWindowSnapEnabled && (IS_KEY_DOWN(gafAsyncKeyState, VK_LWIN) || IS_KEY_DOWN(gafAsyncKeyState, VK_RWIN)))
         {
            BOOL IsTaskBar;
            DWORD StyleTB;
            DWORD ExStyleTB;
            HWND hwndTop = UserGetForegroundWindow();
            PWND topWnd = UserGetWindowObject(hwndTop);
 
            // We want to forbid snapping operations on the TaskBar
            // We use a heuristic for detecting the TaskBar Wnd by its typical Style & ExStyle Values
            ExStyleTB = (topWnd->ExStyle & WS_EX_TOOLWINDOW);
            StyleTB = (topWnd->style & (WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN));
            IsTaskBar = (StyleTB == (WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN))
                        && (ExStyleTB == WS_EX_TOOLWINDOW);
            TRACE("ExStyle=%x Style=%x IsTaskBar=%d\n", ExStyleTB, StyleTB, IsTaskBar);
 
            if (topWnd && !IsTaskBar)
            {
               if ((topWnd->style & WS_THICKFRAME) == 0)
                  return 0;
 
               if (wParam == VK_DOWN)
               {
                   if (topWnd->style & WS_MAXIMIZE)
                   {
                       co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_RESTORE, lParam);
 
                       /* "Normal size" must be erased after restoring, otherwise it will block next side snap actions */
                       RECTL_vSetEmptyRect(&topWnd->InternalPos.NormalRect);
                   }
                   else
                   {
                       co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_MINIMIZE, lParam);
                   }
               }
               else if (wParam == VK_UP)
               {
                  RECT currentRect;
                  if ((topWnd->InternalPos.NormalRect.right == topWnd->InternalPos.NormalRect.left) ||
                      (topWnd->InternalPos.NormalRect.top == topWnd->InternalPos.NormalRect.bottom))
                  {
                      currentRect = topWnd->rcWindow;
                  }
                  else
                  {
                      currentRect = topWnd->InternalPos.NormalRect;
                  }
                  co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_MAXIMIZE, 0);
 
                  // save normal rect if maximazing snapped window
                  topWnd->InternalPos.NormalRect = currentRect;
               }
               else if (wParam == VK_LEFT || wParam == VK_RIGHT)
               {
                  RECT snapRect, normalRect, windowRect;
                  BOOL snapped;
                  normalRect = topWnd->InternalPos.NormalRect;
                  snapped = (normalRect.left != 0 && normalRect.right != 0 &&
                             normalRect.top != 0 && normalRect.bottom != 0);
 
                  if (topWnd->style & WS_MAXIMIZE)
                  {
                     co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_RESTORE, lParam);
                     snapped = FALSE;
                  }
                  windowRect = topWnd->rcWindow;
 
                  UserSystemParametersInfo(SPI_GETWORKAREA, 0, &snapRect, 0);
                  if (wParam == VK_LEFT)
                  {
                     snapRect.right = (snapRect.left + snapRect.right) / 2;
                  }
                  else // VK_RIGHT
                  {
                     snapRect.left = (snapRect.left + snapRect.right) / 2;
                  }
 
                  if (snapped)
                  {
                     // if window was snapped but moved to other location - restore normal size
                     if (!IntEqualRect(&snapRect, &windowRect))
                     {
                        RECT empty = {0, 0, 0, 0};
                        co_WinPosSetWindowPos(topWnd,
                                              0,
                                              normalRect.left,
                                              normalRect.top,
                                              normalRect.right - normalRect.left,
                                              normalRect.bottom - normalRect.top,
                                              0);
                        topWnd->InternalPos.NormalRect = empty;
                     }
                  }
                  else
                  {
                     co_WinPosSetWindowPos(topWnd,
                                           0,
                                           snapRect.left,
                                           snapRect.top,
                                           snapRect.right - snapRect.left,
                                           snapRect.bottom - snapRect.top,
                                           0);
                     topWnd->InternalPos.NormalRect = windowRect;
                  }
               }
            }
         }
         break;
 
      case WM_SYSKEYDOWN:
      {
            if (HIWORD(lParam) & KF_ALTDOWN)
            {   /* Previous state, if the key was down before this message,
                   this is a cheap way to ignore autorepeat keys. */
                if ( !(HIWORD(lParam) & KF_REPEAT) )
                {
                   if ( ( wParam == VK_MENU  ||
                          wParam == VK_LMENU ||
                          wParam == VK_RMENU ) && !(pti->MessageQueue->QF_flags & QF_FMENUSTATUS)) //iMenuSysKey )
                       pti->MessageQueue->QF_flags |= QF_FMENUSTATUS; //iMenuSysKey = 1;
                   else
                       pti->MessageQueue->QF_flags &= ~QF_FMENUSTATUS; //iMenuSysKey = 0;
                }
 
                pti->MessageQueue->QF_flags &= ~QF_FF10STATUS; //iF10Key = 0;
 
                if (wParam == VK_F4) /* Try to close the window */
                {
                   PWND top = UserGetAncestor(Wnd, GA_ROOT);
                   if (!(top->style & CS_NOCLOSE))
                      UserPostMessage(UserHMGetHandle(top), WM_SYSCOMMAND, SC_CLOSE, 0);
                }
                else if (wParam == VK_SNAPSHOT) // Alt-VK_SNAPSHOT?
                {
                   PWND pwnd = Wnd;
                   while (IntGetParent(pwnd) != NULL)
                   {
                       pwnd = IntGetParent(pwnd);
                   }
                   ERR("DefWndScreenshot\n");
                   DefWndScreenshot(pwnd);
                }
                else if ( wParam == VK_ESCAPE || wParam == VK_TAB ) // Alt-Tab/ESC Alt-Shift-Tab/ESC
                {
                   WPARAM wParamTmp;
                   HWND Active = UserGetActiveWindow(); // Noticed MDI problem.
                   if (!Active)
                   {
                      FIXME("WM_SYSKEYDOWN VK_ESCAPE no active\n");
                      break;
                   }
                   wParamTmp = UserGetKeyState(VK_SHIFT) & 0x8000 ? SC_PREVWINDOW : SC_NEXTWINDOW;
                   co_IntSendMessage( Active, WM_SYSCOMMAND, wParamTmp, wParam );
                }
                else if (wParam == VK_SHIFT) // Alt+Shift
                {
                    RTL_ATOM ClassAtom = 0;
                    UNICODE_STRING ustrClass, ustrWindow;
                    HWND hwndSwitch;
 
                    RtlInitUnicodeString(&ustrClass, L"kbswitcher");
                    RtlInitUnicodeString(&ustrWindow, L"");
 
                    IntGetAtomFromStringOrAtom(&ustrClass, &ClassAtom);
 
                    hwndSwitch = IntFindWindow(UserGetDesktopWindow(), NULL, ClassAtom, &ustrWindow);
                    if (hwndSwitch)
                    {
#define ID_NEXTLAYOUT 10003
                        UserPostMessage(hwndSwitch, WM_COMMAND, ID_NEXTLAYOUT, (LPARAM)UserHMGetHandle(Wnd));
                    }
                }
            }
            else if( wParam == VK_F10 )
            {
                if (UserGetKeyState(VK_SHIFT) & 0x8000)
                    co_IntSendMessage( UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), MAKELPARAM(-1, -1) );
                pti->MessageQueue->QF_flags |= QF_FF10STATUS; //iF10Key = 1;
            }
            else if( wParam == VK_ESCAPE && (UserGetKeyState(VK_SHIFT) & 0x8000))
                  co_IntSendMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_KEYMENU, ' ' );
            break;
      }
 
      case WM_KEYUP:
      case WM_SYSKEYUP:
      {
           /* Press and release F10 or ALT */
            if (((wParam == VK_MENU || wParam == VK_LMENU || wParam == VK_RMENU)
                 && (pti->MessageQueue->QF_flags & (QF_FMENUSTATUS|QF_FMENUSTATUSBREAK)) == QF_FMENUSTATUS /*iMenuSysKey*/) ||
                 ((wParam == VK_F10) && pti->MessageQueue->QF_flags & QF_FF10STATUS /*iF10Key*/))
                co_IntSendMessage( UserHMGetHandle(UserGetAncestor( Wnd, GA_ROOT )), WM_SYSCOMMAND, SC_KEYMENU, 0L );
            pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK|QF_FF10STATUS); //iMenuSysKey = iF10Key = 0;
            break;
      }
 
      case WM_SYSCHAR:
      {
            pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK); //iMenuSysKey = 0;
            if (wParam == VK_RETURN && (Wnd->style & WS_MINIMIZE) != 0)
            {
                UserPostMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_RESTORE, 0L );
                break;
            }
            if ((HIWORD(lParam) & KF_ALTDOWN) && wParam)
            {
                if (wParam == VK_TAB || wParam == VK_ESCAPE) break;
                if (wParam == VK_SPACE && Wnd->style & WS_CHILD)
                    co_IntSendMessage( UserHMGetHandle(IntGetParent(Wnd)), Msg, wParam, lParam );
                else
                    co_IntSendMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_KEYMENU, wParam );
            }
            else /* check for Ctrl-Esc */
                if (wParam != VK_ESCAPE) UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); //MessageBeep(0);
            break;
      }
 
      case WM_CANCELMODE:
      {
         pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK);
 
         MENU_EndMenu( Wnd );
         if (IntGetCaptureWindow() == UserHMGetHandle(Wnd))
         {
            IntReleaseCapture();
         }
         break;
      }
 
      case WM_CLOSE:
         co_UserDestroyWindow(Wnd);
         break;
 
      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_SETCURSOR:
      {
         if (Wnd->style & WS_CHILD)
         {
             /* with the exception of the border around a resizable wnd,
              * give the parent first chance to set the cursor */
             if (LOWORD(lParam) < HTLEFT || LOWORD(lParam) > HTBOTTOMRIGHT)
             {
                 PWND parent = Wnd->spwndParent;//IntGetParent( Wnd );
                 if (parent != UserGetDesktopWindow() &&
                     co_IntSendMessage( UserHMGetHandle(parent), WM_SETCURSOR, wParam, lParam))
                    return TRUE;
             }
         }
         return DefWndHandleSetCursor(Wnd, wParam, lParam);
      }
 
      case WM_MOUSEACTIVATE:
         if (Wnd->style & WS_CHILD)
         {
             LONG Ret;
             HWND hwndParent;
             PWND pwndParent = IntGetParent(Wnd);
             hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
             if (hwndParent) Ret = co_IntSendMessage(hwndParent, 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 &&
              !(Wnd->style & WS_MINIMIZE))
         {
            //ERR("WM_ACTIVATE %p\n",hWnd);
            co_UserSetFocus(Wnd);
         }
         break;
 
      case WM_MOUSEWHEEL:
         if (Wnd->style & WS_CHILD)
         {
            HWND hwndParent;
            PWND pwndParent = IntGetParent(Wnd);
            hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
            return co_IntSendMessage( hwndParent, WM_MOUSEWHEEL, wParam, lParam);
         }
         break;
 
      case WM_ERASEBKGND:
      case WM_ICONERASEBKGND:
      {
         RECT Rect;
         HBRUSH hBrush = Wnd->pcls->hbrBackground;
         if (!hBrush) return 0;
         if (hBrush <= (HBRUSH)COLOR_MENUBAR)
         {
            hBrush = IntGetSysColorBrush(HandleToUlong(hBrush));
         }
         if (Wnd->pcls->style & CS_PARENTDC)
         {
            /* can't use GetClipBox with a parent DC or we fill the whole parent */
            IntGetClientRect(Wnd, &Rect);
            GreDPtoLP((HDC)wParam, (LPPOINT)&Rect, 2);
         }
         else
         {
            GdiGetClipBox((HDC)wParam, &Rect);
         }
         FillRect((HDC)wParam, &Rect, hBrush);
         return (1);
      }
 
      case WM_GETHOTKEY:
         //ERR("WM_GETHOTKEY\n");
         return DefWndGetHotKey(Wnd);
      case WM_SETHOTKEY:
         //ERR("WM_SETHOTKEY\n");
         return DefWndSetHotKey(Wnd, wParam);
 
      case WM_NCHITTEST:
      {
         POINT Point;
         Point.x = GET_X_LPARAM(lParam);
         Point.y = GET_Y_LPARAM(lParam);
         return GetNCHitEx(Wnd, Point);
      }
 
      case WM_PRINT:
      {
         DefWndPrint(Wnd, (HDC)wParam, lParam);
         return (0);
      }
 
      case WM_SYSCOLORCHANGE:
      {
         /* force to redraw non-client area */
         UserPaintCaption(Wnd, DC_NC);
         /* Use InvalidateRect to redraw client area, enable
          * erase to redraw all subcontrols otherwise send the
          * WM_SYSCOLORCHANGE to child windows/controls is required
          */
         co_UserRedrawWindow( Wnd, NULL, NULL, RDW_ALLCHILDREN|RDW_INVALIDATE|RDW_ERASE);
         return (0);
      }
 
      case WM_PAINTICON:
      case WM_PAINT:
      {
         PAINTSTRUCT Ps;
         HDC hDC;
 
         /* If already in Paint and Client area is not empty just return. */
         if (Wnd->state2 & WNDS2_STARTPAINT && !RECTL_bIsEmptyRect(&Wnd->rcClient))
         {
            ERR("In Paint and Client area is not empty!\n");
            return 0;
         }
 
         hDC = IntBeginPaint(Wnd, &Ps);
         if (hDC)
         {
             if (((Wnd->style & WS_MINIMIZE) != 0) && (Wnd->pcls->spicn))
             {
                 RECT ClientRect;
                 INT x, y;
 
                 ERR("Doing Paint and Client area is empty!\n");
                 IntGetClientRect(Wnd, &ClientRect);
                 x = (ClientRect.right - ClientRect.left - UserGetSystemMetrics(SM_CXICON)) / 2;
                 y = (ClientRect.bottom - ClientRect.top - UserGetSystemMetrics(SM_CYICON)) / 2;
                 UserReferenceObject(Wnd->pcls->spicn);
                 UserDrawIconEx(hDC, x, y, Wnd->pcls->spicn, 0, 0, 0, 0, DI_NORMAL | DI_COMPAT | DI_DEFAULTSIZE);
                 UserDereferenceObject(Wnd->pcls->spicn);
             }
 
             IntEndPaint(Wnd, &Ps);
         }
         return (0);
      }
 
      case WM_SYNCPAINT:
      {
         HRGN hRgn;
         Wnd->state &= ~WNDS_SYNCPAINTPENDING;
         TRACE("WM_SYNCPAINT\n");
         hRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
         if (hRgn)
         {
             if (co_UserGetUpdateRgn(Wnd, hRgn, FALSE) != NULLREGION)
             {
                PREGION pRgn = REGION_LockRgn(hRgn);
                if (pRgn) REGION_UnlockRgn(pRgn);
                if (!wParam)
                    wParam = (RDW_ERASENOW | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN);
                co_UserRedrawWindow(Wnd, NULL, pRgn, wParam);
             }
             GreDeleteObject(hRgn);
         }
         return 0;
      }
 
      case WM_SETREDRAW:
          if (wParam)
          {
             if (!(Wnd->style & WS_VISIBLE))
             {
                IntSetStyle( Wnd, WS_VISIBLE, 0 );
                Wnd->state |= WNDS_SENDNCPAINT;
             }
          }
          else
          {
             if (Wnd->style & WS_VISIBLE)
             {
                co_UserRedrawWindow( Wnd, NULL, NULL, RDW_ALLCHILDREN | RDW_VALIDATE );
                IntSetStyle( Wnd, 0, WS_VISIBLE );
             }
          }
          return 0;
 
      case WM_WINDOWPOSCHANGING:
      {
          return (DefWndHandleWindowPosChanging(Wnd, (WINDOWPOS*)lParam));
      }
 
      case WM_WINDOWPOSCHANGED:
      {
          return (DefWndHandleWindowPosChanged(Wnd, (WINDOWPOS*)lParam));
      }
 
      case WM_NCCALCSIZE:
      {
         return NC_HandleNCCalcSize( Wnd, wParam, (RECTL *)lParam, FALSE );
      }
 
      case WM_NCACTIVATE:
      {
          return NC_HandleNCActivate( Wnd, wParam, lParam );
      }
 
      //
      // NC Paint mode.
      //
      case WM_NCPAINT:
      {
          HDC hDC = UserGetDCEx(Wnd, (HRGN)wParam, DCX_WINDOW | DCX_INTERSECTRGN | DCX_USESTYLE | DCX_KEEPCLIPRGN);
          Wnd->state |= WNDS_FORCEMENUDRAW;
          NC_DoNCPaint(Wnd, hDC, -1);
          Wnd->state &= ~WNDS_FORCEMENUDRAW;
          UserReleaseDC(Wnd, hDC, FALSE);
          return 0;
      }
      //
      //  Draw Caption mode.
      //
      //  wParam are DC_* flags.
      //
      case WM_NCUAHDRAWCAPTION:
      {
          HDC hDC = UserGetDCEx(Wnd, NULL, DCX_WINDOW|DCX_USESTYLE);
          TRACE("WM_NCUAHDRAWCAPTION: wParam DC_ flags %08x\n",wParam);
          UserDrawCaptionBar(Wnd, hDC, wParam | DC_FRAME); // Include DC_FRAME to comp for drawing glitch.
          UserReleaseDC(Wnd, hDC, FALSE);
          return 0;
      }
      //
      //  Draw Frame mode.
      //
      //  wParam is HDC, lParam are DC_ACTIVE and or DC_REDRAWHUNGWND.
      //
      case WM_NCUAHDRAWFRAME:
      {
          TRACE("WM_NCUAHDRAWFRAME: wParam hDC %p lParam DC_ flags %08x\n",wParam,lParam);
          NC_DoNCPaint(Wnd, (HDC)wParam, lParam|DC_NC);
          return 0;
      }
 
      /* ReactOS only. */
      case WM_CBT:
      {
         switch (wParam)
         {
            case HCBT_MOVESIZE:
            {
               RECTL rt;
 
               if (lParam)
               {
                  _SEH2_TRY
                  {
                      ProbeForRead((PVOID)lParam,
                                   sizeof(RECT),
                                   1);
 
                      RtlCopyMemory(&rt,
                                    (PVOID)lParam,
                                    sizeof(RECT));
                  }
                  _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
                  {
                      lResult = 1;
                  }
                  _SEH2_END;
               }
               if (!lResult)
                  lResult = co_HOOK_CallHooks(WH_CBT, HCBT_MOVESIZE, (WPARAM)Wnd->head.h, lParam ? (LPARAM)&rt : 0);
           }
            break;
         }
         break;
      }
      break;
   }
   return lResult;
}

Referenced by GetControlColor(), NtUserMessageCall(), PopupMenuWndProc(), and UserMessageWindowProc().

UserPaintCaption()

BOOL UserPaintCaption	(	PWND	pWnd,
		INT	Flags
	)

Definition at line 399 of file defwnd.c.

{
  BOOL Ret = FALSE;
 
  if ( (pWnd->style & WS_VISIBLE) && ((pWnd->style & WS_CAPTION) == WS_CAPTION) )
  {
      if (pWnd->state & WNDS_HASCAPTION && pWnd->head.pti->MessageQueue == gpqForeground)
         Flags |= DC_ACTIVE;
    /*
     * When themes are not enabled we can go on and paint the non client area.
     * However if we do that with themes enabled we will draw a classic frame.
     * This is solved by sending a themes specific message to notify the themes
     * engine that the caption needs to be redrawn.
     */
      if (gpsi->dwSRVIFlags & SRVINFO_APIHOOK)
      {
        /*
         * This will cause uxtheme to either paint the themed caption or call
         * RealUserDrawCaption in order to draw the classic caption when themes
         * are disabled but the themes service is enabled.
         */
         TRACE("UDCB Flags %08x\n", Flags);
         co_IntSendMessage(UserHMGetHandle(pWnd), WM_NCUAHDRAWCAPTION, Flags, 0);
      }
      else
      {
         HDC hDC = UserGetDCEx(pWnd, NULL, DCX_WINDOW|DCX_USESTYLE);
         UserDrawCaptionBar(pWnd, hDC, Flags | DC_FRAME); // DCFRAME added as fix for CORE-10855.
         UserReleaseDC(pWnd, hDC, FALSE);
      }
      Ret = TRUE;
   }
   // Support window tray
   return Ret;
}

Referenced by DefWndSetIcon(), IntDefWindowProc(), IntEnableMenuItem(), NtUserCallTwoParam(), NtUserSetClassLong(), RealDefWindowProcA(), and RealDefWindowProcW().