userfuncs.h File Reference

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

Go to the source code of this file.

Macros
#define	ASSERT_REFS_CO(_obj_)
#define	DUMP_REFS(obj)   TRACE_CH(UserObj,"obj 0x%x, refs %i\n",obj, ((PHEAD)obj)->cLockObj)

Functions
FORCEINLINE PMENU	UserGetMenuObject (HMENU hMenu)
PWND FASTCALL	IntGetWindowObject (HWND hWnd)
BOOL FASTCALL	IntDdeSendMessageHook (PWND, UINT, WPARAM, LPARAM)
BOOL APIENTRY	IntDdePostMessageHook (IN PWND, IN UINT, IN WPARAM, IN OUT LPARAM *, IN OUT LONG_PTR *)
BOOL APIENTRY	IntDdeGetMessageHook (PMSG, LONG_PTR)
NTSTATUS NTAPI	InitThreadCallback (PETHREAD Thread)
HWINSTA FASTCALL	UserGetProcessWindowStation (VOID)
HWND FASTCALL	UserGetActiveWindow (VOID)
HWND FASTCALL	UserGetForegroundWindow (VOID)
HWND FASTCALL	co_UserSetFocus (PWND Window)
INT FASTCALL	UserReleaseDC (PWND Window, HDC hDc, BOOL EndPaint)
HDC FASTCALL	UserGetDCEx (PWND Window OPTIONAL, HANDLE ClipRegion, ULONG Flags)
HDC FASTCALL	UserGetWindowDC (PWND Wnd)
NTSTATUS FASTCALL	InitSessionImpl (VOID)
BOOL NTAPI	InitMetrics (VOID)
LONG NTAPI	UserGetSystemMetrics (ULONG Index)
DWORD FASTCALL	UserGetKeyState (DWORD key)
DWORD FASTCALL	UserGetKeyboardType (DWORD TypeFlag)
HKL FASTCALL	UserGetKeyboardLayout (DWORD dwThreadId)
int __cdecl	_scwprintf (const wchar_t *format,...)
BOOL FASTCALL	UserSystemParametersInfo (UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
VOID FASTCALL	IntSetWindowState (PWND, UINT)
VOID FASTCALL	IntClearWindowState (PWND, UINT)
PTHREADINFO FASTCALL	IntTID2PTI (HANDLE)
HBRUSH FASTCALL	GetControlBrush (PWND, HDC, UINT)
HBRUSH FASTCALL	GetControlColor (PWND, PWND, HDC, UINT)
NTSTATUS	GetProcessLuid (IN PETHREAD Thread OPTIONAL, IN PEPROCESS Process OPTIONAL, OUT PLUID Luid)
BOOL FASTCALL	UserPostMessage (HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
PWND FASTCALL	UserGetWindowObject (HWND hWnd)
VOID FASTCALL	co_DestroyThreadWindows (struct _ETHREAD *Thread)
HWND FASTCALL	UserGetShellWindow (VOID)
BOOLEAN	co_UserDestroyWindow (PVOID Object)
PWND FASTCALL	UserGetAncestor (PWND Wnd, UINT Type)
BOOL APIENTRY	DefSetText (PWND Wnd, PCWSTR WindowText)
DWORD FASTCALL	IntGetWindowContextHelpId (PWND pWnd)
HMENU FASTCALL	UserCreateMenu (PDESKTOP Desktop, BOOL PopupMenu)
BOOL FASTCALL	UserSetMenuDefaultItem (PMENU Menu, UINT uItem, UINT fByPos)
BOOL FASTCALL	UserDestroyMenu (HMENU hMenu)
VOID FASTCALL	DefWndDoSizeMove (PWND pwnd, WORD wParam)
LRESULT	NC_DoNCPaint (PWND, HDC, INT)
void FASTCALL	NC_GetSysPopupPos (PWND, RECT *)
LRESULT	NC_HandleNCActivate (PWND Wnd, WPARAM wParam, LPARAM lParam)
LRESULT	NC_HandleNCCalcSize (PWND wnd, WPARAM wparam, RECTL *winRect, BOOL Suspended)
VOID	NC_DrawFrame (HDC hDC, RECT *CurrentRect, BOOL Active, DWORD Style, DWORD ExStyle)
VOID	UserDrawCaptionBar (PWND pWnd, HDC hDC, INT Flags)
void FASTCALL	NC_GetInsideRect (PWND Wnd, RECT *rect)
LRESULT	NC_HandleNCLButtonDown (PWND Wnd, WPARAM wParam, LPARAM lParam)
LRESULT	NC_HandleNCLButtonDblClk (PWND Wnd, WPARAM wParam, LPARAM lParam)
LRESULT	NC_HandleNCRButtonDown (PWND wnd, WPARAM wParam, LPARAM lParam)
HBRUSH FASTCALL	DefWndControlColor (HDC hDC, UINT ctlType)
BOOL	UserDrawSysMenuButton (PWND pWnd, HDC hDC, LPRECT Rect, BOOL Down)
BOOL	UserPaintCaption (PWND pWnd, INT Flags)
BOOL FASTCALL	SetLayeredStatus (PWND pWnd, BYTE set)
BOOL FASTCALL	GetLayeredStatus (PWND pWnd)

Variables
PRTL_ATOM_TABLE	gAtomTable

Macro Definition Documentation

ASSERT_REFS_CO

#define ASSERT_REFS_CO

(

_obj_

)

Value:

{ \
   LONG ref = ((PHEAD)_obj_)->cLockObj;\
   if (!(ref >= 1)){ \
      ERR_CH(UserObj, "ASSERT: obj 0x%p, refs %ld\n", _obj_, ref); \
      ASSERT(FALSE); \
   } \
}

Definition at line 13 of file userfuncs.h.

DUMP_REFS

#define DUMP_REFS

(

obj

)

TRACE_CH(UserObj,"obj 0x%x, refs %i\n",obj, ((PHEAD)obj)->cLockObj)

Definition at line 44 of file userfuncs.h.

Function Documentation

_scwprintf()

int __cdecl _scwprintf	(	const wchar_t *	format,
			...
	)

Definition at line 13 of file _scwprintf.c.

{
    int len;
    va_list args;

    va_start(args, format);
    len = _vscwprintf(format, args);
    va_end(args);

    return len;
}

Referenced by UserpFormatMessages().

co_DestroyThreadWindows()

VOID FASTCALL co_DestroyThreadWindows

(

struct _ETHREAD *

Thread

)

co_UserDestroyWindow()

BOOLEAN co_UserDestroyWindow

(

PVOID

Object

)

Definition at line 2579 of file window.c.

{
   HWND hWnd;
   PWND pwndTemp;
   PTHREADINFO ti;
   MSG msg;
   PWND Window = Object;

   ASSERT_REFS_CO(Window); // FIXME: Temp HACK?

   hWnd = Window->head.h;
   ti = PsGetCurrentThreadWin32Thread();

   TRACE("co_UserDestroyWindow(Window = 0x%p, hWnd = 0x%p)\n", Window, hWnd);

   /* Check for owner thread */
   if ( Window->head.pti != PsGetCurrentThreadWin32Thread())
   {
       /* Check if we are destroying the desktop window */
       if (! ((Window->head.rpdesk->dwDTFlags & DF_DESTROYED) && Window == Window->head.rpdesk->pDeskInfo->spwnd))
       {
           EngSetLastError(ERROR_ACCESS_DENIED);
           return FALSE;
       }
   }

   /* If window was created successfully and it is hooked */
   if ((Window->state2 & WNDS2_WMCREATEMSGPROCESSED))
   {
      if (co_HOOK_CallHooks(WH_CBT, HCBT_DESTROYWND, (WPARAM) hWnd, 0))
      {
         ERR("Destroy Window WH_CBT Call Hook return!\n");
         return FALSE;
      }
   }

   if (Window->pcls->atomClassName != gpsi->atomSysClass[ICLS_IME])
   {
      if ((Window->style & (WS_POPUP|WS_CHILD)) != WS_CHILD)
      {
         if (Window->spwndOwner)
         {
            //ERR("DestroyWindow Owner out.\n");
            UserAttachThreadInput(Window->head.pti, Window->spwndOwner->head.pti, FALSE);
         }
      }
   }

   /* Inform the parent */
   if (Window->style & WS_CHILD)
   {
      IntSendParentNotify(Window, WM_DESTROY);
   }

   if (!Window->spwndOwner && !IntGetParent(Window))
   {
      co_IntShellHookNotify(HSHELL_WINDOWDESTROYED, (WPARAM) hWnd, 0);
   }

   /* Hide the window */
   if (Window->style & WS_VISIBLE)
   {
      if (Window->style & WS_CHILD)
      {
         /* Only child windows receive WM_SHOWWINDOW in DestroyWindow() */
         co_WinPosShowWindow(Window, SW_HIDE);
      }
      else
      {
         co_WinPosSetWindowPos(Window, 0, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_HIDEWINDOW );
      }
   }

   /* Adjust last active */
   if ((pwndTemp = Window->spwndOwner))
   {
      while (pwndTemp->spwndOwner)
         pwndTemp = pwndTemp->spwndOwner;

      if (pwndTemp->spwndLastActive == Window)
         pwndTemp->spwndLastActive = Window->spwndOwner;
   }

   if (Window->spwndParent && IntIsWindow(UserHMGetHandle(Window)))
   {
      if ((Window->style & (WS_POPUP | WS_CHILD)) == WS_CHILD)
      {
         if (!IntIsTopLevelWindow(Window))
         {
            //ERR("DestroyWindow Parent out.\n");
            UserAttachThreadInput(Window->head.pti, Window->spwndParent->head.pti, FALSE);
         }
      }
   }

   if (Window->head.pti->MessageQueue->spwndActive == Window)
      Window->head.pti->MessageQueue->spwndActive = NULL;
   if (Window->head.pti->MessageQueue->spwndFocus == Window)
      Window->head.pti->MessageQueue->spwndFocus = NULL;
   if (Window->head.pti->MessageQueue->spwndActivePrev == Window)
      Window->head.pti->MessageQueue->spwndActivePrev = NULL;
   if (Window->head.pti->MessageQueue->spwndCapture == Window)
      Window->head.pti->MessageQueue->spwndCapture = NULL;

   /*
    * Check if this window is the Shell's Desktop Window. If so set hShellWindow to NULL
    */

   if ((ti != NULL) && (ti->pDeskInfo != NULL))
   {
      if (ti->pDeskInfo->hShellWindow == hWnd)
      {
         ERR("Destroying the ShellWindow!\n");
         ti->pDeskInfo->hShellWindow = NULL;
      }
   }

   IntEngWindowChanged(Window, WOC_DELETE);

   if (!IntIsWindow(UserHMGetHandle(Window)))
   {
      return TRUE;
   }

    /* Recursively destroy owned windows */
    if (!(Window->style & WS_CHILD))
    {
        HWND* List;
        HWND* phWnd;
        PWND pWnd;

        List = IntWinListOwnedPopups(Window);
        if (List)
        {
            for (phWnd = List; *phWnd; ++phWnd)
            {
                pWnd = ValidateHwndNoErr(*phWnd);
                if (pWnd == NULL)
                    continue;
                ASSERT(pWnd->spwndOwner == Window);
                ASSERT(pWnd != Window);

                pWnd->spwndOwner = NULL;
                if (IntWndBelongsToThread(pWnd, PsGetCurrentThreadWin32Thread()))
                {
                    USER_REFERENCE_ENTRY Ref;
                    UserRefObjectCo(pWnd, &Ref); // Temp HACK?
                    co_UserDestroyWindow(pWnd);
                    UserDerefObjectCo(pWnd); // Temp HACK?
                }
                else
                {
                    ERR("IntWndBelongsToThread(0x%p) is FALSE, ignoring.\n", pWnd);
                }
            }

            ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
        }
    }

    /* Generate mouse move message for the next window */
    msg.message = WM_MOUSEMOVE;
    msg.wParam = UserGetMouseButtonsState();
    msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
    msg.pt = gpsi->ptCursor;
    co_MsqInsertMouseMessage(&msg, 0, 0, TRUE);

   IntNotifyWinEvent(EVENT_OBJECT_DESTROY, Window, OBJID_WINDOW, CHILDID_SELF, 0);

   /* Send destroy messages */
   IntSendDestroyMsg(UserHMGetHandle(Window));

   if (!IntIsWindow(UserHMGetHandle(Window)))
   {
      return TRUE;
   }

   /* Destroy the window storage */
   co_UserFreeWindow(Window, PsGetCurrentProcessWin32Process(), PsGetCurrentThreadWin32Thread(), TRUE);

   return TRUE;
}

Referenced by co_UserCreateWindowEx(), handle_internal_message(), IntDefWindowProc(), IntDesktopObjectDelete(), IntTrackPopupMenuEx(), MENU_HideSubPopups(), MENU_TrackMenu(), and NtUserDestroyWindow().

co_UserSetFocus()

HWND FASTCALL co_UserSetFocus

(

PWND

Window

)

Definition at line 1196 of file focus.c.

{
   HWND hWndPrev = 0;
   PWND pwndTop;
   PTHREADINFO pti;
   PUSER_MESSAGE_QUEUE ThreadQueue;

   if (Window)
      ASSERT_REFS_CO(Window);

   pti = PsGetCurrentThreadWin32Thread();
   ThreadQueue = pti->MessageQueue;
   ASSERT(ThreadQueue != 0);

   TRACE("Enter SetFocus hWnd 0x%p pti 0x%p\n",Window ? UserHMGetHandle(Window) : 0, pti );

   hWndPrev = ThreadQueue->spwndFocus ? UserHMGetHandle(ThreadQueue->spwndFocus) : 0;

   if (Window != 0)
   {
      if (hWndPrev == UserHMGetHandle(Window))
      {
         return hWndPrev ? (IntIsWindow(hWndPrev) ? hWndPrev : 0) : 0; /* Nothing to do */
      }

      if (Window->head.pti->MessageQueue != ThreadQueue)
      {
         ERR("SetFocus Must have the same Q!\n");
         return 0;
      }

      /* Check if we can set the focus to this window */
      for (pwndTop = Window; pwndTop; pwndTop = pwndTop->spwndParent)
      {
         if (pwndTop->style & (WS_MINIMIZED|WS_DISABLED)) return 0;
         if ((pwndTop->style & (WS_POPUP|WS_CHILD)) != WS_CHILD) break;
         if (pwndTop->spwndParent == NULL) break;
      }
      if (co_HOOK_CallHooks( WH_CBT, HCBT_SETFOCUS, (WPARAM)Window->head.h, (LPARAM)hWndPrev))
      {
         ERR("SetFocus 1 WH_CBT Call Hook return!\n");
         return 0;
      }

      /* Activate pwndTop if needed. */
      if (pwndTop != ThreadQueue->spwndActive)
      {
         PUSER_MESSAGE_QUEUE ForegroundQueue = IntGetFocusMessageQueue(); // Keep it based on desktop.
         if (ThreadQueue != ForegroundQueue && IsAllowedFGActive(pti, pwndTop)) // Rule 2 & 3.
         {
            //ERR("SetFocus: Set Foreground!\n");
            if (!(pwndTop->style & WS_VISIBLE))
            {
                pti->ppi->W32PF_flags |= W32PF_ALLOWFOREGROUNDACTIVATE;
            }
            if (!co_IntSetForegroundAndFocusWindow(pwndTop, FALSE, TRUE))
            {
               ERR("SetFocus: Set Foreground and Focus Failed!\n");
               return 0;
            }
         }

         /* Set Active when it is needed. */
         if (pwndTop != ThreadQueue->spwndActive)
         {
            //ERR("SetFocus: Set Active! %p\n",pwndTop?UserHMGetHandle(pwndTop):0);
            if (!co_IntSetActiveWindow(pwndTop, FALSE, FALSE, FALSE))
            {
               ERR("SetFocus: Set Active Failed!\n");
               return 0;
            }
         }

         /* Abort if window destroyed */
         if (Window->state2 & WNDS2_INDESTROY) return 0;
         /* Do not change focus if the window is no longer active */
         if (pwndTop != ThreadQueue->spwndActive)
         {
            ERR("SetFocus: Top window did not go active!\n");
            return 0;
         }
      }

      // Check again! SetActiveWindow could have set the focus via WM_ACTIVATE.
      hWndPrev = ThreadQueue->spwndFocus ? UserHMGetHandle(ThreadQueue->spwndFocus) : 0;

      IntSendFocusMessages( pti, Window);

      TRACE("Focus: %p -> %p\n", hWndPrev, Window->head.h);
   }
   else /* NULL hwnd passed in */
   {
      if (co_HOOK_CallHooks( WH_CBT, HCBT_SETFOCUS, (WPARAM)0, (LPARAM)hWndPrev))
      {
         ERR("SetFocus: 2 WH_CBT Call Hook return!\n");
         return 0;
      }
      //ERR("SetFocus: Set Focus NULL\n");
      /* set the current thread focus window null */
      IntSendFocusMessages( pti, NULL);
   }
   return hWndPrev ? (IntIsWindow(hWndPrev) ? hWndPrev : 0) : 0;
}

Referenced by co_WinPosShowWindow(), IntDefWindowProc(), IntEnableWindow(), IntSendDestroyMsg(), and NtUserSetFocus().

DefSetText()

BOOL APIENTRY DefSetText	(	PWND	Wnd,
		PCWSTR	WindowText
	)

Definition at line 4111 of file window.c.

{
   UNICODE_STRING UnicodeString;
   BOOL Ret = FALSE;

   RtlInitUnicodeString(&UnicodeString, WindowText);

   if (UnicodeString.Length != 0)
   {
      if (Wnd->strName.MaximumLength > 0 &&
          UnicodeString.Length <= Wnd->strName.MaximumLength - sizeof(UNICODE_NULL))
      {
         ASSERT(Wnd->strName.Buffer != NULL);

         Wnd->strName.Length = UnicodeString.Length;
         Wnd->strName.Buffer[UnicodeString.Length / sizeof(WCHAR)] = L'\0';
         RtlCopyMemory(Wnd->strName.Buffer,
                              UnicodeString.Buffer,
                              UnicodeString.Length);
      }
      else
      {
         PWCHAR buf;
         Wnd->strName.MaximumLength = Wnd->strName.Length = 0;
         buf = Wnd->strName.Buffer;
         Wnd->strName.Buffer = NULL;
         if (buf != NULL)
         {
            DesktopHeapFree(Wnd->head.rpdesk, buf);
         }

         Wnd->strName.Buffer = DesktopHeapAlloc(Wnd->head.rpdesk,
                                                   UnicodeString.Length + sizeof(UNICODE_NULL));
         if (Wnd->strName.Buffer != NULL)
         {
            Wnd->strName.Buffer[UnicodeString.Length / sizeof(WCHAR)] = L'\0';
            RtlCopyMemory(Wnd->strName.Buffer,
                                 UnicodeString.Buffer,
                                 UnicodeString.Length);
            Wnd->strName.MaximumLength = UnicodeString.Length + sizeof(UNICODE_NULL);
            Wnd->strName.Length = UnicodeString.Length;
         }
         else
         {
            EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
            goto Exit;
         }
      }
   }
   else
   {
      Wnd->strName.Length = 0;
      if (Wnd->strName.Buffer != NULL)
          Wnd->strName.Buffer[0] = L'\0';
   }

   // FIXME: HAX! Windows does not do this in here!
   // In User32, these are called after: NotifyWinEvent EVENT_OBJECT_NAMECHANGE than
   // RepaintButton, StaticRepaint, NtUserCallHwndLock HWNDLOCK_ROUTINE_REDRAWFRAMEANDHOOK, etc.
   /* Send shell notifications */
   if (!Wnd->spwndOwner && !IntGetParent(Wnd))
   {
      co_IntShellHookNotify(HSHELL_REDRAW, (WPARAM) UserHMGetHandle(Wnd), FALSE); // FIXME Flashing?
   }

   Ret = TRUE;
Exit:
   if (UnicodeString.Buffer) RtlFreeUnicodeString(&UnicodeString);
   return Ret;
}

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);
}

DefWndDoSizeMove()

VOID FASTCALL DefWndDoSizeMove	(	PWND	pwnd,
		WORD	wParam
	)

Definition at line 239 of file nonclient.c.

{
   MSG msg;
   RECT sizingRect, mouseRect, origRect, unmodRect;
   HDC hdc;
   LONG hittest = (LONG)(wParam & 0x0f);
   PCURICON_OBJECT DragCursor = NULL, OldCursor = NULL;
   POINT minTrack, maxTrack;
   POINT capturePoint, pt;
   ULONG Style, ExStyle;
   BOOL thickframe;
   BOOL iconic;
   BOOL moved = FALSE;
   BOOL DragFullWindows = FALSE;
   PWND pWndParent = NULL;
   WPARAM syscommand = (wParam & 0xfff0);
   PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
   //PMONITOR mon = 0; Don't port sync from wine!!! This breaks explorer task bar sizing!!
   //                  The task bar can grow in size and can not reduce due to the change
   //                  in the work area.
   DWORD ExStyleTB, StyleTB;
   BOOL IsTaskBar;

   Style = pwnd->style;
   ExStyle = pwnd->ExStyle;
   iconic = (Style & WS_MINIMIZE) != 0;

   if ((Style & WS_MAXIMIZE) || !IntIsWindowVisible(pwnd)) return;

   thickframe = UserHasThickFrameStyle(Style, ExStyle) && !iconic;

   //
   // Show window contents while dragging the window, get flag from registry data.
   //
   UserSystemParametersInfo(SPI_GETDRAGFULLWINDOWS, 0, &DragFullWindows, 0);

   pt.x = pti->ptLast.x;
   pt.y = pti->ptLast.y;
   capturePoint = pt;
   UserClipCursor( NULL );

   TRACE("pwnd %p command %04lx, hittest %d, pos %d,%d\n",
          pwnd, syscommand, hittest, pt.x, pt.y);

   if (syscommand == SC_MOVE)
   {
      if (!hittest) hittest = DefWndStartSizeMove(pwnd, wParam, &capturePoint);
      if (!hittest) return;
   }
   else  /* SC_SIZE */
   {
      if (!thickframe) return;
      if (hittest && (syscommand != SC_MOUSEMENU))
      {
          hittest += (HTLEFT - WMSZ_LEFT);
      }
      else
      {
          co_UserSetCapture(UserHMGetHandle(pwnd));
          hittest = DefWndStartSizeMove(pwnd, wParam, &capturePoint);
      if (!hittest)
          {
              IntReleaseCapture();
              return;
          }
      }
   }

   /* Get min/max info */

   co_WinPosGetMinMaxInfo(pwnd, NULL, NULL, &minTrack, &maxTrack);
   sizingRect = pwnd->rcWindow;
   origRect = sizingRect;
   if (Style & WS_CHILD)
   {
      pWndParent = IntGetParent(pwnd);
      IntGetClientRect( pWndParent, &mouseRect );
      IntMapWindowPoints( pWndParent, 0, (LPPOINT)&mouseRect, 2 );
      IntMapWindowPoints( 0, pWndParent, (LPPOINT)&sizingRect, 2 );
      unmodRect = sizingRect;
   }
   else
   {
      if (!(ExStyle & WS_EX_TOPMOST))
      {
        UserSystemParametersInfo(SPI_GETWORKAREA, 0, &mouseRect, 0);
      }
      else
      {
        RECTL_vSetRect(&mouseRect, 0, 0, UserGetSystemMetrics(SM_CXSCREEN), UserGetSystemMetrics(SM_CYSCREEN));
      }
      unmodRect = sizingRect;
   }

   if (ON_LEFT_BORDER(hittest))
   {
      mouseRect.left  = max( mouseRect.left, sizingRect.right-maxTrack.x+capturePoint.x-sizingRect.left );
      mouseRect.right = min( mouseRect.right, sizingRect.right-minTrack.x+capturePoint.x-sizingRect.left );
   }
   else if (ON_RIGHT_BORDER(hittest))
   {
      mouseRect.left  = max( mouseRect.left, sizingRect.left+minTrack.x+capturePoint.x-sizingRect.right );
      mouseRect.right = min( mouseRect.right, sizingRect.left+maxTrack.x+capturePoint.x-sizingRect.right );
   }
   if (ON_TOP_BORDER(hittest))
   {
      mouseRect.top    = max( mouseRect.top, sizingRect.bottom-maxTrack.y+capturePoint.y-sizingRect.top );
      mouseRect.bottom = min( mouseRect.bottom,sizingRect.bottom-minTrack.y+capturePoint.y-sizingRect.top);
   }
   else if (ON_BOTTOM_BORDER(hittest))
   {
      mouseRect.top    = max( mouseRect.top, sizingRect.top+minTrack.y+capturePoint.y-sizingRect.bottom );
      mouseRect.bottom = min( mouseRect.bottom, sizingRect.top+maxTrack.y+capturePoint.y-sizingRect.bottom );
   }

   hdc = UserGetDCEx( pWndParent, 0, DCX_CACHE );
   if (iconic)
   {
       DragCursor = pwnd->pcls->spicn;
       if (DragCursor)
       {
           UserReferenceObject(DragCursor);
       }
       else
       {
           HCURSOR CursorHandle = (HCURSOR)co_IntSendMessage( UserHMGetHandle(pwnd), WM_QUERYDRAGICON, 0, 0 );
           if (CursorHandle)
           {
               DragCursor = UserGetCurIconObject(CursorHandle);
           }
           else
           {
               iconic = FALSE;
           }
       }
   }

   /* repaint the window before moving it around */
   co_UserRedrawWindow( pwnd, NULL, 0, RDW_UPDATENOW | RDW_ALLCHILDREN);

   IntNotifyWinEvent( EVENT_SYSTEM_MOVESIZESTART, pwnd, OBJID_WINDOW, CHILDID_SELF, 0);

   co_IntSendMessage( UserHMGetHandle(pwnd), WM_ENTERSIZEMOVE, 0, 0 );

   MsqSetStateWindow(pti, MSQ_STATE_MOVESIZE, UserHMGetHandle(pwnd));

   if (IntGetCapture() != UserHMGetHandle(pwnd)) co_UserSetCapture( UserHMGetHandle(pwnd) );

   pwnd->head.pti->TIF_flags |= TIF_MOVESIZETRACKING;

   for(;;)
   {
      int dx = 0, dy = 0;

      if (!co_IntGetPeekMessage(&msg, 0, 0, 0, PM_REMOVE, TRUE)) break;
      if (IntCallMsgFilter( &msg, MSGF_SIZE )) continue;

      /* Exit on button-up */
      if (msg.message == WM_LBUTTONUP)
      {
         /* Test for typical TaskBar ExStyle Values */
         ExStyleTB = (ExStyle & WS_EX_TOOLWINDOW);
         TRACE("ExStyle is '%x'.\n", ExStyleTB);

         /* Test for typical TaskBar Style Values */
         StyleTB = (Style & (WS_POPUP | WS_VISIBLE |
                        WS_CLIPSIBLINGS | WS_CLIPCHILDREN));
         TRACE("Style is '%x'.\n", StyleTB);

         /* Test for masked typical TaskBar Style and ExStyles to detect TaskBar */
         IsTaskBar = (StyleTB == (WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN))
                     && (ExStyleTB == WS_EX_TOOLWINDOW);
         TRACE("This %s the TaskBar.\n", IsTaskBar ? "is" : "is not");

         // check for snapping if was moved by caption
         if (hittest == HTCAPTION && thickframe && (ExStyle & WS_EX_MDICHILD) == 0)
         {
            RECT snapRect;
            BOOL doSideSnap = FALSE;
            UserSystemParametersInfo(SPI_GETWORKAREA, 0, &snapRect, 0);

            /* if this is the taskbar, then we want to just exit */
            if (IsTaskBar)
            {
               break;
            }
            // snap to left
            if (pt.x <= snapRect.left)
            {
               snapRect.right = (snapRect.right - snapRect.left) / 2 + snapRect.left;
               doSideSnap = TRUE;
            }
            // snap to right
            if (pt.x >= snapRect.right-1)
            {
               snapRect.left = (snapRect.right - snapRect.left) / 2 + snapRect.left;
               doSideSnap = TRUE;
            }
            
            if (doSideSnap)
            {
               co_WinPosSetWindowPos(pwnd,
                                     0,
                                     snapRect.left,
                                     snapRect.top,
                                     snapRect.right - snapRect.left,
                                     snapRect.bottom - snapRect.top,
                                     0);
               pwnd->InternalPos.NormalRect = origRect;
            }
            else
            {
               // maximize if on dragged to top
               if (pt.y <= snapRect.top)
               {
                  co_IntSendMessage(UserHMGetHandle(pwnd), WM_SYSCOMMAND, SC_MAXIMIZE, 0);
                  pwnd->InternalPos.NormalRect = origRect;
               }
            }
         }
         break;
      }
      
      /* Exit on Return or Esc */
      if (msg.message == WM_KEYDOWN &&
          (msg.wParam == VK_RETURN || msg.wParam == VK_ESCAPE))
      {
         break;
      }

      if ((msg.message != WM_KEYDOWN) && (msg.message != WM_MOUSEMOVE))
      {
         IntTranslateKbdMessage( &msg , 0 );
         IntDispatchMessage( &msg );
         continue;  /* We are not interested in other messages */
      }

      pt = msg.pt;

      if (msg.message == WM_KEYDOWN) switch(msg.wParam)
      {
    case VK_UP:    pt.y -= 8; break;
    case VK_DOWN:  pt.y += 8; break;
    case VK_LEFT:  pt.x -= 8; break;
    case VK_RIGHT: pt.x += 8; break;
      }

      pt.x = max( pt.x, mouseRect.left );
      pt.x = min( pt.x, mouseRect.right - 1 );
      pt.y = max( pt.y, mouseRect.top );
      pt.y = min( pt.y, mouseRect.bottom - 1 );

      dx = pt.x - capturePoint.x;
      dy = pt.y - capturePoint.y;

      if (dx || dy)
      {
      if ( !moved )
      {
          moved = TRUE;
          if ( iconic ) /* ok, no system popup tracking */
          {
              OldCursor = UserSetCursor(DragCursor, FALSE);
              UserShowCursor( TRUE );
          }
          else if(!DragFullWindows)
             UserDrawMovingFrame( hdc, &sizingRect, thickframe );
      }

      if (msg.message == WM_KEYDOWN) UserSetCursorPos(pt.x, pt.y, 0, 0, FALSE);
      else
      {
          RECT newRect = unmodRect;

          if (!iconic && !DragFullWindows) UserDrawMovingFrame( hdc, &sizingRect, thickframe );
          if (hittest == HTCAPTION) RECTL_vOffsetRect( &newRect, dx, dy );
          if (ON_LEFT_BORDER(hittest)) newRect.left += dx;
          else if (ON_RIGHT_BORDER(hittest)) newRect.right += dx;
          if (ON_TOP_BORDER(hittest)) newRect.top += dy;
          else if (ON_BOTTOM_BORDER(hittest)) newRect.bottom += dy;
          capturePoint = pt;

              //
              //  Save the new position to the unmodified rectangle. This allows explorer task bar
              //  sizing. Explorer will forces back the position unless a certain amount of sizing
              //  has occurred.
              //
              unmodRect = newRect;

          /* determine the hit location */
              if (syscommand == SC_SIZE)
              {
                  WPARAM wpSizingHit = 0;

                  if (hittest >= HTLEFT && hittest <= HTBOTTOMRIGHT)
                      wpSizingHit = WMSZ_LEFT + (hittest - HTLEFT);
                  co_IntSendMessage( UserHMGetHandle(pwnd), WM_SIZING, wpSizingHit, (LPARAM)&newRect );
              }
              else
                  co_IntSendMessage( UserHMGetHandle(pwnd), WM_MOVING, 0, (LPARAM)&newRect );

          if (!iconic)
              {
                 if (!DragFullWindows)
                     UserDrawMovingFrame( hdc, &newRect, thickframe );
                 else
                 {  // Moving the whole window now!
                    HRGN hrgnNew;
                    HRGN hrgnOrig = GreCreateRectRgnIndirect(&pwnd->rcWindow);

                    if (pwnd->hrgnClip != NULL)
                       NtGdiCombineRgn(hrgnOrig, hrgnOrig, pwnd->hrgnClip, RGN_AND);

                    //IntMapWindowPoints( 0, pWndParent, (POINT *)&rect, 2 );
            co_WinPosSetWindowPos( pwnd,
                                   0,
                                   newRect.left,
                                   newRect.top,
                           newRect.right - newRect.left,
                           newRect.bottom - newRect.top,
                          ( hittest == HTCAPTION ) ? SWP_NOSIZE : 0 );

                    hrgnNew = GreCreateRectRgnIndirect(&pwnd->rcWindow);
                    if (pwnd->hrgnClip != NULL)
                       NtGdiCombineRgn(hrgnNew, hrgnNew, pwnd->hrgnClip, RGN_AND);

                    if (hrgnNew)
                    {
                       if (hrgnOrig)
                          NtGdiCombineRgn(hrgnOrig, hrgnOrig, hrgnNew, RGN_DIFF);
                    }
                    else
                    {
                       if (hrgnOrig)
                       {
                          GreDeleteObject(hrgnOrig);
                          hrgnOrig = 0;
                       }
                    }

                    // Update all the windows after the move or size, including this window.
                    UpdateThreadWindows(UserGetDesktopWindow()->spwndChild, pti, hrgnOrig);

                    if (hrgnOrig) GreDeleteObject(hrgnOrig);
                    if (hrgnNew) GreDeleteObject(hrgnNew);
                 }
              }
              sizingRect = newRect;
      }
      }
   }

   pwnd->head.pti->TIF_flags &= ~TIF_MOVESIZETRACKING;

   IntReleaseCapture();

   if ( iconic )
   {
      if ( moved ) /* restore cursors, show icon title later on */
      {
          UserShowCursor( FALSE );
          OldCursor = UserSetCursor(OldCursor, FALSE);
      }

      /* It could be that the cursor was already changed while we were proceeding,
       * so we must unreference whatever cursor was current at the time we restored the old one.
       * Maybe it is DragCursor, but maybe it is another one and DragCursor got already freed.
       */
      if (OldCursor) UserDereferenceObject(OldCursor);
   }
   else if ( moved && !DragFullWindows )
      UserDrawMovingFrame( hdc, &sizingRect, thickframe );

   UserReleaseDC(NULL, hdc, FALSE);

   //if (pWndParent) IntMapWindowPoints( 0, pWndParent, (POINT *)&sizingRect, 2 );

   if (co_HOOK_CallHooks(WH_CBT, HCBT_MOVESIZE, (WPARAM)UserHMGetHandle(pwnd), (LPARAM)&sizingRect))
   {
      ERR("DoSizeMove : WH_CBT Call Hook return!\n");
      moved = FALSE;
   }

   IntNotifyWinEvent( EVENT_SYSTEM_MOVESIZEEND, pwnd, OBJID_WINDOW, CHILDID_SELF, 0);

   MsqSetStateWindow(pti, MSQ_STATE_MOVESIZE, NULL);

   co_IntSendMessage( UserHMGetHandle(pwnd), WM_EXITSIZEMOVE, 0, 0 );
   co_IntSendMessage( UserHMGetHandle(pwnd), WM_SETVISIBLE, !!(pwnd->style & WS_MINIMIZE), 0L);
   /* window moved or resized */
   if (moved)
   {
      /* if the moving/resizing isn't canceled call SetWindowPos
       * with the new position or the new size of the window
       */
      if (!((msg.message == WM_KEYDOWN) && (msg.wParam == VK_ESCAPE)) )
      {
      /* NOTE: SWP_NOACTIVATE prevents document window activation in Word 6 */
      if (!DragFullWindows || iconic )
      {
        co_WinPosSetWindowPos( pwnd,
                               0,
                               sizingRect.left,
                               sizingRect.top,
                       sizingRect.right - sizingRect.left,
                       sizingRect.bottom - sizingRect.top,
                      ( hittest == HTCAPTION ) ? SWP_NOSIZE : 0 );
          }
      }
      else
      { /* restore previous size/position */
    if ( DragFullWindows )
    {
      co_WinPosSetWindowPos( pwnd,
                             0,
                             origRect.left,
                             origRect.top,
                     origRect.right - origRect.left,
                     origRect.bottom - origRect.top,
                    ( hittest == HTCAPTION ) ? SWP_NOSIZE : 0 );
        }
      }
   }

   if ( IntIsWindow(UserHMGetHandle(pwnd)) )
   {
     if ( iconic )
     {
    /* Single click brings up the system menu when iconized */
    if ( !moved )
        {
        if( Style & WS_SYSMENU )
          co_IntSendMessage( UserHMGetHandle(pwnd), WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, MAKELONG(pt.x,pt.y));
        }
     }
   }
}

Referenced by DefWndHandleSysCommand().

GetControlBrush()

HBRUSH FASTCALL GetControlBrush	(	PWND	,
		HDC	,
		UINT
	)

Definition at line 171 of file misc.c.

{
    PWND pwndParent = IntGetParent(pwnd);
    return GetControlColor( pwndParent, pwnd, hdc, ctlType);
}

Referenced by EDIT_NotifyCtlColor(), IntDrawScrollInterior(), NtUserGetControlBrush(), and STATIC_SendWmCtlColorStatic().

GetControlColor()

HBRUSH FASTCALL GetControlColor	(	PWND	,
		PWND	,
		HDC	,
		UINT
	)

Definition at line 145 of file misc.c.

{
    HBRUSH hBrush;

    if (!pwndParent) pwndParent = pwnd;

    if ( pwndParent->head.pti->ppi != PsGetCurrentProcessWin32Process())
    {
       return (HBRUSH)IntDefWindowProc( pwndParent, CtlMsg, (WPARAM)hdc, (LPARAM)UserHMGetHandle(pwnd), FALSE);
    }

    hBrush = (HBRUSH)co_IntSendMessage( UserHMGetHandle(pwndParent), CtlMsg, (WPARAM)hdc, (LPARAM)UserHMGetHandle(pwnd));

    if (!hBrush || !GreIsHandleValid(hBrush))
    {
       hBrush = (HBRUSH)IntDefWindowProc( pwndParent, CtlMsg, (WPARAM)hdc, (LPARAM)UserHMGetHandle(pwnd), FALSE);
    }
    return hBrush;
}

Referenced by ButtonWndProc_common(), CB_Paint(), COMBO_PrepareColors(), DEFDLG_Proc(), GB_Paint(), GetControlBrush(), IntFillWindow(), LISTBOX_Paint(), LISTBOX_RepaintItem(), ListBoxWndProc_common(), NtUserGetControlColor(), OB_Paint(), PB_Paint(), and UB_Paint().

GetLayeredStatus()

BOOL FASTCALL GetLayeredStatus

(

PWND

pWnd

)

Definition at line 23 of file layered.c.

{
   PLRD_PROP pLrdProp = UserGetProp(pWnd, AtomLayer, TRUE);
   if (pLrdProp)
   {
      return pLrdProp->is_Layered;
   }
   return FALSE;
}

Referenced by NtUserUpdateLayeredWindow().

GetProcessLuid()

NTSTATUS GetProcessLuid	(	IN PETHREAD Thread	OPTIONAL,
		IN PEPROCESS Process	OPTIONAL,
		OUT PLUID	Luid
	)

Definition at line 787 of file misc.c.

{
    NTSTATUS Status;
    PACCESS_TOKEN Token = NULL;
    SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
    BOOLEAN CopyOnOpen, EffectiveOnly;

    if (Thread && Process)
        return STATUS_INVALID_PARAMETER;

    /* If nothing has been specified, use the current thread */
    if (!Thread && !Process)
        Thread = PsGetCurrentThread();

    if (Thread)
    {
        /* Use a thread token */
        ASSERT(!Process);
        Token = PsReferenceImpersonationToken(Thread,
                                              &CopyOnOpen,
                                              &EffectiveOnly,
                                              &ImpersonationLevel);

        /* If we don't have a thread token, use a process token */
        if (!Token)
            Process = PsGetThreadProcess(Thread);
    }
    if (!Token && Process)
    {
        /* Use a process token */
        Token = PsReferencePrimaryToken(Process);

        /* If we don't have a token, fail */
        if (!Token)
            return STATUS_NO_TOKEN;
    }
    ASSERT(Token);

    /* Query the LUID */
    Status = SeQueryAuthenticationIdToken(Token, Luid);

    /* Get rid of the token and return */
    ObDereferenceObject(Token);
    return Status;
}

Referenced by BuildUserModeWindowStationName(), IntResolveDesktop(), UserEndShutdown(), and UserInitiateShutdown().

InitMetrics()

BOOL NTAPI InitMetrics

(

VOID

)

Definition at line 19 of file metric.c.

{
    INT *piSysMet = gpsi->aiSysMet;
    ULONG Width, Height;

    /* Note: used for the SM_CLEANBOOT metric */
    DWORD dwValue = 0;
    HKEY hKey = 0;

    /* Clean boot */
    piSysMet[SM_CLEANBOOT] = 0; // Fallback value of 0 (normal mode)
    if(NT_SUCCESS(RegOpenKey(L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Control\\SafeBoot\\Option", &hKey)))
    {
        if(RegReadDWORD(hKey, L"OptionValue", &dwValue)) piSysMet[SM_CLEANBOOT] = (INT)dwValue;
        ZwClose(hKey);
    }

    /* FIXME: HACK, due to missing PDEV on first init */
    if (!gppdevPrimary)
    {
        Width = 640;
        Height = 480;
    }
    else
    {
        Width = gppdevPrimary->gdiinfo.ulHorzRes;
        Height = gppdevPrimary->gdiinfo.ulVertRes;
    }

    /* Screen sizes */
    piSysMet[SM_CXSCREEN] = Width;
    piSysMet[SM_CYSCREEN] = Height;
    piSysMet[SM_XVIRTUALSCREEN] = 0;
    piSysMet[SM_YVIRTUALSCREEN] = 0;
    piSysMet[SM_CXVIRTUALSCREEN] = Width;
    piSysMet[SM_CYVIRTUALSCREEN] = Height;

    /* NC area sizes */
    piSysMet[SM_CYCAPTION] = gspv.ncm.iCaptionHeight + 1;       // 19
    piSysMet[SM_CYSMCAPTION] = gspv.ncm.iSmCaptionHeight + 1;   // 15;
    piSysMet[SM_CXSIZE] = gspv.ncm.iCaptionHeight;              // 18;
    piSysMet[SM_CYSIZE] = gspv.ncm.iCaptionHeight;              // 18;
    piSysMet[SM_CXSMSIZE] = gspv.ncm.iSmCaptionWidth;   // 12; XP: piSysMet(SM_CYSMCAPTION) - 1
    piSysMet[SM_CYSMSIZE] = gspv.ncm.iSmCaptionHeight;  // 14;
    piSysMet[SM_CXBORDER] = 1; // Seems to be hardcoded
    piSysMet[SM_CYBORDER] = 1; // Seems to be hardcoded
    piSysMet[SM_CXFOCUSBORDER] = 1;
    piSysMet[SM_CYFOCUSBORDER] = 1;
    piSysMet[SM_CXDLGFRAME] = 3;
    piSysMet[SM_CYDLGFRAME] = 3;
    piSysMet[SM_CXEDGE] = 2;
    piSysMet[SM_CYEDGE] = 2;
    piSysMet[SM_CXFRAME] = piSysMet[SM_CXDLGFRAME] + gspv.ncm.iBorderWidth; // 4
    piSysMet[SM_CYFRAME] = piSysMet[SM_CYDLGFRAME] + gspv.ncm.iBorderWidth; // 4
#if (_WIN32_WINNT >= 0x0600)
    piSysMet[SM_CXPADDEDBORDER] = 0;
#endif

    /* Window sizes */
    TRACE("ncm.iCaptionWidth=%d,GetSystemMetrics(SM_CYSIZE)=%d,GetSystemMetrics(SM_CXFRAME)=%d,avcwCaption=%d \n",
           gspv.ncm.iCaptionWidth, piSysMet[SM_CYSIZE],piSysMet[SM_CXFRAME], gspv.tmCaptionFont.tmAveCharWidth);

    piSysMet[SM_CXMIN] = 3 * max(gspv.ncm.iCaptionWidth, 8) // 112
                         + piSysMet[SM_CYSIZE] + 4
                         + 4 * gspv.tmCaptionFont.tmAveCharWidth
                         + 2 * piSysMet[SM_CXFRAME];
    piSysMet[SM_CYMIN] = piSysMet[SM_CYCAPTION] + 2 * piSysMet[SM_CYFRAME]; // 27
    piSysMet[SM_CXMAXIMIZED] = piSysMet[SM_CXSCREEN] + 2 * piSysMet[SM_CXFRAME];
    piSysMet[SM_CYMAXIMIZED] = piSysMet[SM_CYSCREEN] - 20;
    piSysMet[SM_CXFULLSCREEN] = piSysMet[SM_CXSCREEN];
    piSysMet[SM_CYFULLSCREEN] = piSysMet[SM_CYMAXIMIZED] - piSysMet[SM_CYMIN];
    piSysMet[SM_CYKANJIWINDOW] = 0;
    piSysMet[SM_CXMINIMIZED] = gspv.mm.iWidth + 6;
    piSysMet[SM_CYMINIMIZED] = piSysMet[SM_CYCAPTION] + 5;
    piSysMet[SM_CXMINSPACING] = piSysMet[SM_CXMINIMIZED] + gspv.mm.iHorzGap;
    piSysMet[SM_CYMINSPACING] = piSysMet[SM_CYMINIMIZED] + gspv.mm.iVertGap;
    piSysMet[SM_CXMAXTRACK] = piSysMet[SM_CXVIRTUALSCREEN] + 4
                              + 2 * piSysMet[SM_CXFRAME];
    piSysMet[SM_CYMAXTRACK] = piSysMet[SM_CYVIRTUALSCREEN] + 4
                              + 2 * piSysMet[SM_CYFRAME];

    /* Icon */
    piSysMet[SM_CXVSCROLL] = gspv.ncm.iScrollWidth;     // 16;
    piSysMet[SM_CYVTHUMB] = gspv.ncm.iScrollHeight;     // 16;
    piSysMet[SM_CYHSCROLL] = gspv.ncm.iScrollWidth;     // 16;
    piSysMet[SM_CXHTHUMB] = gspv.ncm.iScrollHeight;     // 16;
    piSysMet[SM_CYVSCROLL] = gspv.ncm.iScrollHeight;    // 16
    piSysMet[SM_CXHSCROLL] = gspv.ncm.iScrollHeight;    // 16;
    piSysMet[SM_CXICON] = 32;
    piSysMet[SM_CYICON] = 32;
    piSysMet[SM_CXSMICON] = 16;
    piSysMet[SM_CYSMICON] = 16;
    piSysMet[SM_CXICONSPACING] = gspv.im.iHorzSpacing;  // 64;
    piSysMet[SM_CYICONSPACING] = gspv.im.iVertSpacing;  // 64;
    piSysMet[SM_CXCURSOR] = 32;
    piSysMet[SM_CYCURSOR] = 32;
    piSysMet[SM_CXMINTRACK] = piSysMet[SM_CXMIN];       // 117
    piSysMet[SM_CYMINTRACK] = piSysMet[SM_CYMIN];       // 27
    piSysMet[SM_CXDRAG] = 4;
    piSysMet[SM_CYDRAG] = 4;
    piSysMet[SM_ARRANGE] = gspv.mm.iArrange;            // 8;

    /* Menu */
    piSysMet[SM_CYMENU] = gspv.ncm.iMenuHeight + 1;     // 19;
    piSysMet[SM_MENUDROPALIGNMENT] = gspv.bMenuDropAlign;
    piSysMet[SM_CXMENUCHECK] = ((1 + gspv.tmMenuFont.tmHeight +
                                 gspv.tmMenuFont.tmExternalLeading) & ~1) - 1; // 13;
    piSysMet[SM_CYMENUCHECK] = piSysMet[SM_CXMENUCHECK];
    piSysMet[SM_CXMENUSIZE] = gspv.ncm.iMenuWidth;      // 18;
    piSysMet[SM_CYMENUSIZE] = gspv.ncm.iMenuHeight;     // 18;

    /* Mouse */
    piSysMet[SM_MOUSEPRESENT] = 1;
    piSysMet[SM_MOUSEWHEELPRESENT] = 1;
    piSysMet[SM_CMOUSEBUTTONS] = 2;
    piSysMet[SM_SWAPBUTTON] = gspv.bMouseBtnSwap ? 1 : 0;
    piSysMet[SM_CXDOUBLECLK] = gspv.iDblClickWidth;
    piSysMet[SM_CYDOUBLECLK] = gspv.iDblClickHeight;
#if (_WIN32_WINNT >= 0x0600)
    piSysMet[SM_MOUSEHORIZONTALWHEELPRESENT] = 0;
#endif

    /* Version info */
    piSysMet[SM_TABLETPC] = 0;
    piSysMet[SM_MEDIACENTER] = 0;
    piSysMet[SM_STARTER] = 0;
    piSysMet[SM_SERVERR2] = 0;
    piSysMet[SM_PENWINDOWS] = 0;

    /* Other */
    piSysMet[SM_DEBUG] = 0;
    piSysMet[SM_NETWORK] = 3;
    piSysMet[SM_SLOWMACHINE] = 0;
    piSysMet[SM_SECURE] = 0;
    piSysMet[SM_DBCSENABLED] = 0;
    piSysMet[SM_SHOWSOUNDS] = gspv.bShowSounds;
    piSysMet[SM_MIDEASTENABLED] = 0;
    piSysMet[SM_CMONITORS] = 1;
    piSysMet[SM_SAMEDISPLAYFORMAT] = 1;
    piSysMet[SM_IMMENABLED] = 0;

    /* Reserved */
    piSysMet[SM_RESERVED1] = 0;
    piSysMet[SM_RESERVED2] = 0;
    piSysMet[SM_RESERVED3] = 0;
    piSysMet[SM_RESERVED4] = 0;
    piSysMet[64] = 0;
    piSysMet[65] = 0;
    piSysMet[66] = 0;
#if (_WIN32_WINNT >= 0x0600)
    piSysMet[90] = 0;
#endif

    gpsi->dwSRVIFlags |= SRVINFO_METRICS;
    Setup = TRUE;

    return TRUE;
}

Referenced by co_IntInitializeDesktopGraphics(), SpiUpdatePerUserSystemParameters(), UserChangeDisplaySettings(), UserRefreshDisplay(), and UserSystemParametersInfo().

InitSessionImpl()

NTSTATUS FASTCALL InitSessionImpl

(

VOID

)

Definition at line 18 of file session.c.

{
   return RtlCreateAtomTable(37, &gAtomTable);
}

Referenced by InitUserImpl().

InitThreadCallback()

NTSTATUS NTAPI InitThreadCallback

(

PETHREAD

Thread

)

Definition at line 448 of file main.c.

{
    PEPROCESS Process;
    PCLIENTINFO pci;
    PTHREADINFO ptiCurrent;
    int i;
    NTSTATUS Status = STATUS_SUCCESS;
    PTEB pTeb;
    PRTL_USER_PROCESS_PARAMETERS ProcessParams;

    Process = Thread->ThreadsProcess;

    pTeb = NtCurrentTeb();
    ASSERT(pTeb);

    ProcessParams = pTeb->ProcessEnvironmentBlock->ProcessParameters;

    /* Allocate a new Win32 thread info */
    Status = AllocW32Thread(Thread, &ptiCurrent);
    if (!NT_SUCCESS(Status))
    {
        ERR_CH(UserThread, "Failed to allocate pti for TID:0x%lx\n",
               HandleToUlong(Thread->Cid.UniqueThread));
        return Status;
    }

    /* Initialize the THREADINFO */
    ptiCurrent->pEThread = Thread;
    ptiCurrent->ppi = PsGetProcessWin32Process(Process);
    IntReferenceProcessInfo(ptiCurrent->ppi);
    pTeb->Win32ThreadInfo = ptiCurrent;
    ptiCurrent->pClientInfo = (PCLIENTINFO)pTeb->Win32ClientInfo;
    ptiCurrent->pcti = &ptiCurrent->cti;

    /* Mark the process as having threads */
    ptiCurrent->ppi->W32PF_flags |= W32PF_THREADCONNECTED;

    InitializeListHead(&ptiCurrent->WindowListHead);
    InitializeListHead(&ptiCurrent->W32CallbackListHead);
    InitializeListHead(&ptiCurrent->PostedMessagesListHead);
    InitializeListHead(&ptiCurrent->SentMessagesListHead);
    InitializeListHead(&ptiCurrent->PtiLink);
    for (i = 0; i < NB_HOOKS; i++)
    {
        InitializeListHead(&ptiCurrent->aphkStart[i]);
    }
    ptiCurrent->ptiSibling = ptiCurrent->ppi->ptiList;
    ptiCurrent->ppi->ptiList = ptiCurrent;
    ptiCurrent->ppi->cThreads++;

    ptiCurrent->hEventQueueClient = NULL;
    Status = ZwCreateEvent(&ptiCurrent->hEventQueueClient, EVENT_ALL_ACCESS,
                            NULL, SynchronizationEvent, FALSE);
    if (!NT_SUCCESS(Status))
    {
        ERR_CH(UserThread, "Event creation failed, Status 0x%08x.\n", Status);
        goto error;
    }
    Status = ObReferenceObjectByHandle(ptiCurrent->hEventQueueClient, 0,
                                       *ExEventObjectType, UserMode,
                                       (PVOID*)&ptiCurrent->pEventQueueServer, NULL);
    if (!NT_SUCCESS(Status))
    {
        ERR_CH(UserThread, "Failed referencing the event object, Status 0x%08x.\n", Status);
        ObCloseHandle(ptiCurrent->hEventQueueClient, UserMode);
        ptiCurrent->hEventQueueClient = NULL;
        goto error;
    }

    ptiCurrent->pcti->timeLastRead = EngGetTickCount32();

    ptiCurrent->MessageQueue = MsqCreateMessageQueue(ptiCurrent);
    if (ptiCurrent->MessageQueue == NULL)
    {
        ERR_CH(UserThread, "Failed to allocate message loop\n");
        Status = STATUS_NO_MEMORY;
        goto error;
    }

    ptiCurrent->KeyboardLayout = W32kGetDefaultKeyLayout();
    if (ptiCurrent->KeyboardLayout)
        UserReferenceObject(ptiCurrent->KeyboardLayout);

    ptiCurrent->TIF_flags &= ~TIF_INCLEANUP;

    // FIXME: Flag SYSTEM threads with... TIF_SYSTEMTHREAD !!

    /* CSRSS threads have some special features */
    if (Process == gpepCSRSS || !gpepCSRSS)
        ptiCurrent->TIF_flags = TIF_CSRSSTHREAD | TIF_DONTATTACHQUEUE;

    /* Initialize the CLIENTINFO */
    pci = (PCLIENTINFO)pTeb->Win32ClientInfo;
    RtlZeroMemory(pci, sizeof(*pci));
    pci->ppi = ptiCurrent->ppi;
    pci->fsHooks = ptiCurrent->fsHooks;
    pci->dwTIFlags = ptiCurrent->TIF_flags;
    if (ptiCurrent->KeyboardLayout)
    {
        pci->hKL = ptiCurrent->KeyboardLayout->hkl;
        pci->CodePage = ptiCurrent->KeyboardLayout->CodePage;
    }

    /* Need to pass the user Startup Information to the current process. */
    if ( ProcessParams )
    {
       if ( ptiCurrent->ppi->usi.cb == 0 )      // Not initialized yet.
       {
          if ( ProcessParams->WindowFlags != 0 ) // Need window flags set.
          {
             ptiCurrent->ppi->usi.cb          = sizeof(USERSTARTUPINFO);
             ptiCurrent->ppi->usi.dwX         = ProcessParams->StartingX;
             ptiCurrent->ppi->usi.dwY         = ProcessParams->StartingY;
             ptiCurrent->ppi->usi.dwXSize     = ProcessParams->CountX;
             ptiCurrent->ppi->usi.dwYSize     = ProcessParams->CountY;
             ptiCurrent->ppi->usi.dwFlags     = ProcessParams->WindowFlags;
             ptiCurrent->ppi->usi.wShowWindow = (WORD)ProcessParams->ShowWindowFlags;
          }
       }
    }

    /*
     * Assign a default window station and desktop to the process.
     * Do not try to open a desktop or window station before the very first
     * (interactive) window station has been created by Winlogon.
     */
    if (!(ptiCurrent->TIF_flags & (TIF_SYSTEMTHREAD | TIF_CSRSSTHREAD)) &&
        ptiCurrent->ppi->hdeskStartup == NULL &&
        InputWindowStation != NULL)
    {
        HWINSTA hWinSta = NULL;
        HDESK hDesk = NULL;
        UNICODE_STRING DesktopPath;
        PDESKTOP pdesk;

        /*
         * Inherit the thread desktop and process window station (if not yet inherited)
         * from the process startup info structure. See documentation of CreateProcess().
         */
        Status = STATUS_UNSUCCESSFUL;
        if (ProcessParams && ProcessParams->DesktopInfo.Length > 0)
        {
            Status = IntSafeCopyUnicodeStringTerminateNULL(&DesktopPath, &ProcessParams->DesktopInfo);
        }
        if (!NT_SUCCESS(Status))
        {
            RtlInitUnicodeString(&DesktopPath, NULL);
        }

        Status = IntResolveDesktop(Process,
                                   &DesktopPath,
                                   !!(ProcessParams->WindowFlags & STARTF_INHERITDESKTOP),
                                   &hWinSta,
                                   &hDesk);

        if (DesktopPath.Buffer)
            ExFreePoolWithTag(DesktopPath.Buffer, TAG_STRING);

        if (!NT_SUCCESS(Status))
        {
            ERR_CH(UserThread, "Failed to assign default desktop and winsta to process\n");
            goto error;
        }

        if (!UserSetProcessWindowStation(hWinSta))
        {
            Status = STATUS_UNSUCCESSFUL;
            ERR_CH(UserThread, "Failed to set initial process winsta\n");
            goto error;
        }

        /* Validate the new desktop */
        Status = IntValidateDesktopHandle(hDesk, UserMode, 0, &pdesk);
        if (!NT_SUCCESS(Status))
        {
            ERR_CH(UserThread, "Failed to validate initial desktop handle\n");
            goto error;
        }

        /* Store the parsed desktop as the initial desktop */
        ASSERT(ptiCurrent->ppi->hdeskStartup == NULL);
        ASSERT(Process->UniqueProcessId != gpidLogon);
        ptiCurrent->ppi->hdeskStartup = hDesk;
        ptiCurrent->ppi->rpdeskStartup = pdesk;
    }

    if (ptiCurrent->ppi->hdeskStartup != NULL)
    {
        if (!IntSetThreadDesktop(ptiCurrent->ppi->hdeskStartup, FALSE))
        {
            ERR_CH(UserThread, "Failed to set thread desktop\n");
            Status = STATUS_UNSUCCESSFUL;
            goto error;
        }
    }

    /* Mark the thread as fully initialized */
    ptiCurrent->TIF_flags |= TIF_GUITHREADINITIALIZED;

    if (!(ptiCurrent->ppi->W32PF_flags & (W32PF_ALLOWFOREGROUNDACTIVATE | W32PF_APPSTARTING)) &&
         (gptiForeground && gptiForeground->ppi == ptiCurrent->ppi ))
    {
        ptiCurrent->TIF_flags |= TIF_ALLOWFOREGROUNDACTIVATE;
    }
    ptiCurrent->pClientInfo->dwTIFlags = ptiCurrent->TIF_flags;

    /* Last things to do only if we are not a SYSTEM or CSRSS thread */
    if (!(ptiCurrent->TIF_flags & (TIF_SYSTEMTHREAD | TIF_CSRSSTHREAD)))
    {
        /* Callback to User32 Client Thread Setup */
        TRACE_CH(UserThread, "Call co_IntClientThreadSetup...\n");
        Status = co_IntClientThreadSetup();
        if (!NT_SUCCESS(Status))
        {
            ERR_CH(UserThread, "ClientThreadSetup failed with Status 0x%08lx\n", Status);
            goto error;
        }
        TRACE_CH(UserThread, "co_IntClientThreadSetup succeeded!\n");
    }
    else
    {
        TRACE_CH(UserThread, "co_IntClientThreadSetup cannot be called...\n");
    }

    TRACE_CH(UserThread, "UserCreateW32Thread pti 0x%p\n", ptiCurrent);
    return STATUS_SUCCESS;

error:
    ERR_CH(UserThread, "InitThreadCallback failed! Freeing pti 0x%p for TID:0x%lx\n",
           ptiCurrent, HandleToUlong(Thread->Cid.UniqueThread));
    ExitThreadCallback(Thread);
    return Status;
}

Referenced by Win32kThreadCallback().

IntClearWindowState()

VOID FASTCALL IntClearWindowState	(	PWND	,
		UINT
	)

Definition at line 588 of file misc.c.

{
   UINT bit;
   if (gptiCurrent->ppi != pWnd->head.pti->ppi) return;
   bit = 1 << LOWORD(Flag);
   TRACE("CWS %x\n",bit);
   switch(HIWORD(Flag))
   {
      case 0:
          pWnd->state &= ~bit;
          break;
      case 1:
          pWnd->state2 &= ~bit;
          break;
      case 2:
          pWnd->ExStyle2 &= ~bit;
          break;
   }
}

Referenced by NtUserCallHwndParam().

IntDdeGetMessageHook()

BOOL APIENTRY IntDdeGetMessageHook	(	PMSG	,
		LONG_PTR
	)

Definition at line 326 of file dde.c.

{
   PWND pWnd, pWndClient;
   PDDE_DATA pddeData;
   PDDE_PROP pddeProp;
   BOOL Ret;

   pWnd = UserGetWindowObject(pMsg->hwnd);
   if (pWnd == NULL)
   {
      ERR("DDE Get Window is dead. %p\n", pMsg->hwnd);
      return TRUE;
   }

   if (pMsg->message == WM_DDE_TERMINATE)
   {
      pddeProp = (PDDE_PROP)UserGetProp(pWnd, AtomDDETrack, TRUE);
      if (pddeProp)
      {
         pWndClient = UserGetWindowObject((HWND)pMsg->wParam);
         if (pWndClient == NULL)
         {
            ERR("DDE Get Client WM_DDE_TERMINATE\n");
         }

         UserRemoveProp(pWnd, AtomDDETrack, TRUE);
         ExFreePoolWithTag(pddeProp, USERTAG_DDE1);
      }
      return TRUE;
   }

   TRACE("DDE Get Msg 0x%x\n",pMsg->message);

   pddeData = (PDDE_DATA)ExtraInfo;

   if ( pddeData )
   {
      TRACE("DDE Get size %d lParam c=%08lx lp c=%08lx\n",pddeData->cbSize, pMsg->lParam, pddeData->lParam);

      // Callback.
      Ret = IntDDEGetCallback( pWnd, pMsg, pddeData->pvBuffer, pddeData->cbSize);
      if (!Ret)
      {
         ERR("DDE Get CB failed\n");
      }

      if (pddeData->pvBuffer) ExFreePoolWithTag(pddeData->pvBuffer, USERTAG_DDE);

      ExFreePoolWithTag(pddeData, USERTAG_DDE5);

      return Ret;
   }
   TRACE("DDE Get No DDE Data found!\n");
   return TRUE;
}

Referenced by co_IntGetPeekMessage().

IntDdePostMessageHook()

BOOL APIENTRY IntDdePostMessageHook	(	IN	PWND,
		IN	UINT,
		IN	WPARAM,
		IN OUT LPARAM *	,
		IN OUT LONG_PTR *
	)

Definition at line 172 of file dde.c.

{
   PWND pWndClient;
   PDDE_DATA pddeData;
   int size;
   HGDIOBJ Object = NULL;
   PVOID userBuf = NULL;
   PVOID Buffer = NULL;
   LPARAM lp = *lParam;

   if (pWnd->head.pti->ppi != gptiCurrent->ppi)
   {
      TRACE("Posting long DDE 0x%x\n",Msg);
      // Initiate is sent only across borders.
      if (Msg == WM_DDE_INITIATE)
      {
         return FALSE;
      }

      pWndClient = UserGetWindowObject((HWND)wParam);
      if (pWndClient == NULL)
      {
         // This is terminating so post it.
         if ( Msg == WM_DDE_TERMINATE)
         {
            TRACE("DDE Posted WM_DDE_TERMINATE\n");
            return TRUE;
         }
         TRACE("Invalid DDE Client Window handle\n");
         return FALSE;
      }

      if ( Msg == WM_DDE_REQUEST || Msg == WM_DDE_UNADVISE )
      {
         // Do not bother to callback after validation.
         return TRUE;
      }

      if ( Msg == WM_DDE_TERMINATE )
      {

         // Do not bother to callback.
         return TRUE;
      }

      if ( Msg == WM_DDE_EXECUTE && *lParam == 0)
      {
         // Do not bother to do a callback.
         TRACE("DDE Post EXECUTE lParam 0\n");
         return FALSE;
      }

      // Callback.
      if ((size = IntDDEPostCallback(pWnd, Msg, wParam, &lp, &userBuf)) == 0)
      {
         ERR("DDE Post Callback return 0 0x%x\n", Msg);
         return FALSE;
      }

      // No error HACK.
      if (size == -1)
      {
         size = 0;
      }
      else
      {
         // Set buffer with users data size.
         Buffer = ExAllocatePoolWithTag(PagedPool, size, USERTAG_DDE);
         if (Buffer == NULL)
         {
             ERR("Failed to allocate %i bytes.\n", size);
             return FALSE;
         }
         // No SEH? Yes, the user memory is freed after the Acknowledgment or at Termination.
         RtlCopyMemory(Buffer, userBuf, size);
      }

      TRACE("DDE Post size %d 0x%x\n",size, Msg);

      switch(Msg)
      {
          case WM_DDE_POKE:
          {
              DDEPOKE *pddePoke = Buffer;
              NT_ASSERT(pddePoke != NULL);
              switch(pddePoke->cfFormat)
              {
                 case CF_BITMAP:
                 case CF_DIB:
                 case CF_PALETTE:
                    RtlCopyMemory(&Object, pddePoke->Value, sizeof(HGDIOBJ));
                    break;
                 default:
                    break;
              }
              break;
          }
          case WM_DDE_DATA:
          {
              DDEDATA *pddeData2 = Buffer;
              NT_ASSERT(pddeData2 != NULL);
              switch(pddeData2->cfFormat)
              {
                 case CF_BITMAP:
                 case CF_DIB:
                 case CF_PALETTE:
                    RtlCopyMemory(&Object, pddeData2->Value, sizeof(HGDIOBJ));
                    break;
                 default:
                    break;
              }
              break;
          }
          default:
              break;
      }

      if (Object)
      {
         // Give gdi object to the other process.
         GreSetObjectOwner(Object, pWnd->head.pti->ppi->W32Pid);
      }

      pddeData = ExAllocatePoolWithTag(PagedPool, sizeof(DDE_DATA), USERTAG_DDE5);
      if (pddeData == NULL)
      {
         ERR("Failed to allocate DDE_DATA\n");
         ExFreePoolWithTag(Buffer, USERTAG_DDE);
         return FALSE;
      }

      pddeData->cbSize       = size;
      pddeData->pvBuffer     = Buffer;
      pddeData->lParam       = lp;

      TRACE("DDE Post lParam c=%08lx\n",lp);
      *lParam = lp;

      // Attach this data packet to the user message.
      *ExtraInfo = (LONG_PTR)pddeData;
   }
   return TRUE;
}

Referenced by UserPostMessage().

IntDdeSendMessageHook()

BOOL FASTCALL IntDdeSendMessageHook	(	PWND	,
		UINT	,
		WPARAM	,
		LPARAM
	)

Definition at line 386 of file dde.c.

{
   PWND pWndServer;
   PDDE_PROP pddeProp;

   if (pWnd->head.pti->ppi != gptiCurrent->ppi)
   {
      TRACE("Sending long DDE 0x%x\n",Msg);

      // Allow only Acknowledge and Initiate to be sent across borders.
      if (Msg != WM_DDE_ACK )
      {
         if (Msg == WM_DDE_INITIATE) return TRUE;
         return FALSE;
      }

      TRACE("Sending long WM_DDE_ACK\n");

      pWndServer = UserGetWindowObject((HWND)wParam);
      if (pWndServer == NULL)
      {
         ERR("Invalid DDE Server Window handle\n");
         return FALSE;
      }

      // Setup property so this conversation can be tracked.
      pddeProp = ExAllocatePoolWithTag(PagedPool, sizeof(DDE_PROP), USERTAG_DDE1);
      if (pddeProp == NULL)
      {
         ERR("failed to allocate DDE_PROP\n");
         return FALSE;
      }

      pddeProp->spwnd        = pWndServer;
      pddeProp->spwndPartner = pWnd;

      UserSetProp(pWndServer, AtomDDETrack, (HANDLE)pddeProp, TRUE);
   }
   return TRUE;
}

Referenced by co_IntSendMessageTimeoutSingle().

IntGetWindowContextHelpId()

DWORD FASTCALL IntGetWindowContextHelpId

(

PWND

pWnd

)

Definition at line 410 of file window.c.

{
   DWORD HelpId;

   do
   {
      HelpId = (DWORD)(DWORD_PTR)UserGetProp(pWnd, gpsi->atomContextHelpIdProp, TRUE);
      if (!HelpId) break;
      pWnd = IntGetParent(pWnd);
   }
   while (pWnd && pWnd->fnid != FNID_DESKTOP);
   return HelpId;
}

Referenced by IntDefWindowProc().

IntGetWindowObject()

PWND FASTCALL IntGetWindowObject

(

HWND

hWnd

)

Definition at line 51 of file window.c.

{
   PWND Window;

   if (!hWnd) return NULL;

   Window = UserGetWindowObject(hWnd);
   if (Window)
      Window->head.cLockObj++;

   return Window;
}

Referenced by co_UserFreeWindow(), IntHideDesktop(), and IntSetOwner().

IntSetWindowState()

VOID FASTCALL IntSetWindowState	(	PWND	,
		UINT
	)

Definition at line 567 of file misc.c.

{
   UINT bit;
   if (gptiCurrent->ppi != pWnd->head.pti->ppi) return;
   bit = 1 << LOWORD(Flag);
   TRACE("SWS %x\n",bit);
   switch(HIWORD(Flag))
   {
      case 0:
          pWnd->state |= bit;
          break;
      case 1:
          pWnd->state2 |= bit;
          break;
      case 2:
          pWnd->ExStyle2 |= bit;
          break;
   }
}

Referenced by NtUserCallHwndParam().

IntTID2PTI()

PTHREADINFO FASTCALL IntTID2PTI

(

HANDLE

)

Definition at line 41 of file misc.c.

{
   NTSTATUS Status;
   PETHREAD Thread;
   PTHREADINFO pti;
   Status = PsLookupThreadByThreadId(id, &Thread);
   if (!NT_SUCCESS(Status))
   {
      return NULL;
   }
   if (PsIsThreadTerminating(Thread))
   {
      ObDereferenceObject(Thread);
      return NULL;
   }
   pti = PsGetThreadWin32Thread(Thread);
   if (!pti)
   {
      ObDereferenceObject(Thread);
      return NULL;
   }
   // Validate and verify!
   _SEH2_TRY
   {
      if (pti->TIF_flags & TIF_INCLEANUP) pti = NULL;
      if (pti && !(pti->TIF_flags & TIF_GUITHREADINITIALIZED)) pti = NULL;
      if (PsGetThreadId(Thread) != id) pti = NULL;
   }
   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
   {
      pti = NULL;
   }
   _SEH2_END
   ObDereferenceObject(Thread);
   return pti;
}

Referenced by NtUserAttachThreadInput(), NtUserGetGUIThreadInfo(), NtUserGetThreadDesktop(), and NtUserSetWindowsHookEx().

NC_DoNCPaint()

LRESULT NC_DoNCPaint	(	PWND	,
		HDC	,
		INT
	)

Definition at line 1042 of file nonclient.c.

{
   DWORD Style, ExStyle;
   PWND Parent;
   RECT WindowRect, CurrentRect, TempRect;
   BOOL Active = FALSE;

   if (!IntIsWindowVisible(pWnd) ||
       (pWnd->state & WNDS_NONCPAINT && !(pWnd->state & WNDS_FORCEMENUDRAW)) ||
        IntEqualRect(&pWnd->rcWindow, &pWnd->rcClient) )
      return 0;

   Style = pWnd->style;

   TRACE("DefWndNCPaint: pWnd %p, hDc %p, Active %s.\n", pWnd, hDC, Flags & DC_ACTIVE ? "TRUE" : "FALSE");

   Parent = IntGetParent(pWnd);
   ExStyle = pWnd->ExStyle;

   if (Flags == -1) // NC paint mode.
   {
      if (ExStyle & WS_EX_MDICHILD)
      {
         Active = IntIsChildWindow(gpqForeground->spwndActive, pWnd);

         if (Active)
            Active = (UserHMGetHandle(pWnd) == (HWND)co_IntSendMessage(UserHMGetHandle(Parent), WM_MDIGETACTIVE, 0, 0));
      }
      else
      {
         Active = (gpqForeground == pWnd->head.pti->MessageQueue);
      }
      Flags = DC_NC; // Redraw everything!
   }
   else
      Flags |= DC_NC;


   IntGetWindowRect(pWnd, &WindowRect);

   CurrentRect.top = CurrentRect.left = 0;
   CurrentRect.right = WindowRect.right - WindowRect.left;
   CurrentRect.bottom = WindowRect.bottom - WindowRect.top;

   /* Draw outer edge */
   if (UserHasWindowEdge(pWnd->style, pWnd->ExStyle))
   {
      DrawEdge(hDC, &CurrentRect, EDGE_RAISED, BF_RECT | BF_ADJUST);
   }
   else if (pWnd->ExStyle & WS_EX_STATICEDGE)
   {
#if 0
      DrawEdge(hDC, &CurrentRect, BDR_SUNKENINNER, BF_RECT | BF_ADJUST | BF_FLAT);
#else
      NtGdiSelectBrush(hDC, IntGetSysColorBrush(COLOR_BTNSHADOW));
      NtGdiPatBlt(hDC, CurrentRect.left, CurrentRect.top, CurrentRect.right - CurrentRect.left, 1, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect.left, CurrentRect.top, 1, CurrentRect.bottom - CurrentRect.top, PATCOPY);

      NtGdiSelectBrush(hDC, IntGetSysColorBrush(COLOR_BTNHIGHLIGHT));
      NtGdiPatBlt(hDC, CurrentRect.left, CurrentRect.bottom - 1, CurrentRect.right - CurrentRect.left, 1, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect.right - 1, CurrentRect.top, 1, CurrentRect.bottom - CurrentRect.top, PATCOPY);

      RECTL_vInflateRect(&CurrentRect, -1, -1);
#endif
   }

   if (Flags & DC_FRAME) NC_DrawFrame(hDC, &CurrentRect, Active ? Active : (Flags & DC_ACTIVE), Style, ExStyle);

   /* Draw caption */
   if ((Style & WS_CAPTION) == WS_CAPTION)
   {
      HPEN PreviousPen;
      BOOL Gradient = FALSE;

      if (Flags & DC_REDRAWHUNGWND)
      {
         Flags &= ~DC_REDRAWHUNGWND;
         Flags |= DC_NOSENDMSG;
      }

      if (UserSystemParametersInfo(SPI_GETGRADIENTCAPTIONS, 0, &Gradient, 0) && Gradient)
      {
         Flags |= DC_GRADIENT;
      }

      if (Active)
      {
         if (pWnd->state & WNDS_ACTIVEFRAME)
            Flags |= DC_ACTIVE;
         else
         {
            ERR("Wnd is active and not set active!\n");
         }
      }

      TempRect = CurrentRect;

      if (ExStyle & WS_EX_TOOLWINDOW)
      {
         Flags |= DC_SMALLCAP;
         TempRect.bottom = TempRect.top + UserGetSystemMetrics(SM_CYSMCAPTION) - 1;
         CurrentRect.top += UserGetSystemMetrics(SM_CYSMCAPTION);
      }
      else
      {
         TempRect.bottom = TempRect.top + UserGetSystemMetrics(SM_CYCAPTION) - 1;
         CurrentRect.top += UserGetSystemMetrics(SM_CYCAPTION);
      }

      UserDrawCaption(pWnd, hDC, &TempRect, NULL, NULL, NULL, Flags);

      /* Draw buttons */
      if (Style & WS_SYSMENU)
      {
         UserDrawCaptionButton(pWnd, &TempRect, Style, ExStyle, hDC, FALSE, DFCS_CAPTIONCLOSE);
         if ((Style & (WS_MAXIMIZEBOX | WS_MINIMIZEBOX)) && !(ExStyle & WS_EX_TOOLWINDOW))
         {
            UserDrawCaptionButton(pWnd, &TempRect, Style, ExStyle, hDC, FALSE, DFCS_CAPTIONMIN);
            UserDrawCaptionButton(pWnd, &TempRect, Style, ExStyle, hDC, FALSE, DFCS_CAPTIONMAX);
         }
      }
      if (!(Style & WS_MINIMIZE))
      {
        /* Line under caption */
         PreviousPen = NtGdiSelectPen(hDC, NtGdiGetStockObject(DC_PEN));

         IntSetDCPenColor( hDC, IntGetSysColor(
                         ((ExStyle & (WS_EX_STATICEDGE | WS_EX_CLIENTEDGE | WS_EX_DLGMODALFRAME)) == WS_EX_STATICEDGE) ?
                          COLOR_WINDOWFRAME : COLOR_3DFACE));

         GreMoveTo(hDC, TempRect.left, TempRect.bottom, NULL);

         NtGdiLineTo(hDC, TempRect.right, TempRect.bottom);

         NtGdiSelectPen(hDC, PreviousPen);
      }
   }

   if (!(Style & WS_MINIMIZE))
   {
     /* Draw menu bar */
     if (pWnd->state & WNDS_HASMENU && pWnd->IDMenu) // Should be pWnd->spmenu
     {
         if (!(Flags & DC_NOSENDMSG))
         {
             PMENU menu;
             // Fix crash in test_menu_locked_by_window, should use pWnd->spmenu....
             if ((menu = UserGetMenuObject(UlongToHandle(pWnd->IDMenu)))) // FIXME! Use pWnd->spmenu,
             {
                TempRect = CurrentRect;
                TempRect.bottom = TempRect.top + menu->cyMenu; // Should be pWnd->spmenu->cyMenu;
                CurrentRect.top += MENU_DrawMenuBar(hDC, &TempRect, pWnd, FALSE);
             }
         }
     }

     if (ExStyle & WS_EX_CLIENTEDGE)
     {
         DrawEdge(hDC, &CurrentRect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
     }

     /* Draw the scrollbars */
     if ((Style & WS_VSCROLL) && (Style & WS_HSCROLL) &&
         IntIsScrollBarVisible(pWnd, OBJID_VSCROLL) && IntIsScrollBarVisible(pWnd, OBJID_HSCROLL))
     {
        RECT ParentClientRect;

        TempRect = CurrentRect;

        if (ExStyle & WS_EX_LEFTSCROLLBAR)
           TempRect.right = TempRect.left + UserGetSystemMetrics(SM_CXVSCROLL);
        else
           TempRect.left = TempRect.right - UserGetSystemMetrics(SM_CXVSCROLL);

        TempRect.top = TempRect.bottom - UserGetSystemMetrics(SM_CYHSCROLL);

        FillRect(hDC, &TempRect, IntGetSysColorBrush(COLOR_BTNFACE));

        if (Parent)
        {
           IntGetClientRect(Parent, &ParentClientRect);

           if (HASSIZEGRIP(Style, ExStyle, Parent->style, WindowRect, ParentClientRect))
           {
              DrawFrameControl(hDC, &TempRect, DFC_SCROLL, DFCS_SCROLLSIZEGRIP);
           }
        }

        IntDrawScrollBar(pWnd, hDC, SB_VERT);
        IntDrawScrollBar(pWnd, hDC, SB_HORZ);
     }
     else
     {
        if (Style & WS_VSCROLL && IntIsScrollBarVisible(pWnd, OBJID_VSCROLL))
        {
           IntDrawScrollBar(pWnd, hDC, SB_VERT);
        }
        else if (Style & WS_HSCROLL && IntIsScrollBarVisible(pWnd, OBJID_HSCROLL))
        {
           IntDrawScrollBar(pWnd, hDC, SB_HORZ);
        }
     }
   }
   return 0; // For WM_NCPAINT message, return 0.
}

Referenced by IntDefWindowProc(), NC_HandleNCActivate(), NtUserDrawCaptionTemp(), and PaintSuspendedWindow().

NC_DrawFrame()

VOID NC_DrawFrame	(	HDC	hDC,
		RECT *	CurrentRect,
		BOOL	Active,
		DWORD	Style,
		DWORD	ExStyle
	)

Definition at line 854 of file nonclient.c.

{
   /* Firstly the "thick" frame */
   if ((Style & WS_THICKFRAME) && !(Style & WS_MINIMIZE))
   {
      LONG Width =
         (UserGetSystemMetrics(SM_CXFRAME) - UserGetSystemMetrics(SM_CXDLGFRAME)) *
         UserGetSystemMetrics(SM_CXBORDER);

      LONG Height =
         (UserGetSystemMetrics(SM_CYFRAME) - UserGetSystemMetrics(SM_CYDLGFRAME)) *
         UserGetSystemMetrics(SM_CYBORDER);

      NtGdiSelectBrush(hDC, IntGetSysColorBrush(Active ? COLOR_ACTIVEBORDER : COLOR_INACTIVEBORDER));

      /* Draw frame */
      NtGdiPatBlt(hDC, CurrentRect->left, CurrentRect->top, CurrentRect->right - CurrentRect->left, Height, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect->left, CurrentRect->top, Width, CurrentRect->bottom - CurrentRect->top, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect->left, CurrentRect->bottom - 1, CurrentRect->right - CurrentRect->left, -Height, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect->right - 1, CurrentRect->top, -Width, CurrentRect->bottom - CurrentRect->top, PATCOPY);

      RECTL_vInflateRect(CurrentRect, -Width, -Height);
   }

   /* Now the other bit of the frame */
   if (Style & (WS_DLGFRAME | WS_BORDER) || ExStyle & WS_EX_DLGMODALFRAME)
   {
      LONG Width = UserGetSystemMetrics(SM_CXBORDER);
      LONG Height = UserGetSystemMetrics(SM_CYBORDER);

      NtGdiSelectBrush(hDC, IntGetSysColorBrush(
         (ExStyle & (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE)) ? COLOR_3DFACE :
         (ExStyle & WS_EX_STATICEDGE) ? COLOR_WINDOWFRAME :
         (Style & (WS_DLGFRAME | WS_THICKFRAME)) ? COLOR_3DFACE :
         COLOR_WINDOWFRAME));

      /* Draw frame */
      NtGdiPatBlt(hDC, CurrentRect->left, CurrentRect->top, CurrentRect->right - CurrentRect->left, Height, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect->left, CurrentRect->top, Width, CurrentRect->bottom - CurrentRect->top, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect->left, CurrentRect->bottom - 1, CurrentRect->right - CurrentRect->left, -Height, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect->right - 1, CurrentRect->top, -Width, CurrentRect->bottom - CurrentRect->top, PATCOPY);

      RECTL_vInflateRect(CurrentRect, -Width, -Height);
   }
}

Referenced by NC_DoNCPaint(), and UserDrawCaptionBar().

NC_GetInsideRect()

void FASTCALL NC_GetInsideRect	(	PWND	Wnd,
		RECT *	rect
	)

Definition at line 71 of file nonclient.c.

{
    ULONG Style;
    ULONG ExStyle;

    Style = Wnd->style;
    ExStyle = Wnd->ExStyle;

    rect->top    = rect->left = 0;
    rect->right  = Wnd->rcWindow.right - Wnd->rcWindow.left;
    rect->bottom = Wnd->rcWindow.bottom - Wnd->rcWindow.top;

    if (Style & WS_ICONIC) return;

    /* Remove frame from rectangle */
    if (UserHasThickFrameStyle(Style, ExStyle))
    {
        RECTL_vInflateRect(rect, -UserGetSystemMetrics(SM_CXFRAME), -UserGetSystemMetrics(SM_CYFRAME));
    }
    else if (UserHasDlgFrameStyle(Style, ExStyle))
    {
        RECTL_vInflateRect(rect, -UserGetSystemMetrics(SM_CXDLGFRAME), -UserGetSystemMetrics(SM_CYDLGFRAME));
        /* FIXME: this isn't in NC_AdjustRect? why not? */
        if (ExStyle & WS_EX_DLGMODALFRAME)
            RECTL_vInflateRect( rect, -1, 0 );
    }
    else if (UserHasThinFrameStyle(Style, ExStyle))
    {
        RECTL_vInflateRect(rect, -UserGetSystemMetrics(SM_CXBORDER), -UserGetSystemMetrics(SM_CYBORDER));
    }

    /* We have additional border information if the window
     * is a child (but not an MDI child) */
    if ((Style & WS_CHILD) && !(ExStyle & WS_EX_MDICHILD))
    {
       if (ExStyle & WS_EX_CLIENTEDGE)
          RECTL_vInflateRect (rect, -UserGetSystemMetrics(SM_CXEDGE), -UserGetSystemMetrics(SM_CYEDGE));
       if (ExStyle & WS_EX_STATICEDGE)
          RECTL_vInflateRect (rect, -UserGetSystemMetrics(SM_CXBORDER), -UserGetSystemMetrics(SM_CYBORDER));
    }
}

Referenced by MENU_DrawMenuItem(), NC_GetSysPopupPos(), and NC_HandleNCLButtonDown().

NC_GetSysPopupPos()

void FASTCALL NC_GetSysPopupPos	(	PWND	,
		RECT *
	)

Definition at line 117 of file nonclient.c.

{
  RECT WindowRect;

  if ((Wnd->style & WS_MINIMIZE) != 0)
  {
      IntGetWindowRect(Wnd, Rect);
  }
  else
    {
      NC_GetInsideRect(Wnd, Rect);
      IntGetWindowRect(Wnd, &WindowRect);
      RECTL_vOffsetRect(Rect, WindowRect.left, WindowRect.top);
      if (Wnd->style & WS_CHILD)
      {
          IntClientToScreen(IntGetParent(Wnd), (POINT *) Rect);
      }
      Rect->right = Rect->left + UserGetSystemMetrics(SM_CYCAPTION) - 1;
      Rect->bottom = Rect->top + UserGetSystemMetrics(SM_CYCAPTION) - 1;
    }
}

Referenced by MENU_ShowSubPopup().

NC_HandleNCActivate()

LRESULT NC_HandleNCActivate	(	PWND	Wnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1382 of file nonclient.c.

{
   INT Flags;
  /* Lotus Notes draws menu descriptions in the caption of its main
   * window. When it wants to restore original "system" view, it just
   * sends WM_NCACTIVATE message to itself. Any optimizations here in
   * attempt to minimize redrawings lead to a not restored caption.
   */
   if (wParam & DC_ACTIVE)
   {
      Wnd->state |= WNDS_ACTIVEFRAME|WNDS_HASCAPTION;
      wParam = DC_CAPTION|DC_ACTIVE;
   }
   else
   {
      Wnd->state &= ~WNDS_ACTIVEFRAME;
      wParam = DC_CAPTION;
   }

   if ((Wnd->state & WNDS_NONCPAINT) || !(Wnd->style & WS_VISIBLE))
      return TRUE;

   /* This isn't documented but is reproducible in at least XP SP2 and
    * Outlook 2007 depends on it
    */
   // MSDN:
   // If this parameter is set to -1, DefWindowProc does not repaint the
   // nonclient area to reflect the state change.
   if ( lParam != -1 &&
        ( Flags = NC_DoNCActive(Wnd)) != 0 )
   {
      HDC hDC;
      HRGN hRgnTemp = NULL, hRgn = (HRGN)lParam;

      if (GreIsHandleValid(hRgn))
      {
         hRgnTemp = NtGdiCreateRectRgn(0, 0, 0, 0);
         if (NtGdiCombineRgn(hRgnTemp, hRgn, 0, RGN_COPY) == ERROR)
         {
            GreDeleteObject(hRgnTemp);
            hRgnTemp = NULL;
         }
      }

      if ((hDC = UserGetDCEx(Wnd, hRgnTemp, DCX_WINDOW|DCX_USESTYLE)))
      {
         NC_DoNCPaint(Wnd, hDC, wParam | Flags); // Redraw MENUs.
         UserReleaseDC(Wnd, hDC, FALSE);
      }
      else
         GreDeleteObject(hRgnTemp);
   }

   return TRUE;
}

Referenced by IntDefWindowProc().

NC_HandleNCCalcSize()

LRESULT NC_HandleNCCalcSize	(	PWND	wnd,
		WPARAM	wparam,
		RECTL *	winRect,
		BOOL	Suspended
	)

Definition at line 1248 of file nonclient.c.

{
   LRESULT Result = 0;
   SIZE WindowBorders;
   RECT OrigRect;
   LONG Style = Wnd->style;
   LONG  exStyle = Wnd->ExStyle; 

   if (Rect == NULL)
   {
      return Result;
   }
   OrigRect = *Rect;

   Wnd->state &= ~WNDS_HASCAPTION;

   if (wparam)
   {
      if (Wnd->pcls->style & CS_VREDRAW)
      {
         Result |= WVR_VREDRAW;
      }
      if (Wnd->pcls->style & CS_HREDRAW)
      {
         Result |= WVR_HREDRAW;
      }
      Result |= WVR_VALIDRECTS;
   }

   if (!(Wnd->style & WS_MINIMIZE))
   {
      if (UserHasWindowEdge(Wnd->style, Wnd->ExStyle))
      {
         UserGetWindowBorders(Wnd->style, Wnd->ExStyle, &WindowBorders, FALSE);
         RECTL_vInflateRect(Rect, -WindowBorders.cx, -WindowBorders.cy);
      }
      else if ((Wnd->ExStyle & WS_EX_STATICEDGE) || (Wnd->style & WS_BORDER))
      {
         RECTL_vInflateRect(Rect, -1, -1);
      }

      if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
      {
         Wnd->state |= WNDS_HASCAPTION;

         if (Wnd->ExStyle & WS_EX_TOOLWINDOW)
            Rect->top += UserGetSystemMetrics(SM_CYSMCAPTION);
         else
            Rect->top += UserGetSystemMetrics(SM_CYCAPTION);
      }

      if (HAS_MENU(Wnd, Style))
      {
         HDC hDC = UserGetDCEx(Wnd, 0, DCX_USESTYLE | DCX_WINDOW);

         Wnd->state |= WNDS_HASMENU;

         if (hDC)
         {
           RECT CliRect = *Rect;
           CliRect.bottom -= OrigRect.top;
           CliRect.right -= OrigRect.left;
           CliRect.left -= OrigRect.left;
           CliRect.top -= OrigRect.top;
           if (!Suspended) Rect->top += MENU_DrawMenuBar(hDC, &CliRect, Wnd, TRUE);
           UserReleaseDC(Wnd, hDC, FALSE);
         }
      }

      if (Wnd->ExStyle & WS_EX_CLIENTEDGE)
      {
         RECTL_vInflateRect(Rect, -2 * UserGetSystemMetrics(SM_CXBORDER), -2 * UserGetSystemMetrics(SM_CYBORDER));
      }

      if (Style & WS_VSCROLL)
      {
         if (Rect->right - Rect->left >= UserGetSystemMetrics(SM_CXVSCROLL))
         {
             Wnd->state |= WNDS_HASVERTICALSCROOLLBAR;

             /* rectangle is in screen coords when wparam is false */
             if (!wparam && (exStyle & WS_EX_LAYOUTRTL)) exStyle ^= WS_EX_LEFTSCROLLBAR;

             if((exStyle & WS_EX_LEFTSCROLLBAR) != 0)
                 Rect->left  += UserGetSystemMetrics(SM_CXVSCROLL);
             else
                 Rect->right -= UserGetSystemMetrics(SM_CXVSCROLL);
          }
      }

      if (Style & WS_HSCROLL)
      {
         if( Rect->bottom - Rect->top > UserGetSystemMetrics(SM_CYHSCROLL))
         {
              Wnd->state |= WNDS_HASHORIZONTALSCROLLBAR;

              Rect->bottom -= UserGetSystemMetrics(SM_CYHSCROLL);
         }
      }

      if (Rect->top > Rect->bottom)
         Rect->bottom = Rect->top;

      if (Rect->left > Rect->right)
         Rect->right = Rect->left;
   }
   else
   {
      Rect->right = Rect->left;
      Rect->bottom = Rect->top;
   }

   return Result;
}

Referenced by IntDefWindowProc().

NC_HandleNCLButtonDblClk()

LRESULT NC_HandleNCLButtonDblClk	(	PWND	Wnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1610 of file nonclient.c.

{
  ULONG Style;

  Style = pWnd->style;
  switch(wParam)
  {
    case HTCAPTION:
    {
      /* Maximize/Restore the window */
      if((Style & WS_CAPTION) == WS_CAPTION && (Style & WS_MAXIMIZEBOX))
      {
        co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, ((Style & (WS_MINIMIZE | WS_MAXIMIZE)) ? SC_RESTORE : SC_MAXIMIZE), 0);
      }
      break;
    }
    case HTSYSMENU:
    {
      PMENU SysMenu = IntGetSystemMenu(pWnd, FALSE);
      UINT state = IntGetMenuState(SysMenu ? UserHMGetHandle(SysMenu) : NULL, SC_CLOSE, MF_BYCOMMAND);
                  
      /* If the close item of the sysmenu is disabled or not present do nothing */
      if ((state & (MF_DISABLED | MF_GRAYED)) || (state == 0xFFFFFFFF))
          break;

      co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_CLOSE, lParam);
      break;
    }
    case HTTOP:
    case HTBOTTOM:
    {
      RECT sizingRect = pWnd->rcWindow, mouseRect;
      
      if (pWnd->ExStyle & WS_EX_MDICHILD)
          break;
      
      UserSystemParametersInfo(SPI_GETWORKAREA, 0, &mouseRect, 0);
        
      co_WinPosSetWindowPos(pWnd,
                            0,
                            sizingRect.left,
                            mouseRect.top,
                            sizingRect.right - sizingRect.left,
                            mouseRect.bottom - mouseRect.top,
                            0);
      break;
    }
    default:
      return NC_HandleNCLButtonDown(pWnd, wParam, lParam);
  }
  return(0);
}

Referenced by IntDefWindowProc().

NC_HandleNCLButtonDown()

LRESULT NC_HandleNCLButtonDown	(	PWND	Wnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1519 of file nonclient.c.

{
    switch (wParam)
    {
        case HTCAPTION:
        {
            PWND TopWnd = pWnd, parent;
            while(1)
            {
                if ((TopWnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD)
                    break;
                parent = UserGetAncestor( TopWnd, GA_PARENT );
                if (!parent || UserIsDesktopWindow(parent)) break;
                TopWnd = parent;
            }

            if ( co_IntSetForegroundWindowMouse(TopWnd) ||
                 //NtUserCallHwndLock(hTopWnd, HWNDLOCK_ROUTINE_SETFOREGROUNDWINDOWMOUSE) ||
                 UserGetActiveWindow() == UserHMGetHandle(TopWnd))
            {
               co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam);
            }
            break;
        }
        case HTSYSMENU:
        {
          LONG style = pWnd->style;
          if (style & WS_SYSMENU)
          {
              if(!(style & WS_MINIMIZE) )
              {
                RECT rect;
                HDC hDC = UserGetWindowDC(pWnd);
                NC_GetInsideRect(pWnd, &rect);
                UserDrawSysMenuButton(pWnd, hDC, &rect, TRUE);
                UserReleaseDC( pWnd, hDC, FALSE );
              }
          co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam);
      }
      break;
        }
        case HTMENU:
        {
            co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_MOUSEMENU + HTMENU, lParam);
            break;
        }
        case HTHSCROLL:
        {
            co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam);
            break;
        }
        case HTVSCROLL:
        {
            co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam);
            break;
        }
        case HTMINBUTTON:
        case HTMAXBUTTON:
        case HTCLOSE:
        {
          NC_DoButton(pWnd, wParam, lParam);
          break;
        }
        case HTLEFT:
        case HTRIGHT:
        case HTTOP:
        case HTBOTTOM:
        case HTTOPLEFT:
        case HTTOPRIGHT:
        case HTBOTTOMLEFT:
        case HTBOTTOMRIGHT:
        {
           /* Old comment:
            * "make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU"
            * This was previously done by setting wParam=SC_SIZE + wParam - 2
            */
           /* But that is not what WinNT does. Instead it sends this. This
            * is easy to differentiate from HTSYSMENU, because HTSYSMENU adds
            * SC_MOUSEMENU into wParam.
            */
            co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_SIZE + wParam - (HTLEFT - WMSZ_LEFT), lParam);
            break;
        }
        case HTBORDER:
            break;
    }
    return(0);
}