able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/comctl32/v6/trackbar.c

2068 lines
58 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "ctlspriv.h"
#include "limits.h"
#include "image.h" // for CreateColorBitmap
#if defined(MAINWIN)
#include <mainwin.h>
#endif
//#define TB_DEBUG
//#define FEATURE_DEBUG // Ctrl+Shift force-enables rare features for debugging
typedef struct {
// standard header information for each control
CCONTROLINFO ci;
HDC hdc; // current DC
HBITMAP hbmBuffer; // double buffer
LONG lLogMin; // Logical minimum
LONG lLogMax; // Logical maximum
LONG lLogPos; // Logical position
LONG lSelStart; // Logical selection start
LONG lSelEnd; // Logical selection end
int iThumbWidth; // Width of the thumb
int iThumbHeight; // Height of the thumb
int iSizePhys; // Size of where thumb lives
RECT rc; // track bar rect.
RECT rcThumb; // Rectangle we current thumb
DWORD dwDragPos; // Logical position of mouse while dragging.
int dwDragOffset; // how many pixels off the center did they click
int nTics; // number of ticks.
PDWORD pTics; // the tick marks.
int ticFreq; // the frequency of ticks
LONG lPageSize; // how much to thumb up and down.
LONG lLineSize; // how muhc to scroll up and down on line up/down
HWND hwndToolTips;
// these should probably be word or bytes
UINT wDirtyFlags;
UINT uTipSide; // which side should the tip be on?
UINT Flags; // Flags for our window
UINT Cmd; // The command we're repeating.
HTHEME hTheme;
BOOL bThumbHot;
HIMC hPrevImc; // previous input context handle
HWND hwndBuddyLeft;
HWND hwndBuddyRight;
} TRACKBAR, *PTRACKBAR;
// Trackbar flags
#define TBF_NOTHUMB 0x0001 // No thumb because not wide enough.
#define TBF_SELECTION 0x0002 // a selection has been established (draw the range)
#define MIN_THUMB_HEIGHT (2 * g_cxEdge)
/*
useful constants.
*/
#define REPEATTIME 500 // mouse auto repeat 1/2 of a second
#define TIMER_ID 1
/*
Function Prototypes
*/
void DoTrack(PTRACKBAR, int, DWORD);
WORD WTrackType(PTRACKBAR, LONG);
void TBTrackInit(PTRACKBAR, LPARAM);
void TBTrackEnd(PTRACKBAR);
void TBTrack(PTRACKBAR, LPARAM);
void DrawThumb(PTRACKBAR, LPRECT, BOOL);
HBRUSH SelectColorObjects(PTRACKBAR, BOOL);
void SetTBCaretPos(PTRACKBAR);
#define TICKHEIGHT 3
#define BORDERSIZE 2
#define ISVERT(tb) (tb->ci.style & TBS_VERT)
#define TBC_TICS 0x1
#define TBC_THUMB 0x2
#define TBC_ALL 0xF
// this is called internally when the trackbar has
// changed and we need to update the double buffer bitmap
// we only set a flag. we do the actual draw
// during WM_PAINT. This prevents wasted efforts drawing.
#define TBChanged(ptb, wFlags) ((ptb)->wDirtyFlags |= (wFlags))
//
// Function Prototypes
//
LPARAM CALLBACK TrackBarWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
void FlushChanges(PTRACKBAR tb);
//--------------------------------------------------------------------------;
//
// LONG MulDiv32(a,b,c) = (a * b + c/2) / c
//
//--------------------------------------------------------------------------;
#ifdef WIN32
#define MulDiv32 MulDiv // use KERNEL32 version (it rounds)
#else // WIN32
#define ASM66 _asm _emit 0x66 _asm
#define DB _asm _emit
#define EAX_TO_DXAX \
DB 0x66 \
DB 0x0F \
DB 0xA4 \
DB 0xC2 \
DB 0x10
#pragma warning(disable:4035 4704)
static LONG MulDiv32(LONG a,LONG b,LONG c)
{
ASM66 mov ax,word ptr c // mov eax, c
ASM66 sar ax,1 // sar eax,1
ASM66 cwd // cdq
ASM66 mov bx,ax // mov ebx,eax
ASM66 mov cx,dx // mov ecx,edx
ASM66 mov ax,word ptr a // mov eax, a
ASM66 imul word ptr b // imul b
ASM66 add ax,bx // add eax,ebx
ASM66 adc dx,cx // adc edx,ecx
ASM66 idiv word ptr c // idiv c
EAX_TO_DXAX
} // MulDiv32()
#pragma warning(default:4035 4704)
#endif // WIN32
//--------------------------------------------------------------------------;
//--------------------------------------------------------------------------;
//
// convert a logical scroll-bar position to a physical pixel position
//
int TBLogToPhys(PTRACKBAR tb, DWORD dwPos)
{
int x;
x = tb->rc.left;
if (tb->lLogMax == tb->lLogMin)
return x;
return (int)MulDiv32(dwPos - tb->lLogMin, tb->iSizePhys - 1,
tb->lLogMax - tb->lLogMin) + x;
}
LONG TBPhysToLog(PTRACKBAR ptb, int iPos)
{
int min, max, x;
min = ptb->rc.left;
max = ptb->rc.right;
x = ptb->rc.left;
if (ptb->iSizePhys <= 1)
return ptb->lLogMin;
if (iPos <= min)
return ptb->lLogMin;
if (iPos >= max)
return ptb->lLogMax;
return MulDiv32(iPos - x, ptb->lLogMax - ptb->lLogMin,
ptb->iSizePhys - 1) + ptb->lLogMin;
}
#pragma code_seg(CODESEG_INIT)
/*
* Initialize the trackbar code
*/
BOOL InitTrackBar(HINSTANCE hInstance)
{
WNDCLASS wc;
// See if we must register a window class
wc.lpfnWndProc = TrackBarWndProc;
wc.lpszClassName = s_szSTrackBarClass;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hIcon = NULL;
wc.lpszMenuName = NULL;
wc.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
wc.hInstance = hInstance;
wc.style = CS_GLOBALCLASS;
wc.cbClsExtra = 0;
wc.cbWndExtra = sizeof(PTRACKBAR);
if (!RegisterClass(&wc) && !GetClassInfo(hInstance, s_szSTrackBarClass, &wc))
return FALSE;
return TRUE;
}
#pragma code_seg()
/*
* To add vertical capabilities, I'm using a virtual coordinate
* system. the ptb->rcThumb and ptb->rc are in the virtual space (which
* is just a horizontal trackbar). Draw routines use PatRect and
* TBBitBlt which switch to the real coordinate system as needed.
*
* The one gotcha is that the Thumb Bitmap has the pressed bitmap
* to the real right, and the masks to the real right again for both
* the vertical and horizontal Thumbs. So those cases are hardcoded.
* Do a search for ISVERT to find these dependancies.
* -Chee
*/
/*
FlipRect Function is moved to cutils.c as other controls were also using it.
-Arul
*/
void TBFlipPoint(PTRACKBAR ptb, LPPOINT lppt)
{
if (ISVERT(ptb)) {
FlipPoint(lppt);
}
}
/* added trackbar variable to do auto verticalization */
void PatRect(HDC hdc,int x,int y,int dx,int dy, PTRACKBAR ptb)
{
RECT rc;
rc.left = x;
rc.top = y;
rc.right = x + dx;
rc.bottom = y + dy;
if (ISVERT(ptb))
FlipRect(&rc);
ExtTextOut(hdc,0,0,ETO_OPAQUE,&rc,NULL,0,NULL);
}
#define TBInvalidateRect(hwnd, prc, bErase, ptb) VertInvalidateRect(hwnd, prc, bErase, ISVERT(ptb))
void VertInvalidateRect(HWND hwnd, LPRECT qrc, BOOL b, BOOL fVert)
{
RECT rc;
rc = *qrc;
if (fVert) FlipRect(&rc);
InvalidateRect(hwnd, &rc, b);
}
#define TBDrawEdge(hdc, prc, uType, grfFlags, ptb, hTheme, iPartId, iStateId) VertDrawEdge(hdc, prc, uType, grfFlags, ISVERT(ptb), hTheme, iPartId, iStateId)
// VertDrawEdge is theme aware (RENDERS)
void VertDrawEdge(HDC hdc, LPRECT qrc, UINT edgeType, UINT grfFlags,
BOOL fVert, HTHEME hTheme, int iPartId, int iStateId)
{
RECT temprc;
UINT uFlags = grfFlags;
temprc = *qrc;
if (fVert) {
FlipRect(&temprc);
if (!(uFlags & BF_DIAGONAL)) {
if (grfFlags & BF_TOP) uFlags |= BF_LEFT;
else uFlags &= ~BF_LEFT;
if (grfFlags & BF_LEFT) uFlags |= BF_TOP;
else uFlags &= ~BF_TOP;
if (grfFlags & BF_BOTTOM) uFlags |= BF_RIGHT;
else uFlags &= ~BF_RIGHT;
if (grfFlags & BF_RIGHT) uFlags |= BF_BOTTOM;
else uFlags &= ~BF_BOTTOM;
} else {
if ((grfFlags & (BF_BOTTOM | BF_RIGHT)) == (BF_BOTTOM | BF_RIGHT)) {
uFlags = BF_TOP | BF_LEFT;
if (edgeType == EDGE_RAISED) {
edgeType = EDGE_SUNKEN;
} else {
edgeType = EDGE_RAISED;
}
uFlags |= grfFlags & (~BF_RECT);
uFlags ^= BF_SOFT;
}
}
}
if (hTheme)
{
DrawThemeBackground(hTheme, hdc, iPartId, iStateId, &temprc, 0);
}
else
{
DrawEdge(hdc, &temprc, edgeType, uFlags);
}
}
void TBBitBlt(HDC hdc1, int x1, int y1, int w, int h,
HDC hdc2, int x2, int y2, DWORD rop, PTRACKBAR ptb)
{
if (ISVERT(ptb))
BitBlt(hdc1, y1, x1, h, w, hdc2, x2, y2, rop);
else
BitBlt(hdc1, x1, y1, w, h, hdc2, x2, y2, rop);
}
#define TBPatBlt(hdc1, x1, y1, w, h, rop, ptb) VertPatBlt(hdc1, x1, y1, w, h, rop, ISVERT(ptb), NULL, 0, 0)
// VertPatBlt is theme aware (RENDERS)
void VertPatBlt(HDC hdc1, int x1, int y1, int w, int h,
DWORD rop, BOOL fVert, HTHEME hTheme, int iPartId, int iStateId)
{
if (hTheme)
{
RECT rc;
if (fVert)
SetRect(&rc, y1, x1, h, w);
else
SetRect(&rc, x1, y1, w, h);
DrawThemeBackground(hTheme, hdc1, iPartId, iStateId, &rc, 0);
}
else
{
if (fVert)
PatBlt(hdc1, y1, x1, h, w, rop);
else
PatBlt(hdc1, x1, y1, w, h, rop);
}
}
// DrawTic is theme aware (RENDERS)
void DrawTic(PTRACKBAR ptb, int x, int y, int dir)
{
if (dir == -1) y -= TICKHEIGHT;
if (ptb->hTheme)
{
COLORREF cr = 0;
GetThemeColor(ptb->hTheme, ISVERT(ptb) ? TKP_TICSVERT : TKP_TICS, TSS_NORMAL, TMT_COLOR, &cr);
SetBkColor(ptb->hdc, cr);
}
else
{
SetBkColor(ptb->hdc, g_clrBtnText);
}
PatRect(ptb->hdc,x,y,1,TICKHEIGHT, ptb);
}
// dir = direction multiplier (drawing up or down)
// yTic = where (vertically) to draw the line of tics
void DrawTicsOneLine(PTRACKBAR ptb, int dir, int yTic)
{
PDWORD pTics;
int iPos;
int i;
DrawTic(ptb, ptb->rc.left, yTic, dir); // first
DrawTic(ptb, ptb->rc.left, yTic+ (dir * 1), dir);
DrawTic(ptb, ptb->rc.right-1, yTic, dir); // last
DrawTic(ptb, ptb->rc.right-1, yTic+ (dir * 1), dir);
// those inbetween
pTics = ptb->pTics;
if (ptb->ticFreq && pTics) {
for (i = 0; i < ptb->nTics; ++i) {
if (((i+1) % ptb->ticFreq) == 0) {
iPos = TBLogToPhys(ptb,pTics[i]);
DrawTic(ptb, iPos, yTic, dir);
}
}
}
// draw the selection range (triangles)
if ((ptb->Flags & TBF_SELECTION) &&
(ptb->lSelStart <= ptb->lSelEnd) && (ptb->lSelEnd >= ptb->lLogMin)) {
SetBkColor(ptb->hdc, g_clrBtnText);
iPos = TBLogToPhys(ptb,ptb->lSelStart);
for (i = 0; i < TICKHEIGHT; i++)
PatRect(ptb->hdc,iPos-i,yTic+(dir==1 ? i : -TICKHEIGHT),
1,TICKHEIGHT-i, ptb);
iPos = TBLogToPhys(ptb,ptb->lSelEnd);
for (i = 0; i < TICKHEIGHT; i++)
PatRect(ptb->hdc,iPos+i,yTic+(dir==1 ? i : -TICKHEIGHT),
1,TICKHEIGHT-i, ptb);
}
}
/* DrawTics() */
/* There is always a tick at the beginning and end of the bar, but you can */
/* add some more of your own with a TBM_SETTIC message. This draws them. */
/* They are kept in an array whose handle is a window word. The first */
/* element is the number of extra ticks, and then the positions. */
void DrawTics(PTRACKBAR ptb)
{
// do they even want this?
if (ptb->ci.style & TBS_NOTICKS) return;
if ((ptb->ci.style & TBS_BOTH) || !(ptb->ci.style & TBS_TOP)) {
DrawTicsOneLine(ptb, 1, ptb->rc.bottom + 1);
}
if ((ptb->ci.style & (TBS_BOTH | TBS_TOP))) {
DrawTicsOneLine(ptb, -1, ptb->rc.top - 1);
}
}
void GetChannelRect(PTRACKBAR ptb, LPRECT lprc)
{
int iwidth, iheight;
if (!lprc)
return;
lprc->left = ptb->rc.left - ptb->iThumbWidth / 2;
iwidth = ptb->iSizePhys + ptb->iThumbWidth - 1;
lprc->right = lprc->left + iwidth;
if (ptb->ci.style & TBS_ENABLESELRANGE) {
iheight = ptb->iThumbHeight / 4 * 3; // this is Scrollheight
} else {
iheight = 4;
}
lprc->top = (ptb->rc.top + ptb->rc.bottom - iheight) /2;
if (!(ptb->ci.style & TBS_BOTH))
if (ptb->ci.style & TBS_TOP) lprc->top++;
else lprc->top--;
lprc->bottom = lprc->top + iheight;
}
/* This draws the track bar itself */
// DrawChannel is theme aware (RENDERS)
void DrawChannel(PTRACKBAR ptb, LPRECT lprc)
{
TBDrawEdge(ptb->hdc, lprc, EDGE_SUNKEN, BF_RECT,ptb, ptb->hTheme, ISVERT(ptb) ? TKP_TRACKVERT : TKP_TRACK, TRS_NORMAL);
if (!ptb->hTheme)
{
SetBkColor(ptb->hdc, g_clrBtnHighlight);
// Fill the center
PatRect(ptb->hdc, lprc->left+2, lprc->top+2, (lprc->right-lprc->left)-4,
(lprc->bottom-lprc->top)-4, ptb);
// now highlight the selection range
if ((ptb->Flags & TBF_SELECTION) &&
(ptb->lSelStart <= ptb->lSelEnd) && (ptb->lSelEnd > ptb->lLogMin)) {
int iStart, iEnd;
iStart = TBLogToPhys(ptb,ptb->lSelStart);
iEnd = TBLogToPhys(ptb,ptb->lSelEnd);
if (iStart + 2 <= iEnd) {
SetBkColor(ptb->hdc, g_clrHighlight);
PatRect(ptb->hdc, iStart+1, lprc->top+3,
iEnd-iStart-1, (lprc->bottom-lprc->top)-6, ptb);
}
}
}
}
// DrawThumb is theme aware (RENDERS)
void DrawThumb(PTRACKBAR ptb, LPRECT lprc, BOOL fSelected)
{
// iDpt direction from middle to point of thumb
// a negative value inverts things.
// this allows one code path..
int iDpt = 0;
int i = 0; // size of point triangle
int iYpt = 0; // vertical location of tip;
int iXmiddle = 0;
int icount; // just a loop counter
UINT uEdgeFlags = 0;
RECT rcThumb = *lprc;
if (ptb->Flags & TBF_NOTHUMB ||
ptb->ci.style & TBS_NOTHUMB) // If no thumb, just leave.
return;
ASSERT(ptb->iThumbHeight >= MIN_THUMB_HEIGHT);
ASSERT(ptb->iThumbWidth > 1);
if (!ptb->hTheme)
{
// draw the rectangle part
if (!(ptb->ci.style & TBS_BOTH)) {
int iMiddle;
// do -3 because wThumb is odd (triangles ya know)
// and because draw rects draw inside the rects passed.
// actually should be (width-1)/2-1, but this is the same...
i = (ptb->iThumbWidth - 3) / 2;
iMiddle = ptb->iThumbHeight / 2 + rcThumb.top;
//draw the rectangle part
if (ptb->ci.style & TBS_TOP) {
iMiddle++; //correction because drawing routines
iDpt = -1;
rcThumb.top += (i+1);
uEdgeFlags = BF_SOFT | BF_LEFT | BF_RIGHT | BF_BOTTOM;
} else {
iDpt = 1;
rcThumb.bottom -= (i+1);
// draw on the inside, not on the bottom and rt edge
uEdgeFlags = BF_SOFT | BF_LEFT | BF_RIGHT | BF_TOP;
}
iYpt = iMiddle + (iDpt * (ptb->iThumbHeight / 2));
iXmiddle = rcThumb.left + i;
} else {
uEdgeFlags = BF_SOFT | BF_RECT;
}
// fill in the center
if (fSelected || !IsWindowEnabled(ptb->ci.hwnd)) {
HBRUSH hbrTemp;
// draw the dithered insides;
hbrTemp = SelectObject(ptb->hdc, g_hbrMonoDither);
if (hbrTemp) {
SetTextColor(ptb->hdc, g_clrBtnHighlight);
SetBkColor(ptb->hdc, g_clrBtnFace);
TBPatBlt(ptb->hdc, rcThumb.left +2 , rcThumb.top,
rcThumb.right-rcThumb.left -4, rcThumb.bottom-rcThumb.top,
PATCOPY,ptb);
if (!(ptb->ci.style & TBS_BOTH)) {
for (icount = 1; icount <= i; icount++) {
TBPatBlt(ptb->hdc, iXmiddle-icount+1,
iYpt - (iDpt*icount),
icount*2, 1, PATCOPY, ptb);
}
}
SelectObject(ptb->hdc, hbrTemp);
}
} else {
SetBkColor(ptb->hdc, g_clrBtnFace);
PatRect(ptb->hdc, rcThumb.left+2, rcThumb.top,
rcThumb.right-rcThumb.left-4, rcThumb.bottom-rcThumb.top, ptb);
if (!(ptb->ci.style & TBS_BOTH)) {
for (icount = 1; icount <= i; icount++) {
PatRect(ptb->hdc, iXmiddle-icount+1,
iYpt - (iDpt*icount),
icount*2, 1, ptb);
}
}
}
}
if (ptb->hTheme)
{
int iPartId;
// States in overriding order
int iStateId = TUS_NORMAL;
if (ISVERT(ptb))
{
if (ptb->ci.style & TBS_BOTH)
{
iPartId = TKP_THUMBVERT;
}
else if (ptb->ci.style & TBS_LEFT)
{
iPartId = TKP_THUMBLEFT;
}
else
{
iPartId = TKP_THUMBRIGHT;
}
}
else
{
if (ptb->ci.style & TBS_BOTH)
{
iPartId = TKP_THUMB;
}
else if (ptb->ci.style & TBS_TOP)
{
iPartId = TKP_THUMBTOP;
}
else
{
iPartId = TKP_THUMBBOTTOM;
}
}
#ifdef DEBUG
if (!IsThemePartDefined(ptb->hTheme, iPartId, 0))
DebugMsg(DM_WARNING, TEXT("WARNING: Trackbar_Drawthumb: Theme Part not defined: %d\n"), iPartId);
#endif
if (ptb->ci.hwnd == GetFocus() && !(CCGetUIState(&(ptb->ci)) & UISF_HIDEFOCUS))
iStateId = TUS_FOCUSED;
if (ptb->bThumbHot)
iStateId = TUS_HOT;
if (fSelected)
iStateId = TUS_PRESSED;
if (ptb->ci.style & WS_DISABLED)
iStateId = TUS_DISABLED;
// Thumb and ThumbVert parts share the same enum values
TBDrawEdge(ptb->hdc, &rcThumb, EDGE_RAISED, uEdgeFlags, ptb, ptb->hTheme, iPartId, iStateId);
}
else
{
TBDrawEdge(ptb->hdc, &rcThumb, EDGE_RAISED, uEdgeFlags, ptb, NULL, 0, 0);
}
if (!ptb->hTheme)
{
//now draw the point
if (!(ptb->ci.style & TBS_BOTH)) {
UINT uEdgeFlags2;
// uEdgeFlags is now used to switch between top and bottom.
// we'll or it in with the diagonal and left/right flags below
if (ptb->ci.style & TBS_TOP) {
rcThumb.bottom = rcThumb.top + 1;
rcThumb.top = rcThumb.bottom - (i + 2);
uEdgeFlags = BF_TOP | BF_RIGHT | BF_DIAGONAL | BF_SOFT;
uEdgeFlags2 = BF_BOTTOM | BF_RIGHT | BF_DIAGONAL;
} else {
rcThumb.top = rcThumb.bottom - 1;
rcThumb.bottom = rcThumb.top + (i + 2);
uEdgeFlags = BF_TOP | BF_LEFT | BF_DIAGONAL | BF_SOFT;
uEdgeFlags2 = BF_BOTTOM | BF_LEFT | BF_DIAGONAL;
}
rcThumb.right = rcThumb.left + (i + 2);
// do the left side first
TBDrawEdge(ptb->hdc, &rcThumb, EDGE_RAISED, uEdgeFlags , ptb, NULL, 0, 0);
// then do th right side
OffsetRect(&rcThumb, i + 1, 0);
TBDrawEdge(ptb->hdc, &rcThumb, EDGE_RAISED, uEdgeFlags2 , ptb, NULL, 0, 0);
}
}
}
void TBInvalidateAll(PTRACKBAR ptb)
{
if (ptb) {
TBChanged(ptb, TBC_ALL);
InvalidateRect(ptb->ci.hwnd, NULL, FALSE);
}
}
void MoveThumb(PTRACKBAR ptb, LONG lPos)
{
long lOld = ptb->lLogPos;
TBInvalidateRect(ptb->ci.hwnd, &ptb->rcThumb, FALSE,ptb);
ptb->lLogPos = BOUND(lPos,ptb->lLogMin,ptb->lLogMax);
ptb->rcThumb.left = TBLogToPhys(ptb, ptb->lLogPos) - ptb->iThumbWidth / 2;
ptb->rcThumb.right = ptb->rcThumb.left + ptb->iThumbWidth;
TBInvalidateRect(ptb->ci.hwnd, &ptb->rcThumb, FALSE,ptb);
TBChanged(ptb, TBC_THUMB);
UpdateWindow(ptb->ci.hwnd);
if (lOld != ptb->lLogPos)
NotifyWinEvent(EVENT_OBJECT_VALUECHANGE, ptb->ci.hwnd, OBJID_CLIENT, 0);
}
void DrawFocus(PTRACKBAR ptb, HBRUSH hbrBackground)
{
RECT rc;
if (ptb->ci.hwnd == GetFocus() &&
!(CCGetUIState(&(ptb->ci)) & UISF_HIDEFOCUS))
{
SetBkColor(ptb->hdc, g_clrBtnHighlight);
GetClientRect(ptb->ci.hwnd, &rc);
// Successive calls to DrawFocusRect will invert it thereby erasing it.
// To avoid this, whenever we process WM_PAINT, we erase the focus rect ourselves
// before we draw it below.
if (hbrBackground)
FrameRect(ptb->hdc, &rc, hbrBackground);
DrawFocusRect(ptb->hdc, &rc);
}
}
void DoAutoTics(PTRACKBAR ptb)
{
LONG *pl;
LONG l;
if (!(ptb->ci.style & TBS_AUTOTICKS))
return;
if (ptb->pTics)
LocalFree((HLOCAL)ptb->pTics);
ptb->nTics = (int)(ptb->lLogMax - ptb->lLogMin - 1);
if (ptb->nTics > 0)
ptb->pTics = (DWORD *)LocalAlloc(LPTR, sizeof(DWORD) * ptb->nTics);
else
ptb->pTics = NULL;
if (!ptb->pTics) {
ptb->nTics = 0;
return;
}
for (pl = (LONG *)ptb->pTics, l = ptb->lLogMin + 1; l < ptb->lLogMax; l++)
*pl++ = l;
}
void ValidateThumbHeight(PTRACKBAR ptb)
{
if (ptb->iThumbHeight < MIN_THUMB_HEIGHT)
ptb->iThumbHeight = MIN_THUMB_HEIGHT;
ptb->iThumbWidth = ptb->iThumbHeight / 2;
ptb->iThumbWidth |= 0x01; // make sure it's odd at at least 3
if (ptb->ci.style & TBS_ENABLESELRANGE) {
if (ptb->ci.style & TBS_FIXEDLENGTH) {
// half of 9/10
ptb->iThumbWidth = (ptb->iThumbHeight * 9) / 20;
ptb->iThumbWidth |= 0x01;
} else {
ptb->iThumbHeight += (ptb->iThumbWidth * 2) / 9;
}
}
}
void TBPositionBuddies(PTRACKBAR ptb)
{
POINT pt;
HWND hwndParent;
RECT rcBuddy;
RECT rcClient;
RECT rcChannel;
int yMid;
GetChannelRect(ptb, &rcChannel);
yMid = (rcChannel.top + rcChannel.bottom) / 2;
GetClientRect(ptb->ci.hwnd, &rcClient);
if (ISVERT(ptb))
FlipRect(&rcClient);
if (ptb->hwndBuddyLeft) {
GetClientRect(ptb->hwndBuddyLeft, &rcBuddy);
if (ISVERT(ptb))
FlipRect(&rcBuddy);
pt.y = yMid - ((RECTHEIGHT(rcBuddy))/2);
pt.x = rcClient.left - RECTWIDTH(rcBuddy) - g_cxEdge;
// x and y are now in trackbar's coordinates.
// convert them to the parent of the buddy's coordinates
hwndParent = GetParent(ptb->hwndBuddyLeft);
TBFlipPoint(ptb, &pt);
MapWindowPoints(ptb->ci.hwnd, hwndParent, &pt, 1);
SetWindowPos(ptb->hwndBuddyLeft, NULL, pt.x, pt.y, 0, 0, SWP_NOSIZE |SWP_NOZORDER | SWP_NOACTIVATE);
}
if (ptb->hwndBuddyRight) {
GetClientRect(ptb->hwndBuddyRight, &rcBuddy);
if (ISVERT(ptb))
FlipRect(&rcBuddy);
pt.y = yMid - ((RECTHEIGHT(rcBuddy))/2);
pt.x = rcClient.right + g_cxEdge;
// x and y are now in trackbar's coordinates.
// convert them to the parent of the buddy's coordinates
hwndParent = GetParent(ptb->hwndBuddyRight);
TBFlipPoint(ptb, &pt);
MapWindowPoints(ptb->ci.hwnd, hwndParent, &pt, 1);
SetWindowPos(ptb->hwndBuddyRight, NULL, pt.x, pt.y, 0, 0, SWP_NOSIZE |SWP_NOZORDER | SWP_NOACTIVATE);
}
}
void TBNukeBuffer(PTRACKBAR ptb)
{
if (ptb->hbmBuffer) {
DeleteObject(ptb->hbmBuffer);
ptb->hbmBuffer = NULL;
TBChanged(ptb, TBC_ALL); // Must do a full repaint
}
}
void TBResize(PTRACKBAR ptb)
{
GetClientRect(ptb->ci.hwnd, &ptb->rc);
if (ISVERT(ptb))
FlipRect(&ptb->rc);
if (!(ptb->ci.style & TBS_FIXEDLENGTH)) {
ptb->iThumbHeight = (g_cyHScroll * 4) / 3;
ValidateThumbHeight(ptb);
if ((ptb->iThumbHeight > MIN_THUMB_HEIGHT) && (ptb->rc.bottom < (int)ptb->iThumbHeight)) {
ptb->iThumbHeight = ptb->rc.bottom - 3*g_cyEdge; // top, bottom, and tic
if (ptb->ci.style & TBS_ENABLESELRANGE)
ptb->iThumbHeight = (ptb->iThumbHeight * 3 / 4);
ValidateThumbHeight(ptb);
}
} else {
ValidateThumbHeight(ptb);
}
if (ptb->ci.style & (TBS_BOTH | TBS_TOP) && !(ptb->ci.style & TBS_NOTICKS))
ptb->rc.top += TICKHEIGHT + BORDERSIZE + 3;
ptb->rc.top += BORDERSIZE;
ptb->rc.bottom = ptb->rc.top + ptb->iThumbHeight;
ptb->rc.left += (ptb->iThumbWidth + BORDERSIZE);
ptb->rc.right -= (ptb->iThumbWidth + BORDERSIZE);
ptb->rcThumb.top = ptb->rc.top;
ptb->rcThumb.bottom = ptb->rc.bottom;
// Figure out how much room we have to move the thumb in
ptb->iSizePhys = ptb->rc.right - ptb->rc.left;
// Elevator isn't there if there's no room.
if (ptb->iSizePhys == 0) {
// Lost our thumb.
ptb->Flags |= TBF_NOTHUMB;
ptb->iSizePhys = 1;
} else {
// Ah. We have a thumb.
ptb->Flags &= ~TBF_NOTHUMB;
}
TBNukeBuffer(ptb);
MoveThumb(ptb, ptb->lLogPos);
TBInvalidateAll(ptb);
TBPositionBuddies(ptb);
}
LRESULT TrackOnCreate(HWND hwnd, LPCREATESTRUCT lpCreate)
{
PTRACKBAR ptb;
#ifdef MAINWIN
DWORD exStyle = WS_EX_MW_UNMANAGED_WINDOW;
#else
DWORD exStyle = 0;
#endif
InitDitherBrush();
InitGlobalColors();
// Get us our window structure.
ptb = (PTRACKBAR)LocalAlloc(LPTR, sizeof(TRACKBAR));
if (!ptb)
return -1;
SetWindowPtr(hwnd, 0, ptb);
CIInitialize(&ptb->ci, hwnd, lpCreate);
ptb->Cmd = (UINT)-1;
ptb->lLogMax = 100;
ptb->ticFreq = 1;
// ptb->hbmBuffer = 0;
ptb->lPageSize = -1;
ptb->lLineSize = 1;
// initial size;
ptb->iThumbHeight = (g_cyHScroll * 4) / 3;
if (g_fDBCSInputEnabled)
ptb->hPrevImc = ImmAssociateContext(hwnd, 0L);
if (ISVERT(ptb))
{
if (ptb->ci.style & TBS_TOP)
{
ptb->uTipSide = TBTS_RIGHT;
}
else
{
ptb->uTipSide = TBTS_LEFT;
}
}
else
{
if (ptb->ci.style & TBS_TOP)
{
ptb->uTipSide = TBTS_BOTTOM;
}
else
{
ptb->uTipSide = TBTS_TOP;
}
}
if (ptb->ci.style & TBS_TOOLTIPS)
{
ptb->hwndToolTips = CreateWindowEx(exStyle,
c_szSToolTipsClass, TEXT(""),
WS_POPUP,
CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT,
ptb->ci.hwnd, NULL, HINST_THISDLL,
NULL);
if (ptb->hwndToolTips)
{
TOOLINFO ti;
// don't bother setting the rect because we'll do it below
// in FlushToolTipsMgr;
ti.cbSize = sizeof(ti);
ti.uFlags = TTF_TRACK | TTF_IDISHWND | TTF_CENTERTIP;
ti.hwnd = ptb->ci.hwnd;
ti.uId = (UINT_PTR)ptb->ci.hwnd;
ti.lpszText = LPSTR_TEXTCALLBACK;
ti.rect.left = ti.rect.top = ti.rect.bottom = ti.rect.right = 0; // update this on size
SendMessage(ptb->hwndToolTips, TTM_ADDTOOL, 0,
(LPARAM)(LPTOOLINFO)&ti);
}
else
ptb->ci.style &= ~(TBS_TOOLTIPS);
}
// Initialize themes. No themese for owner drawn tab controls
ptb->hTheme = OpenThemeData(ptb->ci.hwnd, L"TrackBar");
ptb->bThumbHot = FALSE;
TBResize(ptb);
return 0;
}
void TrackOnNotify(PTRACKBAR ptb, LPNMHDR lpnm)
{
if (lpnm->hwndFrom == ptb->hwndToolTips)
{
switch (lpnm->code)
{
case TTN_NEEDTEXT:
#define lpttt ((LPTOOLTIPTEXT)lpnm)
wsprintf(lpttt->szText, TEXT("%d"), ptb->lLogPos);
default:
SendNotifyEx(ptb->ci.hwndParent, (HWND)-1,
lpnm->code, lpnm, ptb->ci.bUnicode);
break;
}
}
}
HWND TBSetBuddy(PTRACKBAR ptb, BOOL fLeft, HWND hwndBuddy)
{
HWND hwndOldBuddy;
if (fLeft)
{
hwndOldBuddy = ptb->hwndBuddyLeft;
ptb->hwndBuddyLeft = hwndBuddy;
}
else
{
hwndOldBuddy = ptb->hwndBuddyRight;
ptb->hwndBuddyRight = hwndBuddy;
}
TBResize(ptb);
return hwndOldBuddy;
}
// Theme helper
void TBRedrawThumb(PTRACKBAR ptb)
{
// Update display
TBInvalidateRect(ptb->ci.hwnd, &ptb->rcThumb, FALSE, ptb);
TBChanged(ptb, TBC_THUMB);
UpdateWindow(ptb->ci.hwnd);
}
// TrackBarWndProc is theme aware
LPARAM CALLBACK TrackBarWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
PTRACKBAR ptb;
PAINTSTRUCT ps;
HLOCAL h;
ptb = GetWindowPtr(hwnd, 0);
if (!ptb) {
if (uMsg == WM_CREATE)
return TrackOnCreate(hwnd, (LPCREATESTRUCT)lParam);
goto DoDefault;
}
// Track hot state for themes
if ((uMsg >= WM_MOUSEFIRST) && (uMsg <= WM_MOUSELAST))
{
TRACKMOUSEEVENT tme;
tme.cbSize = sizeof(tme);
tme.hwndTrack = hwnd;
tme.dwFlags = TME_LEAVE;
TrackMouseEvent(&tme);
}
switch (uMsg) {
case WM_MOUSELEAVE:
if (ptb->hTheme)
{
// Make sure thumb hot is turned off
if (ptb->bThumbHot)
{
ptb->bThumbHot = FALSE;
TBRedrawThumb(ptb);
}
}
break;
// If color depth changes, the old buffer is no longer any good
case WM_DISPLAYCHANGE:
TBNukeBuffer(ptb);
break;
case WM_WININICHANGE:
InitGlobalMetrics(wParam);
// fall through to WM_SIZE
case WM_SIZE:
TBResize(ptb);
break;
case WM_SYSCOLORCHANGE:
InitGlobalColors();
TBInvalidateAll(ptb);
break;
case WM_NOTIFYFORMAT:
return CIHandleNotifyFormat(&ptb->ci,lParam);
case WM_NOTIFY:
TrackOnNotify(ptb, (LPNMHDR)lParam);
break;
case WM_DESTROY:
TerminateDitherBrush();
if (ptb)
{
if (g_fDBCSInputEnabled)
ImmAssociateContext(hwnd, ptb->hPrevImc);
if ((ptb->ci.style & TBS_TOOLTIPS) && IsWindow(ptb->hwndToolTips))
{
DestroyWindow (ptb->hwndToolTips);
}
TBNukeBuffer(ptb);
if (ptb->pTics)
LocalFree((HLOCAL)ptb->pTics);
// Close theme
if (ptb->hTheme)
CloseThemeData(ptb->hTheme);
LocalFree((HLOCAL)ptb);
SetWindowPtr(hwnd, 0, 0);
}
break;
case WM_KILLFOCUS:
// Reset wheel scroll amount
gcWheelDelta = 0;
// fall-through
case WM_SETFOCUS:
ASSERT(gcWheelDelta == 0);
if (ptb)
TBInvalidateAll(ptb);
break;
case WM_ENABLE:
if (wParam) {
ptb->ci.style &= ~WS_DISABLED;
} else {
ptb->ci.style |= WS_DISABLED;
}
// Redraw all if themes are enabled since more is configurable
TBChanged(ptb, (ptb->hTheme) ? TBC_ALL : TBC_THUMB);
InvalidateRect(hwnd, NULL, FALSE);
break;
case WM_PRINTCLIENT:
case WM_PAINT: {
RECT rc;
HBITMAP hbmOld;
HDC hdc;
hdc = wParam ? (HDC)wParam : BeginPaint(hwnd, &ps);
//DebugMsg(DM_TRACE, "NumTics = %d", SendMessage(ptb->ci.hwnd, TBM_GETNUMTICS, 0, 0));
//ptb->hdc = GetDC(NULL);
ptb->hdc = CreateCompatibleDC(hdc);
if (!ptb->hbmBuffer) {
GetClientRect(hwnd, &rc);
ptb->hbmBuffer = CreateColorBitmap(rc.right, rc.bottom);
}
hbmOld = SelectObject(ptb->hdc, ptb->hbmBuffer);
FlushChanges(ptb);
//only copy the area that's changable.. ie the clip box
switch(GetClipBox(hdc, &rc)) {
case NULLREGION:
case ERROR:
GetClientRect(ptb->ci.hwnd, &rc);
}
BitBlt(hdc, rc.left, rc.top,
rc.right - rc.left, rc.bottom - rc.top,
ptb->hdc, rc.left, rc.top, SRCCOPY);
#ifdef TB_DEBUG
{
HDC hdcScreen;
RECT rcClient;
hdcScreen = GetDC(NULL);
GetClientRect(ptb->ci.hwnd, &rcClient);
BitBlt(hdcScreen, 0, 0, rcClient.right, rcClient.bottom, ptb->hdc, 0,0, SRCCOPY);
ReleaseDC(NULL, hdcScreen);
}
#endif
SelectObject(ptb->hdc, hbmOld);
DeleteDC(ptb->hdc);
//ReleaseDC(NULL, ptb->hdc);
if (wParam == 0)
EndPaint(hwnd, &ps);
ptb->hdc = NULL;
break;
}
case WM_GETDLGCODE:
return DLGC_WANTARROWS;
case WM_LBUTTONDOWN:
/* Give ourselves focus */
if (!(ptb->ci.style & WS_DISABLED)) {
SetFocus(hwnd); // REVIEW: we may not want to do this
TBTrackInit(ptb, lParam);
}
break;
case WM_LBUTTONUP:
// We're through doing whatever we were doing with the
// button down.
if (!(ptb->ci.style & WS_DISABLED)) {
TBTrackEnd(ptb);
if (GetCapture() == hwnd)
CCReleaseCapture(&ptb->ci);
}
break;
case WM_TIMER:
// The only way we get a timer message is if we're
// autotracking.
lParam = GetMessagePosClient(ptb->ci.hwnd, NULL);
// fall through to WM_MOUSEMOVE
case WM_MOUSEMOVE:
// We only care that the mouse is moving if we're
// tracking the bloody thing.
if (!(ptb->ci.style & WS_DISABLED))
{
if ((ptb->Cmd != (UINT)-1))
TBTrack(ptb, lParam);
else
{
// No user actions, track hot state if theme
if (ptb->hTheme)
{
// Check if mouse is currently over thumb
if (WTrackType(ptb, (LONG)lParam) == TB_THUMBTRACK)
{
if (!ptb->bThumbHot)
{
// Hot bit not set, set now and invalidate
ptb->bThumbHot = TRUE;
// Update display
TBRedrawThumb(ptb);
}
}
else
{
// Mouse not over thumb
if (ptb->bThumbHot)
{
ptb->bThumbHot = FALSE;
// Update display
TBRedrawThumb(ptb);
}
}
}
}
}
break;
case WM_CAPTURECHANGED:
// someone is stealing the capture from us
TBTrackEnd(ptb);
break;
case WM_KEYUP:
if (!(ptb->ci.style & WS_DISABLED)) {
// If key was any of the keyboard accelerators, send end
// track message when user up clicks on keyboard
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:
DoTrack(ptb, TB_ENDTRACK, 0);
break;
default:
break;
}
}
break;
case WM_KEYDOWN:
if (!(ptb->ci.style & WS_DISABLED)) {
// Swap the left and right arrow key if the control is mirrored.
wParam = RTLSwapLeftRightArrows(&ptb->ci, wParam);
// If TBS_DOWNISLEFT, then swap left/right or up/down
// depending on whether we are vertical or horizontal.
// Some horizontal trackbars (e.g.) prefer that
// UpArrow=TB_PAGEDOWN.
if (ptb->ci.style & TBS_DOWNISLEFT) {
if (ISVERT(ptb)) {
wParam = CCSwapKeys(wParam, VK_LEFT, VK_RIGHT);
} else {
wParam = CCSwapKeys(wParam, VK_UP, VK_DOWN);
wParam = CCSwapKeys(wParam, VK_PRIOR, VK_NEXT);
}
}
switch (wParam) {
case VK_HOME:
wParam = TB_TOP;
goto KeyTrack;
case VK_END:
wParam = TB_BOTTOM;
goto KeyTrack;
case VK_PRIOR:
wParam = TB_PAGEUP;
goto KeyTrack;
case VK_NEXT:
wParam = TB_PAGEDOWN;
goto KeyTrack;
case VK_LEFT:
case VK_UP:
wParam = TB_LINEUP;
goto KeyTrack;
case VK_RIGHT:
case VK_DOWN:
wParam = TB_LINEDOWN;
KeyTrack:
DoTrack(ptb, (int) wParam, 0);
//notify of navigation key usage
CCNotifyNavigationKeyUsage(&(ptb->ci), UISF_HIDEFOCUS);
break;
default:
break;
}
}
break;
case WM_MBUTTONDOWN:
SetFocus(hwnd);
break;
case WM_STYLECHANGED:
if (wParam == GWL_STYLE) {
ptb->ci.style = ((LPSTYLESTRUCT)lParam)->styleNew;
TBResize(ptb);
}
break;
case WM_UPDATEUISTATE:
{
DWORD dwUIStateMask = MAKEWPARAM(0xFFFF, UISF_HIDEFOCUS);
if (CCOnUIState(&(ptb->ci), WM_UPDATEUISTATE, wParam & dwUIStateMask, lParam))
InvalidateRect(hwnd, NULL, TRUE);
goto DoDefault;
}
case TBM_GETPOS:
return ptb->lLogPos;
case TBM_GETSELSTART:
return ptb->lSelStart;
case TBM_GETSELEND:
return ptb->lSelEnd;
case TBM_GETRANGEMIN:
return ptb->lLogMin;
case TBM_GETRANGEMAX:
return ptb->lLogMax;
case TBM_GETPTICS:
return (LRESULT)ptb->pTics;
case TBM_CLEARSEL:
ptb->Flags &= ~TBF_SELECTION;
ptb->lSelStart = -1;
ptb->lSelEnd = -1;
goto RedrawTB;
case TBM_CLEARTICS:
if (ptb->pTics)
LocalFree((HLOCAL)ptb->pTics);
ptb->pTics = NULL;
ptb->nTics = 0;
goto RedrawTB;
case TBM_GETTIC:
if (ptb->pTics == NULL || (int)wParam >= ptb->nTics)
return -1L;
return ptb->pTics[wParam];
case TBM_GETTICPOS:
if (ptb->pTics == NULL || (int)wParam >= ptb->nTics)
return -1L;
return TBLogToPhys(ptb,ptb->pTics[wParam]);
case TBM_GETNUMTICS:
if (ptb->ci.style & TBS_NOTICKS)
return 0;
if (ptb->ticFreq) {
// first and last +
return 2 + (ptb->nTics / ptb->ticFreq);
}
// if there's no ticFreq, then we fall down here.
// 2 for the first and last tics that we always draw
// when NOTICS isn't set.
return 2;
case TBM_SETTIC:
/* not a valid position */
if (((LONG)lParam) < ptb->lLogMin || ((LONG)lParam) > ptb->lLogMax)
break;
h = CCLocalReAlloc(ptb->pTics,
sizeof(DWORD) * (ptb->nTics + 1));
if (!h)
return (LONG)FALSE;
ptb->pTics = (PDWORD)h;
ptb->pTics[ptb->nTics++] = (DWORD)lParam;
TBInvalidateAll(ptb);
return (LONG)TRUE;
case TBM_SETTICFREQ:
ptb->ticFreq = (int) wParam;
DoAutoTics(ptb);
goto RedrawTB;
case TBM_SETPOS:
/* Only redraw if it will physically move */
if (wParam && TBLogToPhys(ptb, (DWORD) lParam) !=
TBLogToPhys(ptb, ptb->lLogPos))
MoveThumb(ptb, (DWORD) lParam);
else
ptb->lLogPos = BOUND((LONG)lParam,ptb->lLogMin,ptb->lLogMax);
break;
case TBM_SETSEL:
if (!(ptb->ci.style & TBS_ENABLESELRANGE)) break;
ptb->Flags |= TBF_SELECTION;
if (((LONG)(SHORT)LOWORD(lParam)) < ptb->lLogMin)
ptb->lSelStart = ptb->lLogMin;
else
ptb->lSelStart = (LONG)(SHORT)LOWORD(lParam);
if (((LONG)(SHORT)HIWORD(lParam)) > ptb->lLogMax)
ptb->lSelEnd = ptb->lLogMax;
else
ptb->lSelEnd = (LONG)(SHORT)HIWORD(lParam);
if (ptb->lSelEnd < ptb->lSelStart)
ptb->lSelEnd = ptb->lSelStart;
goto RedrawTB;
case TBM_SETSELSTART:
if (!(ptb->ci.style & TBS_ENABLESELRANGE)) break;
ptb->Flags |= TBF_SELECTION;
if (lParam < ptb->lLogMin)
ptb->lSelStart = ptb->lLogMin;
else
ptb->lSelStart = (LONG) lParam;
if (ptb->lSelEnd < ptb->lSelStart || ptb->lSelEnd == -1)
ptb->lSelEnd = ptb->lSelStart;
goto RedrawTB;
case TBM_SETSELEND:
if (!(ptb->ci.style & TBS_ENABLESELRANGE)) break;
ptb->Flags |= TBF_SELECTION;
if (lParam > ptb->lLogMax)
ptb->lSelEnd = ptb->lLogMax;
else
ptb->lSelEnd = (LONG) lParam;
if (ptb->lSelStart > ptb->lSelEnd || ptb->lSelStart == -1)
ptb->lSelStart = ptb->lSelEnd;
goto RedrawTB;
case TBM_SETRANGE:
ptb->lLogMin = (LONG)(SHORT)LOWORD(lParam);
ptb->lLogMax = (LONG)(SHORT)HIWORD(lParam);
if (ptb->lSelStart < ptb->lLogMin)
ptb->lSelStart = ptb->lLogMin;
if (ptb->lSelEnd > ptb->lLogMax)
ptb->lSelEnd = ptb->lLogMax;
DoAutoTics(ptb);
goto RedrawTB;
case TBM_SETRANGEMIN:
ptb->lLogMin = (LONG)lParam;
if (ptb->lSelStart < ptb->lLogMin)
ptb->lSelStart = ptb->lLogMin;
DoAutoTics(ptb);
goto RedrawTB;
case TBM_SETRANGEMAX:
ptb->lLogMax = (LONG)lParam;
if (ptb->lSelEnd > ptb->lLogMax)
ptb->lSelEnd = ptb->lLogMax;
DoAutoTics(ptb);
RedrawTB:
ptb->lLogPos = BOUND(ptb->lLogPos, ptb->lLogMin,ptb->lLogMax);
TBChanged(ptb, TBC_ALL);
/* Only redraw if flag says so */
if (wParam) {
InvalidateRect(hwnd, NULL, FALSE);
MoveThumb(ptb, ptb->lLogPos);
}
break;
case TBM_SETTHUMBLENGTH:
if (ptb->ci.style & TBS_FIXEDLENGTH) {
ptb->iThumbHeight = (UINT)wParam;
TBResize(ptb);
}
break;
case TBM_GETTHUMBLENGTH:
return ptb->iThumbHeight;
case TBM_SETPAGESIZE: {
LONG lOldPage = ptb->lPageSize == -1 ? (ptb->lLogMax - ptb->lLogMin)/5 : ptb->lPageSize;
ptb->lPageSize = (LONG)lParam;
return lOldPage;
}
case TBM_GETPAGESIZE:
return ptb->lPageSize == -1 ? (ptb->lLogMax - ptb->lLogMin)/5 : ptb->lPageSize;
case TBM_SETLINESIZE: {
LONG lOldLine = ptb->lLineSize;
ptb->lLineSize = (LONG)lParam;
return lOldLine;
}
case TBM_GETLINESIZE:
return ptb->lLineSize;
case TBM_GETTHUMBRECT:
if (lParam) {
*((LPRECT)lParam) = ptb->rcThumb;
if (ISVERT(ptb)) FlipRect((LPRECT)lParam);
}
break;
case TBM_GETTOOLTIPS:
return (LRESULT)ptb->hwndToolTips;
case TBM_SETTOOLTIPS:
ptb->hwndToolTips = (HWND)wParam;
break;
case TBM_SETTIPSIDE:
{
UINT uOldSide = ptb->uTipSide;
ptb->uTipSide = (UINT) wParam;
return uOldSide;
}
case TBM_GETCHANNELRECT:
GetChannelRect(ptb, (LPRECT)lParam);
break;
case TBM_SETBUDDY:
return (LRESULT)TBSetBuddy(ptb, (BOOL)wParam, (HWND)lParam);
case TBM_GETBUDDY:
return (LRESULT)(wParam ? ptb->hwndBuddyLeft : ptb->hwndBuddyRight);
case WM_GETOBJECT:
if( lParam == OBJID_QUERYCLASSNAMEIDX )
return MSAA_CLASSNAMEIDX_TRACKBAR;
goto DoDefault;
case WM_THEMECHANGED:
if (ptb->hTheme)
CloseThemeData(ptb->hTheme);
ptb->hTheme = OpenThemeData(ptb->ci.hwnd, L"TrackBar");
TBInvalidateAll(ptb);
break;
default:
if (uMsg == g_msgMSWheel)
{
int cDetants;
long lPos;
ULONG ulPos;
int iWheelDelta = (int)(short)HIWORD(wParam);
// Update count of scroll amount
gcWheelDelta -= iWheelDelta;
cDetants = gcWheelDelta / WHEEL_DELTA;
if (cDetants != 0)
{
gcWheelDelta %= WHEEL_DELTA;
}
if (wParam & (MK_SHIFT | MK_CONTROL))
goto DoDefault;
if (SHRT_MIN <= ptb->lLogPos && ptb->lLogPos <= SHRT_MAX)
{
// Update position based on the logical unit length of the trackbar
// The larger the spread, the more logical units traversed
int cMult = (ptb->lLogMax - ptb->lLogMin) / 50;
if (cMult == 0)
cMult = 1;
lPos = ptb->lLogPos + (cDetants * cMult);
lPos = BOUND(lPos, ptb->lLogMin, ptb->lLogMax);
ulPos = BOUND(lPos, SHRT_MIN, SHRT_MAX);
if ((long) ulPos != ptb->lLogPos)
{
MoveThumb(ptb, (long) ulPos);
DoTrack(ptb, TB_THUMBPOSITION, ulPos);
}
}
return TRUE;
}
else
{
LRESULT lres;
if (CCWndProc(&ptb->ci, uMsg, wParam, lParam, &lres))
return lres;
}
DoDefault:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0L;
}
/* DoTrack() */
void DoTrack(PTRACKBAR ptb, int cmd, DWORD dwPos)
{
LONG dpos;
switch(cmd) {
case TB_LINEDOWN:
dpos = ptb->lLineSize;
goto DMoveThumb;
case TB_LINEUP:
dpos = -ptb->lLineSize;
goto DMoveThumb;
case TB_PAGEUP:
case TB_PAGEDOWN:
if (ptb->lPageSize == -1) {
dpos = (ptb->lLogMax - ptb->lLogMin) / 5;
if (!dpos)
dpos = 1;
} else {
dpos = ptb->lPageSize;
}
if (cmd == TB_PAGEUP)
dpos *= -1;
DMoveThumb: // move delta
MoveThumb(ptb, ptb->lLogPos + dpos);
break;
case TB_BOTTOM:
dpos = ptb->lLogMax; // the BOUND will take care of this;
goto ABSMoveThumb;
case TB_TOP:
dpos = ptb->lLogMin; // the BOUND will take care of this;
ABSMoveThumb: // move absolute
MoveThumb(ptb, dpos);
break;
default: // do nothing
break;
}
// note: we only send back a WORD worth of the position.
if (ISVERT(ptb)) {
FORWARD_WM_VSCROLL(ptb->ci.hwndParent, ptb->ci.hwnd, cmd, LOWORD(dwPos), SendMessage);
} else
FORWARD_WM_HSCROLL(ptb->ci.hwndParent, ptb->ci.hwnd, cmd, LOWORD(dwPos), SendMessage);
}
/* WTrackType() */
WORD WTrackType(PTRACKBAR ptb, LONG lParam)
{
POINT pt;
pt.x = GET_X_LPARAM(lParam);
pt.y = GET_Y_LPARAM(lParam);
if (ptb->Flags & TBF_NOTHUMB ||
ptb->ci.style & TBS_NOTHUMB) // If no thumb, just leave.
return 0;
if (ISVERT(ptb)) {
// put point in virtual coordinates
int temp;
temp = pt.x;
pt.x = pt.y;
pt.y = temp;
}
if (PtInRect(&ptb->rcThumb, pt))
return TB_THUMBTRACK;
if (!PtInRect(&ptb->rc, pt))
return 0;
if (pt.x >= ptb->rcThumb.left)
return TB_PAGEDOWN;
else
return TB_PAGEUP;
}
/* TBTrackInit() */
void TBTrackInit(PTRACKBAR ptb, LPARAM lParam)
{
WORD wCmd;
if (ptb->Flags & TBF_NOTHUMB ||
ptb->ci.style & TBS_NOTHUMB) // No thumb: just leave.
return;
wCmd = WTrackType(ptb, (LONG) lParam);
if (!wCmd)
return;
SetCapture(ptb->ci.hwnd);
ptb->Cmd = wCmd;
ptb->dwDragPos = (DWORD)-1;
// Set up for auto-track (if needed).
if (wCmd != TB_THUMBTRACK) {
// Set our timer up
SetTimer(ptb->ci.hwnd, TIMER_ID, REPEATTIME, NULL);
} else {
int xPos;
// thumb tracking...
// store the offset between the cursor's position and the center of the thumb
xPos = TBLogToPhys(ptb, ptb->lLogPos);
ptb->dwDragOffset = (ISVERT(ptb) ? HIWORD(lParam) : LOWORD(lParam)) - xPos;
if (ptb->hwndToolTips) {
TOOLINFO ti;
// don't bother setting the rect because we'll do it below
// in FlushToolTipsMgr;
ti.cbSize = sizeof(ti);
ti.uFlags = TTF_TRACK | TTF_CENTERTIP;
ti.hwnd = ptb->ci.hwnd;
ti.uId = (UINT_PTR)ptb->ci.hwnd;
SendMessage(ptb->hwndToolTips, TTM_TRACKACTIVATE, (WPARAM)TRUE, (LPARAM)&ti);
}
}
TBTrack(ptb, lParam);
}
/* EndTrack() */
void TBTrackEnd(PTRACKBAR ptb)
{
// Decide how we're ending this thing.
if (ptb->Cmd == TB_THUMBTRACK) {
if (ptb->hwndToolTips)
SendMessage(ptb->hwndToolTips, TTM_TRACKACTIVATE, (WPARAM)FALSE, 0);
DoTrack(ptb, TB_THUMBPOSITION, ptb->dwDragPos);
}
KillTimer(ptb->ci.hwnd, TIMER_ID);
// Always send TB_ENDTRACK message if there's some sort of command tracking.
if (ptb->Cmd != (UINT)-1) {
DoTrack(ptb, TB_ENDTRACK, 0);
// Nothing going on.
ptb->Cmd = (UINT)-1;
}
MoveThumb(ptb, ptb->lLogPos);
}
#define TBTS_RIGHTLEFT 1 // low bit means it's on the right or left
void TBTrack(PTRACKBAR ptb, LPARAM lParam)
{
DWORD dwPos;
WORD pos;
// See if we're tracking the thumb
if (ptb->Cmd == TB_THUMBTRACK) {
pos = (ISVERT(ptb)) ? HIWORD(lParam) : LOWORD(lParam);
pos -= (WORD) ptb->dwDragOffset;
dwPos = TBPhysToLog(ptb, (int)(SHORT)pos);
// Tentative position changed -- notify the guy.
if (dwPos != ptb->dwDragPos) {
ptb->dwDragPos = dwPos;
MoveThumb(ptb, dwPos);
DoTrack(ptb, TB_THUMBTRACK, dwPos);
}
if (ptb->hwndToolTips) {
RECT rc;
POINT pt;
int iPixel;
UINT uTipSide = ptb->uTipSide;
// find the center of the window
GetClientRect(ptb->ci.hwnd, &rc);
pt.x = rc.right / 2;
pt.y = rc.bottom / 2;
//find the position of the thumb
iPixel = TBLogToPhys(ptb, dwPos);
if (ISVERT(ptb)) {
pt.y = iPixel;
uTipSide |= TBTS_RIGHTLEFT;
} else {
pt.x = iPixel;
uTipSide &= ~TBTS_RIGHTLEFT;
}
// move it out to the requested side
switch (uTipSide) {
case TBTS_TOP:
pt.y = -1;
break;
case TBTS_LEFT:
pt.x = -1;
break;
case TBTS_BOTTOM:
pt.y = rc.bottom + 1;
break;
case TBTS_RIGHT:
pt.x = rc.right + 1;
break;
}
// map it to screen coordinates
MapWindowPoints(ptb->ci.hwnd, HWND_DESKTOP, &pt, 1);
SendMessage(ptb->hwndToolTips, TTM_TRACKPOSITION, 0, MAKELONG(pt.x, pt.y));
}
}
else {
if (ptb->Cmd != WTrackType(ptb, (LONG) lParam))
return;
DoTrack(ptb, ptb->Cmd, 0);
}
}
// FlushChanges is theme aware (RENDERS)
void FlushChanges(PTRACKBAR ptb)
{
HBRUSH hbr;
NMCUSTOMDRAW nmcd;
hbr = FORWARD_WM_CTLCOLORSTATIC(ptb->ci.hwndParent, ptb->hdc, ptb->ci.hwnd, SendMessage);
if (hbr)
{
RECT rc;
BOOL fClear = FALSE;
if ( ptb->wDirtyFlags == TBC_ALL )
{
GetClientRect(ptb->ci.hwnd, &rc);
fClear = TRUE;
}
else if (ptb->wDirtyFlags & TBC_THUMB)
{
rc = ptb->rc;
rc.left = 0;
rc.right += ptb->iThumbWidth;
if (ISVERT(ptb))
FlipRect(&rc);
fClear = TRUE;
}
// Background fill
if (fClear)
{
FillRect(ptb->hdc, &rc, hbr);
}
}
nmcd.hdc = ptb->hdc;
if (ptb->ci.hwnd == GetFocus())
nmcd.uItemState = CDIS_FOCUS;
else
nmcd.uItemState = 0;
nmcd.lItemlParam = 0;
ptb->ci.dwCustom = CICustomDrawNotify(&ptb->ci, CDDS_PREPAINT, &nmcd);
// for skip default, no other flags make sense.. only allow that one
if (!(ptb->ci.dwCustom == CDRF_SKIPDEFAULT))
{
DWORD dwRet = 0;
// do the actual drawing
if (nmcd.uItemState & CDIS_FOCUS)
{
DrawFocus(ptb, hbr);
}
nmcd.uItemState = 0;
if (ptb->wDirtyFlags & TBC_TICS)
{
nmcd.dwItemSpec = TBCD_TICS;
dwRet = CICustomDrawNotify(&ptb->ci, CDDS_ITEMPREPAINT, &nmcd);
if (!(dwRet == CDRF_SKIPDEFAULT))
{
DrawTics(ptb);
if (dwRet & CDRF_NOTIFYPOSTPAINT)
{
nmcd.dwItemSpec = TBCD_TICS;
CICustomDrawNotify(&ptb->ci, CDDS_ITEMPOSTPAINT, &nmcd);
}
}
}
if (ptb->wDirtyFlags & TBC_THUMB)
{
// the channel
GetChannelRect(ptb, &nmcd.rc);
if (ISVERT(ptb))
FlipRect(&nmcd.rc);
nmcd.dwItemSpec = TBCD_CHANNEL;
dwRet = CICustomDrawNotify(&ptb->ci, CDDS_ITEMPREPAINT, &nmcd);
if (!(dwRet == CDRF_SKIPDEFAULT))
{
// flip it back from the last notify
if (ISVERT(ptb))
FlipRect(&nmcd.rc);
// the actual drawing
DrawChannel(ptb, &nmcd.rc);
if (dwRet & CDRF_NOTIFYPOSTPAINT)
{
if (ISVERT(ptb))
FlipRect(&nmcd.rc);
nmcd.dwItemSpec = TBCD_CHANNEL;
CICustomDrawNotify(&ptb->ci, CDDS_ITEMPOSTPAINT, &nmcd);
}
}
// the thumb
nmcd.rc = ptb->rcThumb;
if (ptb->Cmd == TB_THUMBTRACK)
{
nmcd.uItemState = CDIS_SELECTED;
}
if (ISVERT(ptb))
FlipRect(&nmcd.rc);
nmcd.dwItemSpec = TBCD_THUMB;
dwRet = CICustomDrawNotify(&ptb->ci, CDDS_ITEMPREPAINT, &nmcd);
if (!(dwRet == CDRF_SKIPDEFAULT))
{
if (ISVERT(ptb))
FlipRect(&nmcd.rc);
// the actual drawing
DrawThumb(ptb, &nmcd.rc, nmcd.uItemState & CDIS_SELECTED);
if (dwRet & CDRF_NOTIFYPOSTPAINT)
{
if (ISVERT(ptb))
FlipRect(&nmcd.rc);
nmcd.dwItemSpec = TBCD_THUMB;
CICustomDrawNotify(&ptb->ci, CDDS_ITEMPOSTPAINT, &nmcd);
}
}
}
ptb->wDirtyFlags = 0;
// notify parent afterwards if they want us to
if (ptb->ci.dwCustom & CDRF_NOTIFYPOSTPAINT)
{
CICustomDrawNotify(&ptb->ci, CDDS_POSTPAINT, &nmcd);
}
}
#ifdef TB_DEBUG
DebugMsg(DM_TRACE, TEXT("DrawDone"));
{
HDC hdcScreen;
RECT rcClient;
hdcScreen = GetDC(NULL);
GetClientRect(ptb->ci.hwnd, &rcClient);
BitBlt(hdcScreen, 200, 0, 200 + rcClient.right, rcClient.bottom, ptb->hdc, 0,0, SRCCOPY);
ReleaseDC(NULL, hdcScreen);
}
#endif
}
Reference in a new issue Copy permalink