painting.h File Reference

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

Go to the source code of this file.

Macros
#define	FLASHW_MASK   0x0000000f
#define	FLASHW_SYSTIMER   0x00000400
#define	FLASHW_FINISHED   0x00000800
#define	FLASHW_STARTED   0x00001000
#define	FLASHW_COUNT   0x00002000
#define	FLASHW_KILLSYSTIMER   0x00004000
#define	FLASHW_ACTIVE   0x00008000
#define	PRGN_NULL   ((PREGION)0) /* NULL empty region */
#define	PRGN_WINDOW   ((PREGION)1) /* region from window rcWindow */
#define	PRGN_MONITOR   ((PREGION)2) /* region from monitor region. */
#define	RDW_CLIPCHILDREN   4096
#define	RDW_NOUPDATEDIRTY   32768

Functions
BOOL FASTCALL	co_UserRedrawWindow (PWND Wnd, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
VOID FASTCALL	IntInvalidateWindows (PWND Window, PREGION Rgn, ULONG Flags)
BOOL FASTCALL	IntGetPaintMessage (PWND Window, UINT MsgFilterMin, UINT MsgFilterMax, PTHREADINFO Thread, MSG *Message, BOOL Remove)
INT FASTCALL	UserRealizePalette (HDC)
INT FASTCALL	co_UserGetUpdateRgn (PWND, HRGN, BOOL)
BOOL FASTCALL	co_UserGetUpdateRect (PWND, PRECT, BOOL)
VOID FASTCALL	co_IntPaintWindows (PWND Window, ULONG Flags, BOOL Recurse)
VOID FASTCALL	IntSendSyncPaint (PWND, ULONG)
VOID FASTCALL	co_IntUpdateWindows (PWND, ULONG, BOOL)
BOOL FASTCALL	IntIsWindowDirty (PWND)
BOOL FASTCALL	IntEndPaint (PWND, PPAINTSTRUCT)
HDC FASTCALL	IntBeginPaint (PWND, PPAINTSTRUCT)
PCURICON_OBJECT FASTCALL	NC_IconForWindow (PWND)
BOOL FASTCALL	IntFlashWindowEx (PWND, PFLASHWINFO)
BOOL FASTCALL	IntIntersectWithParents (PWND, RECTL *)
BOOL FASTCALL	IntIsWindowDrawable (PWND)
BOOL	UserDrawCaption (PWND, HDC, RECTL *, HFONT, HICON, const PUNICODE_STRING, UINT)
VOID FASTCALL	UpdateThreadWindows (PWND, PTHREADINFO, HRGN)
VOID FASTCALL	UserSyncAndPaintWindows (PWND pWnd, ULONG Flags)
VOID FASTCALL	IntPaintWindow (PWND)
VOID FASTCALL	IntSendNCPaint (PWND, HRGN)

Macro Definition Documentation

FLASHW_ACTIVE

#define FLASHW_ACTIVE   0x00008000

Definition at line 9 of file painting.h.

FLASHW_COUNT

#define FLASHW_COUNT   0x00002000

Definition at line 7 of file painting.h.

FLASHW_FINISHED

#define FLASHW_FINISHED   0x00000800

Definition at line 5 of file painting.h.

FLASHW_KILLSYSTIMER

#define FLASHW_KILLSYSTIMER   0x00004000

Definition at line 8 of file painting.h.

FLASHW_MASK

#define FLASHW_MASK   0x0000000f

Definition at line 3 of file painting.h.

FLASHW_STARTED

#define FLASHW_STARTED   0x00001000

Definition at line 6 of file painting.h.

FLASHW_SYSTIMER

#define FLASHW_SYSTIMER   0x00000400

Definition at line 4 of file painting.h.

PRGN_MONITOR

#define PRGN_MONITOR   ((PREGION)2) /* region from monitor region. */

Definition at line 13 of file painting.h.

PRGN_NULL

#define PRGN_NULL   ((PREGION)0) /* NULL empty region */

Definition at line 11 of file painting.h.

PRGN_WINDOW

#define PRGN_WINDOW   ((PREGION)1) /* region from window rcWindow */

Definition at line 12 of file painting.h.

RDW_CLIPCHILDREN

#define RDW_CLIPCHILDREN   4096

Definition at line 15 of file painting.h.

RDW_NOUPDATEDIRTY

#define RDW_NOUPDATEDIRTY   32768

Definition at line 16 of file painting.h.

Function Documentation

co_IntPaintWindows()

VOID FASTCALL co_IntPaintWindows	(	PWND	Window,
		ULONG	Flags,
		BOOL	Recurse
	)

Definition at line 403 of file painting.c.

{
   HDC hDC;
   HWND hWnd = UserHMGetHandle(Wnd);
   HRGN TempRegion = NULL;
 
   Wnd->state &= ~WNDS_PAINTNOTPROCESSED;
 
   if (Wnd->state & WNDS_SENDNCPAINT ||
       Wnd->state & WNDS_SENDERASEBACKGROUND)
   {
      if (!(Wnd->style & WS_VISIBLE))
      {
         Wnd->state &= ~(WNDS_SENDNCPAINT|WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
         return;
      }
      else
      {
         if (Wnd->hrgnUpdate == NULL)
         {
            Wnd->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
         }
 
         if (Wnd->head.pti == PsGetCurrentThreadWin32Thread())
         {
            if (Wnd->state & WNDS_SENDNCPAINT)
            {
               TempRegion = IntGetNCUpdateRgn(Wnd, TRUE);
 
               IntSendNCPaint(Wnd, TempRegion);
 
               if (TempRegion > HRGN_WINDOW && GreIsHandleValid(TempRegion))
               {
                  /* NOTE: The region can already be deleted! */
                  GreDeleteObject(TempRegion);
               }
            }
 
            if (Wnd->state & WNDS_SENDERASEBACKGROUND)
            {
               PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
               if (Wnd->hrgnUpdate)
               {
                  hDC = UserGetDCEx( Wnd,
                                     Wnd->hrgnUpdate,
                                     DCX_CACHE|DCX_USESTYLE|DCX_INTERSECTRGN|DCX_KEEPCLIPRGN);
 
                  if (Wnd->head.pti->ppi != pti->ppi)
                  {
                     ERR("Sending DC to another Process!!!\n");
                  }
 
                  Wnd->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
                  // Kill the loop, so Clear before we send.
                  if (!co_IntSendMessage(hWnd, WM_ERASEBKGND, (WPARAM)hDC, 0))
                  {
                     Wnd->state |= (WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
                  }
                  UserReleaseDC(Wnd, hDC, FALSE);
               }
            }
         }
 
      }
   }
 
   /*
    * Check that the window is still valid at this point
    */
   if (!IntIsWindow(hWnd))
   {
      return;
   }
 
   /*
    * Paint child windows.
    */
 
   if (!(Flags & RDW_NOCHILDREN) &&
       !(Wnd->style & WS_MINIMIZE) &&
        ( Flags & RDW_ALLCHILDREN ||
         (Flags & RDW_CLIPCHILDREN && Wnd->style & WS_CLIPCHILDREN) ) )
   {
      HWND *List, *phWnd;
      PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
 
      if ((List = IntWinListChildren(Wnd)))
      {
         for (phWnd = List; *phWnd; ++phWnd)
         {
            if ((Wnd = UserGetWindowObject(*phWnd)) == NULL)
               continue;
 
            if (Wnd->head.pti != pti && Wnd->style & WS_CHILD)
               continue;
 
            if (Wnd->style & WS_VISIBLE)
            {
               USER_REFERENCE_ENTRY Ref;
               UserRefObjectCo(Wnd, &Ref);
               co_IntPaintWindows(Wnd, Flags, TRUE);
               UserDerefObjectCo(Wnd);
            }
         }
         ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
      }
   }
}

Referenced by co_IntGetUpdateRgn(), co_IntPaintWindows(), co_IntUpdateWindows(), co_UserGetUpdateRect(), co_UserGetUpdateRgn(), co_WinPosSetWindowPos(), IntPaintWindow(), and UserSyncAndPaintWindows().

co_IntUpdateWindows()

VOID FASTCALL co_IntUpdateWindows	(	PWND	Wnd,
		ULONG	Flags,
		BOOL	Recurse
	)

Definition at line 519 of file painting.c.

{
   HWND hWnd = UserHMGetHandle(Wnd);
   USER_REFERENCE_ENTRY Ref;
 
   if ( Wnd->hrgnUpdate != NULL || Wnd->state & WNDS_INTERNALPAINT )
   {
      if (Wnd->hrgnUpdate)
      {
         if (!IntValidateParents(Wnd, Recurse))
         {
            return;
         }
      }
 
      if (Wnd->state & WNDS_INTERNALPAINT)
      {
          Wnd->state &= ~WNDS_INTERNALPAINT;
 
          if (Wnd->hrgnUpdate == NULL)
             MsqDecPaintCountQueue(Wnd->head.pti);
      }
 
      Wnd->state |= WNDS_PAINTNOTPROCESSED;
      Wnd->state &= ~WNDS_UPDATEDIRTY;
 
      Wnd->state2 |= WNDS2_WMPAINTSENT;
 
      UserRefObjectCo(Wnd, &Ref);
      co_IntSendMessage(hWnd, WM_PAINT, 0, 0);
 
      if (Wnd->state & WNDS_PAINTNOTPROCESSED)
      {
         co_IntPaintWindows(Wnd, RDW_NOCHILDREN, FALSE);
      }
      UserDerefObjectCo(Wnd);
   }
 
   // Force flags as a toggle. Fixes msg:test_paint_messages:WmChildPaintNc.
   Flags = (Flags & RDW_NOCHILDREN) ? RDW_NOCHILDREN : RDW_ALLCHILDREN; // All children is the default.
 
  /*
   * Update child windows.
   */
 
   if (!(Flags & RDW_NOCHILDREN)  &&
        (Flags & RDW_ALLCHILDREN) &&
        !UserIsDesktopWindow(Wnd))
   {
      PWND Child;
 
      for (Child = Wnd->spwndChild; Child; Child = Child->spwndNext)
      {
         /* transparent window, check for non-transparent sibling to paint first, then skip it */
         if ( Child->ExStyle & WS_EX_TRANSPARENT &&
             ( Child->hrgnUpdate != NULL || Child->state & WNDS_INTERNALPAINT ) )
         {
            PWND Next = Child->spwndNext;
            while (Next)
            {
               if ( Next->hrgnUpdate != NULL || Next->state & WNDS_INTERNALPAINT ) break;
 
               Next = Next->spwndNext;
            }
 
            if (Next) continue;
         }
 
         if (Child->style & WS_VISIBLE)
         {
             USER_REFERENCE_ENTRY Ref;
             UserRefObjectCo(Child, &Ref);
             co_IntUpdateWindows(Child, Flags, TRUE);
             UserDerefObjectCo(Child);
         }
      }
   }
}

Referenced by co_IntUpdateWindows(), IntPrintWindow(), MENU_ShowPopup(), NC_DoButton(), NtUserCallHwndLock(), and UserUpdateWindows().

co_UserGetUpdateRect()

BOOL FASTCALL co_UserGetUpdateRect	(	PWND	Window,
		PRECT	pRect,
		BOOL	bErase
	)

Definition at line 1863 of file painting.c.

{
   INT RegionType;
   BOOL Ret = TRUE;
 
   if (bErase)
   {
      USER_REFERENCE_ENTRY Ref;
      UserRefObjectCo(Window, &Ref);
      co_IntPaintWindows(Window, RDW_NOCHILDREN, FALSE);
      UserDerefObjectCo(Window);
   }
 
   Window->state &= ~WNDS_UPDATEDIRTY;
 
   if (Window->hrgnUpdate == NULL)
   {
      pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
      Ret = FALSE;
   }
   else
   {
      /* Get the update region bounding box. */
      if (Window->hrgnUpdate == HRGN_WINDOW)
      {
         *pRect = Window->rcClient;
         ERR("GURt: Caller is retrieving Window Region 1\n");
      }
      else
      {
         RegionType = IntGdiGetRgnBox(Window->hrgnUpdate, pRect);
 
         if (RegionType != ERROR && RegionType != NULLREGION)
            RECTL_bIntersectRect(pRect, pRect, &Window->rcClient);
      }
 
      if (IntIntersectWithParents(Window, pRect))
      {
         if (!UserIsDesktopWindow(Window))
         {
            RECTL_vOffsetRect(pRect,
                              -Window->rcClient.left,
                              -Window->rcClient.top);
         }
         if (Window->pcls->style & CS_OWNDC)
         {
            HDC hdc;
            //DWORD layout;
            hdc = UserGetDCEx(Window, NULL, DCX_USESTYLE);
            //layout = NtGdiSetLayout(hdc, -1, 0);
            //IntMapWindowPoints( 0, Window, (LPPOINT)pRect, 2 );
            GreDPtoLP( hdc, (LPPOINT)pRect, 2 );
            //NtGdiSetLayout(hdc, -1, layout);
            UserReleaseDC(Window, hdc, FALSE);
         }
      }
      else
      {
         pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
      }
   }
   return Ret;
}

Referenced by NtUserGetUpdateRect().

co_UserGetUpdateRgn()

INT FASTCALL co_UserGetUpdateRgn	(	PWND	Window,
		HRGN	hRgn,
		BOOL	bErase
	)

Definition at line 1791 of file painting.c.

{
   int RegionType;
   BOOL Type;
   RECTL Rect;
 
   ASSERT_REFS_CO(Window);
 
   if (bErase)
   {
      USER_REFERENCE_ENTRY Ref;
      UserRefObjectCo(Window, &Ref);
      co_IntPaintWindows(Window, RDW_NOCHILDREN, FALSE);
      UserDerefObjectCo(Window);
   }
 
   Window->state &= ~WNDS_UPDATEDIRTY;
 
   if (Window->hrgnUpdate == NULL)
   {
       NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
       return NULLREGION;
   }
 
   Rect = Window->rcClient;
   Type = IntIntersectWithParents(Window, &Rect);
 
   if (Window->hrgnUpdate == HRGN_WINDOW)
   {
      // Trap it out.
      ERR("GURn: Caller is passing Window Region 1\n");
      if (!Type)
      {
         NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
         return NULLREGION;
      }
 
      RegionType = SIMPLEREGION;
 
      if (!UserIsDesktopWindow(Window))
      {
         RECTL_vOffsetRect(&Rect,
                          -Window->rcClient.left,
                          -Window->rcClient.top);
      }
      GreSetRectRgnIndirect(hRgn, &Rect);
   }
   else
   {
      HRGN hrgnTemp = GreCreateRectRgnIndirect(&Rect);
 
      RegionType = NtGdiCombineRgn(hRgn, hrgnTemp, Window->hrgnUpdate, RGN_AND);
 
      if (RegionType == ERROR || RegionType == NULLREGION)
      {
         if (hrgnTemp) GreDeleteObject(hrgnTemp);
         NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
         return RegionType;
      }
 
      if (!UserIsDesktopWindow(Window))
      {
         NtGdiOffsetRgn(hRgn,
                       -Window->rcClient.left,
                       -Window->rcClient.top);
      }
      if (hrgnTemp) GreDeleteObject(hrgnTemp);
   }
   return RegionType;
}

Referenced by IntDefWindowProc(), and NtUserGetUpdateRgn().

co_UserRedrawWindow()

BOOL FASTCALL co_UserRedrawWindow	(	PWND	Wnd,
		const RECTL *	UpdateRect,
		PREGION	UpdateRgn,
		ULONG	Flags
	)

Definition at line 895 of file painting.c.

{
   PREGION TmpRgn = NULL;
   TRACE("co_UserRedrawWindow start Rgn %p\n",UpdateRgn);
 
   /*
    * Step 1.
    * Validation of passed parameters.
    */
 
   if (!IntIsWindowDrawable(Window))
   {
      return TRUE; // Just do nothing!!!
   }
 
   if (Window == NULL)
   {
      Window = UserGetDesktopWindow();
   }
 
   /*
    * Step 2.
    * Transform the parameters UpdateRgn and UpdateRect into
    * a region hRgn specified in screen coordinates.
    */
 
   if (Flags & (RDW_INVALIDATE | RDW_VALIDATE)) // Both are OKAY!
   {
      /* We can't hold lock on GDI objects while doing roundtrips to user mode,
       * so use a copy instead */
      if (UpdateRgn)
      {
          TmpRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
 
          if (UpdateRgn > PRGN_WINDOW)
          {
             IntGdiCombineRgn(TmpRgn, UpdateRgn, NULL, RGN_COPY);
          }
 
          if (Window != UserGetDesktopWindow())
          {
             REGION_bOffsetRgn(TmpRgn, Window->rcClient.left, Window->rcClient.top);
          }
      }
      else
      {
         if (UpdateRect != NULL)
         {
            if (Window == UserGetDesktopWindow())
            {
               TmpRgn = IntSysCreateRectpRgnIndirect(UpdateRect);
            }
            else
            {
               TmpRgn = IntSysCreateRectpRgn(Window->rcClient.left + UpdateRect->left,
                                             Window->rcClient.top  + UpdateRect->top,
                                             Window->rcClient.left + UpdateRect->right,
                                             Window->rcClient.top  + UpdateRect->bottom);
            }
         }
         else
         {
            if ((Flags & (RDW_INVALIDATE | RDW_FRAME)) == (RDW_INVALIDATE | RDW_FRAME) ||
                (Flags & (RDW_VALIDATE | RDW_NOFRAME)) == (RDW_VALIDATE | RDW_NOFRAME))
            {
               if (!RECTL_bIsEmptyRect(&Window->rcWindow))
                   TmpRgn = IntSysCreateRectpRgnIndirect(&Window->rcWindow);
            }
            else
            {
               if (!RECTL_bIsEmptyRect(&Window->rcClient))
                   TmpRgn = IntSysCreateRectpRgnIndirect(&Window->rcClient);
            }
         }
      }
   }
 
   /* Fixes test RDW_INTERNALPAINT behavior */
   if (TmpRgn == NULL)
   {
      TmpRgn = PRGN_WINDOW; // Need a region so the bits can be set!!!
   }
 
   /*
    * Step 3.
    * Adjust the window update region depending on hRgn and flags.
    */
 
   if (Flags & (RDW_INVALIDATE | RDW_VALIDATE | RDW_INTERNALPAINT | RDW_NOINTERNALPAINT) &&
       TmpRgn != NULL)
   {
      IntInvalidateWindows(Window, TmpRgn, Flags);
   }
 
   /*
    * Step 4.
    * Repaint and erase windows if needed.
    */
 
   if (Flags & RDW_UPDATENOW)
   {
      UserUpdateWindows(Window, Flags);
   }
   else if (Flags & RDW_ERASENOW)
   {
      if ((Flags & (RDW_NOCHILDREN|RDW_ALLCHILDREN)) == 0)
         Flags |= RDW_CLIPCHILDREN;
 
      UserSyncAndPaintWindows(Window, Flags);
   }
 
   /*
    * Step 5.
    * Cleanup ;-)
    */
 
   if (TmpRgn > PRGN_WINDOW)
   {
      REGION_Delete(TmpRgn);
   }
   TRACE("co_UserRedrawWindow exit\n");
 
   return TRUE;
}

Referenced by co_IntSetScrollInfo(), co_IntShowDesktop(), co_UserFreeWindow(), co_VIS_WindowLayoutChanged(), co_WinPosMinMaximize(), co_WinPosSetWindowPos(), DefWndDoSizeMove(), DesktopWindowProc(), IntDefWindowProc(), IntForceMinimizeWindow(), IntScrollWindowEx(), IntSetLayeredWindowAttributes(), NtGdiUpdateColors(), NtUserCallHwndParamLock(), and NtUserRedrawWindow().

IntBeginPaint()

HDC FASTCALL IntBeginPaint	(	PWND	Window,
		PPAINTSTRUCT	Ps
	)

Definition at line 1442 of file painting.c.

{
   RECT Rect;
   INT type;
   BOOL Erase = FALSE;
 
   co_UserHideCaret(Window);
 
   Window->state2 |= WNDS2_STARTPAINT;
   Window->state &= ~WNDS_PAINTNOTPROCESSED;
 
   if (Window->state & WNDS_SENDNCPAINT)
   {
      HRGN hRgn;
      // Application can keep update dirty.
      do
      {
         Window->state &= ~WNDS_UPDATEDIRTY;
         hRgn = IntGetNCUpdateRgn(Window, FALSE);
         IntSendNCPaint(Window, hRgn);
         if (hRgn > HRGN_WINDOW && GreIsHandleValid(hRgn))
         {
            /* NOTE: The region can already be deleted! */
            GreDeleteObject(hRgn);
         }
      }
      while(Window->state & WNDS_UPDATEDIRTY);
   }
   else
   {
      Window->state &= ~WNDS_UPDATEDIRTY;
   }
 
   RtlZeroMemory(Ps, sizeof(PAINTSTRUCT));
 
   if (Window->state2 & WNDS2_ENDPAINTINVALIDATE)
   {
      ERR("BP: Another thread invalidated this window\n");
   }
 
   Ps->hdc = UserGetDCEx( Window,
                          Window->hrgnUpdate,
                          DCX_INTERSECTRGN | DCX_USESTYLE);
   if (!Ps->hdc)
   {
      return NULL;
   }
 
   // If set, always clear flags out due to the conditions later on for sending the message.
   if (Window->state & WNDS_SENDERASEBACKGROUND)
   {
      Window->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
      Erase = TRUE;
   }
 
   if (Window->hrgnUpdate != NULL)
   {
      MsqDecPaintCountQueue(Window->head.pti);
      IntGdiSetRegionOwner(Window->hrgnUpdate, GDI_OBJ_HMGR_POWNED);
      /* The region is part of the dc now and belongs to the process! */
      Window->hrgnUpdate = NULL;
   }
   else
   {
      if (Window->state & WNDS_INTERNALPAINT)
         MsqDecPaintCountQueue(Window->head.pti);
   }
 
   type = GdiGetClipBox(Ps->hdc, &Ps->rcPaint);
 
   IntGetClientRect(Window, &Rect);
 
   Window->state &= ~WNDS_INTERNALPAINT;
 
   if ( Erase &&               // Set to erase,
        type != NULLREGION &&  // don't erase if the clip box is empty,
        (!(Window->pcls->style & CS_PARENTDC) || // not parent dc or
         RECTL_bIntersectRect( &Rect, &Rect, &Ps->rcPaint) ) ) // intersecting.
   {
      Ps->fErase = !co_IntSendMessage(UserHMGetHandle(Window), WM_ERASEBKGND, (WPARAM)Ps->hdc, 0);
      if ( Ps->fErase )
      {
         Window->state |= (WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
      }
   }
   else
   {
      Ps->fErase = FALSE;
   }
 
   IntSendChildNCPaint(Window);
 
   return Ps->hdc;
}

Referenced by DesktopWindowProc(), IntDefWindowProc(), NtUserBeginPaint(), and PopupMenuWndProc().

IntEndPaint()

BOOL FASTCALL IntEndPaint	(	PWND	Wnd,
		PPAINTSTRUCT	Ps
	)

Definition at line 1539 of file painting.c.

{
   HDC hdc = NULL;
 
   hdc = Ps->hdc;
 
   UserReleaseDC(Wnd, hdc, TRUE);
 
   if (Wnd->state2 & WNDS2_ENDPAINTINVALIDATE)
   {
      ERR("EP: Another thread invalidated this window\n");
      Wnd->state2 &= ~WNDS2_ENDPAINTINVALIDATE;
   }
 
   Wnd->state2 &= ~(WNDS2_WMPAINTSENT|WNDS2_STARTPAINT);
 
   co_UserShowCaret(Wnd);
 
   return TRUE;
}

Referenced by DesktopWindowProc(), IntDefWindowProc(), NtUserEndPaint(), and PopupMenuWndProc().

IntFlashWindowEx()

BOOL FASTCALL IntFlashWindowEx	(	PWND	pWnd,
		PFLASHWINFO	pfwi
	)

Definition at line 1311 of file painting.c.

{
   DWORD_PTR FlashState;
   UINT uCount = pfwi->uCount;
   BOOL Activate = FALSE, Ret = FALSE;
 
   ASSERT(pfwi);
 
   FlashState = (DWORD_PTR)UserGetProp(pWnd, AtomFlashWndState, TRUE);
 
   if (FlashState == FLASHW_FINISHED)
   {
      // Cycle has finished, kill timer and set this to Stop.
      FlashState |= FLASHW_KILLSYSTIMER;
      pfwi->dwFlags = FLASHW_STOP;
   }
   else
   {
      if (FlashState)
      {
         if (pfwi->dwFlags == FLASHW_SYSTIMER)
         {
             // Called from system timer, restore flags, counts and state.
             pfwi->dwFlags = LOWORD(FlashState);
             uCount = HIWORD(FlashState);
             FlashState = MAKELONG(LOWORD(FlashState),0);
         }
         else
         {
             // Clean out the trash! Fix SeaMonkey crash after restart.
             FlashState = 0;
         }
      }
 
      if (FlashState == 0)
      {  // First time in cycle, setup flash state.
         if ( pWnd->state & WNDS_ACTIVEFRAME ||
             (pfwi->dwFlags & FLASHW_CAPTION && pWnd->style & (WS_BORDER|WS_DLGFRAME)))
         {
             FlashState = FLASHW_STARTED|FLASHW_ACTIVE;
         }
      }
 
      // Set previous window state.
      Ret = !!(FlashState & FLASHW_ACTIVE);
 
      if ( (pfwi->dwFlags & FLASHW_TIMERNOFG) == FLASHW_TIMERNOFG &&
           gpqForeground == pWnd->head.pti->MessageQueue )
      {
          // Flashing until foreground, set this to Stop.
          pfwi->dwFlags = FLASHW_STOP;
      }
   }
 
   // Toggle activate flag.
   if ( pfwi->dwFlags == FLASHW_STOP )
   {
      if (gpqForeground && gpqForeground->spwndActive == pWnd)
         Activate = TRUE;
      else
         Activate = FALSE;
   }
   else
   {
      Activate = (FlashState & FLASHW_ACTIVE) == 0;
   }
 
   if ( pfwi->dwFlags == FLASHW_STOP || pfwi->dwFlags & FLASHW_CAPTION )
   {
      co_IntSendMessage(UserHMGetHandle(pWnd), WM_NCACTIVATE, Activate, 0);
   }
 
   // FIXME: Check for a Stop Sign here.
   if ( pfwi->dwFlags & FLASHW_TRAY )
   {
      // Need some shell work here too.
      TRACE("FIXME: Flash window no Tray support!\n");
   }
 
   if ( pfwi->dwFlags == FLASHW_STOP )
   {
      if (FlashState & FLASHW_KILLSYSTIMER)
      {
         IntKillTimer(pWnd, ID_EVENT_SYSTIMER_FLASHWIN, TRUE);
      }
 
      UserRemoveProp(pWnd, AtomFlashWndState, TRUE);
   }
   else
   {  // Have a count and started, set timer.
      if ( uCount )
      {
         FlashState |= FLASHW_COUNT;
 
         if (!(Activate ^ !!(FlashState & FLASHW_STARTED)))
             uCount--;
 
         if (!(FlashState & FLASHW_KILLSYSTIMER))
             pfwi->dwFlags |= FLASHW_TIMER;
      }
 
      if (pfwi->dwFlags & FLASHW_TIMER)
      {
         FlashState |= FLASHW_KILLSYSTIMER;
 
         IntSetTimer( pWnd,
                      ID_EVENT_SYSTIMER_FLASHWIN,
                      pfwi->dwTimeout ? pfwi->dwTimeout : gpsi->dtCaretBlink,
                      SystemTimerProc,
                      TMRF_SYSTEM );
      }
 
      if (FlashState & FLASHW_COUNT && uCount == 0)
      {
         // Keep spinning? Nothing else to do.
         FlashState = FLASHW_FINISHED;
      }
      else
      {
         // Save state and flags so this can be restored next time through.
         FlashState ^= (FlashState ^ -!!(Activate)) & FLASHW_ACTIVE;
         FlashState ^= (FlashState ^ pfwi->dwFlags) & (FLASHW_MASK & ~FLASHW_TIMER);
      }
      FlashState = MAKELONG(LOWORD(FlashState),uCount);
      UserSetProp(pWnd, AtomFlashWndState, (HANDLE)FlashState, TRUE);
   }
   return Ret;
}

Referenced by DefWndHandleSetCursor(), NtUserFlashWindowEx(), and SystemTimerProc().

IntGetPaintMessage()

BOOL FASTCALL IntGetPaintMessage	(	PWND	Window,
		UINT	MsgFilterMin,
		UINT	MsgFilterMax,
		PTHREADINFO	Thread,
		MSG *	Message,
		BOOL	Remove
	)

Definition at line 1191 of file painting.c.

{
   PWND PaintWnd, StartWnd;
 
   if ((MsgFilterMin != 0 || MsgFilterMax != 0) &&
         (MsgFilterMin > WM_PAINT || MsgFilterMax < WM_PAINT))
      return FALSE;
 
   if (Thread->TIF_flags & TIF_SYSTEMTHREAD )
   {
      ERR("WM_PAINT is in a System Thread!\n");
   }
 
   StartWnd = UserGetDesktopWindow();
   PaintWnd = IntFindWindowToRepaint(StartWnd, Thread);
 
   Message->hwnd = PaintWnd ? UserHMGetHandle(PaintWnd) : NULL;
 
   if (Message->hwnd == NULL && Thread->cPaintsReady)
   {
      // Find note in window.c:"PAINTING BUG".
      ERR("WARNING SOMETHING HAS GONE WRONG: Thread marked as containing dirty windows, but no dirty windows found! Counts %u\n",Thread->cPaintsReady);
      /* Hack to stop spamming the debug log ! */
      Thread->cPaintsReady = 0;
      return FALSE;
   }
 
   if (Message->hwnd == NULL)
      return FALSE;
 
   if (!(Window == NULL ||
         PaintWnd == Window ||
         IntIsChildWindow(Window, PaintWnd))) /* check that it is a child of the specified parent */
      return FALSE;
 
   if (PaintWnd->state & WNDS_INTERNALPAINT)
   {
      PaintWnd->state &= ~WNDS_INTERNALPAINT;
      if (!PaintWnd->hrgnUpdate)
         MsqDecPaintCountQueue(Thread);
   }
   PaintWnd->state2 &= ~WNDS2_STARTPAINT;
   PaintWnd->state &= ~WNDS_UPDATEDIRTY;
 
   Window = PaintWnd;
   while (Window && !UserIsDesktopWindow(Window))
   {
      // Role back and check for clip children, do not set if any.
      if (Window->spwndParent && !(Window->spwndParent->style & WS_CLIPCHILDREN))
      {
         PaintWnd->state2 |= WNDS2_WMPAINTSENT;
      }
      Window = Window->spwndParent;
   }
 
   Message->wParam = Message->lParam = 0;
   Message->message = WM_PAINT;
   return TRUE;
}

Referenced by co_IntPeekMessage().

IntIntersectWithParents()

BOOL FASTCALL IntIntersectWithParents	(	PWND	Child,
		RECTL *	WindowRect
	)

Definition at line 35 of file painting.c.

{
   PWND ParentWnd;
 
   if (Child->ExStyle & WS_EX_REDIRECTED)
      return TRUE;
 
   ParentWnd = Child->spwndParent;
   while (ParentWnd != NULL)
   {
      if (!(ParentWnd->style & WS_VISIBLE)  ||
           (ParentWnd->style & WS_MINIMIZE) ||
          !RECTL_bIntersectRect(WindowRect, WindowRect, &ParentWnd->rcClient) )
      {
         return FALSE;
      }
 
      if (ParentWnd->ExStyle & WS_EX_REDIRECTED)
         return TRUE;
 
      ParentWnd = ParentWnd->spwndParent;
   }
 
   return TRUE;
}

Referenced by co_IntGetUpdateRgn(), co_UserGetUpdateRect(), co_UserGetUpdateRgn(), and IntValidateParents().

IntInvalidateWindows()

VOID FASTCALL IntInvalidateWindows	(	PWND	Window,
		PREGION	Rgn,
		ULONG	Flags
	)

Definition at line 643 of file painting.c.

{
   INT RgnType = NULLREGION;
   BOOL HadPaintMessage;
 
   TRACE("IntInvalidateWindows start Rgn %p\n",Rgn);
 
   if ( Rgn > PRGN_WINDOW )
   {
      /*
       * If the nonclient is not to be redrawn, clip the region to the client
       * rect
       */
      if ((Flags & RDW_INVALIDATE) != 0 && (Flags & RDW_FRAME) == 0)
      {
         PREGION RgnClient;
 
         RgnClient = IntSysCreateRectpRgnIndirect(&Wnd->rcClient);
         if (RgnClient)
         {
             RgnType = IntGdiCombineRgn(Rgn, Rgn, RgnClient, RGN_AND);
             REGION_Delete(RgnClient);
         }
      }
 
      /*
       * Clip the given region with window rectangle (or region)
       */
 
      if (!Wnd->hrgnClip || (Wnd->style & WS_MINIMIZE))
      {
         PREGION RgnWindow = IntSysCreateRectpRgnIndirect(&Wnd->rcWindow);
         if (RgnWindow)
         {
             RgnType = IntGdiCombineRgn(Rgn, Rgn, RgnWindow, RGN_AND);
             REGION_Delete(RgnWindow);
         }
      }
      else
      {
          PREGION RgnClip = REGION_LockRgn(Wnd->hrgnClip);
          if (RgnClip)
          {
              REGION_bOffsetRgn(Rgn,
                                -Wnd->rcWindow.left,
                                -Wnd->rcWindow.top);
              RgnType = IntGdiCombineRgn(Rgn, Rgn, RgnClip, RGN_AND);
              REGION_bOffsetRgn(Rgn,
                                Wnd->rcWindow.left,
                                Wnd->rcWindow.top);
              REGION_UnlockRgn(RgnClip);
          }
      }
   }
   else
   {
      RgnType = NULLREGION;
   }
 
   /* Nothing to paint, just return */
   if ((RgnType == NULLREGION && (Flags & RDW_INVALIDATE)) || RgnType == ERROR)
   {
      return;
   }
 
   /*
    * Save current state of pending updates
    */
 
   HadPaintMessage = IntIsWindowDirty(Wnd);
 
   /*
    * Update the region and flags
    */
 
   // The following flags are used to invalidate the window.
   if (Flags & (RDW_INVALIDATE|RDW_INTERNALPAINT|RDW_ERASE|RDW_FRAME))
   {
      if (Flags & RDW_INTERNALPAINT)
      {
         Wnd->state |= WNDS_INTERNALPAINT;
      }
 
      if (Flags & RDW_INVALIDATE )
      {
         PREGION RgnUpdate;
 
         Wnd->state &= ~WNDS_NONCPAINT;
 
         /* If not the same thread set it dirty. */
         if (Wnd->head.pti != PsGetCurrentThreadWin32Thread())
         {
            Wnd->state |= WNDS_UPDATEDIRTY;
            if (Wnd->state2 & WNDS2_WMPAINTSENT)
               Wnd->state2 |= WNDS2_ENDPAINTINVALIDATE;
         }
 
         if (Flags & RDW_FRAME)
            Wnd->state |= WNDS_SENDNCPAINT;
 
         if (Flags & RDW_ERASE)
            Wnd->state |= WNDS_SENDERASEBACKGROUND;
 
         if (RgnType != NULLREGION && Rgn > PRGN_WINDOW)
         {
            if (Wnd->hrgnUpdate == NULL)
            {
               Wnd->hrgnUpdate = NtGdiCreateRectRgn(0, 0, 0, 0);
               IntGdiSetRegionOwner(Wnd->hrgnUpdate, GDI_OBJ_HMGR_PUBLIC);
            }
 
            if (Wnd->hrgnUpdate != HRGN_WINDOW)
            {
               RgnUpdate = REGION_LockRgn(Wnd->hrgnUpdate);
               if (RgnUpdate)
               {
                  RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, Rgn, RGN_OR);
                  REGION_UnlockRgn(RgnUpdate);
                  if (RgnType == NULLREGION)
                  {
                     IntGdiSetRegionOwner(Wnd->hrgnUpdate, GDI_OBJ_HMGR_POWNED);
                     GreDeleteObject(Wnd->hrgnUpdate);
                     Wnd->hrgnUpdate = NULL;
                  }
               }
            }
         }
 
         Flags |= RDW_ERASE|RDW_FRAME; // For children.
 
      }
 
      if (!HadPaintMessage && IntIsWindowDirty(Wnd))
      {
         MsqIncPaintCountQueue(Wnd->head.pti);
      }
 
   }    // The following flags are used to validate the window.
   else if (Flags & (RDW_VALIDATE|RDW_NOINTERNALPAINT|RDW_NOERASE|RDW_NOFRAME))
   {
      if (Wnd->state & WNDS_UPDATEDIRTY && !(Flags & RDW_NOUPDATEDIRTY))
         return;
 
      if (Flags & RDW_NOINTERNALPAINT)
      {
         Wnd->state &= ~WNDS_INTERNALPAINT;
      }
 
      if (Flags & RDW_VALIDATE)
      {
         if (Flags & RDW_NOFRAME)
            Wnd->state &= ~WNDS_SENDNCPAINT;
 
         if (Flags & RDW_NOERASE)
            Wnd->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
 
         if (Wnd->hrgnUpdate > HRGN_WINDOW && RgnType != NULLREGION && Rgn > PRGN_WINDOW)
         {
             PREGION RgnUpdate = REGION_LockRgn(Wnd->hrgnUpdate);
 
             if (RgnUpdate)
             {
                 RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, Rgn, RGN_DIFF);
                 REGION_UnlockRgn(RgnUpdate);
 
                 if (RgnType == NULLREGION)
                 {
                     IntGdiSetRegionOwner(Wnd->hrgnUpdate, GDI_OBJ_HMGR_POWNED);
                     GreDeleteObject(Wnd->hrgnUpdate);
                     Wnd->hrgnUpdate = NULL;
                 }
             }
         }
         // If update is null, do not erase.
         if (Wnd->hrgnUpdate == NULL)
         {
            Wnd->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
         }
      }
 
      if (HadPaintMessage && !IntIsWindowDirty(Wnd))
      {
         MsqDecPaintCountQueue(Wnd->head.pti);
      }
   }
 
   /*
    * Process children if needed
    */
 
   if (!(Flags & RDW_NOCHILDREN) &&
       !(Wnd->style & WS_MINIMIZE) &&
         ((Flags & RDW_ALLCHILDREN) || !(Wnd->style & WS_CLIPCHILDREN)))
   {
      PWND Child;
 
      for (Child = Wnd->spwndChild; Child; Child = Child->spwndNext)
      {
         if (Child->style & WS_VISIBLE)
         {
            /*
             * Recursive call to update children hrgnUpdate
             */
            PREGION RgnTemp = IntSysCreateRectpRgn(0, 0, 0, 0);
            if (RgnTemp)
            {
                if (Rgn > PRGN_WINDOW) IntGdiCombineRgn(RgnTemp, Rgn, 0, RGN_COPY);
                IntInvalidateWindows(Child, ((Rgn > PRGN_WINDOW)?RgnTemp:Rgn), Flags);
                REGION_Delete(RgnTemp);
            }
         }
      }
   }
   TRACE("IntInvalidateWindows exit\n");
}

Referenced by co_UserRedrawWindow(), co_WinPosSetWindowPos(), IntInvalidateWindows(), IntValidateParent(), IntValidateParents(), PaintSuspendedWindow(), and UserRedrawDesktop().

IntIsWindowDirty()

BOOL FASTCALL IntIsWindowDirty

(

PWND

Wnd

)

Definition at line 1125 of file painting.c.

{
   return ( Wnd->style & WS_VISIBLE &&
           ( Wnd->hrgnUpdate != NULL ||
             Wnd->state & WNDS_INTERNALPAINT ) );
}

Referenced by IntFindWindowToRepaint(), and IntInvalidateWindows().

IntIsWindowDrawable()

BOOL FASTCALL IntIsWindowDrawable

(

PWND

Wnd

)

Definition at line 868 of file painting.c.

{
   PWND WndObject;
 
   for (WndObject = Wnd; WndObject != NULL; WndObject = WndObject->spwndParent)
   {
      if ( WndObject->state2 & WNDS2_INDESTROY ||
           WndObject->state & WNDS_DESTROYED ||
           !WndObject ||
           !(WndObject->style & WS_VISIBLE) ||
            ((WndObject->style & WS_MINIMIZE) && (WndObject != Wnd)))
      {
         return FALSE;
      }
   }
 
   return TRUE;
}

Referenced by co_UserRedrawWindow(), IntScrollWindowEx(), and NtUserScrollWindowEx().

IntPaintWindow()

VOID FASTCALL IntPaintWindow

(

PWND

Window

)

Definition at line 1184 of file painting.c.

{
   // Handle normal painting.
   co_IntPaintWindows( Window, RDW_NOCHILDREN, FALSE );
}

Referenced by IntDispatchMessage().

IntSendNCPaint()

VOID FASTCALL IntSendNCPaint	(	PWND	pWnd,
		HRGN	hRgn
	)

Definition at line 348 of file painting.c.

{
   pWnd->state &= ~WNDS_SENDNCPAINT;
 
   if ( pWnd == GetW32ThreadInfo()->MessageQueue->spwndActive &&
       !(pWnd->state & WNDS_ACTIVEFRAME))
   {
      pWnd->state |= WNDS_ACTIVEFRAME;
      pWnd->state &= ~WNDS_NONCPAINT;
      hRgn = HRGN_WINDOW;
   }
 
   if (pWnd->state2 & WNDS2_FORCEFULLNCPAINTCLIPRGN)
   {
      pWnd->state2 &= ~WNDS2_FORCEFULLNCPAINTCLIPRGN;
      hRgn = HRGN_WINDOW;
   }
 
   if (hRgn) co_IntSendMessage(UserHMGetHandle(pWnd), WM_NCPAINT, (WPARAM)hRgn, 0);
}

Referenced by co_IntPaintWindows(), co_WinPosSetWindowPos(), ForceNCPaintErase(), IntBeginPaint(), and IntSendChildNCPaint().

IntSendSyncPaint()

VOID FASTCALL IntSendSyncPaint	(	PWND	Wnd,
		ULONG	Flags
	)

Definition at line 132 of file painting.c.

{
   PTHREADINFO ptiCur, ptiWnd;
   PUSER_SENT_MESSAGE Message;
   PLIST_ENTRY Entry;
   BOOL bSend = TRUE;
 
   ptiWnd = Wnd->head.pti;
   ptiCur = PsGetCurrentThreadWin32Thread();
   /*
      Not the current thread, Wnd is in send Nonclient paint also in send erase background and it is visiable.
   */
   if ( Wnd->head.pti != ptiCur &&
        Wnd->state & WNDS_SENDNCPAINT &&
        Wnd->state & WNDS_SENDERASEBACKGROUND &&
        Wnd->style & WS_VISIBLE)
   {
      // For testing, if you see this, break out the Champagne and have a party!
      TRACE("SendSyncPaint Wnd in State!\n");
      if (!IsListEmpty(&ptiWnd->SentMessagesListHead))
      {
         // Scan sent queue messages to see if we received sync paint messages.
         Entry = ptiWnd->SentMessagesListHead.Flink;
         Message = CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry);
         do
         {
            TRACE("LOOP it\n");
            if (Message->Msg.message == WM_SYNCPAINT &&
                Message->Msg.hwnd == UserHMGetHandle(Wnd))
            {  // Already received so exit out.
                ERR("SendSyncPaint Found one in the Sent Msg Queue!\n");
                bSend = FALSE;
                break;
            }
            Entry = Message->ListEntry.Flink;
            Message = CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry);
         }
         while (Entry != &ptiWnd->SentMessagesListHead);
      }
      if (bSend)
      {
         TRACE("Sending WM_SYNCPAINT\n");
         // This message has no parameters. But it does! Pass Flags along.
         co_IntSendMessageNoWait(UserHMGetHandle(Wnd), WM_SYNCPAINT, Flags, 0);
         Wnd->state |= WNDS_SYNCPAINTPENDING;
      }
   }
 
   // Send to all the children if this is the desktop window.
   if (UserIsDesktopWindow(Wnd))
   {
      if ( Flags & RDW_ALLCHILDREN ||
          ( !(Flags & RDW_NOCHILDREN) && Wnd->style & WS_CLIPCHILDREN))
      {
         PWND spwndChild = Wnd->spwndChild;
         while(spwndChild)
         {
            if ( spwndChild->style & WS_CHILD &&
                 spwndChild->head.pti != ptiCur)
            {
               spwndChild = spwndChild->spwndNext;
               continue;
            }
            IntSendSyncPaint( spwndChild, Flags );
            spwndChild = spwndChild->spwndNext;
         }
      }
   }
}

Referenced by IntSendSyncPaint(), and UserSyncAndPaintWindows().

NC_IconForWindow()

PCURICON_OBJECT FASTCALL NC_IconForWindow

(

PWND

pWnd

)

Definition at line 736 of file nonclient.c.

{
    PCURICON_OBJECT pIcon = NULL;
    HICON hIcon;
 
   hIcon = UserGetProp(pWnd, gpsi->atomIconSmProp, TRUE);
   if (!hIcon) hIcon = UserGetProp(pWnd, gpsi->atomIconProp, TRUE);
 
   if (!hIcon && pWnd->pcls->spicnSm)
       return pWnd->pcls->spicnSm;
   if (!hIcon && pWnd->pcls->spicn)
       return pWnd->pcls->spicn;
 
   // WARNING: Wine code has this test completely wrong. The following is how
   // Windows behaves for windows having the WS_EX_DLGMODALFRAME style set:
   // it does not use the default icon! And it does not check for DS_MODALFRAME.
   if (!hIcon && !(pWnd->ExStyle & WS_EX_DLGMODALFRAME))
   {
      hIcon = gpsi->hIconSmWindows; // Both are IDI_WINLOGO Small
      if (!hIcon) hIcon = gpsi->hIconWindows;   // Reg size.
   }
   if (hIcon)
   {
       pIcon = (PCURICON_OBJECT)UserGetObjectNoErr(gHandleTable,
                                                   hIcon,
                                                   TYPE_CURSOR);
   }
   return pIcon;
}

Referenced by GetNCHitEx(), MENU_DrawBitmapItem(), UserDrawCaption(), UserDrawCaptionBar(), and UserDrawSysMenuButton().

UpdateThreadWindows()

VOID FASTCALL UpdateThreadWindows	(	PWND	pWnd,
		PTHREADINFO	pti,
		HRGN	hRgn
	)

Definition at line 1100 of file painting.c.

{
   PWND pwndTemp;
 
   for ( pwndTemp = pWnd;
         pwndTemp;
         pwndTemp = pwndTemp->spwndNext )
   {
      if (pwndTemp->head.pti == pti)
      {
          UserUpdateWindows(pwndTemp, RDW_ALLCHILDREN);
      }
      else
      {
          if (IsThreadSuspended(pwndTemp->head.pti) || MsqIsHung(pwndTemp->head.pti, MSQ_HUNG))
          {
             UpdateTheadChildren(pwndTemp, hRgn);
          }
          else
             UserUpdateWindows(pwndTemp, RDW_ALLCHILDREN);
      }
   }
}

Referenced by DefWndDoSizeMove().

UserDrawCaption()

BOOL UserDrawCaption	(	PWND	pWnd,
		HDC	hDc,
		RECTL *	lpRc,
		HFONT	hFont,
		HICON	hIcon,
		const	PUNICODE_STRING,
		UINT	uFlags
	)

Definition at line 2192 of file painting.c.

{
   BOOL Ret = FALSE;
   HBRUSH hBgBrush, hOldBrush = NULL;
   RECTL Rect = *lpRc;
   BOOL HasIcon;
 
   RECTL_vMakeWellOrdered(lpRc);
 
   /* Determine whether the icon needs to be displayed */
   if (!hIcon && pWnd != NULL)
   {
     HasIcon = (uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP) &&
               (pWnd->style & WS_SYSMENU) && !(pWnd->ExStyle & WS_EX_TOOLWINDOW);
   }
   else
     HasIcon = (hIcon != NULL);
 
   // Draw the caption background
   if((uFlags & DC_GRADIENT) && !(uFlags & DC_INBUTTON))
   {
      static GRADIENT_RECT gcap = {0, 1};
      TRIVERTEX Vertices[2];
      COLORREF Colors[2];
 
      Colors[0] = IntGetSysColor((uFlags & DC_ACTIVE) ?
            COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION);
 
      Colors[1] = IntGetSysColor((uFlags & DC_ACTIVE) ?
            COLOR_GRADIENTACTIVECAPTION : COLOR_GRADIENTINACTIVECAPTION);
 
      Vertices[0].x = Rect.left;
      Vertices[0].y = Rect.top;
      Vertices[0].Red = (WORD)Colors[0]<<8;
      Vertices[0].Green = (WORD)Colors[0] & 0xFF00;
      Vertices[0].Blue = (WORD)(Colors[0]>>8) & 0xFF00;
      Vertices[0].Alpha = 0;
 
      Vertices[1].x = Rect.right;
      Vertices[1].y = Rect.bottom;
      Vertices[1].Red = (WORD)Colors[1]<<8;
      Vertices[1].Green = (WORD)Colors[1] & 0xFF00;
      Vertices[1].Blue = (WORD)(Colors[1]>>8) & 0xFF00;
      Vertices[1].Alpha = 0;
 
      if(!GreGradientFill(hDc, Vertices, 2, &gcap, 1, GRADIENT_FILL_RECT_H))
      {
         ERR("GreGradientFill() failed!\n");
         goto cleanup;
      }
   }
   else
   {
      if(uFlags & DC_INBUTTON)
         hBgBrush = IntGetSysColorBrush(COLOR_3DFACE);
      else if(uFlags & DC_ACTIVE)
         hBgBrush = IntGetSysColorBrush(COLOR_ACTIVECAPTION);
      else
         hBgBrush = IntGetSysColorBrush(COLOR_INACTIVECAPTION);
 
      hOldBrush = NtGdiSelectBrush(hDc, hBgBrush);
 
      if(!hOldBrush)
      {
         ERR("NtGdiSelectBrush() failed!\n");
         goto cleanup;
      }
 
      if(!NtGdiPatBlt(hDc, Rect.left, Rect.top,
         Rect.right - Rect.left,
         Rect.bottom - Rect.top,
         PATCOPY))
      {
         ERR("NtGdiPatBlt() failed!\n");
         goto cleanup;
      }
   }
 
   /* Draw icon */
   if (HasIcon)
   {
      PCURICON_OBJECT pIcon = NULL;
 
      if (hIcon)
      {
          pIcon = UserGetCurIconObject(hIcon);
      }
      else if (pWnd)
      {
          pIcon = NC_IconForWindow(pWnd);
          // FIXME: NC_IconForWindow should reference it for us */
          if (pIcon)
              UserReferenceObject(pIcon);
      }
 
      if (pIcon)
      {
         LONG cx = UserGetSystemMetrics(SM_CXSMICON);
         LONG cy = UserGetSystemMetrics(SM_CYSMICON);
         LONG x = Rect.left - cx/2 + 1 + (Rect.bottom - Rect.top)/2; // this is really what Window does
         LONG y = (Rect.top + Rect.bottom - cy)/2; // center
         UserDrawIconEx(hDc, x, y, pIcon, cx, cy, 0, NULL, DI_NORMAL);
         UserDereferenceObject(pIcon);
      }
      else
      {
          HasIcon = FALSE;
      }
   }
 
   if (HasIcon)
      Rect.left += Rect.bottom - Rect.top;
 
   if((uFlags & DC_TEXT))
   {
      BOOL Set = FALSE;
      Rect.left += 2;
 
      if (Str)
         Set = UserDrawCaptionText(pWnd, hDc, Str, &Rect, uFlags, hFont);
      else if (pWnd != NULL) // FIXME: Windows does not do that
      {
         UNICODE_STRING ustr;
         ustr.Buffer = pWnd->strName.Buffer; // FIXME: LARGE_STRING truncated!
         ustr.Length = (USHORT)min(pWnd->strName.Length, MAXUSHORT);
         ustr.MaximumLength = (USHORT)min(pWnd->strName.MaximumLength, MAXUSHORT);
         Set = UserDrawCaptionText(pWnd, hDc, &ustr, &Rect, uFlags, hFont);
      }
      if (pWnd)
      {
         if (Set)
            pWnd->state2 &= ~WNDS2_CAPTIONTEXTTRUNCATED;
         else
            pWnd->state2 |= WNDS2_CAPTIONTEXTTRUNCATED;
      }
   }
 
   Ret = TRUE;
 
cleanup:
   if (hOldBrush) NtGdiSelectBrush(hDc, hOldBrush);
 
   return Ret;
}

Referenced by NC_DoNCPaint(), NtUserDrawCaptionTemp(), and UserDrawCaptionBar().

UserRealizePalette()

INT FASTCALL UserRealizePalette

(

HDC

hdc

)

Definition at line 2346 of file painting.c.

{
  HWND hWnd, hWndDesktop;
  DWORD Ret;
 
  Ret = IntGdiRealizePalette(hdc);
  if (Ret) // There was a change.
  {
      hWnd = IntWindowFromDC(hdc);
      if (hWnd) // Send broadcast if dc is associated with a window.
      {  // FYI: Thread locked in CallOneParam.
         hWndDesktop = IntGetDesktopWindow();
         if ( hWndDesktop != hWnd )
         {
            PWND pWnd = UserGetWindowObject(hWndDesktop);
            ERR("RealizePalette Desktop.\n");
            hdc = UserGetWindowDC(pWnd);
            IntPaintDesktop(hdc);
            UserReleaseDC(pWnd,hdc,FALSE);
         }
         UserSendNotifyMessage((HWND)HWND_BROADCAST, WM_PALETTECHANGED, (WPARAM)hWnd, 0);
      }
  }
  return Ret;
}

UserSyncAndPaintWindows()

VOID FASTCALL UserSyncAndPaintWindows	(	PWND	pWnd,
		ULONG	Flags
	)

Definition at line 621 of file painting.c.

{
   PWND Parent = pWnd;
   // Find parent, if it needs to be painted, leave.
   while(TRUE)
   {
      if ((Parent = Parent->spwndParent) == NULL) break;
      if ( Parent->style & WS_CLIPCHILDREN ) break;
      if ( Parent->hrgnUpdate != NULL || Parent->state & WNDS_INTERNALPAINT ) return;
   }
 
   IntSendSyncPaint(pWnd, Flags);
   co_IntPaintWindows(pWnd, Flags, FALSE);
}

Referenced by co_UserRedrawWindow(), and co_WinPosSetWindowPos().