archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/shell/themes/uxtheme/scroll.cpp

4288 lines
130 KiB
Raw Permalink Blame History

//---------------------------------------------------------------------------
#include "stdafx.h"
#include "scroll.h"
#if defined(_UXTHEME_)
// non-client scrollbar
#include "nctheme.h"
#include "scrollp.h"
#else
// scrollbar control
#include "usrctl32.h"
#endif _UXTHEME_
// comment this out to visually match user32 scrollbar:
//#define _VISUAL_DELTA_
#ifdef _VISUAL_DELTA_
#define CARET_BORDERWIDTH 2
#endif _VISUAL_DELTA_
//-------------------------------------------------------------------------//
#define FNID_SCROLLBAR 0x0000029A // UxScrollBarWndProc;
#define GetOwner(hwnd) GetWindow(hwnd, GW_OWNER)
#define HW(x) x
#define HWq(x) x
#define RIPERR0(s1,s2,errno)
#define RIPMSG1(errno,fmt,arg1)
#define RIPMSG2(errno,fmt,arg1,arg2)
#define RIPMSG3(errno,fmt,arg1,arg2,arg3)
#define RIP_VERBOSE()
#define ClrWF ClearWindowState
#define SetWF SetWindowState
#define Lock(phwnd, hwnd) InterlockedExchangePointer((PVOID*)(phwnd), (PVOID)hwnd)
#define Unlock(phwnd) Lock(phwnd, NULL)
#define CheckLock(hwnd)
#define ThreadLock(w,t)
#define ThreadUnlock(t)
#define VALIDATECLASSANDSIZE
#define DTTIME (MulDiv( GetDoubleClickTime(), 4, 5 ))
#define _KillSystemTimer KillTimer
#define _SetSystemTimer SetTimer
#define IsWinEventNotifyDeferredOK() TRUE
#define IsWinEventNotifyDeferred() FALSE
//-------------------------------------------------------------------------//
// scroll type flags userk.h
#define SCROLL_NORMAL 0
#define SCROLL_DIRECT 1
#define SCROLL_MENU 2
//-------------------------------------------------------------------------//
// internal Scrollbar state/style bits
//#define SBFSIZEBOXTOPLEFT 0x0C02
//#define SBFSIZEBOXBOTTOMRIGHT 0x0C04
//#define SBFSIZEBOX 0x0C08
#define SBFSIZEGRIP 0x0C10
//----------------------------------//
// Scrollbar arrow disable flags
#define LTUPFLAG 0x0001 // Left/Up arrow disable flag.
#define RTDNFLAG 0x0002 // Right/Down arrow disable flag.
//----------------------------------//
// function forwards
UINT _SysToChar(UINT message, LPARAM lParam);
//-------------------------------------------------------------------------//
// private hittest codes
//#define HTEXSCROLLFIRST 60
#define HTSCROLLUP 60
#define HTSCROLLDOWN 61
#define HTSCROLLUPPAGE 62
#define HTSCROLLDOWNPAGE 63
#define HTSCROLLTHUMB 64
//#define HTEXSCROLLLAST 64
//#define HTEXMENUFIRST 65
//#define HTMDISYSMENU 65
//#define HTMDIMAXBUTTON 66
//#define HTMDIMINBUTTON 67
//#define HTMDICLOSE 68
//#define HTMENUITEM 69
//#define HTEXMENULAST 69
#define IDSYS_SCROLL 0x0000FFFEL // timer ID, user.h
typedef HWND SBHWND;
typedef HMENU PMENU;
//-------------------------------------------------------------------------//
// SBDATA
typedef struct tagSBDATA
{
int posMin;
int posMax;
int page;
int pos;
} SBDATA, *PSBDATA;
//-------------------------------------------------------------------------//
// SBINFO is the set of values that hang off of a window structure,
// if the window has scrollbars.
typedef struct tagSBINFO
{
int WSBflags;
SBDATA Horz;
SBDATA Vert;
} SBINFO, * PSBINFO;
//-------------------------------------------------------------------------//
// SBCALC
// Scrollbar metrics block.
typedef struct tagSBCALC
{
SBDATA data; /* this must be first -- we cast structure pointers */
int pxTop;
int pxBottom;
int pxLeft;
int pxRight;
int cpxThumb;
int pxUpArrow;
int pxDownArrow;
int pxStart; /* Initial position of thumb */
int pxThumbBottom;
int pxThumbTop;
int cpx;
int pxMin;
} SBCALC, *PSBCALC;
//-------------------------------------------------------------------------//
// SBTRACK
// Scrollbar thumb-tracking state block.
typedef struct tagSBTRACK {
DWORD fHitOld : 1;
DWORD fTrackVert : 1;
DWORD fCtlSB : 1;
DWORD fTrackRecalc: 1;
HWND hwndTrack;
HWND hwndSB;
HWND hwndSBNotify;
RECT rcTrack;
VOID (CALLBACK *pfnSB)(HWND, UINT, WPARAM, LPARAM, PSBCALC);
UINT cmdSB;
UINT_PTR hTimerSB;
int dpxThumb; /* Offset from mouse point to start of thumb box */
int pxOld; /* Previous position of thumb */
int posOld;
int posNew;
int nBar;
PSBCALC pSBCalc;
} SBTRACK, *PSBTRACK;
//-------------------------------------------------------------------------//
// Window scrollbars, control base.
class CUxScrollBar
//-------------------------------------------------------------------------//
{
public:
CUxScrollBar();
virtual ~CUxScrollBar() {}
virtual BOOL IsCtl() const { return FALSE;}
operator HWND() { return _hwnd; }
static CUxScrollBar* Calc( HWND hwnd, PSBCALC pSBCalc, LPRECT prcOverrideClient, BOOL fVert);
virtual void Calc2( PSBCALC pSBCalc, LPRECT lprc, CONST PSBDATA pw, BOOL fVert);
virtual void DoScroll( HWND hwndNotify, int cmd, int pos, BOOL fVert );
virtual void ClearTrack() { ZeroMemory( &_track, sizeof(_track) ); }
SBTRACK* GetTrack() { return &_track; }
SBINFO* GetInfo() { return &_info; }
HTHEME GetTheme() { return _hTheme; }
BOOL IsAttaching() { return _fAttaching; }
INT GetHotComponent(BOOL fVert) { return fVert ? _htVert : _htHorz; }
VOID SetHotComponent(INT ht, BOOL fVert) { (fVert ? _htVert : _htHorz) = ht; }
virtual void ChangeSBTheme();
virtual BOOL FreshenSBData( int nBar, BOOL fRedraw );
// UxScrollBar API.
static CUxScrollBar* Attach( HWND hwnd, BOOL bCtl, BOOL fRedraw );
static CUxScrollBar* FromHwnd( HWND hwnd );
static void Detach( HWND hwnd );
static SBTRACK* GetSBTrack( HWND hwnd );
static void ClearSBTrack( HWND hwnd );
static SBINFO* GetSBInfo( HWND hwnd );
static HTHEME GetSBTheme( HWND hwnd );
static INT GetSBHotComponent( HWND hwnd, BOOL fVert);
protected:
HWND _hwnd;
SBTRACK _track;
SBINFO _info;
INT _htVert; // Scroll bar part the mouse is currently over
INT _htHorz; // Scroll bar part the mouse is currently over
HTHEME _hTheme;// Handle to theme manager
BOOL _fAttaching;
};
//-------------------------------------------------------------------------//
// Scrollbar control
class CUxScrollBarCtl : public CUxScrollBar
//-------------------------------------------------------------------------//
{
public:
CUxScrollBarCtl();
virtual BOOL IsCtl() const { return TRUE;}
BOOL AddRemoveDisableFlags( UINT wAdd, UINT wRemove );
// UxScrollBarCtl API.
static CUxScrollBarCtl* FromHwnd( HWND hwnd );
static UINT GetDisableFlags( HWND hwnd );
static SBCALC* GetCalc( HWND hwnd );
static BOOL AddRemoveDisableFlags( HWND, UINT, UINT );
static LRESULT CALLBACK WndProc( HWND, UINT, WPARAM, LPARAM );
BOOL _fVert;
UINT _wDisableFlags; // Indicates which arrow is disabled;
SBCALC _calc;
};
//-------------------------------------------------------------------------//
// IsScrollBarControl
#ifdef PORTPORT
#define IsScrollBarControl(h) (GETFNID(h) == FNID_SCROLLBAR)
#else //PORTPORT
inline BOOL IsScrollBarControl(HWND hwnd) {
return CUxScrollBarCtl::FromHwnd( hwnd ) != NULL;
}
#endif //PORTPORT
//-------------------------------------------------------------------------//
// Forwards:
void DrawScrollBar( HWND hwnd, HDC hdc, LPRECT prcOverrideClient, BOOL fVert);
HWND SizeBoxHwnd( HWND hwnd );
VOID _DrawPushButton( HWND hwnd, HDC hdc, LPRECT lprc, UINT state, UINT flags, BOOL fVert);
UINT _GetWndSBDisableFlags(HWND, BOOL);
void CALLBACK _TrackThumb( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam, PSBCALC pSBCalc);
void CALLBACK _TrackBox( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam, PSBCALC pSBCalc);
void _RedrawFrame( HWND hwnd );
BOOL _FChildVisible( HWND hwnd );
LONG _SetScrollBar( HWND hwnd, int code, LPSCROLLINFO lpsi, BOOL fRedraw);
HBRUSH _UxGrayBrush(VOID);
//-------------------------------------------------------------------------//
BOOL WINAPI InitScrollBarClass( HINSTANCE hInst )
{
WNDCLASSEX wc;
ZeroMemory( &wc, sizeof(wc) );
wc.cbSize = sizeof(wc);
wc.style = CS_GLOBALCLASS|CS_PARENTDC|CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS;
wc.lpfnWndProc = CUxScrollBarCtl::WndProc;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hInstance = hInst;
wc.lpszClassName = WC_SCROLLBAR;
wc.cbWndExtra = max(sizeof(CUxScrollBar), sizeof(CUxScrollBarCtl));
return RegisterClassEx( &wc ) != 0;
}
//-------------------------------------------------------------------------//
// CUxScrollBar impl
//-------------------------------------------------------------------------//
//-------------------------------------------------------------------------//
CUxScrollBar::CUxScrollBar()
: _hwnd(NULL),
_hTheme(NULL),
_htVert(HTNOWHERE),
_htHorz(HTNOWHERE),
_fAttaching(FALSE)
{
ClearTrack();
ZeroMemory( &_info, sizeof(_info) );
_info.Vert.posMax = 100; // ported from _InitPwSB
_info.Horz.posMax = 100; // ported from _InitPwSB
}
//-------------------------------------------------------------------------//
CUxScrollBar* CUxScrollBar::Attach( HWND hwnd, BOOL bCtl, BOOL fRedraw )
{
CUxScrollBar* psb = FromHwnd( hwnd );
if( NULL == psb )
{
psb = bCtl ? new CUxScrollBarCtl : new CUxScrollBar;
if( psb != NULL )
{
ASSERT( psb->IsCtl() == bCtl );
if( (! hwnd) || (! SetProp( hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_SCROLLBAR)), (HANDLE)psb ) ))
{
delete psb;
psb = NULL;
}
else
{
psb->_hwnd = hwnd;
psb->_fAttaching = TRUE;
if (psb->IsCtl())
{
psb->_hTheme = OpenThemeData(hwnd, L"ScrollBar");
}
else
{
psb->_hTheme = OpenNcThemeData(hwnd, L"ScrollBar");
//
// window SBs must grovel for state data each
// time attached [scotthan]
//
SCROLLINFO si;
ZeroMemory(&si, sizeof(si));
si.cbSize = sizeof(si);
si.fMask = SIF_ALL;
if (GetScrollInfo(hwnd, SB_VERT, &si))
{
si.fMask |= SIF_DISABLENOSCROLL;
_SetScrollBar(hwnd, SB_VERT, &si, FALSE);
}
ZeroMemory(&si, sizeof(si));
si.cbSize = sizeof(si);
si.fMask = SIF_ALL;
if (GetScrollInfo(hwnd, SB_HORZ, &si))
{
si.fMask |= SIF_DISABLENOSCROLL;
_SetScrollBar(hwnd, SB_HORZ, &si, FALSE);
}
}
psb->_fAttaching = FALSE;
}
}
}
return psb;
}
//-------------------------------------------------------------------------//
CUxScrollBar* CUxScrollBar::FromHwnd( HWND hwnd )
{
if (! hwnd)
return NULL;
return (CUxScrollBar*)GetProp( hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_SCROLLBAR)));
}
//-------------------------------------------------------------------------//
void CUxScrollBar::Detach( HWND hwnd )
{
CUxScrollBar* psb = FromHwnd( hwnd );
if ( psb == NULL || !psb->_fAttaching )
{
if (hwnd)
{
RemoveProp( hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_SCROLLBAR)));
}
if( psb != NULL )
{
if ( psb->_hTheme )
{
CloseThemeData(psb->_hTheme);
}
delete psb;
}
}
}
//-------------------------------------------------------------------------//
void WINAPI AttachScrollBars( HWND hwnd )
{
ASSERT( GetWindowLong( hwnd, GWL_STYLE ) & (WS_HSCROLL|WS_VSCROLL) );
CUxScrollBar::Attach( hwnd, FALSE, FALSE );
}
//-------------------------------------------------------------------------//
void WINAPI DetachScrollBars( HWND hwnd )
{
CUxScrollBar::Detach( hwnd );
}
//-------------------------------------------------------------------------//
SBTRACK* CUxScrollBar::GetSBTrack( HWND hwnd )
{
CUxScrollBar* psb = FromHwnd( hwnd );
if( psb )
return &psb->_track;
return NULL;
}
//-------------------------------------------------------------------------//
void CUxScrollBar::ClearSBTrack( HWND hwnd )
{
CUxScrollBar* psb = FromHwnd( hwnd );
if( psb )
psb->ClearTrack();
}
//-------------------------------------------------------------------------//
SBINFO* CUxScrollBar::GetSBInfo( HWND hwnd )
{
CUxScrollBar* psb = FromHwnd( hwnd );
if( psb )
return &psb->_info;
return NULL;
}
//-------------------------------------------------------------------------//
HTHEME CUxScrollBar::GetSBTheme( HWND hwnd )
{
CUxScrollBar* psb = FromHwnd( hwnd );
if( psb )
return psb->_hTheme;
return NULL;
}
//-------------------------------------------------------------------------//
INT CUxScrollBar::GetSBHotComponent( HWND hwnd, BOOL fVert )
{
CUxScrollBar* psb = FromHwnd( hwnd );
if( psb )
return psb->GetHotComponent(fVert);
return 0;
}
//-------------------------------------------------------------------------//
BOOL CUxScrollBar::FreshenSBData( int nBar, BOOL fRedraw )
{
#ifdef __POLL_FOR_SCROLLINFO__
ASSERT(IsWindow(_hwnd));
if( !IsCtl() )
{
// Note scrollbar ctls don't go stale because
// they receive SBM notifications
SCROLLINFO si;
si.cbSize = sizeof(si);
si.fMask = SIF_ALL;
switch(nBar)
{
case SB_VERT:
case SB_HORZ:
if( GetScrollInfo( _hwnd, nBar, &si ) )
{
_SetScrollBar( _hwnd, nBar, &si, fRedraw );
}
break;
case SB_BOTH:
return FreshenSBData( SB_VERT, fRedraw ) &&
FreshenSBData( SB_HORZ, fRedraw );
break;
default: return FALSE;
}
}
#endif __POLL_FOR_SCROLLINFO__
return TRUE;
}
//-------------------------------------------------------------------------//
void CUxScrollBar::ChangeSBTheme()
{
if ( _hTheme )
{
CloseThemeData(_hTheme);
}
_hTheme = NULL;
if (IsCtl())
_hTheme = OpenThemeData(_hwnd, L"ScrollBar");
else
_hTheme = OpenNcThemeData(_hwnd, L"ScrollBar");
}
//-------------------------------------------------------------------------//
// CUxScrollBarCtl impl
//-------------------------------------------------------------------------//
//-------------------------------------------------------------------------//
CUxScrollBarCtl::CUxScrollBarCtl()
: _wDisableFlags(0), _fVert(FALSE)
{
ZeroMemory( &_calc, sizeof(_calc) );
}
//-------------------------------------------------------------------------//
CUxScrollBarCtl* CUxScrollBarCtl::FromHwnd( HWND hwnd )
{
CUxScrollBarCtl* psb = (CUxScrollBarCtl*)CUxScrollBar::FromHwnd( hwnd );
if( psb )
return psb->IsCtl() ? psb : NULL;
return NULL;
}
//-------------------------------------------------------------------------//
UINT CUxScrollBarCtl::GetDisableFlags( HWND hwnd )
{
CUxScrollBarCtl* psb = FromHwnd( hwnd );
if( psb )
return psb->_wDisableFlags;
return 0;
}
//-------------------------------------------------------------------------//
SBCALC* CUxScrollBarCtl::GetCalc( HWND hwnd )
{
CUxScrollBarCtl* psb = FromHwnd( hwnd );
if( psb )
return &psb->_calc;
return NULL;
}
//-------------------------------------------------------------------------//
// CUxScrollBarCtl::AddRemoveDisableFlags() - static
BOOL CUxScrollBarCtl::AddRemoveDisableFlags( HWND hwnd, UINT wAdd, UINT wRemove )
{
CUxScrollBarCtl* psb = FromHwnd( hwnd );
if( psb )
return psb->AddRemoveDisableFlags( wAdd, wRemove );
return FALSE;
}
//-------------------------------------------------------------------------//
// CUxScrollBarCtl::AddRemoveDisableFlags() - instance member
BOOL CUxScrollBarCtl::AddRemoveDisableFlags( UINT wAdd, UINT wRemove )
{
// returns TRUE if flags changed, otherwise FALSE.
UINT wOld = _wDisableFlags;
_wDisableFlags |= wAdd;
_wDisableFlags &= ~wRemove;
return _wDisableFlags != wOld;
}
//-------------------------------------------------------------------------//
// CUxScrollBar::Calc(). computes metrics for window SBs only.
// derives rect and calls Calc2.
CUxScrollBar* CUxScrollBar::Calc(
HWND hwnd,
PSBCALC pSBCalc,
LPRECT prcOverrideClient,
BOOL fVert)
{
RECT rcT;
#ifdef USE_MIRRORING
int cx, iTemp;
#endif
//
// Get client rectangle in window-relative coords.
// We know that window scrollbars always align to the right
// and to the bottom of the client area.
//
WINDOWINFO wi;
wi.cbSize = sizeof(wi);
if( !GetWindowInfo( hwnd, &wi ) )
return NULL;
OffsetRect( &wi.rcClient, -wi.rcWindow.left, -wi.rcWindow.top );
#ifdef USE_MIRRORING
if (TestWF(hwnd, WEFLAYOUTRTL)) {
cx = wi.rcWindow.right - wi.rcWindow.left;
iTemp = wi.rcClient.left;
wi.rcClient.left = cx - wi.rcClient.right;
wi.rcClient.right = cx - iTemp;
}
#endif
if (fVert) {
// Only add on space if vertical scrollbar is really there.
if (TestWF(hwnd, WEFLEFTSCROLL)) {
rcT.right = rcT.left = wi.rcClient.left;
if (TestWF(hwnd, WFVPRESENT))
rcT.left -= SYSMET(CXVSCROLL);
} else {
rcT.right = rcT.left = wi.rcClient.right;
if (TestWF(hwnd, WFVPRESENT))
rcT.right += SYSMET(CXVSCROLL);
}
rcT.top = wi.rcClient.top;
rcT.bottom = wi.rcClient.bottom;
} else {
// Only add on space if horizontal scrollbar is really there.
rcT.bottom = rcT.top = wi.rcClient.bottom;
if (TestWF(hwnd, WFHPRESENT))
rcT.bottom += SYSMET(CYHSCROLL);
rcT.left = wi.rcClient.left;
rcT.right = wi.rcClient.right;
}
if (prcOverrideClient)
{
rcT = *prcOverrideClient;
}
// If InitPwSB stuff fails (due to our heap being full) there isn't anything reasonable
// we can do here, so just let it go through. We won't fault but the scrollbar won't work
// properly either...
CUxScrollBar* psb = CUxScrollBar::Attach( hwnd, FALSE, FALSE );
if( psb )
{
SBDATA* pData = fVert ? &psb->_info.Vert : &psb->_info.Horz;
if( psb )
psb->Calc2( pSBCalc, &rcT, pData, fVert );
return psb;
}
return NULL;
}
//-------------------------------------------------------------------------//
// CUxScrollBar::Calc2(). computes metrics for window SBs or SB ctls.
void CUxScrollBar::Calc2( PSBCALC pSBCalc, LPRECT lprc, CONST PSBDATA pw, BOOL fVert)
{
int cpx;
DWORD dwRange;
int denom;
if (fVert) {
pSBCalc->pxTop = lprc->top;
pSBCalc->pxBottom = lprc->bottom;
pSBCalc->pxLeft = lprc->left;
pSBCalc->pxRight = lprc->right;
pSBCalc->cpxThumb = SYSMET(CYVSCROLL);
} else {
/*
* For horiz scroll bars, "left" & "right" are "top" and "bottom",
* and vice versa.
*/
pSBCalc->pxTop = lprc->left;
pSBCalc->pxBottom = lprc->right;
pSBCalc->pxLeft = lprc->top;
pSBCalc->pxRight = lprc->bottom;
pSBCalc->cpxThumb = SYSMET(CXHSCROLL);
}
pSBCalc->data.pos = pw->pos;
pSBCalc->data.page = pw->page;
pSBCalc->data.posMin = pw->posMin;
pSBCalc->data.posMax = pw->posMax;
dwRange = ((DWORD)(pSBCalc->data.posMax - pSBCalc->data.posMin)) + 1;
//
// For the case of short scroll bars that don't have enough
// room to fit the full-sized up and down arrows, shorten
// their sizes to make 'em fit
//
cpx = min((pSBCalc->pxBottom - pSBCalc->pxTop) / 2, pSBCalc->cpxThumb);
pSBCalc->pxUpArrow = pSBCalc->pxTop + cpx;
pSBCalc->pxDownArrow = pSBCalc->pxBottom - cpx;
if ((pw->page != 0) && (dwRange != 0)) {
// JEFFBOG -- This is the one and only place where we should
// see 'range'. Elsewhere it should be 'range - page'.
/*
* The minimun thumb size used to depend on the frame/edge metrics.
* People that increase the scrollbar width/height expect the minimun
* to grow with proportianally. So NT5 bases the minimun on
* CXH/YVSCROLL, which is set by default in cpxThumb.
*/
/*
* i is used to keep the macro "max" from executing MulDiv twice.
*/
int i = MulDiv(pSBCalc->pxDownArrow - pSBCalc->pxUpArrow,
pw->page, dwRange);
pSBCalc->cpxThumb = max(pSBCalc->cpxThumb / 2, i);
}
pSBCalc->pxMin = pSBCalc->pxTop + cpx;
pSBCalc->cpx = pSBCalc->pxBottom - cpx - pSBCalc->cpxThumb - pSBCalc->pxMin;
denom = dwRange - (pw->page ? pw->page : 1);
if (denom)
pSBCalc->pxThumbTop = MulDiv(pw->pos - pw->posMin,
pSBCalc->cpx, denom) +
pSBCalc->pxMin;
else
pSBCalc->pxThumbTop = pSBCalc->pxMin - 1;
pSBCalc->pxThumbBottom = pSBCalc->pxThumbTop + pSBCalc->cpxThumb;
}
//-------------------------------------------------------------------------//
void CUxScrollBar::DoScroll( HWND hwndNotify, int cmd, int pos, BOOL fVert )
{
HWND hwnd = _hwnd;
//
// Send scroll notification to the scrollbar owner. If this is a control
// the lParam is the control's handle, NULL otherwise.
//
SendMessage(hwndNotify,
(UINT)(fVert ? WM_VSCROLL : WM_HSCROLL),
MAKELONG(cmd, pos),
(LPARAM)(IsCtl() ? _hwnd : NULL));
//
// The hwnd can have it's scrollbar removed as the result
// of the previous sendmessge.
//
if( CUxScrollBar::GetSBTrack(hwnd) && !IsCtl() )
{
FreshenSBData( fVert ? SB_VERT : SB_HORZ, TRUE );
}
}
/*
* Now it is possible to selectively Enable/Disable just one arrow of a Window
* scroll bar; Various bits in the 7th word in the rgwScroll array indicates which
* one of these arrows are disabled; The following masks indicate which bit of the
* word indicates which arrow;
*/
#define WSB_HORZ_LF 0x0001 // Represents the Left arrow of the horizontal scroll bar.
#define WSB_HORZ_RT 0x0002 // Represents the Right arrow of the horizontal scroll bar.
#define WSB_VERT_UP 0x0004 // Represents the Up arrow of the vert scroll bar.
#define WSB_VERT_DN 0x0008 // Represents the Down arrow of the vert scroll bar.
#define WSB_VERT (WSB_VERT_UP | WSB_VERT_DN)
#define WSB_HORZ (WSB_HORZ_LF | WSB_HORZ_RT)
void DrawCtlThumb( SBHWND );
/*
* RETURN_IF_PSBTRACK_INVALID:
* This macro tests whether the pSBTrack we have is invalid, which can happen
* if it gets freed during a callback.
* This protects agains the original pSBTrack being freed and no new one
* being allocated or a new one being allocated at a different address.
* This does not protect against the original pSBTrack being freed and a new
* one being allocated at the same address.
* If pSBTrack has changed, we assert that there is not already a new one
* because we are really not expecting this.
*/
#define RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd) \
if ((pSBTrack) != CUxScrollBar::GetSBTrack(hwnd)) { \
ASSERT(CUxScrollBar::GetSBTrack(hwnd) == NULL); \
return; \
}
/*
* REEVALUATE_PSBTRACK
* This macro just refreshes the local variable pSBTrack, in case it has
* been changed during a callback. After performing this operation, pSBTrack
* should be tested to make sure it is not now NULL.
*/
#if (defined(DBG) || defined(DEBUG) || defined(_DEBUG))
#define REEVALUATE_PSBTRACK(pSBTrack, hwnd, str) \
if ((pSBTrack) != CUxScrollBar::GetSBTrack(hwnd)) { \
RIPMSG3(RIP_WARNING, \
"%s: pSBTrack changed from %#p to %#p", \
(str), (pSBTrack), CUxScrollBar::GetSBTrack(hwnd)); \
} \
(pSBTrack) = CUxScrollBar::GetSBTrack(hwnd)
#else
#define REEVALUATE_PSBTRACK(pSBTrack, hwnd, str) \
(pSBTrack) = CUxScrollBar::GetSBTrack(hwnd)
#endif
/***************************************************************************\
* HitTestScrollBar
*
* 11/15/96 vadimg ported from Memphis sources
\***************************************************************************/
int HitTestScrollBar(HWND hwnd, BOOL fVert, POINT pt)
{
UINT wDisable;
int px;
CUxScrollBar* psb = CUxScrollBar::FromHwnd( hwnd );
CUxScrollBarCtl* psbCtl = CUxScrollBarCtl::FromHwnd( hwnd );
BOOL fCtl = psbCtl != NULL;
SBCALC SBCalc = {0};
SBCALC *pSBCalc = NULL;
if (fCtl) {
wDisable = psbCtl->_wDisableFlags;
} else {
RECT rcWindow;
GetWindowRect( hwnd, &rcWindow );
#ifdef USE_MIRRORING
//
// Reflect the click coordinates on the horizontal
// scroll bar if the window is mirrored
//
if (TestWF(hwnd,WEFLAYOUTRTL) && !fVert) {
pt.x = rcWindow.right - pt.x;
}
else
#endif
pt.x -= rcWindow.left;
pt.y -= rcWindow.top;
wDisable = _GetWndSBDisableFlags(hwnd, fVert);
}
if ((wDisable & SB_DISABLE_MASK) == SB_DISABLE_MASK) {
return HTERROR;
}
if (fCtl) {
pSBCalc = CUxScrollBarCtl::GetCalc(hwnd);
} else {
pSBCalc = &SBCalc;
psb->FreshenSBData( SB_BOTH, FALSE );
psb->Calc(hwnd, pSBCalc, NULL, fVert);
}
px = fVert ? pt.y : pt.x;
if( pSBCalc )
{
if (px < pSBCalc->pxUpArrow) {
if (wDisable & LTUPFLAG) {
return HTERROR;
}
return HTSCROLLUP;
} else if (px >= pSBCalc->pxDownArrow) {
if (wDisable & RTDNFLAG) {
return HTERROR;
}
return HTSCROLLDOWN;
} else if (px < pSBCalc->pxThumbTop) {
return HTSCROLLUPPAGE;
} else if (px < pSBCalc->pxThumbBottom) {
return HTSCROLLTHUMB;
} else if (px < pSBCalc->pxDownArrow) {
return HTSCROLLDOWNPAGE;
}
}
return HTERROR;
}
BOOL _SBGetParms(
HWND hwnd,
int code,
PSBDATA pw,
LPSCROLLINFO lpsi)
{
PSBTRACK pSBTrack;
pSBTrack = CUxScrollBar::GetSBTrack(hwnd);
if (lpsi->fMask & SIF_RANGE) {
lpsi->nMin = pw->posMin;
lpsi->nMax = pw->posMax;
}
if (lpsi->fMask & SIF_PAGE)
lpsi->nPage = pw->page;
if (lpsi->fMask & SIF_POS) {
lpsi->nPos = pw->pos;
}
if (lpsi->fMask & SIF_TRACKPOS)
{
if (pSBTrack && (pSBTrack->nBar == code) && (pSBTrack->hwndTrack == hwnd)) {
// posNew is in the context of psbiSB's window and bar code
lpsi->nTrackPos = pSBTrack->posNew;
} else {
lpsi->nTrackPos = pw->pos;
}
}
return ((lpsi->fMask & SIF_ALL) ? TRUE : FALSE);
}
//-------------------------------------------------------------------------//
BOOL WINAPI ThemeGetScrollInfo( HWND hwnd, int nBar, LPSCROLLINFO psi )
{
CUxScrollBar* psb = CUxScrollBar::FromHwnd(hwnd);
if((psb != NULL) && (psb->IsAttaching() == FALSE))
{
#ifdef DEBUG
if( psb->IsCtl() )
{
ASSERT(FALSE); // controls cooperate through an SBM_GETSCROLLINFO message.
}
else
#endif DEBUG
{
SBINFO* psbi;
if( (psbi = psb->GetInfo()) != NULL )
{
SBDATA* psbd = SB_VERT == nBar ? &psbi->Vert :
SB_HORZ == nBar ? &psbi->Horz : NULL;
if( psbd )
return _SBGetParms( hwnd, nBar, psbd, psi );
}
}
}
return FALSE;
}
/***************************************************************************\
* _GetWndSBDisableFlags
*
* This returns the scroll bar Disable flags of the scroll bars of a
* given Window.
*
*
* History:
* 4-18-91 MikeHar Ported for the 31 merge
\***************************************************************************/
UINT _GetWndSBDisableFlags(
HWND hwnd, // The window whose scroll bar Disable Flags are to be returned;
BOOL fVert) // If this is TRUE, it means Vertical scroll bar.
{
PSBINFO pw;
if ((pw = CUxScrollBar::GetSBInfo( hwnd )) == NULL) {
RIPERR0(ERROR_NO_SCROLLBARS, RIP_VERBOSE, "");
return 0;
}
return (fVert ? (pw->WSBflags & WSB_VERT) >> 2 : pw->WSBflags & WSB_HORZ);
}
/***************************************************************************\
* xxxEnableSBCtlArrows()
*
* This function can be used to selectively Enable/Disable
* the arrows of a scroll bar Control
*
* History:
* 04-18-91 MikeHar Ported for the 31 merge
\***************************************************************************/
BOOL xxxEnableSBCtlArrows(
HWND hwnd,
UINT wArrows)
{
UINT wOldFlags = CUxScrollBarCtl::GetDisableFlags( hwnd ); // Get the original status
BOOL bChanged = FALSE;
if (wArrows == ESB_ENABLE_BOTH) { // Enable both the arrows
bChanged = CUxScrollBarCtl::AddRemoveDisableFlags( hwnd, 0, SB_DISABLE_MASK );
} else {
bChanged = CUxScrollBarCtl::AddRemoveDisableFlags( hwnd, wArrows, 0 );
}
/*
* Check if the status has changed because of this call
*/
if (!bChanged)
return FALSE;
/*
* Else, redraw the scroll bar control to reflect the new state
*/
if (IsWindowVisible(hwnd))
InvalidateRect(hwnd, NULL, TRUE);
UINT wNewFlags = CUxScrollBarCtl::GetDisableFlags(hwnd);
// state change notifications
if ((wOldFlags & ESB_DISABLE_UP) != (wNewFlags & ESB_DISABLE_UP))
{
NotifyWinEvent(EVENT_OBJECT_STATECHANGE, hwnd, OBJID_CLIENT, INDEX_SCROLLBAR_UP);
}
if ((wOldFlags & ESB_DISABLE_DOWN) != (wNewFlags & ESB_DISABLE_DOWN))
{
NotifyWinEvent(EVENT_OBJECT_STATECHANGE, hwnd, OBJID_CLIENT, INDEX_SCROLLBAR_DOWN);
}
return TRUE;
}
/***************************************************************************\
* xxxEnableWndSBArrows()
*
* This function can be used to selectively Enable/Disable
* the arrows of a Window Scroll bar(s)
*
* History:
* 4-18-91 MikeHar Ported for the 31 merge
\***************************************************************************/
BOOL xxxEnableWndSBArrows(
HWND hwnd,
UINT wSBflags,
UINT wArrows)
{
INT wOldFlags;
PSBINFO pw;
BOOL bRetValue = FALSE;
HDC hdc;
CheckLock(hwnd);
ASSERT(IsWinEventNotifyDeferredOK());
if ((pw = CUxScrollBar::GetSBInfo( hwnd )) != NULL)
{
wOldFlags = pw->WSBflags;
}
else
{
// Originally everything is enabled; Check to see if this function is
// asked to disable anything; Otherwise, no change in status; So, must
// return immediately;
if(!wArrows)
return FALSE; // No change in status!
wOldFlags = 0; // Both are originally enabled;
CUxScrollBar::Attach( hwnd, FALSE, FALSE );
if((pw = CUxScrollBar::GetSBInfo(hwnd)) == NULL) // Allocate the pSBInfo for hWnd
return FALSE;
}
hdc = GetWindowDC(hwnd);
if (hdc != NULL)
{
/*
* First Take care of the Horizontal Scroll bar, if one exists.
*/
if((wSBflags == SB_HORZ) || (wSBflags == SB_BOTH)) {
if(wArrows == ESB_ENABLE_BOTH) // Enable both the arrows
pw->WSBflags &= ~SB_DISABLE_MASK;
else
pw->WSBflags |= wArrows;
/*
* Update the display of the Horizontal Scroll Bar;
*/
if(pw->WSBflags != wOldFlags) {
bRetValue = TRUE;
wOldFlags = pw->WSBflags;
if (TestWF(hwnd, WFHPRESENT) && !TestWF(hwnd, WFMINIMIZED) &&
IsWindowVisible(hwnd)) {
DrawScrollBar(hwnd, hdc, NULL, FALSE); // Horizontal Scroll Bar.
}
}
// Left button
if ((wOldFlags & ESB_DISABLE_LEFT) != (pw->WSBflags & ESB_DISABLE_LEFT))
{
NotifyWinEvent(EVENT_OBJECT_STATECHANGE, hwnd, OBJID_HSCROLL, INDEX_SCROLLBAR_UP);
}
// Right button
if ((wOldFlags & ESB_DISABLE_RIGHT) != (pw->WSBflags & ESB_DISABLE_RIGHT))
{
NotifyWinEvent(EVENT_OBJECT_STATECHANGE, hwnd, OBJID_HSCROLL, INDEX_SCROLLBAR_DOWN);
}
}
// Then take care of the Vertical Scroll bar, if one exists.
if ((wSBflags == SB_VERT) || (wSBflags == SB_BOTH))
{
if (wArrows == ESB_ENABLE_BOTH)
{
// Enable both the arrows
pw->WSBflags &= ~(SB_DISABLE_MASK << 2);
}
else
{
pw->WSBflags |= (wArrows << 2);
}
// Update the display of the Vertical Scroll Bar;
if(pw->WSBflags != wOldFlags)
{
bRetValue = TRUE;
if (TestWF(hwnd, WFVPRESENT) && !TestWF(hwnd, WFMINIMIZED) && IsWindowVisible(hwnd))
{
// Vertical Scroll Bar
DrawScrollBar(hwnd, hdc, NULL, TRUE);
}
// Up button
if ((wOldFlags & (ESB_DISABLE_UP << 2)) != (pw->WSBflags & (ESB_DISABLE_UP << 2)))
{
NotifyWinEvent(EVENT_OBJECT_STATECHANGE, hwnd, OBJID_VSCROLL, INDEX_SCROLLBAR_UP);
}
// Down button
if ((wOldFlags & (ESB_DISABLE_DOWN << 2)) != (pw->WSBflags & (ESB_DISABLE_DOWN << 2)))
{
NotifyWinEvent(EVENT_OBJECT_STATECHANGE, hwnd, OBJID_VSCROLL, INDEX_SCROLLBAR_DOWN);
}
}
}
ReleaseDC(hwnd,hdc);
}
return bRetValue;
}
/***************************************************************************\
* EnableScrollBar()
*
* This function can be used to selectively Enable/Disable
* the arrows of a scroll bar; It could be used with Windows Scroll
* bars as well as scroll bar controls
*
* History:
* 4-18-91 MikeHar Ported for the 31 merge
\***************************************************************************/
BOOL xxxEnableScrollBar(
HWND hwnd,
UINT wSBflags, // Whether it is a Window Scroll Bar; if so, HORZ or VERT?
// Possible values are SB_HORZ, SB_VERT, SB_CTL or SB_BOTH
UINT wArrows) // Which arrows must be enabled/disabled:
// ESB_ENABLE_BOTH = > Enable both arrows.
// ESB_DISABLE_LTUP = > Disable Left/Up arrow;
// ESB_DISABLE_RTDN = > DIsable Right/Down arrow;
// ESB_DISABLE_BOTH = > Disable both the arrows;
{
#define ES_NOTHING 0
#define ES_DISABLE 1
#define ES_ENABLE 2
UINT wOldFlags;
UINT wEnableWindow;
CheckLock(hwnd);
if(wSBflags != SB_CTL) {
return xxxEnableWndSBArrows(hwnd, wSBflags, wArrows);
}
/*
* Let us assume that we don't have to call EnableWindow
*/
wEnableWindow = ES_NOTHING;
wOldFlags = CUxScrollBarCtl::GetDisableFlags( hwnd ) & (UINT)SB_DISABLE_MASK;
/*
* Check if the present state of the arrows is exactly the same
* as what the caller wants:
*/
if (wOldFlags == wArrows)
return FALSE ; // If so, nothing needs to be done;
/*
* Check if the caller wants to disable both the arrows
*/
if (wArrows == ESB_DISABLE_BOTH) {
wEnableWindow = ES_DISABLE; // Yes! So, disable the whole SB Ctl.
} else {
/*
* Check if the caller wants to enable both the arrows
*/
if(wArrows == ESB_ENABLE_BOTH) {
/*
* We need to enable the SB Ctl only if it was already disabled.
*/
if(wOldFlags == ESB_DISABLE_BOTH)
wEnableWindow = ES_ENABLE;// EnableWindow(.., TRUE);
} else {
/*
* Now, Caller wants to disable only one arrow;
* Check if one of the arrows was already disabled and we want
* to disable the other;If so, the whole SB Ctl will have to be
* disabled; Check if this is the case:
*/
if((wOldFlags | wArrows) == ESB_DISABLE_BOTH)
wEnableWindow = ES_DISABLE; // EnableWindow(, FALSE);
}
}
if(wEnableWindow != ES_NOTHING) {
/*
* EnableWindow returns old state of the window; We must return
* TRUE only if the Old state is different from new state.
*/
if(EnableWindow(hwnd, (BOOL)(wEnableWindow == ES_ENABLE))) {
return !(TestWF(hwnd, WFDISABLED));
} else {
return TestWF(hwnd, WFDISABLED);
}
}
return (BOOL)SendMessage(hwnd, SBM_ENABLE_ARROWS, (DWORD)wArrows, 0);
#undef ES_NOTHING
#undef ES_DISABLE
#undef ES_ENABLE
}
//-------------------------------------------------------------------------
BOOL WINAPI ThemeEnableScrollBar( HWND hwnd, UINT nSBFlags, UINT nArrows )
{
return xxxEnableScrollBar( hwnd, nSBFlags, nArrows );
}
//-------------------------------------------------------------------------
//
// DrawSizeBox() - paints the scrollbar sizebox/gripper given top, left
// point in window coords.
//
void DrawSizeBox(HWND hwnd, HDC hdc, int x, int y)
{
RECT rc;
SetRect(&rc, x, y, x + SYSMET(CXVSCROLL), y + SYSMET(CYHSCROLL));
FillRect(hdc, &rc, GetSysColorBrush(COLOR_3DFACE));
//
// If we have a scrollbar control, or the sizebox is not associated with
// a sizeable window, draw the flat gray sizebox. Otherwise, use the
// sizing grip.
//
if ((IsScrollBarControl(hwnd) && TestWF(hwnd, SBFSIZEGRIP)) || SizeBoxHwnd(hwnd))
{
HTHEME hTheme = CUxScrollBar::GetSBTheme(hwnd);
if (!hTheme)
{
// Blt out the grip bitmap.
DrawFrameControl( hdc, &rc, DFC_SCROLL,
TestWF(hwnd, WEFLEFTSCROLL) ? DFCS_SCROLLSIZEGRIPRIGHT : DFCS_SCROLLSIZEGRIP );
//user: BitBltSysBmp(hdc, x, y, TestWF(hwnd, WEFLEFTSCROLL) ? OBI_NCGRIP_L : OBI_NCGRIP);
}
else
{
DrawThemeBackground(hTheme, hdc, SBP_SIZEBOX, TestWF(hwnd, WEFLEFTSCROLL) ? SZB_LEFTALIGN : SZB_RIGHTALIGN, &rc, 0);
}
}
}
//-------------------------------------------------------------------------
//
// _DrawSizeBoxFromFrame
//
// Calculates position and draws of sizebox/gripper at fixed offset from
// perimeter of host window frame.
//
// This, combined with implementation of DrawSizeBox(),
// was the original DrawSize() port. Needed to expost method to
// draw sizebox at absolute position. [scotthan]
//
void _DrawSizeBoxFromFrame(HWND hwnd, HDC hdc, int cxFrame,int cyFrame )
{
int x, y;
RECT rcWindow;
GetWindowRect(hwnd, &rcWindow);
if (TestWF(hwnd, WEFLEFTSCROLL))
{
x = cxFrame;
}
else
{
x = rcWindow.right - rcWindow.left - cxFrame - SYSMET(CXVSCROLL);
}
y = rcWindow.bottom - rcWindow.top - cyFrame - SYSMET(CYHSCROLL);
DrawSizeBox(hwnd, hdc, x, y);
}
//-------------------------------------------------------------------------
HBRUSH ScrollBar_GetControlColor(HWND hwndParent, HWND hwndCtl, HDC hdc, UINT uMsg, BOOL *pfOwnerBrush)
{
HBRUSH hbrush;
BOOL fOwnerBrush = FALSE;
//
// If we're sending to a window of another thread, don't send this message
// but instead call DefWindowProc(). New rule about the CTLCOLOR messages.
// Need to do this so that we don't send an hdc owned by one thread to
// another thread. It is also a harmless change.
//
if (GetWindowThreadProcessId(hwndParent, NULL) != GetCurrentThreadId())
{
hbrush = (HBRUSH)DefWindowProc(hwndParent, uMsg, (WPARAM)hdc, (LPARAM)hwndCtl);
}
else
{
hbrush = (HBRUSH)SendMessage(hwndParent, uMsg, (WPARAM)hdc, (LPARAM)hwndCtl);
//
// If the brush returned from the parent is invalid, get a valid brush from
// DefWindowProc.
//
if (hbrush == NULL)
{
hbrush = (HBRUSH)DefWindowProc(hwndParent, uMsg, (WPARAM)hdc, (LPARAM)hwndCtl);
}
else
{
fOwnerBrush = TRUE;
}
}
if (pfOwnerBrush)
{
*pfOwnerBrush = fOwnerBrush;
}
return hbrush;
}
//-------------------------------------------------------------------------
HBRUSH ScrollBar_GetControlBrush(HWND hwnd, HDC hdc, UINT uMsg, BOOL *pfOwnerBrush)
{
HWND hwndSend;
hwndSend = TESTFLAG(GetWindowStyle(hwnd), WS_POPUP) ? GetOwner(hwnd) : GetParent(hwnd);
if (hwndSend == NULL)
{
hwndSend = hwnd;
}
return ScrollBar_GetControlColor(hwndSend, hwnd, hdc, uMsg, pfOwnerBrush);
}
//-------------------------------------------------------------------------
HBRUSH ScrollBar_GetColorObjects(HWND hwnd, HDC hdc, BOOL *pfOwnerBrush)
{
HBRUSH hbrRet;
CheckLock(hwnd);
// Use the scrollbar color even if the scrollbar is disabeld.
if (!IsScrollBarControl(hwnd))
{
hbrRet = (HBRUSH)DefWindowProc(hwnd, WM_CTLCOLORSCROLLBAR, (WPARAM)hdc, (LPARAM)HWq(hwnd));
}
else
{
// B#12770 - GetControlBrush sends a WM_CTLCOLOR message to the
// owner. If the app doesn't process the message, DefWindowProc32
// will always return the appropriate system brush. If the app.
// returns an invalid object, GetControlBrush will call DWP for
// the default brush. Thus hbrRet doesn't need any validation
// here.
hbrRet = ScrollBar_GetControlBrush(hwnd, hdc, WM_CTLCOLORSCROLLBAR, pfOwnerBrush);
}
return hbrRet;
}
//-------------------------------------------------------------------------
//
// ScrollBar_PaintTrack
//
// Draws lines & middle of thumb groove
// Note that pw points into prc. Moreover, note that both pw & prc are
// pointers, so *prc better not be on the stack.
//
void ScrollBar_PaintTrack(HWND hwnd, HDC hdc, HBRUSH hbr, LPRECT prc, BOOL fVert, INT iPartId, BOOL fOwnerBrush)
{
HTHEME hTheme = CUxScrollBar::GetSBTheme(hwnd);
// If the scrollbar is unthemed or
// #374054 we've been passed an brush defined by the owner, paint
// the shaft using the brush
if ((hTheme == NULL) || (fOwnerBrush == TRUE))
{
if ((hbr == SYSHBR(3DHILIGHT)) || (hbr == SYSHBR(SCROLLBAR)) || (hbr == _UxGrayBrush()) )
{
FillRect(hdc, prc, hbr);
}
else
{
#ifdef PORTPORT // we need SystemParametersInfo for _UxGrayBrush
// Draw sides
CopyRect(&rc, prc);
DrawEdge(hdc, &rc, EDGE_SUNKEN, BF_ADJUST | BF_FLAT |
(fVert ? BF_LEFT | BF_RIGHT : BF_TOP | BF_BOTTOM));
#endif PORTPORT
// Fill middle
FillRect(hdc, prc, hbr);
}
}
else
{
INT iStateId;
INT ht = CUxScrollBar::GetSBHotComponent(hwnd, fVert);
if ((CUxScrollBarCtl::GetDisableFlags(hwnd) & ESB_DISABLE_BOTH) == ESB_DISABLE_BOTH)
{
iStateId = SCRBS_DISABLED;
}
else if ((((iPartId == SBP_LOWERTRACKHORZ) || (iPartId == SBP_LOWERTRACKVERT)) && (ht == HTSCROLLUPPAGE)) ||
(((iPartId == SBP_UPPERTRACKHORZ) || (iPartId == SBP_UPPERTRACKVERT)) && (ht == HTSCROLLDOWNPAGE)))
{
iStateId = SCRBS_HOT;
}
else
{
iStateId = SCRBS_NORMAL;
}
DrawThemeBackground(hTheme, hdc, iPartId, iStateId, prc, 0);
}
}
/***************************************************************************\
* CalcTrackDragRect
*
* Give the rectangle for a scrollbar in pSBTrack->pSBCalc,
* calculate pSBTrack->rcTrack, the rectangle where tracking
* may occur without cancelling the thumbdrag operation.
*
\***************************************************************************/
void CalcTrackDragRect(PSBTRACK pSBTrack) {
int cx;
int cy;
LPINT pwX, pwY;
//
// Point pwX and pwY at the parts of the rectangle
// corresponding to pSBCalc->pxLeft, pxTop, etc.
//
// pSBTrack->pSBCalc->pxLeft is the left edge of a vertical
// scrollbar and the top edge of horizontal one.
// pSBTrack->pSBCalc->pxTop is the top of a vertical
// scrollbar and the left of horizontal one.
// etc...
//
// Point pwX and pwY to the corresponding parts
// of pSBTrack->rcTrack.
//
pwX = pwY = (LPINT)&pSBTrack->rcTrack;
if (pSBTrack->fTrackVert) {
cy = SYSMET(CYVTHUMB);
pwY++;
} else {
cy = SYSMET(CXHTHUMB);
pwX++;
}
/*
* Later5.0 GerardoB: People keep complaining about this tracking region
* being too narrow so let's make it wider while PM decides what to do
* about it.
* We also used to have some hard coded min and max values but that should
* depend on some metric, if at all needed.
*/
cx = (pSBTrack->pSBCalc->pxRight - pSBTrack->pSBCalc->pxLeft) * 8;
cy *= 2;
*(pwX + 0) = pSBTrack->pSBCalc->pxLeft - cx;
*(pwY + 0) = pSBTrack->pSBCalc->pxTop - cy;
*(pwX + 2) = pSBTrack->pSBCalc->pxRight + cx;
*(pwY + 2) = pSBTrack->pSBCalc->pxBottom + cy;
}
void RecalcTrackRect(PSBTRACK pSBTrack) {
LPINT pwX, pwY;
RECT rcSB;
if (!pSBTrack->fCtlSB)
CUxScrollBar::Calc(pSBTrack->hwndTrack, pSBTrack->pSBCalc, NULL, pSBTrack->fTrackVert);
pwX = (LPINT)&rcSB;
pwY = pwX + 1;
if (!pSBTrack->fTrackVert)
pwX = pwY--;
*(pwX + 0) = pSBTrack->pSBCalc->pxLeft;
*(pwY + 0) = pSBTrack->pSBCalc->pxTop;
*(pwX + 2) = pSBTrack->pSBCalc->pxRight;
*(pwY + 2) = pSBTrack->pSBCalc->pxBottom;
switch(pSBTrack->cmdSB) {
case SB_LINEUP:
*(pwY + 2) = pSBTrack->pSBCalc->pxUpArrow;
break;
case SB_LINEDOWN:
*(pwY + 0) = pSBTrack->pSBCalc->pxDownArrow;
break;
case SB_PAGEUP:
*(pwY + 0) = pSBTrack->pSBCalc->pxUpArrow;
*(pwY + 2) = pSBTrack->pSBCalc->pxThumbTop;
break;
case SB_THUMBPOSITION:
CalcTrackDragRect(pSBTrack);
break;
case SB_PAGEDOWN:
*(pwY + 0) = pSBTrack->pSBCalc->pxThumbBottom;
*(pwY + 2) = pSBTrack->pSBCalc->pxDownArrow;
break;
}
if (pSBTrack->cmdSB != SB_THUMBPOSITION) {
CopyRect(&pSBTrack->rcTrack, &rcSB);
}
}
//-------------------------------------------------------------------------
void DrawThumb2(
HWND hwnd,
PSBCALC pSBCalc,
HDC hdc,
HBRUSH hbr,
BOOL fVert,
UINT wDisable, // Disabled flags for the scroll bar
BOOL fOwnerBrush)
{
int *pLength;
int *pWidth;
RECT rcSB;
PSBTRACK pSBTrack;
HTHEME hTheme = CUxScrollBar::GetSBTheme(hwnd);
//
// Bail out if the scrollbar has an empty rect
//
if ((pSBCalc->pxTop >= pSBCalc->pxBottom) || (pSBCalc->pxLeft >= pSBCalc->pxRight))
{
return;
}
pLength = (LPINT)&rcSB;
if (fVert)
{
pWidth = pLength++;
}
else
{
pWidth = pLength + 1;
}
pWidth[0] = pSBCalc->pxLeft;
pWidth[2] = pSBCalc->pxRight;
// If were're not themed and both buttons are disabled OR there isn't
// enough room to draw a thumb just draw the track and run.
//
// When we are themed the thumb can be drawn disabled.
if (((wDisable & LTUPFLAG) && (wDisable & RTDNFLAG)) ||
((pSBCalc->pxDownArrow - pSBCalc->pxUpArrow) < pSBCalc->cpxThumb))
{
// draw the entire track
pLength[0] = pSBCalc->pxUpArrow;
pLength[2] = pSBCalc->pxDownArrow;
ScrollBar_PaintTrack(hwnd, hdc, hbr, &rcSB, fVert, fVert ? SBP_LOWERTRACKVERT : SBP_LOWERTRACKHORZ, fOwnerBrush);
return;
}
if (pSBCalc->pxUpArrow < pSBCalc->pxThumbTop)
{
// draw the track above the thumb
pLength[0] = pSBCalc->pxUpArrow;
pLength[2] = pSBCalc->pxThumbTop;
ScrollBar_PaintTrack(hwnd, hdc, hbr, &rcSB, fVert, fVert ? SBP_LOWERTRACKVERT : SBP_LOWERTRACKHORZ, fOwnerBrush);
}
if (pSBCalc->pxThumbBottom < pSBCalc->pxDownArrow)
{
// draw the track below the thumb
pLength[0] = pSBCalc->pxThumbBottom;
pLength[2] = pSBCalc->pxDownArrow;
ScrollBar_PaintTrack(hwnd, hdc, hbr, &rcSB, fVert, fVert ? SBP_UPPERTRACKVERT : SBP_UPPERTRACKHORZ, fOwnerBrush);
}
//
// Draw elevator
//
pLength[0] = pSBCalc->pxThumbTop;
pLength[2] = pSBCalc->pxThumbBottom;
// Not soft!
_DrawPushButton(hwnd, hdc, &rcSB, 0, 0, fVert);
#ifdef _VISUAL_DELTA_
InflateRect( &rcSB, -CARET_BORDERWIDTH, -CARET_BORDERWIDTH);
DrawEdge( hdc, &rcSB, EDGE_SUNKEN, BF_RECT );
#endif _VISUAL_DELTA_
/*
* If we're tracking a page scroll, then we've obliterated the hilite.
* We need to correct the hiliting rectangle, and rehilite it.
*/
pSBTrack = CUxScrollBar::GetSBTrack(hwnd);
if (pSBTrack && (pSBTrack->cmdSB == SB_PAGEUP || pSBTrack->cmdSB == SB_PAGEDOWN) &&
(hwnd == pSBTrack->hwndTrack) &&
(BOOL)pSBTrack->fTrackVert == fVert) {
if (pSBTrack->fTrackRecalc) {
RecalcTrackRect(pSBTrack);
pSBTrack->fTrackRecalc = FALSE;
}
pLength = (int *)&pSBTrack->rcTrack;
if (fVert)
pLength++;
if (pSBTrack->cmdSB == SB_PAGEUP)
pLength[2] = pSBCalc->pxThumbTop;
else
pLength[0] = pSBCalc->pxThumbBottom;
if (pLength[0] < pLength[2])
{
if (!hTheme)
{
InvertRect(hdc, &pSBTrack->rcTrack);
}
else
{
DrawThemeBackground(hTheme,
hdc,
pSBTrack->cmdSB == SB_PAGEUP ?
(fVert ? SBP_LOWERTRACKVERT : SBP_LOWERTRACKHORZ) :
(fVert ? SBP_UPPERTRACKVERT : SBP_UPPERTRACKHORZ),
SCRBS_PRESSED,
&pSBTrack->rcTrack,
0);
}
}
}
}
/***************************************************************************\
* xxxDrawSB2
*
*
*
* History:
\***************************************************************************/
void xxxDrawSB2(
HWND hwnd,
PSBCALC pSBCalc,
HDC hdc,
BOOL fVert,
UINT wDisable)
{
int cLength;
int cWidth;
int *pwX;
int *pwY;
HBRUSH hbr;
HBRUSH hbrSave;
int cpxArrow;
RECT rc, rcSB;
COLORREF crText, crBk;
HTHEME hTheme;
INT ht;
INT iStateId;
BOOL fOwnerBrush = FALSE;
CheckLock(hwnd);
cLength = (pSBCalc->pxBottom - pSBCalc->pxTop) / 2;
cWidth = (pSBCalc->pxRight - pSBCalc->pxLeft);
if ((cLength <= 0) || (cWidth <= 0)) {
return;
}
if (fVert)
{
cpxArrow = SYSMET(CYVSCROLL);
}
else
{
cpxArrow = SYSMET(CXHSCROLL);
}
// Save background and DC color, since they get changed in
// ScrollBar_GetColorObjects. Restore before we return.
crBk = GetBkColor(hdc);
crText = GetTextColor(hdc);
hbr = ScrollBar_GetColorObjects(hwnd, hdc, &fOwnerBrush);
if (cLength > cpxArrow)
{
cLength = cpxArrow;
}
pwX = (int *)&rcSB;
pwY = pwX + 1;
if (!fVert)
{
pwX = pwY--;
}
pwX[0] = pSBCalc->pxLeft;
pwY[0] = pSBCalc->pxTop;
pwX[2] = pSBCalc->pxRight;
pwY[2] = pSBCalc->pxBottom;
hbrSave = SelectBrush(hdc, SYSHBR(BTNTEXT));
//
// BOGUS
// Draw scrollbar arrows as disabled if the scrollbar itself is
// disabled OR if the window it is a part of is disabled?
//
hTheme = CUxScrollBar::GetSBTheme(hwnd);
ht = CUxScrollBar::GetSBHotComponent(hwnd, fVert);
if (fVert)
{
// up button
CopyRect(&rc, &rcSB);
rc.bottom = rc.top + cLength;
if (!hTheme)
{
DrawFrameControl(hdc, &rc, DFC_SCROLL,
DFCS_SCROLLUP | ((wDisable & LTUPFLAG) ? DFCS_INACTIVE : 0));
}
else
{
iStateId = (wDisable & LTUPFLAG) ? ABS_UPDISABLED : (ht == HTSCROLLUP) ? ABS_UPHOT : ABS_UPNORMAL;
DrawThemeBackground(hTheme, hdc, SBP_ARROWBTN, iStateId, &rc, 0);
}
// down button
rc.bottom = rcSB.bottom;
rc.top = rcSB.bottom - cLength;
if (!hTheme)
{
DrawFrameControl(hdc, &rc, DFC_SCROLL,
DFCS_SCROLLDOWN | ((wDisable & RTDNFLAG) ? DFCS_INACTIVE : 0));
}
else
{
iStateId = (wDisable & RTDNFLAG) ? ABS_DOWNDISABLED : (ht == HTSCROLLDOWN) ? ABS_DOWNHOT : ABS_DOWNNORMAL;
DrawThemeBackground(hTheme, hdc, SBP_ARROWBTN, iStateId, &rc, 0);
}
}
else
{
// left button
CopyRect(&rc, &rcSB);
rc.right = rc.left + cLength;
if (!hTheme)
{
DrawFrameControl(hdc, &rc, DFC_SCROLL,
DFCS_SCROLLLEFT | ((wDisable & LTUPFLAG) ? DFCS_INACTIVE : 0));
}
else
{
iStateId = (wDisable & LTUPFLAG) ? ABS_LEFTDISABLED : (ht == HTSCROLLUP) ? ABS_LEFTHOT : ABS_LEFTNORMAL;
DrawThemeBackground(hTheme, hdc, SBP_ARROWBTN, iStateId, &rc, 0);
}
// right button
rc.right = rcSB.right;
rc.left = rcSB.right - cLength;
if (!hTheme)
{
DrawFrameControl(hdc, &rc, DFC_SCROLL,
DFCS_SCROLLRIGHT | ((wDisable & RTDNFLAG) ? DFCS_INACTIVE : 0));
}
else
{
iStateId = (wDisable & RTDNFLAG) ? ABS_RIGHTDISABLED : (ht == HTSCROLLDOWN) ? ABS_RIGHTHOT : ABS_RIGHTNORMAL;
DrawThemeBackground(hTheme, hdc, SBP_ARROWBTN, iStateId, &rc, 0);
}
}
hbrSave = SelectBrush(hdc, hbrSave);
DrawThumb2(hwnd, pSBCalc, hdc, hbr, fVert, wDisable, fOwnerBrush);
SelectBrush(hdc, hbrSave);
SetBkColor(hdc, crBk);
SetTextColor(hdc, crText);
}
/***************************************************************************\
* zzzSetSBCaretPos
*
*
*
* History:
\***************************************************************************/
void zzzSetSBCaretPos(
SBHWND hwndSB)
{
if (GetFocus() == hwndSB) {
CUxScrollBarCtl* psb = CUxScrollBarCtl::FromHwnd( hwndSB );
if( psb )
{
int x = (psb->_fVert ? psb->_calc.pxLeft : psb->_calc.pxThumbTop) + SYSMET(CXEDGE);
int y = (psb->_fVert ? psb->_calc.pxThumbTop : psb->_calc.pxLeft) + SYSMET(CYEDGE);
#ifdef _VISUAL_DELTA_
x += CARET_BORDERWIDTH;
y += CARET_BORDERWIDTH;
#endif _VISUAL_DELTA_
SetCaretPos( x, y );
}
}
}
/***************************************************************************\
* SBCtlSetup
*
*
*
* History:
\***************************************************************************/
CUxScrollBarCtl* SBCtlSetup(
SBHWND hwndSB)
{
RECT rc;
GetClientRect( hwndSB, &rc );
CUxScrollBarCtl* psb = (CUxScrollBarCtl*)CUxScrollBar::Attach( hwndSB, TRUE, FALSE );
if( psb )
{
psb->Calc2( &psb->_calc, &rc, &psb->_calc.data, psb->_fVert );
}
return psb;
}
/***************************************************************************\
* HotTrackSB
*
\***************************************************************************/
#ifdef COLOR_HOTTRACKING
DWORD GetTrackFlags(int ht, BOOL fDraw)
{
if (fDraw) {
switch(ht) {
case HTSCROLLUP:
case HTSCROLLUPPAGE:
return LTUPFLAG;
case HTSCROLLDOWN:
case HTSCROLLDOWNPAGE:
return RTDNFLAG;
case HTSCROLLTHUMB:
return LTUPFLAG | RTDNFLAG;
default:
return 0;
}
} else {
return 0;
}
}
void xxxHotTrackSBCtl(SBHWND hwndSB, int ht, BOOL fDraw)
{
DWORD dwTrack = GetTrackFlags(ht, fDraw);
HDC hdc;
CheckLock(hwndSB);
SBCtlSetup(hwndSB);
hdc = _GetDCEx((HWND)hwndSB, NULL, DCX_WINDOW | DCX_USESTYLE | DCX_CACHE);
xxxDrawSB2((HWND)hwndSB, &psb->_calc, hdc, psb->_fVert, psb->_wDisableFlags, dwTrack);
ReleaseDC(hwnd, hdc);
}
#endif // COLOR_HOTTRACKING
BOOL SBSetParms(PSBDATA pw, LPSCROLLINFO lpsi, LPBOOL lpfScroll, LPLONG lplres)
{
// pass the struct because we modify the struct but don't want that
// modified version to get back to the calling app
BOOL fChanged = FALSE;
if (lpsi->fMask & SIF_RETURNOLDPOS)
// save previous position
*lplres = pw->pos;
if (lpsi->fMask & SIF_RANGE) {
// if the range MAX is below the range MIN -- then treat is as a
// zero range starting at the range MIN.
if (lpsi->nMax < lpsi->nMin)
lpsi->nMax = lpsi->nMin;
if ((pw->posMin != lpsi->nMin) || (pw->posMax != lpsi->nMax)) {
pw->posMin = lpsi->nMin;
pw->posMax = lpsi->nMax;
if (!(lpsi->fMask & SIF_PAGE)) {
lpsi->fMask |= SIF_PAGE;
lpsi->nPage = pw->page;
}
if (!(lpsi->fMask & SIF_POS)) {
lpsi->fMask |= SIF_POS;
lpsi->nPos = pw->pos;
}
fChanged = TRUE;
}
}
if (lpsi->fMask & SIF_PAGE) {
DWORD dwMaxPage = (DWORD) abs(pw->posMax - pw->posMin) + 1;
// Clip page to 0, posMax - posMin + 1
if (lpsi->nPage > dwMaxPage)
lpsi->nPage = dwMaxPage;
if (pw->page != (int)(lpsi->nPage)) {
pw->page = lpsi->nPage;
if (!(lpsi->fMask & SIF_POS)) {
lpsi->fMask |= SIF_POS;
lpsi->nPos = pw->pos;
}
fChanged = TRUE;
}
}
if (lpsi->fMask & SIF_POS) {
int iMaxPos = pw->posMax - ((pw->page) ? pw->page - 1 : 0);
// Clip pos to posMin, posMax - (page - 1).
if (lpsi->nPos < pw->posMin)
lpsi->nPos = pw->posMin;
else if (lpsi->nPos > iMaxPos)
lpsi->nPos = iMaxPos;
if (pw->pos != lpsi->nPos) {
pw->pos = lpsi->nPos;
fChanged = TRUE;
}
}
if (!(lpsi->fMask & SIF_RETURNOLDPOS)) {
// Return the new position
*lplres = pw->pos;
}
/*
* This was added by JimA as Cairo merge but will conflict
* with the documentation for SetScrollPos
*/
/*
else if (*lplres == pw->pos)
*lplres = 0;
*/
if (lpsi->fMask & SIF_RANGE) {
*lpfScroll = (pw->posMin != pw->posMax);
if (*lpfScroll)
goto checkPage;
} else if (lpsi->fMask & SIF_PAGE)
checkPage:
*lpfScroll = (pw->page <= (pw->posMax - pw->posMin));
return fChanged;
}
/***************************************************************************\
*
* DrawCtlThumb()
*
\***************************************************************************/
void DrawCtlThumb(SBHWND hwnd)
{
HBRUSH hbr, hbrSave;
HDC hdc = (HDC) GetWindowDC(hwnd);
if ( hdc != NULL )
{
CUxScrollBarCtl* psb = SBCtlSetup(hwnd);
if (psb)
{
BOOL fOwnerBrush = FALSE;
hbr = ScrollBar_GetColorObjects(hwnd, hdc, &fOwnerBrush);
hbrSave = SelectBrush(hdc, hbr);
DrawThumb2(hwnd, &psb->_calc, hdc, hbr, psb->_fVert, psb->_wDisableFlags, fOwnerBrush);
SelectBrush(hdc, hbrSave);
}
ReleaseDC(hwnd, hdc);
}
}
//-------------------------------------------------------------------------
void xxxDrawThumb(HWND hwnd, PSBCALC pSBCalc, BOOL fVert)
{
HBRUSH hbr, hbrSave;
HDC hdc;
UINT wDisableFlags;
SBCALC SBCalc;
CheckLock(hwnd);
if (!pSBCalc)
{
pSBCalc = &SBCalc;
}
CUxScrollBar::Calc( hwnd, pSBCalc, NULL, fVert );
wDisableFlags = _GetWndSBDisableFlags(hwnd, fVert);
hdc = GetWindowDC(hwnd);
if ( hdc != NULL )
{
BOOL fOwnerBrush = FALSE;
hbr = ScrollBar_GetColorObjects(hwnd, hdc, &fOwnerBrush);
hbrSave = SelectBrush(hdc, hbr);
DrawThumb2(hwnd, pSBCalc, hdc, hbr, fVert, wDisableFlags, fOwnerBrush);
SelectBrush(hdc, hbrSave);
ReleaseDC(hwnd, hdc);
}
}
//-------------------------------------------------------------------------
UINT _GetArrowEnableFlags(HWND hwnd, BOOL fVert)
{
SCROLLBARINFO sbi = {0};
UINT uFlags = ESB_ENABLE_BOTH;
sbi.cbSize = sizeof(sbi);
if ( GetScrollBarInfo(hwnd, fVert ? OBJID_VSCROLL : OBJID_HSCROLL, &sbi) )
{
if ( TESTFLAG(sbi.rgstate[INDEX_SCROLLBAR_UP], (STATE_SYSTEM_UNAVAILABLE|STATE_SYSTEM_INVISIBLE)) )
{
uFlags |= ESB_DISABLE_UP;
}
if ( TESTFLAG(sbi.rgstate[INDEX_SCROLLBAR_DOWN], (STATE_SYSTEM_UNAVAILABLE|STATE_SYSTEM_INVISIBLE)) )
{
uFlags |= ESB_DISABLE_DOWN;
}
}
return uFlags;
}
/***************************************************************************\
* _SetScrollBar
*
*
*
* History:
\***************************************************************************/
LONG _SetScrollBar(
HWND hwnd,
int code,
LPSCROLLINFO lpsi,
BOOL fRedraw)
{
BOOL fVert;
PSBDATA pw;
PSBINFO pSBInfo;
BOOL fOldScroll;
BOOL fScroll;
WORD wfScroll;
LONG lres;
BOOL fNewScroll;
CheckLock(hwnd);
ASSERT(IsWinEventNotifyDeferredOK());
if (fRedraw)
// window must be visible to redraw
fRedraw = IsWindowVisible(hwnd);
if (code == SB_CTL)
#ifdef FE_SB // xxxSetScrollBar()
// scroll bar control; send the control a message
if(GETPTI(hwnd)->TIF_flags & TIF_16BIT) {
//
// If the target application is 16bit apps, we don't pass win40's message.
// This fix for Ichitaro v6.3. It eats the message. It never forwards
// the un-processed messages to original windows procedure via
// CallWindowProc().
//
// Is this from xxxSetScrollPos() ?
if(lpsi->fMask == (SIF_POS|SIF_RETURNOLDPOS)) {
return (int)SendMessage(hwnd, SBM_SETPOS, lpsi->nPos, fRedraw);
// Is this from xxxSetScrollRange() ?
} else if(lpsi->fMask == SIF_RANGE) {
SendMessage(hwnd, SBM_SETRANGE, lpsi->nMin, lpsi->nMax);
return TRUE;
// Others...
} else {
return (LONG)SendMessage(hwnd, SBM_SETSCROLLINFO, (WPARAM) fRedraw, (LPARAM) lpsi);
}
} else {
return (LONG)SendMessage(hwnd, SBM_SETSCROLLINFO, (WPARAM) fRedraw, (LPARAM) lpsi);
}
#else
// scroll bar control; send the control a message
return (LONG)SendMessage(hwnd, SBM_SETSCROLLINFO, (WPARAM) fRedraw, (LPARAM) lpsi);
#endif // FE_SB
fVert = (code != SB_HORZ);
wfScroll = (WORD)((fVert) ? WFVSCROLL : WFHSCROLL);
fScroll = fOldScroll = (TestWF(hwnd, wfScroll)) ? TRUE : FALSE;
/*
* Don't do anything if we're setting position of a nonexistent scroll bar.
*/
if (!(lpsi->fMask & SIF_RANGE) && !fOldScroll && (CUxScrollBar::GetSBInfo( hwnd ) == NULL)) {
RIPERR0(ERROR_NO_SCROLLBARS, RIP_VERBOSE, "");
return 0;
}
pSBInfo = CUxScrollBar::GetSBInfo( hwnd );
fNewScroll = !pSBInfo;
if (fNewScroll) {
CUxScrollBar* psb = CUxScrollBar::Attach( hwnd, FALSE, fRedraw );
if( NULL == psb )
return 0;
pSBInfo = psb->GetInfo();
}
pw = (fVert) ? &(pSBInfo->Vert) : &(pSBInfo->Horz);
if (!SBSetParms(pw, lpsi, &fScroll, &lres) && !fNewScroll)
{
// no change -- but if REDRAW is specified and there's a scrollbar,
// redraw the thumb
if (fOldScroll && fRedraw)
{
goto redrawAfterSet;
}
if (lpsi->fMask & SIF_DISABLENOSCROLL)
{
xxxEnableWndSBArrows(hwnd, code, _GetArrowEnableFlags(hwnd, fVert));
}
return lres;
}
ClrWF(hwnd, wfScroll);
if (fScroll)
SetWF(hwnd, wfScroll);
else if (!TestWF(hwnd, (WFHSCROLL | WFVSCROLL)))
{
// if neither scroll bar is set and both ranges are 0, then free up the
// scroll info
CUxScrollBar::Detach( hwnd );
}
if (lpsi->fMask & SIF_DISABLENOSCROLL)
{
if (fOldScroll)
{
SetWF(hwnd, wfScroll);
xxxEnableWndSBArrows(hwnd, code, _GetArrowEnableFlags(hwnd, fVert));
}
}
else if (fOldScroll ^ fScroll)
{
PSBTRACK pSBTrack = CUxScrollBar::GetSBTrack(hwnd);
if (pSBTrack && (hwnd == pSBTrack->hwndTrack))
{
pSBTrack->fTrackRecalc = TRUE;
}
_RedrawFrame(hwnd);
// Note: after xxx, pSBTrack may no longer be valid (but we return now)
return lres;
}
if (fScroll && fRedraw && (fVert ? TestWF(hwnd, WFVPRESENT) : TestWF(hwnd, WFHPRESENT)))
{
PSBTRACK pSBTrack;
redrawAfterSet:
NotifyWinEvent(EVENT_OBJECT_VALUECHANGE,
hwnd,
(fVert ? OBJID_VSCROLL : OBJID_HSCROLL),
INDEX_SCROLLBAR_SELF);
pSBTrack = CUxScrollBar::GetSBTrack(hwnd);
// Bail out if the caller is trying to change the position of
// a scrollbar that is in the middle of tracking. We'll hose
// TrackThumb() otherwise.
if (pSBTrack && (hwnd == pSBTrack->hwndTrack) &&
((BOOL)(pSBTrack->fTrackVert) == fVert) &&
(pSBTrack->pfnSB == _TrackThumb)) {
return lres;
}
xxxDrawThumb(hwnd, NULL, fVert);
// Note: after xxx, pSBTrack may no longer be valid (but we return now)
}
return lres;
}
//-------------------------------------------------------------------------//
LONG WINAPI ThemeSetScrollInfo( HWND hwnd, int nBar, LPCSCROLLINFO psi, BOOL bRedraw )
{
return _SetScrollBar( hwnd, nBar, (LPSCROLLINFO)psi, bRedraw );
}
//-------------------------------------------------------------------------//
BOOL WINAPI ScrollBar_MouseMove( HWND hwnd, LPPOINT ppt, BOOL fVert )
{
BOOL fRet = FALSE;
CUxScrollBar* psb = CUxScrollBar::FromHwnd( hwnd );
if (psb)
{
int htScroll = (ppt != NULL) ? HitTestScrollBar(hwnd, fVert, *ppt) : HTNOWHERE;
//
// Redraw the scroll bar if the mouse is over something different
//
if (htScroll != psb->GetHotComponent(fVert))
{
HDC hdc;
//
// save the hittest code of the Scrollbar element the mouse is
// currently over
//
psb->SetHotComponent(htScroll, fVert);
hdc = GetDCEx(hwnd, NULL, DCX_USESTYLE|DCX_WINDOW|DCX_LOCKWINDOWUPDATE);
if (hdc != NULL)
{
DrawScrollBar(hwnd, hdc, NULL, fVert);
ReleaseDC(hwnd, hdc);
}
fRet = TRUE;
}
}
return fRet;
}
//-------------------------------------------------------------------------//
void DrawScrollBar(HWND hwnd, HDC hdc, LPRECT prcOverrideClient, BOOL fVert)
{
SBCALC SBCalc = {0};
PSBCALC pSBCalc;
PSBTRACK pSBTrack = CUxScrollBar::GetSBTrack(hwnd);
CheckLock(hwnd);
if (pSBTrack && (hwnd == pSBTrack->hwndTrack) && (pSBTrack->fCtlSB == FALSE)
&& (fVert == (BOOL)pSBTrack->fTrackVert))
{
pSBCalc = pSBTrack->pSBCalc;
}
else
{
pSBCalc = &SBCalc;
}
CUxScrollBar::Calc(hwnd, pSBCalc, prcOverrideClient, fVert);
xxxDrawSB2(hwnd, pSBCalc, hdc, fVert, _GetWndSBDisableFlags(hwnd, fVert));
}
/***************************************************************************\
* SBPosFromPx
*
* Compute scroll bar position from pixel location
*
* History:
\***************************************************************************/
int SBPosFromPx(
PSBCALC pSBCalc,
int px)
{
if (px < pSBCalc->pxMin) {
return pSBCalc->data.posMin;
}
if (px >= pSBCalc->pxMin + pSBCalc->cpx) {
return (pSBCalc->data.posMax - (pSBCalc->data.page ? pSBCalc->data.page - 1 : 0));
}
if (pSBCalc->cpx)
return (pSBCalc->data.posMin + MulDiv(pSBCalc->data.posMax - pSBCalc->data.posMin -
(pSBCalc->data.page ? pSBCalc->data.page - 1 : 0),
px - pSBCalc->pxMin, pSBCalc->cpx));
else
return (pSBCalc->data.posMin - 1);
}
/***************************************************************************\
* InvertScrollHilite
*
*
*
* History:
\***************************************************************************/
void InvertScrollHilite(
HWND hwnd,
PSBTRACK pSBTrack)
{
HDC hdc;
/*
* Don't invert if the thumb is all the way at the top or bottom
* or you will end up inverting the line between the arrow and the thumb.
*/
if (!IsRectEmpty(&pSBTrack->rcTrack))
{
if (pSBTrack->fTrackRecalc) {
RecalcTrackRect(pSBTrack);
pSBTrack->fTrackRecalc = FALSE;
}
hdc = (HDC)GetWindowDC(hwnd);
if( hdc )
{
HTHEME hTheme = CUxScrollBar::GetSBTheme(hwnd);
if (!hTheme)
{
InvertRect(hdc, &pSBTrack->rcTrack);
}
else
{
DrawThemeBackground(hTheme,
hdc,
pSBTrack->cmdSB == SB_PAGEUP ?
(pSBTrack->fTrackVert ? SBP_LOWERTRACKVERT : SBP_LOWERTRACKHORZ) :
(pSBTrack->fTrackVert ? SBP_UPPERTRACKVERT : SBP_UPPERTRACKHORZ),
SCRBS_NORMAL,
&pSBTrack->rcTrack,
0);
}
ReleaseDC(hwnd, hdc);
}
}
}
/***************************************************************************\
* xxxDoScroll
*
* Sends scroll notification to the scroll bar owner
*
* History:
\***************************************************************************/
void xxxDoScroll(
HWND hwnd,
HWND hwndNotify,
int cmd,
int pos,
BOOL fVert
)
{
//
// Send scroll notification to the scrollbar owner. If this is a control
// the lParam is the control's handle, NULL otherwise.
//
SendMessage(hwndNotify,
(UINT)(fVert ? WM_VSCROLL : WM_HSCROLL),
MAKELONG(cmd, pos),
(LPARAM)(IsScrollBarControl(hwnd) ? hwnd : NULL));
}
/***************************************************************************\
* xxxMoveThumb
*
* History:
\***************************************************************************/
void xxxMoveThumb(
HWND hwnd,
PSBCALC pSBCalc,
int px)
{
HBRUSH hbr, hbrSave;
HDC hdc;
CUxScrollBar* psb = CUxScrollBar::FromHwnd( hwnd );
PSBTRACK pSBTrack = psb->GetTrack();
CheckLock(hwnd);
if ((pSBTrack == NULL) || (px == pSBTrack->pxOld))
return;
pxReCalc:
pSBTrack->posNew = SBPosFromPx(pSBCalc, px);
/* Tentative position changed -- notify the guy. */
if (pSBTrack->posNew != pSBTrack->posOld) {
if (pSBTrack->hwndSBNotify != NULL) {
psb->DoScroll(pSBTrack->hwndSBNotify, SB_THUMBTRACK, pSBTrack->posNew, pSBTrack->fTrackVert
);
}
// After xxxDoScroll, re-evaluate pSBTrack
REEVALUATE_PSBTRACK(pSBTrack, hwnd, "xxxMoveThumb(1)");
if ((pSBTrack == NULL) || (pSBTrack->pfnSB == NULL))
return;
pSBTrack->posOld = pSBTrack->posNew;
//
// Anything can happen after the SendMessage above!
// Make sure that the SBINFO structure contains data for the
// window being tracked -- if not, recalculate data in SBINFO
//
// CheckScrollRecalc(hwnd, pSBState, pSBCalc);
// when we yield, our range can get messed with
// so make sure we handle this
if (px >= pSBCalc->pxMin + pSBCalc->cpx)
{
px = pSBCalc->pxMin + pSBCalc->cpx;
goto pxReCalc;
}
}
hdc = GetWindowDC(hwnd);
if ( hdc != NULL )
{
BOOL fOwnerBrush = FALSE;
pSBCalc->pxThumbTop = px;
pSBCalc->pxThumbBottom = pSBCalc->pxThumbTop + pSBCalc->cpxThumb;
// at this point, the disable flags are always going to be 0 --
// we're in the middle of tracking.
hbr = ScrollBar_GetColorObjects(hwnd, hdc, &fOwnerBrush);
hbrSave = SelectBrush(hdc, hbr);
// After ScrollBar_GetColorObjects, re-evaluate pSBTrack
REEVALUATE_PSBTRACK(pSBTrack, hwnd, "xxxMoveThumb(2)");
if (pSBTrack == NULL)
{
RIPMSG1(RIP_ERROR, "Did we use to leak hdc %#p?", hdc) ;
ReleaseDC(hwnd, hdc);
return;
}
DrawThumb2(hwnd, pSBCalc, hdc, hbr, pSBTrack->fTrackVert, 0, fOwnerBrush);
SelectBrush(hdc, hbrSave);
ReleaseDC(hwnd, hdc);
}
pSBTrack->pxOld = px;
}
/***************************************************************************\
* zzzDrawInvertScrollArea
*
*
*
* History:
\***************************************************************************/
void zzzDrawInvertScrollArea(
HWND hwnd,
PSBTRACK pSBTrack,
BOOL fHit,
UINT cmd)
{
HDC hdc;
RECT rcTemp;
int cx, cy;
HTHEME hTheme;
if ((cmd != SB_LINEUP) && (cmd != SB_LINEDOWN)) {
// not hitting on arrow -- just invert the area and return
InvertScrollHilite(hwnd, pSBTrack);
if (cmd == SB_PAGEUP)
{
if (fHit)
SetWF(hwnd, WFPAGEUPBUTTONDOWN);
else
ClrWF(hwnd, WFPAGEUPBUTTONDOWN);
}
else
{
if (fHit)
SetWF(hwnd, WFPAGEDNBUTTONDOWN);
else
ClrWF(hwnd, WFPAGEDNBUTTONDOWN);
}
NotifyWinEvent(EVENT_OBJECT_STATECHANGE,
hwnd,
(pSBTrack->fCtlSB ? OBJID_CLIENT : (pSBTrack->fTrackVert ? OBJID_VSCROLL : OBJID_HSCROLL)),
((cmd == SB_PAGEUP) ? INDEX_SCROLLBAR_UPPAGE : INDEX_SCROLLBAR_DOWNPAGE));
// Note: after zzz, pSBTrack may no longer be valid (but we return now)
return;
}
if (pSBTrack->fTrackRecalc) {
RecalcTrackRect(pSBTrack);
pSBTrack->fTrackRecalc = FALSE;
}
CopyRect(&rcTemp, &pSBTrack->rcTrack);
hdc = GetWindowDC(hwnd);
if( hdc != NULL )
{
if (pSBTrack->fTrackVert) {
cx = SYSMET(CXVSCROLL);
cy = SYSMET(CYVSCROLL);
} else {
cx = SYSMET(CXHSCROLL);
cy = SYSMET(CYHSCROLL);
}
hTheme = CUxScrollBar::GetSBTheme(hwnd);
if (!hTheme)
{
DrawFrameControl(hdc, &rcTemp, DFC_SCROLL,
((pSBTrack->fTrackVert) ? DFCS_SCROLLVERT : DFCS_SCROLLHORZ) |
((fHit) ? DFCS_PUSHED | DFCS_FLAT : 0) |
((cmd == SB_LINEUP) ? DFCS_SCROLLMIN : DFCS_SCROLLMAX));
}
else
{
INT iStateId;
// Determine the pressed state of the button
iStateId = fHit ? SCRBS_PRESSED : SCRBS_NORMAL;
// Determine which kind of button it is.
// NOTE: (phellyar) this is dependant on the order of
// the ARROWBTNSTATE enum
if (pSBTrack->fTrackVert)
{
if (cmd == SB_LINEUP)
{
// Up button states are the first four entries
// in the enum
iStateId += 0;
}
else
{
// Down button states are the second four entries
// in the enum
iStateId += 4;
}
}
else
{
if (cmd == SB_LINEUP)
{
// Left button states are the third four entries
// in the enum
iStateId += 8;
}
else
{
// Right button states are the last four entries
// in the enum
iStateId += 12;
}
}
DrawThemeBackground(hTheme, hdc, SBP_ARROWBTN, iStateId, &rcTemp, 0);
}
ReleaseDC(hwnd, hdc);
}
if (cmd == SB_LINEUP) {
if (fHit)
SetWF(hwnd, WFLINEUPBUTTONDOWN);
else
ClrWF(hwnd, WFLINEUPBUTTONDOWN);
} else {
if (fHit)
SetWF(hwnd, WFLINEDNBUTTONDOWN);
else
ClrWF(hwnd, WFLINEDNBUTTONDOWN);
}
NotifyWinEvent(EVENT_OBJECT_STATECHANGE,
hwnd,
(pSBTrack->fCtlSB ? OBJID_CLIENT : (pSBTrack->fTrackVert ? OBJID_VSCROLL : OBJID_HSCROLL)),
(cmd == SB_LINEUP ? INDEX_SCROLLBAR_UP : INDEX_SCROLLBAR_DOWN));
// Note: after zzz, pSBTrack may no longer be valid (but we return now)
}
/***************************************************************************\
* xxxEndScroll
*
*
*
* History:
\***************************************************************************/
void xxxEndScroll(
HWND hwnd,
BOOL fCancel)
{
UINT oldcmd;
PSBTRACK pSBTrack;
CheckLock(hwnd);
ASSERT(!IsWinEventNotifyDeferred());
CUxScrollBar* psb = CUxScrollBar::FromHwnd( hwnd );
ASSERT(psb != NULL);
pSBTrack = psb->GetTrack();
if (pSBTrack && GetCapture() == hwnd && pSBTrack->pfnSB != NULL) {
oldcmd = pSBTrack->cmdSB;
pSBTrack->cmdSB = 0;
ReleaseCapture();
// After ReleaseCapture, revalidate pSBTrack
RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd);
if (pSBTrack->pfnSB == _TrackThumb) {
if (fCancel) {
pSBTrack->posOld = pSBTrack->pSBCalc->data.pos;
}
/*
* DoScroll does thread locking on these two pwnds -
* this is ok since they are not used after this
* call.
*/
if (pSBTrack->hwndSBNotify != NULL) {
psb->DoScroll( pSBTrack->hwndSBNotify,
SB_THUMBPOSITION, pSBTrack->posOld, pSBTrack->fTrackVert
);
// After xxxDoScroll, revalidate pSBTrack
RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd);
}
if (pSBTrack->fCtlSB) {
DrawCtlThumb((SBHWND) hwnd);
} else {
xxxDrawThumb(hwnd, pSBTrack->pSBCalc, pSBTrack->fTrackVert);
// Note: after xxx, pSBTrack may no longer be valid
}
} else if (pSBTrack->pfnSB == _TrackBox) {
DWORD lParam;
POINT ptMsg;
RECT rcWindow;
if (pSBTrack->hTimerSB != 0) {
_KillSystemTimer(hwnd, IDSYS_SCROLL);
pSBTrack->hTimerSB = 0;
}
lParam = GetMessagePos();
GetWindowRect( hwnd, &rcWindow );
#ifdef USE_MIRRORING
if (TestWF(hwnd, WEFLAYOUTRTL)) {
ptMsg.x = rcWindow.right - GET_X_LPARAM(lParam);
} else
#endif
{
ptMsg.x = GET_X_LPARAM(lParam) - rcWindow.left;
}
ptMsg.y = GET_Y_LPARAM(lParam) - rcWindow.top;
if (PtInRect(&pSBTrack->rcTrack, ptMsg)) {
zzzDrawInvertScrollArea(hwnd, pSBTrack, FALSE, oldcmd);
// Note: after zzz, pSBTrack may no longer be valid
}
}
/*
* Always send SB_ENDSCROLL message.
*
* DoScroll does thread locking on these two pwnds -
* this is ok since they are not used after this
* call.
*/
// After xxxDrawThumb or zzzDrawInvertScrollArea, revalidate pSBTrack
RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd);
if (pSBTrack->hwndSBNotify != NULL) {
psb->DoScroll( pSBTrack->hwndSBNotify,
SB_ENDSCROLL, 0, pSBTrack->fTrackVert);
// After xxxDoScroll, revalidate pSBTrack
RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd);
}
ClrWF(hwnd, WFSCROLLBUTTONDOWN);
ClrWF(hwnd, WFVERTSCROLLTRACK);
NotifyWinEvent(EVENT_SYSTEM_SCROLLINGEND,
hwnd,
(pSBTrack->fCtlSB ? OBJID_CLIENT : (pSBTrack->fTrackVert ? OBJID_VSCROLL : OBJID_HSCROLL)),
INDEXID_CONTAINER);
// After NotifyWinEvent, revalidate pSBTrack
RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd);
// If this is a Scroll Bar Control, turn the caret back on.
if (pSBTrack->hwndSB != NULL)
{
ShowCaret(pSBTrack->hwndSB);
// After zzz, revalidate pSBTrack
RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd);
}
pSBTrack->pfnSB = NULL;
/*
* Unlock structure members so they are no longer holding down windows.
*/
Unlock(&pSBTrack->hwndSB);
Unlock(&pSBTrack->hwndSBNotify);
Unlock(&pSBTrack->hwndTrack);
CUxScrollBar::ClearSBTrack( hwnd );
}
}
//-------------------------------------------------------------------------//
VOID CALLBACK xxxContScroll(HWND hwnd, UINT message, UINT_PTR ID, DWORD dwTime)
{
UNREFERENCED_PARAMETER(message);
UNREFERENCED_PARAMETER(ID);
UNREFERENCED_PARAMETER(dwTime);
CUxScrollBar* psb = CUxScrollBar::FromHwnd( hwnd );
if ( psb != NULL )
{
PSBTRACK pSBTrack = psb->GetTrack();
if ( pSBTrack != NULL )
{
LONG pt;
RECT rcWindow;
CheckLock(hwnd);
pt = GetMessagePos();
GetWindowRect( hwnd, &rcWindow );
if (TestWF(hwnd, WEFLAYOUTRTL))
{
pt = MAKELONG(rcWindow.right - GET_X_LPARAM(pt), GET_Y_LPARAM(pt) - rcWindow.top);
}
else
{
pt = MAKELONG( GET_X_LPARAM(pt) - rcWindow.left, GET_Y_LPARAM(pt) - rcWindow.top);
}
_TrackBox(hwnd, WM_NULL, 0, pt, NULL);
// After _TrackBox, revalidate pSBTrack
RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd);
if (pSBTrack->fHitOld)
{
pSBTrack->hTimerSB = _SetSystemTimer(hwnd, IDSYS_SCROLL, DTTIME/8, xxxContScroll);
// DoScroll does thread locking on these two pwnds -
// this is ok since they are not used after this call.
if (pSBTrack->hwndSBNotify != NULL)
{
psb->DoScroll(pSBTrack->hwndSBNotify, pSBTrack->cmdSB, 0, pSBTrack->fTrackVert);
// Note: after xxx, pSBTrack may no longer be valid (but we return now)
}
}
}
}
}
//-------------------------------------------------------------------------//
void CALLBACK _TrackBox(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, PSBCALC pSBCalc)
{
CUxScrollBar* psb = CUxScrollBar::FromHwnd(hwnd);
UNREFERENCED_PARAMETER(wParam);
UNREFERENCED_PARAMETER(pSBCalc);
CheckLock(hwnd);
ASSERT(IsWinEventNotifyDeferredOK());
if ( psb )
{
PSBTRACK pSBTrack = psb->GetTrack();
if ( pSBTrack )
{
BOOL fHit;
POINT ptHit;
int cmsTimer;
if ((uMsg != WM_NULL) && (HIBYTE(uMsg) != HIBYTE(WM_MOUSEFIRST)))
{
return;
}
if (pSBTrack->fTrackRecalc)
{
RecalcTrackRect(pSBTrack);
pSBTrack->fTrackRecalc = FALSE;
}
ptHit.x = GET_X_LPARAM(lParam);
ptHit.y = GET_Y_LPARAM(lParam);
fHit = PtInRect(&pSBTrack->rcTrack, ptHit);
if (fHit != (BOOL)pSBTrack->fHitOld)
{
zzzDrawInvertScrollArea(hwnd, pSBTrack, fHit, pSBTrack->cmdSB);
// After zzz, pSBTrack may no longer be valid
RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd);
}
cmsTimer = DTTIME/8;
switch (uMsg)
{
case WM_LBUTTONUP:
xxxEndScroll(hwnd, FALSE);
// Note: after xxx, pSBTrack may no longer be valid
break;
case WM_LBUTTONDOWN:
pSBTrack->hTimerSB = 0;
cmsTimer = DTTIME;
//
// FALL THRU
//
case WM_MOUSEMOVE:
if (fHit && fHit != (BOOL)pSBTrack->fHitOld)
{
//
// We moved back into the normal rectangle: reset timer
//
pSBTrack->hTimerSB = _SetSystemTimer(hwnd, IDSYS_SCROLL,
cmsTimer, xxxContScroll);
//
// DoScroll does thread locking on these two pwnds -
// this is ok since they are not used after this
// call.
//
if (pSBTrack->hwndSBNotify != NULL)
{
psb->DoScroll( pSBTrack->hwndSBNotify, pSBTrack->cmdSB,
0, pSBTrack->fTrackVert);
// Note: after xxx, pSBTrack may no longer be valid
}
}
break;
}
// After xxxDoScroll or xxxEndScroll, revalidate pSBTrack
RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd);
pSBTrack->fHitOld = fHit;
}
}
}
/***************************************************************************\
* _TrackThumb
*
*
*
* History:
\***************************************************************************/
void CALLBACK _TrackThumb(
HWND hwnd,
UINT message,
WPARAM wParam,
LPARAM lParam,
PSBCALC pSBCalc)
{
int px;
CUxScrollBar* psb = CUxScrollBar::FromHwnd( hwnd );
ASSERT(psb);
PSBTRACK pSBTrack = psb->GetTrack();
POINT pt;
UNREFERENCED_PARAMETER(wParam);
CheckLock(hwnd);
if (HIBYTE(message) != HIBYTE(WM_MOUSEFIRST))
return;
if (pSBTrack == NULL)
return;
// Make sure that the SBINFO structure contains data for the
// window being tracked -- if not, recalculate data in SBINFO
// CheckScrollRecalc(hwnd, pSBState, pSBCalc);
if (pSBTrack->fTrackRecalc) {
RecalcTrackRect(pSBTrack);
pSBTrack->fTrackRecalc = FALSE;
}
pt.y = GET_Y_LPARAM(lParam);
pt.x = GET_X_LPARAM(lParam);
if (!PtInRect(&pSBTrack->rcTrack, pt))
px = pSBCalc->pxStart;
else {
px = (pSBTrack->fTrackVert ? pt.y : pt.x) + pSBTrack->dpxThumb;
if (px < pSBCalc->pxMin)
px = pSBCalc->pxMin;
else if (px >= pSBCalc->pxMin + pSBCalc->cpx)
px = pSBCalc->pxMin + pSBCalc->cpx;
}
xxxMoveThumb(hwnd, pSBCalc, px);
/*
* We won't get the WM_LBUTTONUP message if we got here through
* the scroll menu, so test the button state directly.
*/
if (message == WM_LBUTTONUP || GetKeyState(VK_LBUTTON) >= 0) {
xxxEndScroll(hwnd, FALSE);
}
}
/***************************************************************************\
* _ClientToWindow
* History:
\***************************************************************************/
BOOL _ClientToWindow( HWND hwnd, LPPOINT ppt )
{
WINDOWINFO wi;
wi.cbSize = sizeof(wi);
if( GetWindowInfo( hwnd, &wi ) )
{
ppt->x += (wi.rcClient.left - wi.rcWindow.left);
ppt->y += (wi.rcClient.top - wi.rcWindow.top);
return TRUE;
}
return FALSE;
}
/***************************************************************************\
* xxxSBTrackLoop
*
*
*
* History:
\***************************************************************************/
void xxxSBTrackLoop(
HWND hwnd,
LPARAM lParam,
PSBCALC pSBCalc)
{
MSG msg;
UINT cmd;
VOID (*pfnSB)(HWND, UINT, WPARAM, LPARAM, PSBCALC);
CUxScrollBar* psb = CUxScrollBar::FromHwnd( hwnd );
PSBTRACK pSBTrack = psb->GetSBTrack(hwnd);
CheckLock(hwnd);
ASSERT(IsWinEventNotifyDeferredOK());
if (pSBTrack == NULL)
// mode cancelled -- exit track loop
return;
pfnSB = pSBTrack->pfnSB;
if (pfnSB == NULL)
// mode cancelled -- exit track loop
return;
if (pSBTrack->fTrackVert)
SetWF(hwnd, WFVERTSCROLLTRACK);
NotifyWinEvent(EVENT_SYSTEM_SCROLLINGSTART,
hwnd,
(pSBTrack->fCtlSB ? OBJID_CLIENT : (pSBTrack->fTrackVert ? OBJID_VSCROLL : OBJID_HSCROLL)),
INDEXID_CONTAINER);
// Note: after xxx, pSBTrack may no longer be valid
(*pfnSB)(hwnd, WM_LBUTTONDOWN, 0, lParam, pSBCalc);
// Note: after xxx, pSBTrack may no longer be valid
while (GetCapture() == hwnd) {
if (!GetMessage(&msg, NULL, 0, 0)) {
// Note: after xxx, pSBTrack may no longer be valid
break;
}
if (!CallMsgFilter(&msg, MSGF_SCROLLBAR))
{
BOOL bTrackMsg = FALSE;
cmd = msg.message;
lParam = msg.lParam;
if (msg.hwnd == HWq(hwnd))
{
if( cmd >= WM_MOUSEFIRST && cmd <= WM_MOUSELAST )
{
if( !psb->IsCtl() )
{
POINT pt;
pt.x = GET_X_LPARAM(msg.lParam);
pt.y = GET_Y_LPARAM(msg.lParam);
_ClientToWindow( hwnd, &pt );
lParam = MAKELPARAM(pt.x, pt.y);
}
bTrackMsg = TRUE;
}
else if( cmd >= WM_KEYFIRST && cmd <= WM_KEYLAST )
{
cmd = _SysToChar(cmd, msg.lParam);
bTrackMsg = TRUE;
}
}
if( bTrackMsg )
{
// After NotifyWinEvent, pfnSB, TranslateMessage or
// DispatchMessage, re-evaluate pSBTrack.
REEVALUATE_PSBTRACK(pSBTrack, hwnd, "xxxTrackLoop");
if ((pSBTrack == NULL) || (NULL == (pfnSB = pSBTrack->pfnSB)))
// mode cancelled -- exit track loop
return;
(*pfnSB)(hwnd, cmd, msg.wParam, lParam, pSBCalc);
}
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
}
/***************************************************************************\
* _SBTrackInit
*
* History:
\***************************************************************************/
void _SBTrackInit(
HWND hwnd,
LPARAM lParam,
int curArea,
UINT uType)
{
int px;
LPINT pwX;
LPINT pwY;
UINT wDisable; // Scroll bar disable flags;
SBCALC SBCalc = {0};
PSBCALC pSBCalc;
RECT rcSB;
PSBTRACK pSBTrack;
CheckLock(hwnd);
#ifdef PORTPORT // unneccessary dbgchk w/ port
if (CUxScrollBar::GetSBTrack(hwnd)) {
RIPMSG1(RIP_WARNING, "_SBTrackInit: CUxScrollBar::GetSBTrack(hwnd) == %#p",
CUxScrollBar::GetSBTrack(hwnd));
return;
}
#endif PORTPORT
CUxScrollBar* psb = CUxScrollBar::Attach( hwnd, !curArea, TRUE );
if (!psb)
{
return;
}
CUxScrollBarCtl* psbCtl = psb->IsCtl() ? (CUxScrollBarCtl*)psb : NULL;
pSBTrack = psb->GetTrack();
if (pSBTrack == NULL)
return;
pSBTrack->hTimerSB = 0;
pSBTrack->fHitOld = FALSE;
pSBTrack->pfnSB = _TrackBox;
pSBTrack->hwndTrack = NULL;
pSBTrack->hwndSB = NULL;
pSBTrack->hwndSBNotify = NULL;
Lock(&pSBTrack->hwndTrack, hwnd); // pSBTrack->hwndTrack = hwnd;
pSBTrack->fCtlSB = (!curArea);
if (pSBTrack->fCtlSB)
{
/*
* This is a scroll bar control.
*/
ASSERT(psbCtl != NULL);
pSBTrack->hwndSB = hwnd; //Lock(&pSBTrack->hwndSB, hwnd);
pSBTrack->fTrackVert = psbCtl->_fVert;
Lock(&pSBTrack->hwndSBNotify, GetParent(hwnd)); // pSBTrack->hwndSBNotify = GetParent( hwnd );
wDisable = psbCtl->_wDisableFlags;
pSBCalc = &psbCtl->_calc;
pSBTrack->nBar = SB_CTL;
} else {
/*
* This is a scroll bar that is part of the window frame.
*/
RECT rcWindow;
GetWindowRect( hwnd, &rcWindow );
int x = GET_X_LPARAM(lParam);
int y = GET_Y_LPARAM(lParam);
#ifdef USE_MIRRORING
//
// Mirror the window coord of the scroll bar,
// if it is a mirrored one
//
if (TestWF(hwnd,WEFLAYOUTRTL)) {
lParam = MAKELONG(
rcWindow.right - x,
y - rcWindow.top);
}
else {
#endif
lParam = MAKELONG( x - rcWindow.left, y - rcWindow.top);
#ifdef USE_MIRRORING
}
#endif
Lock(&pSBTrack->hwndSBNotify, hwnd); // pSBTrack->hwndSBNotify = hwnd; //
Lock(&pSBTrack->hwndSB, NULL); // pSBTrack->hwndSB = NULL;
pSBTrack->fTrackVert = (curArea - HTHSCROLL);
wDisable = _GetWndSBDisableFlags(hwnd, pSBTrack->fTrackVert);
pSBCalc = &SBCalc;
pSBTrack->nBar = (curArea - HTHSCROLL) ? SB_VERT : SB_HORZ;
}
pSBTrack->pSBCalc = pSBCalc;
/*
* Check if the whole scroll bar is disabled
*/
if((wDisable & SB_DISABLE_MASK) == SB_DISABLE_MASK) {
CUxScrollBar::Detach( hwnd );
return; // It is a disabled scroll bar; So, do not respond.
}
if (!pSBTrack->fCtlSB) {
psb->FreshenSBData( pSBTrack->nBar, FALSE );
CUxScrollBar::Calc(hwnd, pSBCalc, NULL, pSBTrack->fTrackVert);
}
pwX = (LPINT)&rcSB;
pwY = pwX + 1;
if (!pSBTrack->fTrackVert)
pwX = pwY--;
px = (pSBTrack->fTrackVert ? GET_Y_LPARAM(lParam) : GET_X_LPARAM(lParam));
*(pwX + 0) = pSBCalc->pxLeft;
*(pwY + 0) = pSBCalc->pxTop;
*(pwX + 2) = pSBCalc->pxRight;
*(pwY + 2) = pSBCalc->pxBottom;
pSBTrack->cmdSB = (UINT)-1;
if (px < pSBCalc->pxUpArrow) {
/*
* The click occurred on Left/Up arrow; Check if it is disabled
*/
if(wDisable & LTUPFLAG) {
if(pSBTrack->fCtlSB) { // If this is a scroll bar control,
ShowCaret(pSBTrack->hwndSB); // show the caret before returning;
// After ShowCaret, revalidate pSBTrack
RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd);
}
CUxScrollBar::Detach( hwnd );
return; // Yes! disabled. Do not respond.
}
// LINEUP -- make rcSB the Up Arrow's Rectangle
pSBTrack->cmdSB = SB_LINEUP;
*(pwY + 2) = pSBCalc->pxUpArrow;
} else if (px >= pSBCalc->pxDownArrow) {
/*
* The click occurred on Right/Down arrow; Check if it is disabled
*/
if (wDisable & RTDNFLAG) {
if (pSBTrack->fCtlSB) { // If this is a scroll bar control,
ShowCaret(pSBTrack->hwndSB); // show the caret before returning;
// After ShowCaret, revalidate pSBTrack
RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd);
}
CUxScrollBar::Detach( hwnd );
return;// Yes! disabled. Do not respond.
}
// LINEDOWN -- make rcSB the Down Arrow's Rectangle
pSBTrack->cmdSB = SB_LINEDOWN;
*(pwY + 0) = pSBCalc->pxDownArrow;
} else if (px < pSBCalc->pxThumbTop) {
// PAGEUP -- make rcSB the rectangle between Up Arrow and Thumb
pSBTrack->cmdSB = SB_PAGEUP;
*(pwY + 0) = pSBCalc->pxUpArrow;
*(pwY + 2) = pSBCalc->pxThumbTop;
} else if (px < pSBCalc->pxThumbBottom) {
DoThumbPos:
/*
* Elevator isn't there if there's no room.
*/
if (pSBCalc->pxDownArrow - pSBCalc->pxUpArrow <= pSBCalc->cpxThumb) {
CUxScrollBar::Detach( hwnd );
return;
}
// THUMBPOSITION -- we're tracking with the thumb
pSBTrack->cmdSB = SB_THUMBPOSITION;
CalcTrackDragRect(pSBTrack);
pSBTrack->pfnSB = _TrackThumb;
pSBTrack->pxOld = pSBCalc->pxStart = pSBCalc->pxThumbTop;
pSBTrack->posNew = pSBTrack->posOld = pSBCalc->data.pos;
pSBTrack->dpxThumb = pSBCalc->pxStart - px;
SetCapture( hwnd ); //xxxCapture(PtiCurrent(), hwnd, WINDOW_CAPTURE);
// After xxxCapture, revalidate pSBTrack
RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd);
/*
* DoScroll does thread locking on these two pwnds -
* this is ok since they are not used after this
* call.
*/
if (pSBTrack->hwndSBNotify != NULL) {
psb->DoScroll( pSBTrack->hwndSBNotify, SB_THUMBTRACK,
pSBTrack->posOld, pSBTrack->fTrackVert
);
// Note: after xxx, pSBTrack may no longer be valid
}
} else if (px < pSBCalc->pxDownArrow) {
// PAGEDOWN -- make rcSB the rectangle between Thumb and Down Arrow
pSBTrack->cmdSB = SB_PAGEDOWN;
*(pwY + 0) = pSBCalc->pxThumbBottom;
*(pwY + 2) = pSBCalc->pxDownArrow;
}
/*
* If the shift key is down, we'll position the thumb directly so it's
* centered on the click point.
*/
if ((uType == SCROLL_DIRECT && pSBTrack->cmdSB != SB_LINEUP && pSBTrack->cmdSB != SB_LINEDOWN) ||
(uType == SCROLL_MENU)) {
if (pSBTrack->cmdSB != SB_THUMBPOSITION) {
goto DoThumbPos;
}
pSBTrack->dpxThumb = -(pSBCalc->cpxThumb / 2);
}
SetCapture( hwnd ); // xxxCapture(PtiCurrent(), hwnd, WINDOW_CAPTURE);
// After xxxCapture, revalidate pSBTrack
RETURN_IF_PSBTRACK_INVALID(pSBTrack, hwnd);
if (pSBTrack->cmdSB != SB_THUMBPOSITION) {
CopyRect(&pSBTrack->rcTrack, &rcSB);
}
xxxSBTrackLoop(hwnd, lParam, pSBCalc);
// After xxx, re-evaluate pSBTrack
REEVALUATE_PSBTRACK(pSBTrack, hwnd, "xxxTrackLoop");
if (pSBTrack)
{
CUxScrollBar::ClearSBTrack( hwnd );
}
}
/***************************************************************************\
* HandleScrollCmd
*
* History: added to support and encap SB tracking initialization originating
* from WM_SYSCOMMAND::SC_VSCROLL/SC_HSCROLL [scotthan]
\***************************************************************************/
void WINAPI HandleScrollCmd( HWND hwnd, WPARAM wParam, LPARAM lParam )
{
UINT uArea = (UINT)(wParam & 0x0F);
_SBTrackInit( hwnd, lParam, uArea,
(GetKeyState(VK_SHIFT) < 0) ? SCROLL_DIRECT : SCROLL_NORMAL);
}
//-------------------------------------------------------------------------
HMENU ScrollBar_GetMenu(HWND hwnd, BOOL fVert)
{
static HMODULE hModUser = NULL;
HMENU hMenu = NULL;
if ( !hModUser )
{
hModUser = GetModuleHandle(TEXT("user32"));
}
#define ID_HSCROLLMENU 0x40
#define ID_VSCROLLMENU 0x50
if ( hModUser )
{
hMenu = LoadMenu(hModUser, MAKEINTRESOURCE((fVert ? ID_VSCROLLMENU : ID_HSCROLLMENU)));
if ( hMenu )
{
hMenu = GetSubMenu(hMenu, 0);
}
}
return hMenu;
}
//-------------------------------------------------------------------------
VOID ScrollBar_Menu(HWND hwndNotify, HWND hwnd, LPARAM lParam, BOOL fVert)
{
CUxScrollBar* psb = CUxScrollBar::FromHwnd( hwnd );
CUxScrollBarCtl* psbCtl = CUxScrollBarCtl::FromHwnd( hwnd );
BOOL fCtl = (psbCtl != NULL);
if ( psb || psbCtl )
{
UINT wDisable;
RECT rcWindow;
POINT pt;
GetWindowRect(hwnd, &rcWindow);
POINTSTOPOINT(pt, lParam);
if ( TestWF(hwnd, WEFLAYOUTRTL) && !fVert )
{
MIRROR_POINT(rcWindow, pt);
}
pt.x -= rcWindow.left;
pt.y -= rcWindow.top;
if ( fCtl )
{
wDisable = psbCtl->_wDisableFlags;
}
else
{
wDisable = _GetWndSBDisableFlags(hwndNotify, fVert);
}
// Make sure the scrollbar isn't disabled.
if ( (wDisable & SB_DISABLE_MASK) != SB_DISABLE_MASK)
{
HMENU hMenu = ScrollBar_GetMenu(hwndNotify, fVert);
// Put up a menu and scroll accordingly.
if (hMenu != NULL)
{
int iCmd;
iCmd = TrackPopupMenuEx(hMenu,
TPM_RIGHTBUTTON | TPM_RETURNCMD | TPM_NONOTIFY,
GET_X_LPARAM(lParam),
GET_Y_LPARAM(lParam),
hwndNotify,
NULL);
DestroyMenu(hMenu);
if (iCmd)
{
if ((iCmd & 0x00FF) == SB_THUMBPOSITION)
{
if ( fCtl )
{
_SBTrackInit(hwnd, MAKELPARAM(pt.x, pt.y), 0, SCROLL_MENU);
}
else
{
_SBTrackInit(hwndNotify, lParam, fVert ? HTVSCROLL : HTHSCROLL, SCROLL_MENU);
}
}
else
{
xxxDoScroll(hwnd, hwndNotify, (iCmd & 0x00FF), 0, fVert);
xxxDoScroll(hwnd, hwndNotify, SB_ENDSCROLL, 0, fVert);
}
}
}
}
}
}
//-------------------------------------------------------------------------
LRESULT CUxScrollBarCtl::WndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
LONG l;
LONG lres = 0;
int cx, cy;
UINT cmd;
UINT uSide;
HDC hdc;
RECT rc;
POINT pt;
BOOL fSizeReal;
HBRUSH hbrSave;
BOOL fSize;
PAINTSTRUCT ps;
DWORD dwStyle;
SCROLLINFO si;
LPSCROLLINFO lpsi = &si;
BOOL fRedraw = FALSE;
BOOL fScroll;
CUxScrollBarCtl* psb = CUxScrollBarCtl::FromHwnd( hwnd );
if (!psb && uMsg != WM_NCCREATE)
{
goto CallDWP;
}
CheckLock(hwnd);
ASSERT(IsWinEventNotifyDeferredOK());
VALIDATECLASSANDSIZE(((HWND)hwnd), uMsg, wParam, lParam, FNID_SCROLLBAR, WM_CREATE);
dwStyle = GetWindowStyle(hwnd);
fSize = (((LOBYTE(dwStyle)) & (SBS_SIZEBOX | SBS_SIZEGRIP)) != 0);
switch (uMsg)
{
case WM_NCCREATE:
if( NULL == psb )
{
psb = (CUxScrollBarCtl*)CUxScrollBar::Attach( hwnd, TRUE, FALSE );
}
goto CallDWP;
case WM_NCDESTROY:
CUxScrollBar::Detach(hwnd);
psb = NULL;
goto CallDWP;
case WM_CREATE:
/*
* Guard against lParam being NULL since the thunk allows it [51986]
*/
if (lParam)
{
rc.right = (rc.left = ((LPCREATESTRUCT)lParam)->x) +
((LPCREATESTRUCT)lParam)->cx;
rc.bottom = (rc.top = ((LPCREATESTRUCT)lParam)->y) +
((LPCREATESTRUCT)lParam)->cy;
// This is because we can't just rev CardFile -- we should fix the
// problem here in case anyone else happened to have some EXTRA
// scroll styles on their scroll bar controls (jeffbog 03/21/94)
if (!TestWF((HWND)hwnd, WFWIN40COMPAT))
dwStyle &= ~(WS_HSCROLL | WS_VSCROLL);
if (!fSize)
{
l = PtrToLong(((LPCREATESTRUCT)lParam)->lpCreateParams);
psb->_calc.data.pos = psb->_calc.data.posMin = LOWORD(l);
psb->_calc.data.posMax = HIWORD(l);
psb->_fVert = ((LOBYTE(dwStyle) & SBS_VERT) != 0);
psb->_calc.data.page = 0;
}
if (dwStyle & WS_DISABLED)
psb->_wDisableFlags = SB_DISABLE_MASK;
if (LOBYTE(dwStyle) & (SBS_TOPALIGN | SBS_BOTTOMALIGN)) {
if (fSize) {
if (LOBYTE(dwStyle) & SBS_SIZEBOXBOTTOMRIGHTALIGN) {
rc.left = rc.right - SYSMET(CXVSCROLL);
rc.top = rc.bottom - SYSMET(CYHSCROLL);
}
rc.right = rc.left + SYSMET(CXVSCROLL);
rc.bottom = rc.top + SYSMET(CYHSCROLL);
} else {
if (LOBYTE(dwStyle) & SBS_VERT) {
if (LOBYTE(dwStyle) & SBS_LEFTALIGN)
rc.right = rc.left + SYSMET(CXVSCROLL);
else
rc.left = rc.right - SYSMET(CXVSCROLL);
} else {
if (LOBYTE(dwStyle) & SBS_TOPALIGN)
rc.bottom = rc.top + SYSMET(CYHSCROLL);
else
rc.top = rc.bottom - SYSMET(CYHSCROLL);
}
}
MoveWindow((HWND)hwnd, rc.left, rc.top, rc.right - rc.left,
rc.bottom - rc.top, FALSE);
}
} /* if */
else {
RIPERR0(ERROR_INVALID_PARAMETER, RIP_WARNING,
"UxScrollBarCtlWndProc - NULL lParam for WM_CREATE\n") ;
} /* else */
break;
case WM_SIZE:
if (GetFocus() != (HWND)hwnd)
break;
// scroll bar has the focus -- recalc it's thumb caret size
// no need to DeferWinEventNotify() - see CreateCaret below.
DestroyCaret();
// | |
// | FALL THRU |
// V V
case WM_SETFOCUS:
{
// REVIEW (phellyar) Do we want themed scroll bars to have
// a caret?
if ( !psb->GetTheme() )
{
SBCtlSetup(hwnd);
RECT rcWindow;
GetWindowRect( hwnd, &rcWindow );
cx = (psb->_fVert ? rcWindow.right - rcWindow.left
: psb->_calc.cpxThumb) - 2 * SYSMET(CXEDGE);
cy = (psb->_fVert ? psb->_calc.cpxThumb
: rcWindow.bottom - rcWindow.top) - 2 * SYSMET(CYEDGE);
#ifdef _VISUAL_DELTA_
cx -= (CARET_BORDERWIDTH * 2);
cy -= (CARET_BORDERWIDTH * 2);
#endif _VISUAL_DELTA_
CreateCaret((HWND)hwnd, (HBITMAP)1, cx, cy);
zzzSetSBCaretPos(hwnd);
ShowCaret((HWND)hwnd);
}
break;
}
case WM_KILLFOCUS:
DestroyCaret();
break;
case WM_ERASEBKGND:
/*
* Do nothing, but don't let DefWndProc() do it either.
* It will be erased when its painted.
*/
return (LONG)TRUE;
case WM_PRINTCLIENT:
case WM_PAINT:
if ((hdc = (HDC)wParam) == NULL) {
hdc = BeginPaint((HWND)hwnd, (LPPAINTSTRUCT)&ps);
}
if (!fSize) {
SBCtlSetup(hwnd);
xxxDrawSB2((HWND)hwnd, &psb->_calc, hdc, psb->_fVert, psb->_wDisableFlags);
} else {
fSizeReal = TestWF((HWND)hwnd, WFSIZEBOX);
if (!fSizeReal)
SetWF((HWND)hwnd, WFSIZEBOX);
_DrawSizeBoxFromFrame((HWND)hwnd, hdc, 0, 0);
if (!fSizeReal)
ClrWF((HWND)hwnd, WFSIZEBOX);
}
if (wParam == 0L)
EndPaint((HWND)hwnd, (LPPAINTSTRUCT)&ps);
break;
case WM_GETDLGCODE:
return DLGC_WANTARROWS;
case WM_CONTEXTMENU:
{
HWND hwndParent = GetParent(hwnd);
if (hwndParent)
{
ScrollBar_Menu(hwndParent, hwnd, lParam, psb->_fVert);
}
break;
}
case WM_NCHITTEST:
if (LOBYTE(dwStyle) & SBS_SIZEGRIP) {
#ifdef USE_MIRRORING
/*
* If the scroll bar is RTL mirrored, then
* mirror the hittest of the grip location.
*/
if (TestWF((HWND)hwnd, WEFLAYOUTRTL))
return HTBOTTOMLEFT;
else
#endif
return HTBOTTOMRIGHT;
} else {
goto CallDWP;
}
break;
case WM_MOUSELEAVE:
psb->SetHotComponent(HTNOWHERE, psb->_fVert);
InvalidateRect(hwnd, NULL, TRUE);
break;
case WM_MOUSEMOVE:
{
INT ht;
if (psb->GetHotComponent(psb->_fVert) == 0)
{
TRACKMOUSEEVENT tme;
tme.cbSize = sizeof(TRACKMOUSEEVENT);
tme.dwFlags = TME_LEAVE;
tme.hwndTrack = hwnd;
tme.dwHoverTime = 0;
TrackMouseEvent(&tme);
}
pt.x = GET_X_LPARAM(lParam);
pt.y = GET_Y_LPARAM(lParam);
ht = HitTestScrollBar((HWND)hwnd, psb->_fVert, pt);
if (psb->GetHotComponent(psb->_fVert) != ht)
{
psb->SetHotComponent(ht, psb->_fVert);
InvalidateRect(hwnd, NULL, TRUE);
}
break;
}
case WM_LBUTTONDBLCLK:
cmd = SC_ZOOM;
if (fSize)
goto postmsg;
/*
*** FALL THRU **
*/
case WM_LBUTTONDOWN:
//
// Note that SBS_SIZEGRIP guys normally won't ever see button
// downs. This is because they return HTBOTTOMRIGHT to
// WindowHitTest handling. This will walk up the parent chain
// to the first sizeable ancestor, bailing out at caption windows
// of course. That dude, if he exists, will handle the sizing
// instead.
//
if (!fSize) {
if (TestWF((HWND)hwnd, WFTABSTOP)) {
SetFocus((HWND)hwnd);
}
HideCaret((HWND)hwnd);
SBCtlSetup(hwnd);
/*
* SBCtlSetup enters SEM_SB, and _SBTrackInit leaves it.
*/
_SBTrackInit((HWND)hwnd, lParam, 0, (GetKeyState(VK_SHIFT) < 0) ? SCROLL_DIRECT : SCROLL_NORMAL);
break;
} else {
cmd = SC_SIZE;
postmsg:
pt.x = GET_X_LPARAM(lParam);
pt.y = GET_Y_LPARAM(lParam);
ClientToScreen((HWND)hwnd, &pt);
lParam = MAKELONG(pt.x, pt.y);
/*
* convert HT value into a move value. This is bad,
* but this is purely temporary.
*/
#ifdef USE_MIRRORING
if (TestWF(GetParent(hwnd),WEFLAYOUTRTL))
{
uSide = HTBOTTOMLEFT;
}
else
#endif
{
uSide = HTBOTTOMRIGHT;
}
ThreadLock(((HWND)hwnd)->hwndParent, &tlpwndParent);
SendMessage(GetParent(hwnd), WM_SYSCOMMAND,
(cmd | (uSide - HTSIZEFIRST + 1)), lParam);
ThreadUnlock(&tlpwndParent);
}
break;
case WM_KEYUP:
switch (wParam) {
case VK_HOME:
case VK_END:
case VK_PRIOR:
case VK_NEXT:
case VK_LEFT:
case VK_UP:
case VK_RIGHT:
case VK_DOWN:
/*
* Send end scroll uMsg when user up clicks on keyboard
* scrolling.
*
* DoScroll does thread locking on these two pwnds -
* this is ok since they are not used after this
* call.
*/
xxxDoScroll( (HWND)hwnd, GetParent(hwnd),
SB_ENDSCROLL, 0, psb->_fVert
);
break;
default:
break;
}
break;
case WM_KEYDOWN:
switch (wParam) {
case VK_HOME:
wParam = SB_TOP;
goto KeyScroll;
case VK_END:
wParam = SB_BOTTOM;
goto KeyScroll;
case VK_PRIOR:
wParam = SB_PAGEUP;
goto KeyScroll;
case VK_NEXT:
wParam = SB_PAGEDOWN;
goto KeyScroll;
case VK_LEFT:
case VK_UP:
wParam = SB_LINEUP;
goto KeyScroll;
case VK_RIGHT:
case VK_DOWN:
wParam = SB_LINEDOWN;
KeyScroll:
/*
* DoScroll does thread locking on these two pwnds -
* this is ok since they are not used after this
* call.
*/
xxxDoScroll((HWND)hwnd, GetParent(hwnd), (int)wParam, 0, psb->_fVert
);
break;
default:
break;
}
break;
case WM_ENABLE:
return SendMessage((HWND)hwnd, SBM_ENABLE_ARROWS,
(wParam ? ESB_ENABLE_BOTH : ESB_DISABLE_BOTH), 0);
case SBM_ENABLE_ARROWS:
/*
* This is used to enable/disable the arrows in a SB ctrl
*/
return (LONG)xxxEnableSBCtlArrows((HWND)hwnd, (UINT)wParam);
case SBM_GETPOS:
return (LONG)psb->_calc.data.pos;
case SBM_GETRANGE:
*((LPINT)wParam) = psb->_calc.data.posMin;
*((LPINT)lParam) = psb->_calc.data.posMax;
return MAKELRESULT(LOWORD(psb->_calc.data.posMin), LOWORD(psb->_calc.data.posMax));
case SBM_GETSCROLLINFO:
return (LONG)_SBGetParms((HWND)hwnd, SB_CTL, (PSBDATA)&psb->_calc, (LPSCROLLINFO) lParam);
case SBM_SETRANGEREDRAW:
fRedraw = TRUE;
case SBM_SETRANGE:
// Save the old values of Min and Max for return value
si.cbSize = sizeof(si);
// si.nMin = LOWORD(lParam);
// si.nMax = HIWORD(lParam);
si.nMin = (int)wParam;
si.nMax = (int)lParam;
si.fMask = SIF_RANGE | SIF_RETURNOLDPOS;
goto SetInfo;
case SBM_SETPOS:
fRedraw = (BOOL) lParam;
si.cbSize = sizeof(si);
si.fMask = SIF_POS | SIF_RETURNOLDPOS;
si.nPos = (int)wParam;
goto SetInfo;
case SBM_SETSCROLLINFO:
{
lpsi = (LPSCROLLINFO) lParam;
fRedraw = (BOOL) wParam;
SetInfo:
fScroll = TRUE;
lres = SBSetParms((PSBDATA)&psb->_calc, lpsi, &fScroll, &lres);
if (SBSetParms((PSBDATA)&psb->_calc, lpsi, &fScroll, &lres))
{
NotifyWinEvent(EVENT_OBJECT_VALUECHANGE, hwnd, OBJID_CLIENT, INDEX_SCROLLBAR_SELF);
}
if (!fRedraw)
return lres;
/*
* We must set the new position of the caret irrespective of
* whether the window is visible or not;
* Still, this will work only if the app has done a xxxSetScrollPos
* with fRedraw = TRUE;
* Fix for Bug #5188 --SANKAR-- 10-15-89
* No need to DeferWinEventNotify since hwnd is locked.
*/
HideCaret((HWND)hwnd);
SBCtlSetup(hwnd);
zzzSetSBCaretPos(hwnd);
/*
** The following ShowCaret() must be done after the DrawThumb2(),
** otherwise this caret will be erased by DrawThumb2() resulting
** in this bug:
** Fix for Bug #9263 --SANKAR-- 02-09-90
*
*/
/*
*********** ShowCaret((HWND)hwnd); ******
*/
if (_FChildVisible((HWND)hwnd) && fRedraw)
{
UINT wDisable;
HBRUSH hbrUse;
if (!fScroll)
fScroll = !(lpsi->fMask & SIF_DISABLENOSCROLL);
wDisable = (fScroll) ? ESB_ENABLE_BOTH : ESB_DISABLE_BOTH;
xxxEnableScrollBar((HWND) hwnd, SB_CTL, wDisable);
hdc = GetWindowDC((HWND)hwnd);
if (hdc)
{
BOOL fOwnerBrush = FALSE;
hbrUse = ScrollBar_GetColorObjects(hwnd, hdc, &fOwnerBrush);
hbrSave = SelectBrush(hdc, hbrUse);
// Before we used to only hideshowthumb() if the mesage was
// not SBM_SETPOS. I am not sure why but this case was ever
// needed for win 3.x but on NT it resulted in trashing the border
// of the scrollbar when the app called SetScrollPos() during
// scrollbar tracking. - mikehar 8/26
DrawThumb2((HWND)hwnd, &psb->_calc, hdc, hbrUse, psb->_fVert, psb->_wDisableFlags, fOwnerBrush);
SelectBrush(hdc, hbrSave);
ReleaseDC(hwnd, hdc);
}
}
/*
* This ShowCaret() has been moved to this place from above
* Fix for Bug #9263 --SANKAR-- 02-09-90
*/
ShowCaret((HWND)hwnd);
return lres;
}
case WM_GETOBJECT:
if(lParam == OBJID_QUERYCLASSNAMEIDX)
{
return MSAA_CLASSNAMEIDX_SCROLLBAR;
}
break;
case WM_THEMECHANGED:
psb->ChangeSBTheme();
InvalidateRect(hwnd, NULL, TRUE);
break;
default:
CallDWP:
return DefWindowProc((HWND)hwnd, uMsg, wParam, lParam);
}
return 0L;
}
//-------------------------------------------------------------------------//
// Globals
static HBRUSH g_hbrGray = NULL;
//-------------------------------------------------------------------------//
HBRUSH _UxGrayBrush(VOID)
{
if( NULL == g_hbrGray )
{
CONST static WORD patGray[8] = {0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa};
HBITMAP hbmGray;
/*
* Create a gray brush to be used with GrayString
*/
if( (hbmGray = CreateBitmap(8, 8, 1, 1, (LPBYTE)patGray)) != NULL )
{
g_hbrGray = CreatePatternBrush(hbmGray);
DeleteObject( hbmGray );
}
}
return g_hbrGray;
}
//-------------------------------------------------------------------------//
void _RedrawFrame( HWND hwnd )
{
CheckLock(hwnd);
/*
* We always want to call xxxSetWindowPos, even if invisible or iconic,
* because we need to make sure the WM_NCCALCSIZE message gets sent.
*/
SetWindowPos( hwnd, NULL, 0, 0, 0, 0, SWP_NOZORDER |
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_DRAWFRAME);
}
//-------------------------------------------------------------------------//
// from winmgr.c
BOOL _FChildVisible( HWND hwnd )
{
while (GetWindowStyle( hwnd ) & WS_CHILD )
{
if( NULL == (hwnd = GetParent(hwnd)) )
if (!TestWF(hwnd, WFVISIBLE))
return FALSE;
}
return TRUE;
}
//-------------------------------------------------------------------------//
//
// SizeBoxHwnd
//
// Returns the HWND that will be sized if the user drags in the given window's
// sizebox -- If NULL, then the sizebox is not needed
//
// Criteria for choosing what window will be sized:
// find first sizeable parent; if that parent is not maximized and the child's
// bottom, right corner is within a scroll bar height and width of the parent's
//
HWND SizeBoxHwnd(HWND hwnd)
{
BOOL bMirroredSizeBox = (BOOL)TestWF(hwnd, WEFLAYOUTRTL);
RECT rc;
int xbrChild;
int ybrChild;
GetWindowRect(hwnd, &rc);
xbrChild = bMirroredSizeBox ? rc.left : rc.right;
ybrChild = rc.bottom;
while (hwnd != HWND_DESKTOP)
{
if (TestWF(hwnd, WFSIZEBOX))
{
//
// First sizeable parent found
//
int xbrParent;
int ybrParent;
if (TestWF(hwnd, WFMAXIMIZED))
{
return NULL;
}
GetWindowRect(hwnd, &rc);
xbrParent = bMirroredSizeBox ? rc.left : rc.right;
ybrParent = rc.bottom;
//
// the sizebox dude is within an EDGE of the client's bottom
// right corner (left corner for mirrored windows), let this succeed.
// That way people who draw their own sunken clients will be happy.
//
if (bMirroredSizeBox)
{
if ((xbrChild - SYSMETRTL(CXFRAME) > xbrParent) || (ybrChild + SYSMETRTL(CYFRAME) < ybrParent))
{
//
// Child's bottom, left corner of SIZEBOX isn't close enough
// to bottom left of parent's client.
//
return NULL;
}
}
else
{
if ((xbrChild + SYSMETRTL(CXFRAME) < xbrParent) || (ybrChild + SYSMETRTL(CYFRAME) < ybrParent))
{
//
// Child's bottom, right corner of SIZEBOX isn't close enough
// to bottom right of parent's client.
//
return NULL;
}
}
return hwnd;
}
if (!TestWF(hwnd, WFCHILD) || TestWF(hwnd, WFCPRESENT))
{
break;
}
hwnd = GetParent(hwnd);
}
return NULL;
}
//-------------------------------------------------------------------------//
//
// _DrawPushButton
//
// From ntuser\rtl\draw.c
// Draws a push style button in the given state. Adjusts passed in rectangle
// if desired.
//
// Algorithm:
// Depending on the state we either draw
// - raised edge (undepressed)
// - sunken edge with extra shadow (depressed)
// If it is an option push button (a push button that is
// really a check button or a radio button like buttons
// in tool bars), and it is checked, then we draw it
// depressed with a different fill in the middle.
//
VOID _DrawPushButton(HWND hwnd, HDC hdc, LPRECT lprc, UINT state, UINT flags, BOOL fVert)
{
RECT rc;
HBRUSH hbrMiddle;
DWORD rgbBack = 0;
DWORD rgbFore = 0;
BOOL fDither;
HTHEME hTheme = CUxScrollBar::GetSBTheme(hwnd);
if ( !hTheme )
{
rc = *lprc;
DrawEdge(hdc,
&rc,
(state & (DFCS_PUSHED | DFCS_CHECKED)) ? EDGE_SUNKEN : EDGE_RAISED,
(UINT)(BF_ADJUST | BF_RECT | (flags & (BF_SOFT | BF_FLAT | BF_MONO))));
//
// BOGUS
// On monochrome, need to do something to make pushed buttons look
// better.
//
//
// Fill in middle. If checked, use dither brush (gray brush) with
// black becoming normal color.
//
fDither = FALSE;
if (state & DFCS_CHECKED)
{
if ((GetDeviceCaps(hdc, BITSPIXEL) /*gpsi->BitCount*/ < 8) || (SYSRGBRTL(3DHILIGHT) == RGB(255,255,255)))
{
hbrMiddle = _UxGrayBrush();
rgbBack = SetBkColor(hdc, SYSRGBRTL(3DHILIGHT));
rgbFore = SetTextColor(hdc, SYSRGBRTL(3DFACE));
fDither = TRUE;
}
else
{
hbrMiddle = SYSHBR(3DHILIGHT);
}
}
else
{
hbrMiddle = SYSHBR(3DFACE);
}
FillRect(hdc, &rc, hbrMiddle);
if (fDither)
{
SetBkColor(hdc, rgbBack);
SetTextColor(hdc, rgbFore);
}
if (flags & BF_ADJUST)
{
*lprc = rc;
}
}
else
{
INT iStateId;
INT iPartId;
SIZE sizeGrip;
RECT rcContent;
PSBTRACK pSBTrack = CUxScrollBar::GetSBTrack(hwnd);
if ((CUxScrollBarCtl::GetDisableFlags(hwnd) & ESB_DISABLE_BOTH) == ESB_DISABLE_BOTH)
{
iStateId = SCRBS_DISABLED;
}
else if (pSBTrack && ((BOOL)pSBTrack->fTrackVert == fVert) && (pSBTrack->cmdSB == SB_THUMBPOSITION))
{
iStateId = SCRBS_PRESSED;
}
else if (CUxScrollBar::GetSBHotComponent(hwnd, fVert) == HTSCROLLTHUMB)
{
iStateId = SCRBS_HOT;
}
else
{
iStateId = SCRBS_NORMAL;
}
iPartId = fVert ? SBP_THUMBBTNVERT : SBP_THUMBBTNHORZ;
//
// Draw the thumb
//
DrawThemeBackground(hTheme, hdc, iPartId, iStateId, lprc, 0);
//
// Lastly draw the little gripper image, if there is enough room
//
if ( SUCCEEDED(GetThemeBackgroundContentRect(hTheme, hdc, iPartId, iStateId, lprc, &rcContent)) )
{
iPartId = fVert ? SBP_GRIPPERVERT : SBP_GRIPPERHORZ;
if ( SUCCEEDED(GetThemePartSize(hTheme, hdc, iPartId, iStateId, &rcContent, TS_TRUE, &sizeGrip)) )
{
if ( (sizeGrip.cx < RECTWIDTH(&rcContent)) && (sizeGrip.cy < RECTHEIGHT(&rcContent)) )
{
DrawThemeBackground(hTheme, hdc, iPartId, iStateId, &rcContent, 0);
}
}
}
}
}
// user.h
#define CheckMsgFilter(wMsg, wMsgFilterMin, wMsgFilterMax) \
( ((wMsgFilterMin) == 0 && (wMsgFilterMax) == 0xFFFFFFFF) \
|| ( ((wMsgFilterMin) > (wMsgFilterMax)) \
? (((wMsg) < (wMsgFilterMax)) || ((wMsg) > (wMsgFilterMin))) \
: (((wMsg) >= (wMsgFilterMin)) && ((wMsg) <= (wMsgFilterMax)))))
#define SYS_ALTERNATE 0x2000
#define SYS_PREVKEYSTATE 0x4000
// mnaccel.h
/***************************************************************************\
* _SysToChar
*
* EXIT: If the message was not made with the ALT key down, convert
* the message from a WM_SYSKEY* to a WM_KEY* message.
*
* IMPLEMENTATION:
* The 0x2000 bit in the hi word of lParam is set if the key was
* made with the ALT key down.
*
* History:
* 11/30/90 JimA Ported.
\***************************************************************************/
UINT _SysToChar(
UINT message,
LPARAM lParam)
{
if (CheckMsgFilter(message, WM_SYSKEYDOWN, WM_SYSDEADCHAR) &&
!(HIWORD(lParam) & SYS_ALTERNATE))
return (message - (WM_SYSKEYDOWN - WM_KEYDOWN));
return message;
}