scroll.h File Reference

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

Go to the source code of this file.

Classes
struct	tagSBTRACK

Macros
#define	IntGetScrollbarInfoFromWindow(Window, i)    ((PSCROLLBARINFO)(&((Window)->pSBInfoex + i)->ScrollBarInfo))
#define	IntGetScrollInfoFromWindow(Window, i)    ((LPSCROLLINFO)(&((Window)->pSBInfoex + i)->ScrollInfo))
#define	SBOBJ_TO_SBID(Obj)   ((Obj) - OBJID_HSCROLL)
#define	SBID_IS_VALID(id)   (id == SB_HORZ || id == SB_VERT || id == SB_CTL)

Typedefs
typedef struct tagSBTRACK	SBTRACK
typedef struct tagSBTRACK *	PSBTRACK

Functions
typedef	VOID (NEAR NTAPI *PFN_SCROLLBAR)(PWND
BOOL FASTCALL	co_IntCreateScrollBars (PWND)
BOOL FASTCALL	IntDestroyScrollBars (PWND)
DWORD FASTCALL	co_UserShowScrollBar (PWND, int, BOOL, BOOL)
BOOL FASTCALL	co_IntGetScrollBarInfo (PWND, LONG, PSCROLLBARINFO)
BOOL FASTCALL	co_IntSetScrollBarInfo (PWND, LONG, PSETSCROLLBARINFO)
void	IntDrawScrollBar (PWND, HDC, INT)
BOOL FASTCALL	IntScrollWindow (PWND, int, int, CONST RECT *, CONST RECT *)
DWORD FASTCALL	IntScrollWindowEx (PWND, INT, INT, const RECT *, const RECT *, HRGN, LPRECT, UINT)

Variables
typedef	UINT
typedef	WPARAM
typedef	LPARAM
typedef	PSBCALC

Macro Definition Documentation

IntGetScrollbarInfoFromWindow

#define IntGetScrollbarInfoFromWindow	(		Window,
			i
	)		((PSCROLLBARINFO)(&((Window)->pSBInfoex + i)->ScrollBarInfo))

Definition at line 33 of file scroll.h.

IntGetScrollInfoFromWindow

#define IntGetScrollInfoFromWindow	(		Window,
			i
	)		((LPSCROLLINFO)(&((Window)->pSBInfoex + i)->ScrollInfo))

Definition at line 36 of file scroll.h.

SBID_IS_VALID

#define SBID_IS_VALID

(

id

)

(id == SB_HORZ || id == SB_VERT || id == SB_CTL)

Definition at line 40 of file scroll.h.

SBOBJ_TO_SBID

#define SBOBJ_TO_SBID

(

Obj

)

((Obj) - OBJID_HSCROLL)

Definition at line 39 of file scroll.h.

Typedef Documentation

PSBTRACK

typedef struct tagSBTRACK * PSBTRACK

SBTRACK

typedef struct tagSBTRACK SBTRACK

Function Documentation

co_IntCreateScrollBars()

BOOL FASTCALL co_IntCreateScrollBars

(

PWND

Window

)

Definition at line 748 of file scrollbar.c.

{
   PSCROLLBARINFO psbi;
   PSBDATA pSBData;
   ULONG Size, s;
   INT i;
 
   ASSERT_REFS_CO(Window);
 
   if (Window->pSBInfo && Window->pSBInfoex)
      return TRUE; // No need to create it anymore
 
   // Allocate memory for all scrollbars (HORZ, VERT, CONTROL)
   Size = 3 * (sizeof(SBINFOEX));
   if(!(Window->pSBInfoex = ExAllocatePoolWithTag(PagedPool, Size, TAG_SBARINFO)))
   {
      ERR("Unable to allocate memory for scrollbar information for window %p\n", UserHMGetHandle(Window));
      return FALSE;
   }
 
   RtlZeroMemory(Window->pSBInfoex, Size);
 
   if(!(Window->pSBInfo = DesktopHeapAlloc(Window->head.rpdesk, sizeof(SBINFO))))
   {
      ERR("Unable to allocate memory for scrollbar information for window %p\n", UserHMGetHandle(Window));
      return FALSE;
   }
 
   RtlZeroMemory(Window->pSBInfo, sizeof(SBINFO));
   Window->pSBInfo->Vert.posMax = 100;
   Window->pSBInfo->Horz.posMax = 100;
 
   co_WinPosGetNonClientSize(Window, &Window->rcWindow, &Window->rcClient);
 
   for(s = SB_HORZ; s <= SB_VERT; s++)
   {
      psbi = IntGetScrollbarInfoFromWindow(Window, s);
      psbi->cbSize = sizeof(SCROLLBARINFO);
      for (i = 0; i < CCHILDREN_SCROLLBAR + 1; i++)
         psbi->rgstate[i] = 0;
 
      pSBData = IntGetSBData(Window, s);
 
      IntGetScrollBarRect(Window, s, &(psbi->rcScrollBar));
      IntCalculateThumb(Window, s, psbi, pSBData);
   }
 
   return TRUE;
}

Referenced by co_IntGetScrollBarInfo(), co_IntSetScrollBarInfo(), co_IntSetScrollInfo(), NtUserEnableScrollBar(), and NtUserSetScrollBarInfo().

co_IntGetScrollBarInfo()

BOOL FASTCALL co_IntGetScrollBarInfo	(	PWND	Window,
		LONG	idObject,
		PSCROLLBARINFO	psbi
	)

Definition at line 666 of file scrollbar.c.

{
   INT Bar;
   PSCROLLBARINFO sbi;
   PSBDATA pSBData;
   ASSERT_REFS_CO(Window);
 
   Bar = SBOBJ_TO_SBID(idObject);
 
   if(!SBID_IS_VALID(Bar))
   {
      EngSetLastError(ERROR_INVALID_PARAMETER);
      ERR("Trying to get scrollinfo for unknown scrollbar type %d\n", Bar);
      return FALSE;
   }
 
   if(!co_IntCreateScrollBars(Window))
   {
      ERR("Failed to create scrollbars for window\n");
      return FALSE;
   }
 
   sbi = IntGetScrollbarInfoFromWindow(Window, Bar);
   pSBData = IntGetSBData(Window, Bar);
 
   IntGetScrollBarRect(Window, Bar, &(sbi->rcScrollBar));
   IntCalculateThumb(Window, Bar, sbi, pSBData);
 
    // Scrollbar state
    psbi->rgstate[0] = 0;
    if ((Bar == SB_HORZ && !(Window->style & WS_HSCROLL))
        || (Bar == SB_VERT && !(Window->style & WS_VSCROLL)))
        psbi->rgstate[0] |= STATE_SYSTEM_INVISIBLE;
    if (pSBData->posMin >= pSBData->posMax - max(pSBData->page - 1, 0))
    {
        if (!(psbi->rgstate[0] & STATE_SYSTEM_INVISIBLE))
            psbi->rgstate[0] |= STATE_SYSTEM_UNAVAILABLE;
        else
            psbi->rgstate[0] |= STATE_SYSTEM_OFFSCREEN;
    }
    if (Bar == SB_CTL && !(Window->style & WS_DISABLED))
        psbi->rgstate[0] |= STATE_SYSTEM_UNAVAILABLE;
 
   RtlCopyMemory(psbi, sbi, sizeof(SCROLLBARINFO));
 
   return TRUE;
}

Referenced by IntDrawScrollBar(), IntIsScrollBarVisible(), IntRefeshScrollInterior(), and NtUserGetScrollBarInfo().

co_IntSetScrollBarInfo()

BOOL FASTCALL co_IntSetScrollBarInfo	(	PWND	Window,
		LONG	idObject,
		PSETSCROLLBARINFO	psbi
	)

Definition at line 715 of file scrollbar.c.

{
   INT Bar;
   PSCROLLBARINFO sbi;
   LPSCROLLINFO psi;
   ASSERT_REFS_CO(Window);
 
   Bar = SBOBJ_TO_SBID(idObject);
 
   if(!SBID_IS_VALID(Bar))
   {
      EngSetLastError(ERROR_INVALID_PARAMETER);
      ERR("Trying to get scrollinfo for unknown scrollbar type %d\n", Bar);
      return FALSE;
   }
 
   if(!co_IntCreateScrollBars(Window))
   {
      ERR("Failed to create scrollbars for window\n");
      return FALSE;
   }
 
   sbi = IntGetScrollbarInfoFromWindow(Window, Bar);
   psi = IntGetScrollInfoFromWindow(Window, Bar);
 
   psi->nTrackPos = psbi->nTrackPos;
   sbi->reserved  = psbi->reserved;
   RtlCopyMemory(&sbi->rgstate, &psbi->rgstate, sizeof(psbi->rgstate));
 
   return TRUE;
}

co_UserShowScrollBar()

DWORD FASTCALL co_UserShowScrollBar	(	PWND	Wnd,
		int	nBar,
		BOOL	fShowH,
		BOOL	fShowV
	)

Definition at line 852 of file scrollbar.c.

{
   ULONG old_style, set_bits = 0, clear_bits = 0;
 
   ASSERT_REFS_CO(Wnd);
 
   switch(nBar)
   {
      case SB_CTL:
         {
            //IntUpdateSBInfo(Wnd, SB_CTL); // Is this needed? Was tested w/o!
            co_WinPosShowWindow(Wnd, fShowH ? SW_SHOW : SW_HIDE);
            return TRUE;
         }
      case SB_BOTH:
      case SB_HORZ:
         if (fShowH) set_bits |= WS_HSCROLL;
         else clear_bits |= WS_HSCROLL;
         if( nBar == SB_HORZ ) break;
      // Fall through
      case SB_VERT:
         if (fShowV) set_bits |= WS_VSCROLL;
         else clear_bits |= WS_VSCROLL;
         break;
      default:
         EngSetLastError(ERROR_INVALID_PARAMETER);
         return FALSE; // Nothing to do
   }
 
   old_style = IntSetStyle(Wnd, set_bits, clear_bits);
   if ((old_style & clear_bits) != 0 || (old_style & set_bits) != set_bits)
   {
      //if (Wnd->style & WS_HSCROLL) IntUpdateSBInfo(Wnd, SB_HORZ);
      //if (Wnd->style & WS_VSCROLL) IntUpdateSBInfo(Wnd, SB_VERT);
 
      // Frame has been changed, let the window redraw itself
      co_WinPosSetWindowPos(Wnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE
                           | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED);
      return TRUE;
   }
   return FALSE; // no frame changes
}

Referenced by co_IntSetScrollInfo(), co_UserCreateWindowEx(), and NtUserShowScrollBar().

IntDestroyScrollBars()

BOOL FASTCALL IntDestroyScrollBars

(

PWND

Window

)

Definition at line 799 of file scrollbar.c.

{
   if (Window->pSBInfo && Window->pSBInfoex)
   {
      DesktopHeapFree(Window->head.rpdesk, Window->pSBInfo);
      Window->pSBInfo = NULL;
      ExFreePoolWithTag(Window->pSBInfoex, TAG_SBARINFO);
      Window->pSBInfoex = NULL;
      return TRUE;
   }
   return FALSE;
}

Referenced by co_UserFreeWindow().

IntDrawScrollBar()

void IntDrawScrollBar	(	PWND	Wnd,
		HDC	DC,
		INT	Bar
	)

Definition at line 1072 of file scrollbar.c.

{
   PTHREADINFO pti;
   SCROLLBARINFO Info;
   BOOL Vertical;
 
   pti = PsGetCurrentThreadWin32Thread();
 
   // Get scrollbar info
   switch (Bar)
   {
      case SB_HORZ:
        Vertical = FALSE;
        break;
 
      case SB_VERT:
        Vertical = TRUE;
        break;
 
      case SB_CTL:
        Vertical = (Wnd->style & SBS_VERT) != 0;
        break;
 
      default:
        return;
   }
 
   if (!co_IntGetScrollBarInfo(Wnd, IntScrollGetObjectId(Bar), &Info))
      return;
 
   if (RECTL_bIsEmptyRect(&Info.rcScrollBar))
      return;
 
   // Draw arrows
   if (Info.dxyLineButton)
      IntDrawScrollArrows(DC, &Info, Vertical);
 
   // Draw interior
   IntDrawScrollInterior(Wnd, DC, Bar, Vertical, &Info);
 
   // If scrollbar has focus, reposition the caret
   if (Wnd == pti->MessageQueue->spwndFocus && Bar == SB_CTL)
   {
      if (Vertical)
         co_IntSetCaretPos(Info.rcScrollBar.top + 1, Info.dxyLineButton + 1);
      else
         co_IntSetCaretPos(Info.dxyLineButton + 1, Info.rcScrollBar.top + 1);
   }
}

Referenced by NC_DoNCPaint(), SCROLL_RefreshScrollBar(), and ScrollBarWndProc_common().

IntScrollWindow()

BOOL FASTCALL IntScrollWindow	(	PWND	pWnd,
		int	dx,
		int	dy,
		CONST RECT *	lpRect,
		CONST RECT *	prcClip
	)

Definition at line 458 of file scrollex.c.

{
   return IntScrollWindowEx( pWnd, dx, dy, lpRect, prcClip, 0, NULL,
                            (lpRect ? 0 : SW_SCROLLCHILDREN) | (SW_ERASE|SW_INVALIDATE|SW_SCROLLWNDDCE)) != ERROR;
}

Referenced by MENU_EnsureMenuItemVisible().

IntScrollWindowEx()

DWORD FASTCALL IntScrollWindowEx	(	PWND	Window,
		INT	dx,
		INT	dy,
		const RECT *	prcScroll,
		const RECT *	prcClip,
		HRGN	hrgnUpdate,
		LPRECT	prcUpdate,
		UINT	flags
	)

Definition at line 228 of file scrollex.c.

{
   INT Result;
   RECTL rcScroll, rcClip, rcCaret;
   PWND CaretWnd;
   HDC hDC;
   PREGION RgnUpdate = NULL, RgnTemp, RgnWinupd = NULL;
   HWND hwndCaret;
   DWORD dcxflags = 0;
   int rdw_flags;
   USER_REFERENCE_ENTRY CaretRef;
 
   if (!Window || !IntIsWindowDrawable(Window))
   {
      return ERROR;
   }
 
   IntGetClientRect(Window, &rcClip);
 
   if (prcScroll)
      RECTL_bIntersectRect(&rcScroll, &rcClip, prcScroll);
   else
      rcScroll = rcClip;
 
   if (prcClip)
      RECTL_bIntersectRect(&rcClip, &rcClip, prcClip);
 
   if (rcClip.right <= rcClip.left || rcClip.bottom <= rcClip.top ||
         (dx == 0 && dy == 0))
   {
      return NULLREGION;
   }
 
   /* We must use a copy of the region, as we can't hold an exclusive lock
    * on it while doing callouts to user-mode */
   RgnUpdate = IntSysCreateRectpRgn(0, 0, 0, 0);
   if(!RgnUpdate)
   {
       EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
       return ERROR;
   }
 
   if (hrgnUpdate)
   {
       RgnTemp = REGION_LockRgn(hrgnUpdate);
       if (!RgnTemp)
       {
           EngSetLastError(ERROR_INVALID_HANDLE);
           Result = ERROR;
           goto Cleanup;
       }
       IntGdiCombineRgn(RgnUpdate, RgnTemp, NULL, RGN_COPY);
       REGION_UnlockRgn(RgnTemp);
   }
 
   /* ScrollWindow uses the window DC, ScrollWindowEx doesn't */
   if (flags & SW_SCROLLWNDDCE)
   {
      dcxflags = DCX_USESTYLE;
 
      if (!(Window->pcls->style & (CS_OWNDC|CS_CLASSDC)))
         dcxflags |= DCX_CACHE; // AH??? wine~ If not Powned or with Class go Cheap!
 
      if (flags & SW_SCROLLCHILDREN && Window->style & WS_CLIPCHILDREN)
         dcxflags |= DCX_CACHE|DCX_NOCLIPCHILDREN;
   }
   else
   {
       /* So in this case ScrollWindowEx uses Cache DC. */
       dcxflags = DCX_CACHE|DCX_USESTYLE;
       if (flags & SW_SCROLLCHILDREN) dcxflags |= DCX_NOCLIPCHILDREN;
   }
 
   hDC = UserGetDCEx(Window, 0, dcxflags);
   if (!hDC)
   {
      /* FIXME: SetLastError? */
      Result = ERROR;
      goto Cleanup;
   }
 
   rdw_flags = (flags & SW_ERASE) && (flags & SW_INVALIDATE) ? RDW_INVALIDATE | RDW_ERASE : RDW_INVALIDATE ;
 
   rcCaret = rcScroll;
   hwndCaret = co_IntFixCaret(Window, &rcCaret, flags);
 
   Result = UserScrollDC( hDC,
                          dx,
                          dy,
                          &rcScroll,
                          &rcClip,
                          NULL,
                          RgnUpdate,
                          prcUpdate);
 
   UserReleaseDC(Window, hDC, FALSE);
 
   /*
    * Take into account the fact that some damage may have occurred during
    * the scroll. Keep a copy in hrgnWinupd to be added to hrngUpdate at the end.
    */
 
   RgnTemp = IntSysCreateRectpRgn(0, 0, 0, 0);
   if (!RgnTemp)
   {
       EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
       Result = ERROR;
       goto Cleanup;
   }
 
   if (co_IntGetUpdateRgn(Window, RgnTemp, FALSE) != NULLREGION)
   {
      PREGION RgnClip = IntSysCreateRectpRgnIndirect(&rcClip);
      if (RgnClip)
      {
          if (hrgnUpdate)
          {
             RgnWinupd = IntSysCreateRectpRgn(0, 0, 0, 0);
             // FIXME: What to do if RgnWinupd == NULL??
             IntGdiCombineRgn( RgnWinupd, RgnTemp, 0, RGN_COPY);
          }
 
          REGION_bOffsetRgn(RgnTemp, dx, dy);
 
          IntGdiCombineRgn(RgnTemp, RgnTemp, RgnClip, RGN_AND);
 
          if (hrgnUpdate)
              IntGdiCombineRgn( RgnWinupd, RgnWinupd, RgnTemp, RGN_OR );
 
          co_UserRedrawWindow(Window, NULL, RgnTemp, rdw_flags );
 
          REGION_Delete(RgnClip);
      }
   }
   REGION_Delete(RgnTemp);
 
   if (flags & SW_SCROLLCHILDREN)
   {
      PWND Child;
      RECTL rcChild;
      POINT ClientOrigin;
      USER_REFERENCE_ENTRY WndRef;
      RECTL rcDummy;
      LPARAM lParam;
 
      IntGetClientOrigin(Window, &ClientOrigin);
 
      for (Child = Window->spwndChild; Child; Child = Child->spwndNext)
      {
         rcChild = Child->rcWindow;
         RECTL_vOffsetRect(&rcChild, -ClientOrigin.x, -ClientOrigin.y);
 
         /* Adjust window positions */
         RECTL_vOffsetRect(&Child->rcWindow, dx, dy);
         RECTL_vOffsetRect(&Child->rcClient, dx, dy);
 
         if (!prcScroll || RECTL_bIntersectRect(&rcDummy, &rcChild, &rcScroll))
         {
            UserRefObjectCo(Child, &WndRef);
 
            if (UserIsDesktopWindow(Window->spwndParent))
               lParam = MAKELONG(Child->rcClient.left, Child->rcClient.top);
            else
               lParam = MAKELONG(rcChild.left + dx, rcChild.top + dy);
 
            /* wine sends WM_POSCHANGING, WM_POSCHANGED messages */
            /* windows sometimes a WM_MOVE */
            co_IntSendMessage(UserHMGetHandle(Child), WM_MOVE, 0, lParam);
 
            UserDerefObjectCo(Child);
         }
      }
   }
 
   if (flags & (SW_INVALIDATE | SW_ERASE))
   {
      co_UserRedrawWindow( Window,
                           NULL,
                           RgnUpdate,
                           rdw_flags |                                    /*    HACK    */
                          ((flags & SW_SCROLLCHILDREN) ? RDW_ALLCHILDREN : RDW_NOCHILDREN) );
   }
 
   if (hwndCaret && (CaretWnd = UserGetWindowObject(hwndCaret)))
   {
      UserRefObjectCo(CaretWnd, &CaretRef);
 
      co_IntSetCaretPos(rcCaret.left + dx, rcCaret.top + dy);
      co_UserShowCaret(CaretWnd);
 
      UserDerefObjectCo(CaretWnd);
   }
 
   if (hrgnUpdate && (Result != ERROR))
   {
       /* Give everything back to the caller */
       RgnTemp = REGION_LockRgn(hrgnUpdate);
       /* The handle should still be valid */
       ASSERT(RgnTemp);
       if (RgnWinupd)
           IntGdiCombineRgn(RgnTemp, RgnUpdate, RgnWinupd, RGN_OR);
       else
           IntGdiCombineRgn(RgnTemp, RgnUpdate, NULL, RGN_COPY);
       REGION_UnlockRgn(RgnTemp);
   }
 
Cleanup:
   if (RgnWinupd)
   {
       REGION_Delete(RgnWinupd);
   }
 
   if (RgnUpdate)
   {
      REGION_Delete(RgnUpdate);
   }
 
   return Result;
}

Referenced by IntScrollWindow(), and NtUserScrollWindowEx().

VOID()

typedef VOID

(

NEAR NTAPI *

PFN_SCROLLBAR

)

Variable Documentation

LPARAM

typedef LPARAM

Definition at line 3 of file scroll.h.

PSBCALC

typedef PSBCALC

Definition at line 3 of file scroll.h.

UINT

typedef UINT

Definition at line 3 of file scroll.h.

WPARAM

typedef WPARAM

Definition at line 3 of file scroll.h.