//----------------------------------------------------------
//
// BUGBUG: make sure this stuff really works with the DWORD
// ranges
//
//----------------------------------------------------------
#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
CONTROLINFO 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.
#if defined(FE_IME) || !defined(WINNT)
HIMC hPrevImc; // previous input context handle
#endif
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 NEAR PASCAL DoTrack(PTRACKBAR, int, DWORD);
WORD NEAR PASCAL WTrackType(PTRACKBAR, LONG);
void NEAR PASCAL TBTrackInit(PTRACKBAR, LPARAM);
void NEAR PASCAL TBTrackEnd(PTRACKBAR);
void NEAR PASCAL TBTrack(PTRACKBAR, LPARAM);
void NEAR PASCAL DrawThumb(PTRACKBAR, LPRECT, BOOL);
HBRUSH NEAR PASCAL SelectColorObjects(PTRACKBAR, BOOL);
void NEAR PASCAL 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 FAR CALLBACK TrackBarWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
void NEAR PASCAL 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 NEAR PASCAL 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 NEAR PASCAL 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 FAR PASCAL InitTrackBar(HINSTANCE hInstance)
{
WNDCLASS wc;
// See if we must register a window class
if (!GetClassInfo(hInstance, s_szSTrackBarClass, &wc)) {
#ifndef WIN32
extern LRESULT CALLBACK _TrackBarWndProc(HWND, UINT, WPARAM, LPARAM);
wc.lpfnWndProc = _TrackBarWndProc;
#else
wc.lpfnWndProc = TrackBarWndProc;
#endif
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);
return RegisterClass(&wc);
}
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 NEAR PASCAL 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 FAR PASCAL 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) VertDrawEdge(hdc, prc, uType, grfFlags, ISVERT(ptb))
void FAR PASCAL VertDrawEdge(HDC hdc, LPRECT qrc, UINT edgeType, UINT grfFlags,
BOOL fVert)
{
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;
}
}
}
DrawEdge(hdc, &temprc, edgeType, uFlags);
}
void NEAR PASCAL 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))
void FAR PASCAL VertPatBlt(HDC hdc1, int x1, int y1, int w, int h,
DWORD rop, BOOL fVert)
{
if (fVert)
PatBlt(hdc1, y1, x1, h, w, rop);
else
PatBlt(hdc1, x1, y1, w, h, rop);
}
void NEAR PASCAL DrawTic(PTRACKBAR ptb, int x, int y, int dir)
{
if (dir == -1) y -= TICKHEIGHT;
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 NEAR PASCAL 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 NEAR PASCAL 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 NEAR PASCAL 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 */
void NEAR PASCAL DrawChannel(PTRACKBAR ptb, LPRECT lprc)
{
TBDrawEdge(ptb->hdc, lprc, EDGE_SUNKEN, BF_RECT,ptb);
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);
}
}
}
void NEAR PASCAL 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;
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);
// 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);
}
}
}
TBDrawEdge(ptb->hdc, &rcThumb, EDGE_RAISED, uEdgeFlags, ptb);
//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);
// then do th right side
OffsetRect(&rcThumb, i + 1, 0);
TBDrawEdge(ptb->hdc, &rcThumb, EDGE_RAISED, uEdgeFlags2 , ptb);
}
}
void NEAR PASCAL TBInvalidateAll(PTRACKBAR ptb)
{
if (ptb) {
TBChanged(ptb, TBC_ALL);
InvalidateRect(ptb->ci.hwnd, NULL, FALSE);
}
}
void NEAR PASCAL 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)
MyNotifyWinEvent(EVENT_OBJECT_VALUECHANGE, ptb->ci.hwnd, OBJID_CLIENT, 0);
}
void NEAR PASCAL DrawFocus(PTRACKBAR ptb, HBRUSH hbrBackground)
{
RECT rc;
if (ptb->ci.hwnd == GetFocus()
#ifdef KEYBOARDCUES
&& !(CCGetUIState(&(ptb->ci)) & UISF_HIDEFOCUS)
#endif
)
{
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 NEAR PASCAL DoAutoTics(PTRACKBAR ptb)
{
LONG NEAR *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 NEAR *)LocalAlloc(LPTR, sizeof(DWORD) * ptb->nTics);
else
ptb->pTics = NULL;
if (!ptb->pTics) {
ptb->nTics = 0;
return;
}
for (pl = (LONG NEAR *)ptb->pTics, l = ptb->lLogMin + 1; l < ptb->lLogMax; l++)
*pl++ = l;
}
void NEAR PASCAL 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 NEAR PASCAL TBNukeBuffer(PTRACKBAR ptb)
{
if (ptb->hbmBuffer) {
DeleteObject(ptb->hbmBuffer);
ptb->hbmBuffer = NULL;
TBChanged(ptb, TBC_ALL); // Must do a full repaint
}
}
void NEAR PASCAL 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 NEAR PASCAL 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 defined(FE_IME) || !defined(WINNT)
if (g_fDBCSInputEnabled)
ptb->hPrevImc = ImmAssociateContext(hwnd, 0L);
#endif
#ifdef FEATURE_DEBUG
if (GetAsyncKeyState(VK_SHIFT) < 0 &&
GetAsyncKeyState(VK_CONTROL) < 0)
ptb->ci.style |= TBS_TOOLTIPS;
#endif
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);
}
TBResize(ptb);
#ifdef FEATURE_DEBUG
if (GetAsyncKeyState(VK_SHIFT) < 0 &&
GetAsyncKeyState(VK_CONTROL) < 0 )
{
HWND hwnd =
CreateWindowEx(WS_EX_STATICEDGE, TEXT("static"), TEXT("left"), WS_CHILD | WS_VISIBLE, 0, 0, 30, 20, GetParent(ptb->ci.hwnd), NULL, HINST_THISDLL, NULL);
HWND hwnd2 =
CreateWindowEx(WS_EX_STATICEDGE, TEXT("static"), TEXT("right"), WS_CHILD |WS_VISIBLE, 0, 0, 50, 20, GetParent(ptb->ci.hwnd), NULL, HINST_THISDLL, NULL);
SendMessage(ptb->ci.hwnd, TBM_SETBUDDY, TRUE, (LPARAM)hwnd);
SendMessage(ptb->ci.hwnd, TBM_SETBUDDY, FALSE, (LPARAM)hwnd2);
}
#endif
return 0;
}
void NEAR PASCAL 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;
}
LPARAM FAR 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;
}
switch (uMsg) {
// 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 defined(FE_IME) || !defined(WINNT)
if (g_fDBCSInputEnabled)
ImmAssociateContext(hwnd, ptb->hPrevImc);
#endif
if ((ptb->ci.style & TBS_TOOLTIPS) && IsWindow(ptb->hwndToolTips)) {
DestroyWindow (ptb->hwndToolTips);
}
TBNukeBuffer(ptb);
if (ptb->pTics)
LocalFree((HLOCAL)ptb->pTics);
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;
}
TBChanged(ptb, 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->Cmd != (UINT)-1) && (!(ptb->ci.style & WS_DISABLED)))
TBTrack(ptb, lParam);
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);
#ifdef KEYBOARDCUES
//notify of navigation key usage
CCNotifyNavigationKeyUsage(&(ptb->ci), UISF_HIDEFOCUS);
#endif
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;
#ifdef KEYBOARDCUES
case WM_UPDATEUISTATE:
{
DWORD dwUIStateMask = MAKEWPARAM(0xFFFF, UISF_HIDEFOCUS);
if (CCOnUIState(&(ptb->ci), WM_UPDATEUISTATE, wParam & dwUIStateMask, lParam))
InvalidateRect(hwnd, NULL, TRUE);
goto DoDefault;
}
#endif
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;
default:
if (uMsg == g_msgMSWheel) {
int iWheelDelta;
int cDetants;
long lPos;
ULONG ulPos;
if (g_bRunOnNT || g_bRunOnMemphis)
iWheelDelta = (int)(short)HIWORD(wParam);
else
iWheelDelta = (int)wParam;
// Update count of scroll amount
gcWheelDelta -= iWheelDelta;
cDetants = gcWheelDelta / WHEEL_DELTA;
if (cDetants != 0) {
gcWheelDelta %= WHEEL_DELTA;
}
if (g_bRunOnNT || g_bRunOnMemphis)
{
if (wParam & (MK_SHIFT | MK_CONTROL))
goto DoDefault;
}
else
{
if (GetKeyState(VK_SHIFT) < 0 || GetKeyState(VK_CONTROL) < 0)
goto DoDefault;
}
if (SHRT_MIN <= ptb->lLogPos && ptb->lLogPos <= SHRT_MAX) {
lPos = ptb->lLogPos + cDetants;
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 NEAR PASCAL 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;
}
// BUGBUG: for now, send both in vertical mode
// 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 NEAR PASCAL 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 NEAR PASCAL 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 NEAR PASCAL 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 NEAR PASCAL 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);
}
}
void NEAR PASCAL FlushChanges(PTRACKBAR ptb)
{
HBRUSH hbr;
NMCUSTOMDRAW nmcd;
#ifdef WIN32
hbr = FORWARD_WM_CTLCOLORSTATIC(ptb->ci.hwndParent, ptb->hdc, ptb->ci.hwnd, SendMessage);
#else
hbr = FORWARD_WM_CTLCOLOR(ptb->ci.hwndParent, ptb->hdc, ptb->ci.hwnd, CTLCOLOR_STATIC, SendMessage);
#endif
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;
}
if (fClear)
FillRect(ptb->hdc, &rc, hbr);
}
nmcd.hdc = ptb->hdc;
if (ptb->ci.hwnd == GetFocus())
nmcd.uItemState = CDIS_FOCUS;
else
nmcd.uItemState = 0;
#ifdef KEYBOARDCUES
#if 0
// BUGBUG: Custom draw stuff for UISTATE (stephstm)
if (CCGetUIState(&(ptb->ci), KC_TBD))
nmcd.uItemState |= CDIS_SHOWKEYBOARDCUES;
#endif
#endif
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
}