coolscroll.c
上传用户:xhri001
上传日期:2022-07-04
资源大小:99k
文件大小:83k
源码类别:

界面编程

开发平台:

Visual C++

  1. /*
  2.     Cool Scrollbar Library Version 1.2
  3.     Module: coolscroll.c
  4. Copyright (c) J Brown 2001
  5.   
  6. This code is freeware, however, you may not publish
  7. this code elsewhere or charge any money for it. This code
  8. is supplied as-is. I make no guarantees about the suitability
  9. of this code - use at your own risk.
  10. It would be nice if you credited me, in the event
  11. that you use this code in a product.
  12. VERSION HISTORY:
  13.  V1.2: TreeView problem fixed by Diego Tartara
  14.    Small problem in thumbsize calculation also fixed (thanks Diego!)
  15.  V1.1: Added support for Right-left windows
  16.        Changed calling convention of APIs to WINAPI (__stdcall)
  17.    Completely standalone (no need for c-runtime)
  18.    Now supports ALL windows with appropriate USER32.DLL patching
  19.     (you provide!!)
  20.  V1.0: Apr 2001: Initial Version
  21.   IMPORTANT:
  22.  This whole library is based around code for a horizontal scrollbar.
  23.  All "vertical" scrollbar drawing / mouse interaction uses the
  24.  horizontal scrollbar functions, but uses a trick to convert the vertical
  25.  scrollbar coordinates into horizontal equivelants. When I started this project,
  26.  I quickly realised that the code for horz/vert bars was IDENTICAL, apart
  27.  from the fact that horizontal code uses left/right coords, and vertical code
  28.  uses top/bottom coords. On entry to a "vertical" drawing function, for example,
  29.  the coordinates are "rotated" before the horizontal function is called, and
  30.  then rotated back once the function has completed. When something needs to
  31.  be drawn, the coords are converted back again before drawing.
  32.  
  33.      This trick greatly reduces the amount of code required, and makes
  34.  maintanence much simpler. This way, only one function is needed to draw
  35.  a scrollbar, but this can be used for both horizontal and vertical bars
  36.  with careful thought.
  37. */
  38. #define STRICT
  39. #define WIN32_LEAN_AND_MEAN
  40. #include <windows.h>
  41. #include <commctrl.h>
  42. #include <tchar.h>
  43. #include "coolscroll.h"
  44. #include "userdefs.h"
  45. #include "coolsb_internal.h"
  46. //define some values if the new version of common controls
  47. //is not available.
  48. #ifndef NM_CUSTOMDRAW
  49. #define NM_CUSTOMDRAW (NM_FIRST-12)
  50. #define CDRF_DODEFAULT 0x0000
  51. #define CDRF_SKIPDEFAULT 0x0004
  52. #define CDDS_PREPAINT 0x0001
  53. #define CDDS_POSTPAINT 0x0002
  54. #endif
  55. //
  56. // Special thumb-tracking variables
  57. //
  58. //
  59. static UINT uCurrentScrollbar = COOLSB_NONE; //SB_HORZ / SB_VERT
  60. static UINT uCurrentScrollPortion = HTSCROLL_NONE;
  61. static UINT uCurrentButton = 0;
  62. static RECT rcThumbBounds; //area that the scroll thumb can travel in
  63. static int  nThumbSize; //(pixels)
  64. static int  nThumbPos; //(pixels)
  65. static int  nThumbMouseOffset; //(pixels)
  66. static int  nLastPos = -1; //(scrollbar units)
  67. static int  nThumbPos0; //(pixels) initial thumb position
  68. //
  69. // Temporary state used to auto-generate timer messages
  70. //
  71. static UINT uMouseOverId = 0;
  72. static UINT uMouseOverScrollbar = COOLSB_NONE;
  73. static UINT uHitTestPortion = HTSCROLL_NONE;
  74. static UINT uLastHitTestPortion = HTSCROLL_NONE;
  75. static RECT MouseOverRect;
  76. static UINT uScrollTimerMsg = 0;
  77. static UINT uScrollTimerPortion = HTSCROLL_NONE;
  78. static UINT uScrollTimerId = 0;
  79. static HWND hwndCurCoolSB = 0;
  80. //
  81. // Provide this so there are NO dependencies on CRT
  82. //
  83. static void CoolSB_ZeroMemory(void *ptr, DWORD bytes)
  84. {
  85. BYTE *bptr = (BYTE *)ptr;
  86. while(bytes--) *bptr++ = 0;
  87. }
  88. BOOL WINAPI CoolSB_IsThumbTracking(HWND hwnd)
  89. SCROLLWND *sw;
  90. if((sw = GetScrollWndFromHwnd(hwnd)) == NULL)
  91. return FALSE;
  92. else
  93. return sw->fThumbTracking; 
  94. }
  95. //
  96. // swap the rectangle's x coords with its y coords
  97. //
  98. static void __stdcall RotateRect(RECT *rect)
  99. {
  100. int temp;
  101. temp = rect->left;
  102. rect->left = rect->top;
  103. rect->top = temp;
  104. temp = rect->right;
  105. rect->right = rect->bottom;
  106. rect->bottom = temp;
  107. }
  108. //
  109. // swap the coords if the scrollbar is a SB_VERT
  110. //
  111. static void __stdcall RotateRect0(SCROLLBAR *sb, RECT *rect)
  112. {
  113. if(sb->nBarType == SB_VERT)
  114. RotateRect(rect);
  115. }
  116. //
  117. // Calculate if the SCROLLINFO members produce
  118. //  an enabled or disabled scrollbar
  119. //
  120. static BOOL IsScrollInfoActive(SCROLLINFO *si)
  121. {
  122. if((si->nPage > (UINT)si->nMax
  123. || si->nMax <= si->nMin || si->nMax == 0))
  124. return FALSE;
  125. else
  126. return TRUE;
  127. }
  128. //
  129. // Return if the specified scrollbar is enabled or not
  130. //
  131. static BOOL IsScrollbarActive(SCROLLBAR *sb)
  132. {
  133. SCROLLINFO *si = &sb->scrollInfo;
  134. if(((sb->fScrollFlags & ESB_DISABLE_BOTH) == ESB_DISABLE_BOTH) ||
  135. !(sb->fScrollFlags & CSBS_THUMBALWAYS) && !IsScrollInfoActive(si))
  136. return FALSE;
  137. else
  138. return TRUE;
  139. }
  140. //
  141. // Draw a standard scrollbar arrow
  142. //
  143. static int DrawScrollArrow(SCROLLBAR *sbar, HDC hdc, RECT *rect, UINT arrow, BOOL fMouseDown, BOOL fMouseOver)
  144. {
  145. UINT ret;
  146. UINT flags = arrow;
  147. //HACKY bit so this routine can be called by vertical and horizontal code
  148. if(sbar->nBarType == SB_VERT)
  149. {
  150. if(flags & DFCS_SCROLLLEFT) flags = flags & ~DFCS_SCROLLLEFT  | DFCS_SCROLLUP;
  151. if(flags & DFCS_SCROLLRIGHT) flags = flags & ~DFCS_SCROLLRIGHT | DFCS_SCROLLDOWN;
  152. }
  153. if(fMouseDown) flags |= (DFCS_FLAT | DFCS_PUSHED);
  154. #ifdef FLAT_SCROLLBARS
  155. if(sbar->fFlatScrollbar != CSBS_NORMAL)
  156. {
  157. HDC hdcmem1, hdcmem2;
  158. HBITMAP hbm1, oldbm1;
  159. HBITMAP hbm2, oldbm2;
  160. RECT rc;
  161. int width, height;
  162. rc = *rect;
  163. width  = rc.right-rc.left;
  164. height = rc.bottom-rc.top;
  165. SetRect(&rc, 0, 0, width, height);
  166. //MONOCHROME bitmap to convert the arrow to black/white mask
  167. hdcmem1 = CreateCompatibleDC(hdc);
  168. hbm1    = CreateBitmap(width, height, 1, 1, NULL);
  169. UnrealizeObject(hbm1);
  170. oldbm1  = SelectObject(hdcmem1, hbm1);
  171. //NORMAL bitmap to draw the arrow into
  172. hdcmem2 = CreateCompatibleDC(hdc);
  173. hbm2    = CreateCompatibleBitmap(hdc, width, height);
  174. UnrealizeObject(hbm2);
  175. oldbm2  = SelectObject(hdcmem2, hbm2);
  176. flags = flags & ~DFCS_PUSHED | DFCS_FLAT; //just in case
  177. DrawFrameControl(hdcmem2, &rc, DFC_SCROLL, flags);
  178. #ifndef HOT_TRACKING
  179. if(fMouseDown)
  180. {
  181. //uncomment these to make the cool scrollbars
  182. //look like the common controls flat scrollbars
  183. //fMouseDown = FALSE;
  184. //fMouseOver = TRUE;
  185. }
  186. #endif
  187. //draw a flat monochrome version of a scrollbar arrow (dark)
  188. if(fMouseDown)
  189. {
  190. SetBkColor(hdcmem2, GetSysColor(COLOR_BTNTEXT));
  191. BitBlt(hdcmem1, 0, 0, width, height, hdcmem2, 0, 0, SRCCOPY);
  192. SetBkColor(hdc, 0x00ffffff);
  193. SetTextColor(hdc, GetSysColor(COLOR_3DDKSHADOW));
  194. BitBlt(hdc, rect->left, rect->top, width, height, hdcmem1, 0, 0, SRCCOPY);
  195. }
  196. //draw a flat monochrome version of a scrollbar arrow (grey)
  197. else if(fMouseOver)
  198. {
  199. SetBkColor(hdcmem2, GetSysColor(COLOR_BTNTEXT));
  200. FillRect(hdcmem1, &rc, GetStockObject(WHITE_BRUSH));
  201. BitBlt(hdcmem1, 0, 0, width, height, hdcmem2, 0, 0, SRCINVERT);
  202. SetBkColor(hdc, GetSysColor(COLOR_3DSHADOW));
  203. SetTextColor(hdc, 0x00ffffff);
  204. BitBlt(hdc, rect->left, rect->top, width, height, hdcmem1, 0, 0, SRCCOPY);
  205. }
  206. //draw the arrow normally
  207. else
  208. {
  209. BitBlt(hdc, rect->left, rect->top, width, height, hdcmem2, 0, 0, SRCCOPY);
  210. }
  211. SelectObject(hdcmem1, oldbm1);
  212. SelectObject(hdcmem2, oldbm2);
  213. DeleteObject(hbm1);
  214. DeleteObject(hbm2);
  215. DeleteDC(hdcmem1);
  216. DeleteDC(hdcmem2);
  217. ret = 0;
  218. }
  219. else
  220. #endif
  221. ret = DrawFrameControl(hdc, rect, DFC_SCROLL, flags);
  222. return ret;
  223. }
  224. //
  225. // Return the size in pixels for the specified scrollbar metric,
  226. //  for the specified scrollbar
  227. //
  228. static int GetScrollMetric(SCROLLBAR *sbar, int metric)
  229. {
  230. if(sbar->nBarType == SB_HORZ)
  231. {
  232. if(metric == SM_CXHORZSB)
  233. {
  234. if(sbar->nArrowLength < 0)
  235. return -sbar->nArrowLength * GetSystemMetrics(SM_CXHSCROLL);
  236. else
  237. return sbar->nArrowLength;
  238. }
  239. else
  240. {
  241. if(sbar->nArrowWidth < 0)
  242. return -sbar->nArrowWidth * GetSystemMetrics(SM_CYHSCROLL);
  243. else
  244. return sbar->nArrowWidth;
  245. }
  246. }
  247. else if(sbar->nBarType == SB_VERT)
  248. {
  249. if(metric == SM_CYVERTSB)
  250. {
  251. if(sbar->nArrowLength < 0)
  252. return -sbar->nArrowLength * GetSystemMetrics(SM_CYVSCROLL);
  253. else
  254. return sbar->nArrowLength;
  255. }
  256. else
  257. {
  258. if(sbar->nArrowWidth < 0)
  259. return -sbar->nArrowWidth * GetSystemMetrics(SM_CXVSCROLL);
  260. else
  261. return sbar->nArrowWidth;
  262. }
  263. }
  264. return 0;
  265. }
  266. //
  267. //
  268. //
  269. static COLORREF GetSBForeColor(void)
  270. {
  271. COLORREF c1 = GetSysColor(COLOR_3DHILIGHT);
  272. COLORREF c2 = GetSysColor(COLOR_WINDOW);
  273. if(c1 != 0xffffff && c1 == c2)
  274. {
  275. return GetSysColor(COLOR_BTNFACE);
  276. }
  277. else
  278. {
  279. return GetSysColor(COLOR_3DHILIGHT);
  280. }
  281. }
  282. static COLORREF GetSBBackColor(void)
  283. {
  284. return GetSysColor(COLOR_SCROLLBAR);
  285. }
  286. //
  287. // Paint a checkered rectangle, with each alternate
  288. // pixel being assigned a different colour
  289. //
  290. static void DrawCheckedRect(HDC hdc, RECT *rect, COLORREF fg, COLORREF bg)
  291. {
  292. static WORD wCheckPat[8] = 
  293. 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555 
  294. };
  295. HBITMAP hbmp;
  296. HBRUSH  hbr, hbrold;
  297. COLORREF fgold, bgold;
  298. hbmp = CreateBitmap(8, 8, 1, 1, wCheckPat);
  299. hbr  = CreatePatternBrush(hbmp);
  300. UnrealizeObject(hbr);
  301. SetBrushOrgEx(hdc, rect->left, rect->top, 0);
  302. hbrold = (HBRUSH)SelectObject(hdc, hbr);
  303. fgold = SetTextColor(hdc, fg);
  304. bgold = SetBkColor(hdc, bg);
  305. PatBlt(hdc, rect->left, rect->top, 
  306. rect->right - rect->left, 
  307. rect->bottom - rect->top, 
  308. PATCOPY);
  309. SetBkColor(hdc, bgold);
  310. SetTextColor(hdc, fgold);
  311. SelectObject(hdc, hbrold);
  312. DeleteObject(hbr);
  313. DeleteObject(hbmp);
  314. }
  315. //
  316. // Fill the specifed rectangle using a solid colour
  317. //
  318. static void PaintRect(HDC hdc, RECT *rect, COLORREF color)
  319. {
  320. COLORREF oldcol = SetBkColor(hdc, color);
  321. ExtTextOut(hdc, 0, 0, ETO_OPAQUE, rect, _T(""), 0, 0);
  322. SetBkColor(hdc, oldcol);
  323. }
  324. //
  325. // Draw a simple blank scrollbar push-button. Can be used
  326. // to draw a push button, or the scrollbar thumb
  327. // drawflag - could set to BF_FLAT to make flat scrollbars
  328. //
  329. void DrawBlankButton(HDC hdc, const RECT *rect, UINT drawflag)
  330. {
  331. RECT rc = *rect;
  332. #ifndef FLAT_SCROLLBARS
  333. drawflag &= ~BF_FLAT;
  334. #endif
  335. DrawEdge(hdc, &rc, EDGE_RAISED, BF_RECT | drawflag | BF_ADJUST);
  336. FillRect(hdc, &rc, GetSysColorBrush(COLOR_BTNFACE));
  337. }
  338. //
  339. // Send a WM_VSCROLL or WM_HSCROLL message
  340. //
  341. static void SendScrollMessage(HWND hwnd, UINT scrMsg, UINT scrId, UINT pos)
  342. {
  343. SendMessage(hwnd, scrMsg, MAKEWPARAM(scrId, pos), 0);
  344. }
  345. //
  346. // Calculate the screen coordinates of the area taken by
  347. //  the horizontal scrollbar. Take into account the size
  348. //  of the window borders
  349. //
  350. static BOOL GetHScrollRect(SCROLLWND *sw, HWND hwnd, RECT *rect)
  351. {
  352. GetWindowRect(hwnd, rect);
  353. if(sw->fLeftScrollbar)
  354. {
  355. rect->left  += sw->cxLeftEdge + (sw->sbarVert.fScrollVisible ? 
  356. GetScrollMetric(&sw->sbarVert, SM_CXVERTSB) : 0);
  357. rect->right -= sw->cxRightEdge;
  358. }
  359. else
  360. {
  361. rect->left   += sw->cxLeftEdge; //left window edge
  362. rect->right  -= sw->cxRightEdge + //right window edge
  363. (sw->sbarVert.fScrollVisible ? 
  364. GetScrollMetric(&sw->sbarVert, SM_CXVERTSB) : 0);
  365. }
  366. rect->bottom -= sw->cyBottomEdge; //bottom window edge
  367. rect->top   = rect->bottom -
  368. (sw->sbarHorz.fScrollVisible ?
  369. GetScrollMetric(&sw->sbarHorz, SM_CYHORZSB) : 0);
  370. return TRUE;
  371. }
  372. //
  373. // Calculate the screen coordinates of the area taken by the
  374. //  vertical scrollbar
  375. //
  376. static BOOL GetVScrollRect(SCROLLWND *sw, HWND hwnd, RECT *rect)
  377. {
  378. GetWindowRect(hwnd, rect);
  379. rect->top  += sw->cyTopEdge; //top window edge
  380. rect->bottom -= sw->cyBottomEdge + 
  381. (sw->sbarHorz.fScrollVisible ? //bottom window edge
  382. GetScrollMetric(&sw->sbarHorz, SM_CYHORZSB) : 0);
  383. if(sw->fLeftScrollbar)
  384. {
  385. rect->left += sw->cxLeftEdge;
  386. rect->right = rect->left + (sw->sbarVert.fScrollVisible ?
  387. GetScrollMetric(&sw->sbarVert, SM_CXVERTSB) : 0);
  388. }
  389. else
  390. {
  391. rect->right  -= sw->cxRightEdge;
  392. rect->left    = rect->right - (sw->sbarVert.fScrollVisible ?
  393. GetScrollMetric(&sw->sbarVert, SM_CXVERTSB) : 0);
  394. }
  395. return TRUE;
  396. }
  397. // Depending on what type of scrollbar nBar refers to, call the
  398. //  appropriate Get?ScrollRect function
  399. //
  400. BOOL GetScrollRect(SCROLLWND *sw, UINT nBar, HWND hwnd, RECT *rect)
  401. {
  402. if(nBar == SB_HORZ)
  403. return GetHScrollRect(sw, hwnd, rect);
  404. else if(nBar == SB_VERT)
  405. return GetVScrollRect(sw, hwnd, rect);
  406. else
  407. return FALSE;
  408. }
  409. //
  410. // This code is a prime candidate for splitting out into a separate
  411. //  file at some stage
  412. //
  413. #ifdef INCLUDE_BUTTONS
  414. //
  415. // Calculate the size in pixels of the specified button
  416. //
  417. static int GetSingleButSize(SCROLLBAR *sbar, SCROLLBUT *sbut)
  418. {
  419. //multiple of the system button size
  420. //or a specific button size
  421. if(sbut->nSize < 0)
  422. {
  423. if(sbar->nBarType == SB_HORZ)
  424. return -sbut->nSize * GetSystemMetrics(SM_CXHSCROLL);
  425. else 
  426. return -sbut->nSize * GetSystemMetrics(SM_CYVSCROLL);
  427. }
  428. else
  429. return  sbut->nSize;
  430. }
  431. //
  432. // Find the size in pixels of all the inserted buttons,
  433. // either before or after the specified scrollbar
  434. //
  435. static int GetButtonSize(SCROLLBAR *sbar, HWND hwnd, UINT uBeforeAfter)
  436. {
  437. int i;
  438. int nPixels = 0;
  439. SCROLLBUT *sbut = sbar->sbButtons;
  440. for(i = 0; i < sbar->nButtons; i++)
  441. {
  442. //only consider those buttons on the same side as nTopBottom says
  443. if(sbut[i].uPlacement == uBeforeAfter)
  444. {
  445. nPixels += GetSingleButSize(sbar, &sbut[i]);
  446. }
  447. }
  448. return nPixels;
  449. }
  450. #endif //INCLUDE_BUTTONS
  451. //
  452. // Work out the scrollbar width/height for either type of scrollbar (SB_HORZ/SB_VERT)
  453. // rect - coords of the scrollbar.
  454. // store results into *thumbsize and *thumbpos
  455. //
  456. static int CalcThumbSize(SCROLLBAR *sbar, const RECT *rect, int *pthumbsize, int *pthumbpos)
  457. {
  458. SCROLLINFO *si;
  459. int scrollsize; //total size of the scrollbar including arrow buttons
  460. int workingsize; //working area (where the thumb can slide)
  461. int siMaxMin;
  462. int butsize;
  463. int startcoord;
  464. int thumbpos = 0, thumbsize = 0;
  465. int adjust=0;
  466. static int count=0;
  467. //work out the width (for a horizontal) or the height (for a vertical)
  468. //of a standard scrollbar button
  469. butsize = GetScrollMetric(sbar, SM_SCROLL_LENGTH);
  470. if(1) //sbar->nBarType == SB_HORZ)
  471. {
  472. scrollsize = rect->right - rect->left;
  473. startcoord = rect->left;
  474. }
  475. /*else if(sbar->nBarType == SB_VERT)
  476. {
  477. scrollsize = rect->bottom - rect->top;
  478. startcoord = rect->top;
  479. }
  480. else
  481. {
  482. return 0;
  483. }*/
  484. si = &sbar->scrollInfo;
  485. siMaxMin = si->nMax - si->nMin + 1;
  486. workingsize = scrollsize - butsize * 2;
  487. //
  488. // Work out the scrollbar thumb SIZE
  489. //
  490. if(si->nPage == 0)
  491. {
  492. thumbsize = butsize;
  493. }
  494. else if(siMaxMin > 0)
  495. {
  496. thumbsize = MulDiv(si->nPage, workingsize, siMaxMin);
  497. if(thumbsize < sbar->nMinThumbSize)
  498. thumbsize = sbar->nMinThumbSize;
  499. }
  500. //
  501. // Work out the scrollbar thumb position
  502. //
  503. if(siMaxMin > 0)
  504. {
  505. int pagesize = max(1, si->nPage);
  506. thumbpos = MulDiv(si->nPos - si->nMin, workingsize-thumbsize, siMaxMin - pagesize);
  507. if(thumbpos < 0)
  508. thumbpos = 0;
  509. if(thumbpos >= workingsize-thumbsize)
  510. thumbpos = workingsize-thumbsize;
  511. }
  512. thumbpos += startcoord + butsize;
  513. *pthumbpos  = thumbpos;
  514. *pthumbsize = thumbsize;
  515. return 1;
  516. }
  517. //
  518. // return a hit-test value for whatever part of the scrollbar x,y is located in
  519. // rect, x, y: SCREEN coordinates
  520. // the rectangle must not include space for any inserted buttons 
  521. // (i.e, JUST the scrollbar area)
  522. //
  523. static UINT GetHorzScrollPortion(SCROLLBAR *sbar, HWND hwnd, const RECT *rect, int x, int y)
  524. {
  525. int thumbwidth, thumbpos;
  526. int butwidth = GetScrollMetric(sbar, SM_SCROLL_LENGTH);
  527. int scrollwidth  = rect->right-rect->left;
  528. int workingwidth = scrollwidth - butwidth*2;
  529. if(y < rect->top || y >= rect->bottom)
  530. return HTSCROLL_NONE;
  531. CalcThumbSize(sbar, rect, &thumbwidth, &thumbpos);
  532. //if we have had to scale the buttons to fit in the rect,
  533. //then adjust the button width accordingly
  534. if(scrollwidth <= butwidth * 2)
  535. {
  536. butwidth = scrollwidth / 2;
  537. }
  538. //check for left button click
  539. if(x >= rect->left && x < rect->left + butwidth)
  540. {
  541. return HTSCROLL_LEFT;
  542. }
  543. //check for right button click
  544. else if(x >= rect->right-butwidth && x < rect->right)
  545. {
  546. return HTSCROLL_RIGHT;
  547. }
  548. //if the thumb is too big to fit (i.e. it isn't visible)
  549. //then return a NULL scrollbar area
  550. if(thumbwidth >= workingwidth)
  551. return HTSCROLL_NONE;
  552. //check for point in the thumbbar
  553. if(x >= thumbpos && x < thumbpos+thumbwidth)
  554. {
  555. return HTSCROLL_THUMB;
  556. }
  557. //check for left margin
  558. else if(x >= rect->left+butwidth && x < thumbpos)
  559. {
  560. return HTSCROLL_PAGELEFT;
  561. }
  562. else if(x >= thumbpos+thumbwidth && x < rect->right-butwidth)
  563. {
  564. return HTSCROLL_PAGERIGHT;
  565. }
  566. return HTSCROLL_NONE;
  567. }
  568. //
  569. // For vertical scrollbars, rotate all coordinates by -90 degrees
  570. // so that we can use the horizontal version of this function
  571. //
  572. static UINT GetVertScrollPortion(SCROLLBAR *sb, HWND hwnd, RECT *rect, int x, int y)
  573. {
  574. UINT r;
  575. RotateRect(rect);
  576. r = GetHorzScrollPortion(sb, hwnd, rect, y, x);
  577. RotateRect(rect);
  578. return r;
  579. }
  580. //
  581. // CUSTOM DRAW support
  582. //
  583. static LRESULT PostCustomPrePostPaint0(HWND hwnd, HDC hdc, SCROLLBAR *sb, UINT dwStage)
  584. {
  585. #ifdef CUSTOM_DRAW
  586. NMCSBCUSTOMDRAW nmcd;
  587. CoolSB_ZeroMemory(&nmcd, sizeof nmcd);
  588. nmcd.hdr.hwndFrom = hwnd;
  589. nmcd.hdr.idFrom   = GetWindowLong(hwnd, GWL_ID);
  590. nmcd.hdr.code     = NM_COOLSB_CUSTOMDRAW;
  591. nmcd.nBar   = sb->nBarType;
  592. nmcd.dwDrawStage  = dwStage;
  593. nmcd.hdc   = hdc;
  594. hwnd = GetParent(hwnd);
  595. return SendMessage(hwnd, WM_NOTIFY, 0, (LPARAM)&nmcd);
  596. #else
  597. return 0;
  598. #endif
  599. }
  600. static LRESULT PostCustomDrawNotify0(HWND hwnd, HDC hdc, UINT nBar, RECT *prect, UINT nItem, BOOL fMouseDown, BOOL fMouseOver, BOOL fInactive)
  601. {
  602. #ifdef CUSTOM_DRAW
  603. NMCSBCUSTOMDRAW nmcd;
  604. //fill in the standard header
  605. nmcd.hdr.hwndFrom = hwnd;
  606. nmcd.hdr.idFrom   = GetWindowLong(hwnd, GWL_ID);
  607. nmcd.hdr.code     = NM_COOLSB_CUSTOMDRAW;
  608. nmcd.dwDrawStage  = CDDS_ITEMPREPAINT;
  609. nmcd.nBar   = nBar;
  610. nmcd.rect   = *prect;
  611. nmcd.uItem   = nItem;
  612. nmcd.hdc   = hdc;
  613. if(fMouseDown) 
  614. nmcd.uState   = CDIS_SELECTED;
  615. else if(fMouseOver)
  616. nmcd.uState   = CDIS_HOT;
  617. else if(fInactive)
  618. nmcd.uState   = CDIS_DISABLED;
  619. else
  620. nmcd.uState   = CDIS_DEFAULT;
  621. hwnd = GetParent(hwnd);
  622. return SendMessage(hwnd, WM_NOTIFY, nmcd.hdr.idFrom, (LPARAM)&nmcd);
  623. #else
  624. return 0;
  625. #endif
  626. }
  627. // Depending on if we are supporting custom draw, either define
  628. // a macro to the function name, or to nothing at all. If custom draw
  629. // is turned off, then we can save ALOT of code space by binning all 
  630. // calls to the custom draw support.
  631. //
  632. #ifdef CUSTOM_DRAW
  633. #define PostCustomDrawNotify PostCustomDrawNotify0
  634. #define PostCustomPrePostPaint PostCustomPrePostPaint0
  635. #else
  636. #define PostCustomDrawNotify 1 ? (void)0 : PostCustomDrawNotify0
  637. #define PostCustomPrePostPaint 1 ? (void)0 : PostCustomPrePostPaint0
  638. #endif
  639. static LRESULT PostMouseNotify0(HWND hwnd, UINT msg, UINT nBar, RECT *prect, UINT nCmdId, POINT pt)
  640. {
  641. #ifdef NOTIFY_MOUSE
  642. NMCOOLBUTMSG nmcb;
  643. //fill in the standard header
  644. nmcb.hdr.hwndFrom = hwnd;
  645. nmcb.hdr.idFrom = GetWindowLong(hwnd, GWL_ID);
  646. nmcb.hdr.code = NM_CLICK;
  647. nmcb.nBar = nBar;
  648. nmcb.uCmdId = nCmdId;
  649. nmcb.uState = 0;
  650. nmcb.rect = *prect;
  651. nmcb.pt = pt;
  652. hwnd = GetParent(hwnd);
  653. return SendMessage(hwnd, WM_NOTIFY, nmcb.hdr.idFrom, (LPARAM)&nmcb);
  654. #else
  655. return 0;
  656. #endif
  657. }
  658. #ifdef NOTIFY_MOUSE
  659. #define PostMouseNotify PostMouseNotify0
  660. #else
  661. #define PostMouseNotify 1 ? (void)0 : PostMouseNotify0
  662. #endif
  663. //
  664. // Draw a complete HORIZONTAL scrollbar in the given rectangle
  665. // Don't draw any inserted buttons in this procedure
  666. //
  667. // uDrawFlags - hittest code, to say if to draw the
  668. //  specified portion in an active state or not.
  669. //
  670. //
  671. static LRESULT NCDrawHScrollbar(SCROLLBAR *sb, HWND hwnd, HDC hdc, const RECT *rect, UINT uDrawFlags)
  672. {
  673. SCROLLINFO *si;
  674. RECT ctrl, thumb;
  675. RECT sbm;
  676. int butwidth  = GetScrollMetric(sb, SM_SCROLL_LENGTH);
  677. int scrollwidth  = rect->right-rect->left;
  678. int workingwidth = scrollwidth - butwidth*2;
  679. int thumbwidth   = 0, thumbpos = 0;
  680. int siMaxMin;
  681. BOOL fCustomDraw = 0;
  682. BOOL fMouseDownL = 0, fMouseOverL = 0, fBarHot = 0;
  683. BOOL fMouseDownR = 0, fMouseOverR = 0;
  684. COLORREF crCheck1   = GetSBForeColor();
  685. COLORREF crCheck2   = GetSBBackColor();
  686. COLORREF crInverse1 = InvertCOLORREF(crCheck1);
  687. COLORREF crInverse2 = InvertCOLORREF(crCheck2);
  688. UINT uDFCFlat = sb->fFlatScrollbar ? DFCS_FLAT : 0;
  689. UINT uDEFlat  = sb->fFlatScrollbar ? BF_FLAT   : 0;
  690. //drawing flags to modify the appearance of the scrollbar buttons
  691. UINT uLeftButFlags  = DFCS_SCROLLLEFT;
  692. UINT uRightButFlags = DFCS_SCROLLRIGHT;
  693. if(scrollwidth <= 0)
  694. return 0;
  695. si = &sb->scrollInfo;
  696. siMaxMin = si->nMax - si->nMin;
  697. if(hwnd != hwndCurCoolSB)
  698. uDrawFlags = HTSCROLL_NONE;
  699. //
  700. // work out the thumb size and position
  701. //
  702. CalcThumbSize(sb, rect, &thumbwidth, &thumbpos);
  703. if(sb->fScrollFlags & ESB_DISABLE_LEFT) uLeftButFlags  |= DFCS_INACTIVE;
  704. if(sb->fScrollFlags & ESB_DISABLE_RIGHT) uRightButFlags |= DFCS_INACTIVE;
  705. //if we need to grey the arrows because there is no data to scroll
  706. if(!IsScrollInfoActive(si) && !(sb->fScrollFlags & CSBS_THUMBALWAYS))
  707. {
  708. uLeftButFlags  |= DFCS_INACTIVE;
  709. uRightButFlags |= DFCS_INACTIVE;
  710. }
  711. if(hwnd == hwndCurCoolSB)
  712. {
  713. #ifdef FLAT_SCROLLBARS
  714. BOOL ldis = !(uLeftButFlags & DFCS_INACTIVE);
  715. BOOL rdis = !(uRightButFlags & DFCS_INACTIVE);
  716. fBarHot = (sb->nBarType == (int)uMouseOverScrollbar && sb->fFlatScrollbar == CSBS_HOTTRACKED);
  717. fMouseOverL = uHitTestPortion == HTSCROLL_LEFT && fBarHot && ldis;
  718. fMouseOverR = uHitTestPortion == HTSCROLL_RIGHT && fBarHot && rdis;
  719. #endif
  720. fMouseDownL = (uDrawFlags == HTSCROLL_LEFT);
  721. fMouseDownR = (uDrawFlags == HTSCROLL_RIGHT);
  722. }
  723. #ifdef CUSTOM_DRAW
  724. fCustomDraw = ((PostCustomPrePostPaint(hwnd, hdc, sb, CDDS_PREPAINT)) == CDRF_SKIPDEFAULT);
  725. #endif
  726. //
  727. // Draw the scrollbar now
  728. //
  729. if(scrollwidth > butwidth*2)
  730. {
  731. //LEFT ARROW
  732. SetRect(&ctrl, rect->left, rect->top, rect->left + butwidth, rect->bottom);
  733. RotateRect0(sb, &ctrl);
  734. if(fCustomDraw)
  735. PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_LINELEFT, fMouseDownL, fMouseOverL, uLeftButFlags & DFCS_INACTIVE);
  736. else
  737. DrawScrollArrow(sb, hdc, &ctrl, uLeftButFlags, fMouseDownL, fMouseOverL);
  738. RotateRect0(sb, &ctrl);
  739. //MIDDLE PORTION
  740. //if we can fit the thumbbar in, then draw it
  741. if(thumbwidth > 0 && thumbwidth <= workingwidth
  742. && IsScrollInfoActive(si) && ((sb->fScrollFlags & ESB_DISABLE_BOTH) != ESB_DISABLE_BOTH))
  743. {
  744. //Draw the scrollbar margin above the thumb
  745. SetRect(&sbm, rect->left + butwidth, rect->top, thumbpos, rect->bottom);
  746. RotateRect0(sb, &sbm);
  747. if(fCustomDraw)
  748. {
  749. PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &sbm, SB_PAGELEFT, uDrawFlags == HTSCROLL_PAGELEFT, FALSE, FALSE);
  750. }
  751. else
  752. {
  753. if(uDrawFlags == HTSCROLL_PAGELEFT)
  754. DrawCheckedRect(hdc, &sbm, crInverse1, crInverse2);
  755. else
  756. DrawCheckedRect(hdc, &sbm, crCheck1, crCheck2);
  757. }
  758. RotateRect0(sb, &sbm);
  759. //Draw the margin below the thumb
  760. sbm.left = thumbpos+thumbwidth;
  761. sbm.right = rect->right - butwidth;
  762. RotateRect0(sb, &sbm);
  763. if(fCustomDraw)
  764. {
  765. PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &sbm, SB_PAGERIGHT, uDrawFlags == HTSCROLL_PAGERIGHT, 0, 0);
  766. }
  767. else
  768. {
  769. if(uDrawFlags == HTSCROLL_PAGERIGHT)
  770. DrawCheckedRect(hdc, &sbm, crInverse1, crInverse2);
  771. else
  772. DrawCheckedRect(hdc, &sbm, crCheck1, crCheck2);
  773. }
  774. RotateRect0(sb, &sbm);
  775. //Draw the THUMB finally
  776. SetRect(&thumb, thumbpos, rect->top, thumbpos+thumbwidth, rect->bottom);
  777. RotateRect0(sb, &thumb);
  778. if(fCustomDraw)
  779. {
  780. PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &thumb, SB_THUMBTRACK, uDrawFlags==HTSCROLL_THUMB, uHitTestPortion == HTSCROLL_THUMB && fBarHot, FALSE);
  781. }
  782. else
  783. {
  784. #ifdef FLAT_SCROLLBARS
  785. if(hwnd == hwndCurCoolSB && sb->fFlatScrollbar && (uDrawFlags == HTSCROLL_THUMB || 
  786. (uHitTestPortion == HTSCROLL_THUMB && fBarHot)))
  787. {
  788. PaintRect(hdc, &thumb, GetSysColor(COLOR_3DSHADOW));
  789. }
  790. else
  791. #endif
  792. {
  793. DrawBlankButton(hdc, &thumb, uDEFlat);
  794. }
  795. }
  796. RotateRect0(sb, &thumb);
  797. }
  798. //otherwise, just leave that whole area blank
  799. else
  800. {
  801. OffsetRect(&ctrl, butwidth, 0);
  802. ctrl.right = rect->right - butwidth;
  803. //if we always show the thumb covering the whole scrollbar,
  804. //then draw it that way
  805. if(!IsScrollInfoActive(si) && (sb->fScrollFlags & CSBS_THUMBALWAYS) 
  806. && ctrl.right - ctrl.left > sb->nMinThumbSize)
  807. {
  808. //leave a 1-pixel gap between the thumb + right button
  809. ctrl.right --;
  810. RotateRect0(sb, &ctrl);
  811. if(fCustomDraw)
  812. PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_THUMBTRACK, fMouseDownL, FALSE, FALSE);
  813. else
  814. {
  815. #ifdef FLAT_SCROLLBARS
  816. if(sb->fFlatScrollbar == CSBS_HOTTRACKED && uDrawFlags == HTSCROLL_THUMB)
  817. PaintRect(hdc, &ctrl, GetSysColor(COLOR_3DSHADOW));
  818. else
  819. #endif
  820. DrawBlankButton(hdc, &ctrl, uDEFlat);
  821. }
  822. RotateRect0(sb, &ctrl);
  823. //draw the single-line gap
  824. ctrl.left = ctrl.right;
  825. ctrl.right += 1;
  826. RotateRect0(sb, &ctrl);
  827. if(fCustomDraw)
  828. PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_PAGERIGHT, 0, 0, 0);
  829. else
  830. PaintRect(hdc, &ctrl, GetSysColor(COLOR_SCROLLBAR));
  831. RotateRect0(sb, &ctrl);
  832. }
  833. //otherwise, paint a blank if the thumb doesn't fit in
  834. else
  835. {
  836. RotateRect0(sb, &ctrl);
  837. if(fCustomDraw)
  838. PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_PAGERIGHT, 0, 0, 0);
  839. else
  840. DrawCheckedRect(hdc, &ctrl, crCheck1, crCheck2);
  841. RotateRect0(sb, &ctrl);
  842. }
  843. }
  844. //RIGHT ARROW
  845. SetRect(&ctrl, rect->right - butwidth, rect->top, rect->right, rect->bottom);
  846. RotateRect0(sb, &ctrl);
  847. if(fCustomDraw)
  848. PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_LINERIGHT, fMouseDownR, fMouseOverR, uRightButFlags & DFCS_INACTIVE);
  849. else
  850. DrawScrollArrow(sb, hdc, &ctrl, uRightButFlags, fMouseDownR, fMouseOverR);
  851. RotateRect0(sb, &ctrl);
  852. }
  853. //not enough room for the scrollbar, so just draw the buttons (scaled in size to fit)
  854. else
  855. {
  856. butwidth = scrollwidth / 2;
  857. //LEFT ARROW
  858. SetRect(&ctrl, rect->left, rect->top, rect->left + butwidth, rect->bottom);
  859. RotateRect0(sb, &ctrl);
  860. if(fCustomDraw)
  861. PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_LINELEFT, fMouseDownL, fMouseOverL, uLeftButFlags & DFCS_INACTIVE);
  862. else
  863. DrawScrollArrow(sb, hdc, &ctrl, uLeftButFlags, fMouseDownL, fMouseOverL);
  864. RotateRect0(sb, &ctrl);
  865. //RIGHT ARROW
  866. OffsetRect(&ctrl, scrollwidth - butwidth, 0);
  867. RotateRect0(sb, &ctrl);
  868. if(fCustomDraw)
  869. PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_LINERIGHT, fMouseDownR, fMouseOverR, uRightButFlags & DFCS_INACTIVE);
  870. else
  871. DrawScrollArrow(sb, hdc, &ctrl, uRightButFlags, fMouseDownR, fMouseOverR);
  872. RotateRect0(sb, &ctrl);
  873. //if there is a gap between the buttons, fill it with a solid color
  874. //if(butwidth & 0x0001)
  875. if(ctrl.left != rect->left + butwidth)
  876. {
  877. ctrl.left --;
  878. ctrl.right -= butwidth;
  879. RotateRect0(sb, &ctrl);
  880. if(fCustomDraw)
  881. PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_PAGERIGHT, 0, 0, 0);
  882. else
  883. DrawCheckedRect(hdc, &ctrl, crCheck1, crCheck2);
  884. RotateRect0(sb, &ctrl);
  885. }
  886. }
  887. #ifdef CUSTOM_DRAW
  888. PostCustomPrePostPaint(hwnd, hdc, sb, CDDS_POSTPAINT);
  889. #endif
  890. return fCustomDraw;
  891. }
  892. //
  893. // Draw a vertical scrollbar using the horizontal draw routine, but
  894. // with the coordinates adjusted accordingly
  895. //
  896. static LRESULT NCDrawVScrollbar(SCROLLBAR *sb, HWND hwnd, HDC hdc, const RECT *rect, UINT uDrawFlags)
  897. {
  898. LRESULT ret;
  899. RECT rc;
  900. rc = *rect;
  901. RotateRect(&rc);
  902. ret = NCDrawHScrollbar(sb, hwnd, hdc, &rc, uDrawFlags);
  903. RotateRect(&rc);
  904. return ret;
  905. }
  906. //
  907. // Generic wrapper function for the scrollbar drawing
  908. //
  909. static LRESULT NCDrawScrollbar(SCROLLBAR *sb, HWND hwnd, HDC hdc, const RECT *rect, UINT uDrawFlags)
  910. {
  911. if(sb->nBarType == SB_HORZ)
  912. return NCDrawHScrollbar(sb, hwnd, hdc, rect, uDrawFlags);
  913. else
  914. return NCDrawVScrollbar(sb, hwnd, hdc, rect, uDrawFlags);
  915. }
  916. #ifdef INCLUDE_BUTTONS
  917. //
  918. // Draw the specified bitmap centered in the rectangle
  919. //
  920. static void DrawImage(HDC hdc, HBITMAP hBitmap, RECT *rc)
  921. {
  922. BITMAP bm;
  923. int cx;
  924. int cy;   
  925. HDC memdc;
  926. HBITMAP hOldBM;
  927. RECT  rcDest = *rc;   
  928. POINT p;
  929. SIZE  delta;
  930. COLORREF colorOld;
  931. if(hBitmap == NULL) 
  932. return;
  933. // center bitmap in caller's rectangle   
  934. GetObject(hBitmap, sizeof bm, &bm);   
  935. cx = bm.bmWidth;
  936. cy = bm.bmHeight;
  937. delta.cx = (rc->right-rc->left - cx) / 2;
  938. delta.cy = (rc->bottom-rc->top - cy) / 2;
  939. if(rc->right-rc->left > cx)
  940. {
  941. SetRect(&rcDest, rc->left+delta.cx, rc->top + delta.cy, 0, 0);   
  942. rcDest.right = rcDest.left + cx;
  943. rcDest.bottom = rcDest.top + cy;
  944. p.x = 0;
  945. p.y = 0;
  946. }
  947. else
  948. {
  949. p.x = -delta.cx;   
  950. p.y = -delta.cy;
  951. }
  952.    
  953. // select checkmark into memory DC
  954. memdc = CreateCompatibleDC(hdc);
  955. hOldBM = (HBITMAP)SelectObject(memdc, hBitmap);
  956.    
  957. // set BG color based on selected state   
  958. colorOld = SetBkColor(hdc, GetSysColor(COLOR_3DFACE));
  959. BitBlt(hdc, rcDest.left, rcDest.top, rcDest.right-rcDest.left, rcDest.bottom-rcDest.top, memdc, p.x, p.y, SRCCOPY);
  960. // restore
  961. SetBkColor(hdc, colorOld);
  962. SelectObject(memdc, hOldBM);
  963. DeleteDC(memdc);
  964. }
  965. //
  966. // Draw the specified metafile
  967. //
  968. static void DrawMetaFile(HDC hdc, HENHMETAFILE hemf, RECT *rect)
  969. {
  970. RECT rc;
  971. POINT pt;
  972. SetRect(&rc, 0, 0, rect->right-rect->left, rect->bottom-rect->top);
  973. SetWindowOrgEx(hdc, -rect->left, -rect->top, &pt);
  974. PlayEnhMetaFile(hdc, hemf, &rc);
  975. SetWindowOrgEx(hdc, pt.x, pt.y, 0);
  976. }
  977. //
  978. // Draw a single scrollbar inserted button, in whatever style
  979. // it has been defined to use.
  980. //
  981. static UINT DrawScrollButton(SCROLLBUT *sbut, HDC hdc, const RECT *pctrl, UINT flags)
  982. {
  983. NMCSBCUSTOMDRAW nmcd;
  984. HWND hwnd;
  985. RECT rect = *pctrl;
  986. UINT f;
  987. switch(sbut->uButType & SBBT_MASK)
  988. {
  989. case SBBT_OWNERDRAW:
  990. hwnd = WindowFromDC(hdc);
  991. //fill in the standard header
  992. nmcd.hdr.hwndFrom = hwnd;
  993. nmcd.hdr.idFrom   = GetWindowLong(hwnd, GWL_ID);
  994. nmcd.hdr.code     = NM_COOLSB_CUSTOMDRAW;
  995. nmcd.dwDrawStage  = CDDS_ITEMPREPAINT;
  996. nmcd.nBar   = SB_INSBUT;
  997. nmcd.rect   = *pctrl;
  998. nmcd.uItem   = sbut->uCmdId;
  999. nmcd.hdc   = hdc;
  1000. nmcd.uState   = flags;
  1001. IntersectClipRect(hdc, rect.left, rect.top, rect.right, rect.bottom);
  1002. SendMessage(GetParent(hwnd), WM_NOTIFY, nmcd.hdr.idFrom, (LPARAM)&nmcd);
  1003. SelectClipRgn(hdc, NULL);
  1004. break;
  1005. case SBBT_FIXED:
  1006. flags &= ~SBBS_PUSHED;
  1007. case SBBT_TOGGLEBUTTON:
  1008. if(sbut->uState != SBBS_NORMAL)
  1009. flags |= SBBS_PUSHED;
  1010. //intentionally fall through here...
  1011. case SBBT_PUSHBUTTON: 
  1012. f = flags & SBBS_PUSHED ? DFCS_PUSHED | DFCS_FLAT : 0;
  1013. if(sbut->uButType & SBBM_LEFTARROW)
  1014. {
  1015. DrawFrameControl(hdc, &rect, DFC_SCROLL, DFCS_SCROLLLEFT | f);
  1016. }
  1017. else if(sbut->uButType & SBBM_RIGHTARROW)
  1018. {
  1019. DrawFrameControl(hdc, &rect, DFC_SCROLL, DFCS_SCROLLRIGHT | f);
  1020. }
  1021. else if(sbut->uButType & SBBM_UPARROW)
  1022. {
  1023. DrawFrameControl(hdc, &rect, DFC_SCROLL, DFCS_SCROLLUP | f);
  1024. }
  1025. else if(sbut->uButType & SBBM_DOWNARROW)
  1026. {
  1027. DrawFrameControl(hdc, &rect, DFC_SCROLL, DFCS_SCROLLDOWN | f);
  1028. }
  1029. else
  1030. {
  1031. //
  1032. if(flags & SBBS_PUSHED)
  1033. {
  1034. if(sbut->uButType & SBBM_RECESSED)
  1035. {
  1036. InflateRect(&rect, -1, -1);
  1037. DrawEdge(hdc, &rect, EDGE_SUNKEN, BF_RECT|BF_FLAT);
  1038. InflateRect(&rect, 1, 1);
  1039. FrameRect(hdc, &rect, GetSysColorBrush(COLOR_3DDKSHADOW));
  1040. InflateRect(&rect, -2, -2);
  1041. }
  1042. else
  1043. {
  1044. DrawEdge(hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_FLAT | BF_ADJUST);
  1045. InflateRect(&rect, 1, 1);
  1046. }
  1047. }
  1048. else
  1049. {
  1050. // draw the button borders
  1051. if(sbut->uButType & SBBM_TYPE2)
  1052. {
  1053. DrawFrameControl(hdc, &rect, DFC_BUTTON, DFCS_BUTTONPUSH);
  1054. InflateRect(&rect, -2, -2);
  1055. }
  1056. else if(sbut->uButType & SBBM_TYPE3)
  1057. {
  1058. DrawFrameControl(hdc, &rect, DFC_BUTTON, DFCS_BUTTONPUSH);
  1059. InflateRect(&rect, -1, -1);
  1060. }
  1061. else
  1062. {
  1063. DrawEdge(hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
  1064. rect.bottom++;
  1065. rect.right++;
  1066. }
  1067. OffsetRect(&rect, -1, -1);
  1068. rect.top++; rect.left++;
  1069. }
  1070. if(sbut->hBmp)
  1071. {
  1072. PaintRect(hdc, &rect, GetSysColor(COLOR_3DFACE));
  1073. if(flags & SBBS_PUSHED)
  1074. {
  1075. rect.top++; rect.left++;
  1076. }
  1077. IntersectClipRect(hdc, rect.left, rect.top, rect.right,rect.bottom);
  1078. DrawImage(hdc, sbut->hBmp, &rect);
  1079. SelectClipRgn(hdc, 0);
  1080. }
  1081. else if(sbut->hEmf)
  1082. {
  1083. PaintRect(hdc, &rect, GetSysColor(COLOR_3DFACE));
  1084. InflateRect(&rect, -1, -1);
  1085. if(flags & SBBS_PUSHED)
  1086. {
  1087. rect.top++; rect.left++;
  1088. }
  1089. IntersectClipRect(hdc, rect.left, rect.top, rect.right,rect.bottom);
  1090. DrawMetaFile(hdc, sbut->hEmf, &rect);
  1091. SelectClipRgn(hdc, 0);
  1092. }
  1093. else
  1094. {
  1095. PaintRect(hdc, &rect, GetSysColor(COLOR_3DFACE));
  1096. }
  1097. }
  1098. break;
  1099. case SBBT_BLANK:
  1100. PaintRect(hdc, &rect, GetSysColor(COLOR_3DFACE));
  1101. break;
  1102. case SBBT_FLAT:
  1103. DrawBlankButton(hdc, &rect, BF_FLAT);
  1104. break;
  1105. case SBBT_DARK:
  1106. PaintRect(hdc, &rect, GetSysColor(COLOR_3DDKSHADOW));
  1107. break;
  1108. }
  1109. return 0;
  1110. }
  1111. //
  1112. // Draw any buttons inserted into the horizontal scrollbar
  1113. // assume that the button widths have already been calculated
  1114. // Note: RECT *rect is the rectangle of the scrollbar
  1115. //       leftright: 1 = left, 2 = right, 3 = both
  1116. //
  1117. static LRESULT DrawHorzButtons(SCROLLBAR *sbar, HDC hdc, const RECT *rect, int leftright)
  1118. {
  1119. int i;
  1120. int xposl, xposr;
  1121. RECT ctrl;
  1122. SCROLLBUT *sbut = sbar->sbButtons;
  1123. xposl = rect->left - sbar->nButSizeBefore;
  1124. xposr = rect->right;
  1125. for(i = 0; i < sbar->nButtons; i++)
  1126. {
  1127. if((leftright & SBBP_LEFT) && sbut[i].uPlacement == SBBP_LEFT)
  1128. {
  1129. int butwidth = GetSingleButSize(sbar, &sbut[i]);
  1130. SetRect(&ctrl, xposl, rect->top, xposl + butwidth, rect->bottom);
  1131. RotateRect0(sbar, &ctrl);
  1132. DrawScrollButton(&sbut[i], hdc, &ctrl, SBBS_NORMAL);
  1133. xposl += butwidth;
  1134. }
  1135. if((leftright & SBBP_RIGHT) && sbut[i].uPlacement == SBBP_RIGHT)
  1136. {
  1137. int butwidth = GetSingleButSize(sbar, &sbut[i]);
  1138. SetRect(&ctrl, xposr, rect->top, xposr + butwidth, rect->bottom);
  1139. RotateRect0(sbar, &ctrl);
  1140. DrawScrollButton(&sbut[i], hdc, &ctrl, SBBS_NORMAL);
  1141. xposr += butwidth;
  1142. }
  1143. }
  1144. return 0;
  1145. }
  1146. static LRESULT DrawVertButtons(SCROLLBAR *sbar, HDC hdc, const RECT *rect, int leftright)
  1147. {
  1148. RECT rc = *rect;
  1149. RotateRect(&rc);
  1150. DrawHorzButtons(sbar, hdc, &rc, leftright);
  1151. return 0;
  1152. }
  1153. #endif // INCLUDE_BUTTONS
  1154. //
  1155. // Define these two for proper processing of NCPAINT
  1156. // NOT needed if we don't bother to mask the scrollbars we draw
  1157. // to prevent the old window procedure from accidently drawing over them
  1158. //
  1159. HDC CoolSB_GetDC(HWND hwnd, WPARAM wParam)
  1160. {
  1161. // I just can't figure out GetDCEx, so I'll just use this:
  1162. return GetWindowDC(hwnd);
  1163. /*
  1164. RECT rc;
  1165. DWORD flags = 0x10000;
  1166. HRGN hrgn = (HRGN)wParam;
  1167. if(hrgn == (HRGN)1)
  1168. {
  1169. GetWindowRect(hwnd, &rc);
  1170. OffsetRect(&rc, -rc.left, -rc.top);
  1171. hrgn = CreateRectRgnIndirect(&rc);
  1172. }
  1173. if(GetWindowLong(hwnd, GWL_STYLE) & WS_CLIPCHILDREN)
  1174. flags |= DCX_CLIPCHILDREN;
  1175. if(GetWindowLong(hwnd, GWL_STYLE) & WS_CLIPSIBLINGS)
  1176. flags |= DCX_CLIPSIBLINGS;
  1177. return GetDCEx(hwnd, hrgn, flags | DCX_CACHE|DCX_NORESETATTRS|DCX_WINDOW | DCX_INTERSECTUPDATE);
  1178. */
  1179. //return GetDCEx(hwnd, NULL, flags | DCX_WINDOW| DCX_NORESETATTRS);
  1180. }
  1181. static LRESULT NCPaint(SCROLLWND *sw, HWND hwnd, WPARAM wParam, LPARAM lParam)
  1182. {
  1183. SCROLLBAR *sb;
  1184. HDC hdc;
  1185. HRGN hrgn;
  1186. RECT winrect, rect;
  1187. HRGN clip;
  1188. BOOL fUpdateAll = ((LONG)wParam == 1);
  1189. BOOL fCustomDraw = FALSE;
  1190. UINT ret;
  1191. DWORD dwStyle;
  1192. GetWindowRect(hwnd, &winrect);
  1193. //if entire region needs painting, then make a region to cover the entire window
  1194. if(fUpdateAll)
  1195. hrgn = (HRGN)wParam;
  1196. else
  1197. hrgn = (HRGN)wParam;
  1198. //hdc = GetWindowDC(hwnd);
  1199. hdc = CoolSB_GetDC(hwnd, wParam);
  1200. //
  1201. // Only draw the horizontal scrollbar if the window is tall enough
  1202. //
  1203. sb = &sw->sbarHorz;
  1204. if(sb->fScrollVisible)
  1205. {
  1206. int hbarwidth = 0, leftright = 0;
  1207. //get the screen coordinates of the whole horizontal scrollbar area
  1208. GetHScrollRect(sw, hwnd, &rect);
  1209. //make the coordinates relative to the window for drawing
  1210. OffsetRect(&rect, -winrect.left, -winrect.top);
  1211. #ifdef INCLUDE_BUTTONS
  1212. //work out the size of any inserted buttons so we can dra them
  1213. sb->nButSizeBefore  = GetButtonSize(sb, hwnd, SBBP_LEFT);
  1214. sb->nButSizeAfter   = GetButtonSize(sb, hwnd, SBBP_RIGHT);
  1215. //make sure there is room for the buttons
  1216. hbarwidth = rect.right - rect.left;
  1217. //check that we can fit any left/right buttons in the available space
  1218. if(sb->nButSizeAfter < (hbarwidth - MIN_COOLSB_SIZE))
  1219. {
  1220. //adjust the scrollbar rectangle to fit the buttons into
  1221. sb->fButVisibleAfter = TRUE;
  1222. rect.right -= sb->nButSizeAfter;
  1223. leftright |= SBBP_RIGHT;
  1224. //check that there is enough space for the right buttons
  1225. if(sb->nButSizeBefore + sb->nButSizeAfter < (hbarwidth - MIN_COOLSB_SIZE))
  1226. {
  1227. sb->fButVisibleBefore = TRUE;
  1228. rect.left += sb->nButSizeBefore;
  1229. leftright |= SBBP_LEFT;
  1230. }
  1231. else
  1232. sb->fButVisibleBefore = FALSE;
  1233. }
  1234. else
  1235. sb->fButVisibleAfter = FALSE;
  1236. DrawHorzButtons(sb, hdc, &rect, leftright);
  1237. #endif// INCLUDE_BUTTONS
  1238. if(uCurrentScrollbar == SB_HORZ)
  1239. fCustomDraw |= NCDrawHScrollbar(sb, hwnd, hdc, &rect, uScrollTimerPortion);
  1240. else
  1241. fCustomDraw |= NCDrawHScrollbar(sb, hwnd, hdc, &rect, HTSCROLL_NONE);
  1242. }
  1243. //
  1244. // Only draw the vertical scrollbar if the window is wide enough to accomodate it
  1245. //
  1246. sb = &sw->sbarVert;
  1247. if(sb->fScrollVisible)
  1248. {
  1249. int vbarheight = 0, updown = 0;
  1250. //get the screen cooridinates of the whole horizontal scrollbar area
  1251. GetVScrollRect(sw, hwnd, &rect);
  1252. //make the coordinates relative to the window for drawing
  1253. OffsetRect(&rect, -winrect.left, -winrect.top);
  1254. #ifdef INCLUDE_BUTTONS
  1255. //work out the size of any inserted buttons so we can dra them
  1256. sb->nButSizeBefore  = GetButtonSize(sb, hwnd, SBBP_LEFT);
  1257. sb->nButSizeAfter   = GetButtonSize(sb, hwnd, SBBP_RIGHT);
  1258. //make sure there is room for the buttons
  1259. vbarheight = rect.bottom - rect.top;
  1260. //check that we can fit any left/right buttons in the available space
  1261. if(sb->nButSizeAfter < (vbarheight - MIN_COOLSB_SIZE))
  1262. {
  1263. //adjust the scrollbar rectangle to fit the buttons into
  1264. sb->fButVisibleAfter = TRUE;
  1265. rect.bottom -= sb->nButSizeAfter;
  1266. updown |= SBBP_BOTTOM;
  1267. //check that there is enough space for the right buttons
  1268. if(sb->nButSizeBefore + sb->nButSizeAfter < (vbarheight - MIN_COOLSB_SIZE))
  1269. {
  1270. sb->fButVisibleBefore = TRUE;
  1271. rect.top += sb->nButSizeBefore;
  1272. updown |= SBBP_TOP;
  1273. }
  1274. else
  1275. sb->fButVisibleBefore = FALSE;
  1276. }
  1277. else
  1278. sb->fButVisibleAfter = FALSE;
  1279. DrawVertButtons(sb, hdc, &rect, updown);
  1280. #endif // INCLUDE_BUTTONS
  1281. if(uCurrentScrollbar == SB_VERT)
  1282. fCustomDraw |= NCDrawVScrollbar(sb, hwnd, hdc, &rect, uScrollTimerPortion);
  1283. else
  1284. fCustomDraw |= NCDrawVScrollbar(sb, hwnd, hdc, &rect, HTSCROLL_NONE);
  1285. }
  1286. //Call the default window procedure for WM_NCPAINT, with the
  1287. //new window region. ** region must be in SCREEN coordinates **
  1288. dwStyle = GetWindowLong(hwnd, GWL_STYLE);
  1289.     // If the window has WS_(H-V)SCROLL bits set, we should reset them
  1290.     // to avoid windows taking the scrollbars into account.
  1291.     // We temporarily set a flag preventing the subsecuent 
  1292.     // WM_STYLECHANGING/WM_STYLECHANGED to be forwarded to 
  1293.     // the original window procedure
  1294.     if ( dwStyle & (WS_VSCROLL|WS_HSCROLL) )
  1295.     {
  1296.         sw->bPreventStyleChange = TRUE;
  1297.         SetWindowLong(hwnd, GWL_STYLE, dwStyle & ~(WS_VSCROLL|WS_HSCROLL));
  1298.     }
  1299. ret = CallWindowProc(sw->oldproc, hwnd, WM_NCPAINT, (WPARAM)hrgn, lParam);
  1300.     if ( dwStyle & (WS_VSCROLL|WS_HSCROLL) )
  1301.     {
  1302.         SetWindowLong(hwnd, GWL_STYLE, dwStyle);
  1303.         sw->bPreventStyleChange = FALSE;
  1304.     }
  1305. // DRAW THE DEAD AREA
  1306. // only do this if the horizontal and vertical bars are visible
  1307. if(sw->sbarHorz.fScrollVisible && sw->sbarVert.fScrollVisible)
  1308. {
  1309. GetWindowRect(hwnd, &rect);
  1310. OffsetRect(&rect, -winrect.left, -winrect.top);
  1311. rect.bottom -= sw->cyBottomEdge;
  1312. rect.top  = rect.bottom - GetScrollMetric(&sw->sbarHorz, SM_CYHORZSB);
  1313. if(sw->fLeftScrollbar)
  1314. {
  1315. rect.left += sw->cxLeftEdge;
  1316. rect.right = rect.left + GetScrollMetric(&sw->sbarVert, SM_CXVERTSB);
  1317. }
  1318. else
  1319. {
  1320. rect.right -= sw->cxRightEdge;
  1321. rect.left = rect.right  - GetScrollMetric(&sw->sbarVert, SM_CXVERTSB);
  1322. }
  1323. if(fCustomDraw)
  1324. PostCustomDrawNotify(hwnd, hdc, SB_BOTH, &rect, 32, 0, 0, 0);
  1325. else
  1326. {
  1327. //calculate the position of THIS window's dead area
  1328. //with the position of the PARENT window's client rectangle.
  1329. //if THIS window has been positioned such that its bottom-right
  1330. //corner sits in the parent's bottom-right corner, then we should
  1331. //show the sizing-grip.
  1332. //Otherwise, assume this window is not in the right place, and
  1333. //just draw a blank rectangle
  1334. RECT parent;
  1335. RECT rect2;
  1336. HWND hwndParent = GetParent(hwnd);
  1337. GetClientRect(hwndParent, &parent);
  1338. MapWindowPoints(hwndParent, 0, (POINT *)&parent, 2);
  1339. CopyRect(&rect2, &rect);
  1340. OffsetRect(&rect2, winrect.left, winrect.top);
  1341. if(!sw->fLeftScrollbar && parent.right == rect2.right+sw->cxRightEdge && parent.bottom == rect2.bottom+sw->cyBottomEdge
  1342.  || sw->fLeftScrollbar && parent.left  == rect2.left -sw->cxLeftEdge  && parent.bottom == rect2.bottom+sw->cyBottomEdge)
  1343. DrawFrameControl(hdc, &rect, DFC_SCROLL, sw->fLeftScrollbar ? DFCS_SCROLLSIZEGRIPRIGHT : DFCS_SCROLLSIZEGRIP );
  1344. else
  1345. PaintRect(hdc, &rect, GetSysColor(COLOR_3DFACE));
  1346. }
  1347. }
  1348. UNREFERENCED_PARAMETER(clip);
  1349. ReleaseDC(hwnd, hdc);
  1350. return ret;
  1351. }
  1352. //
  1353. // Need to detect if we have clicked in the scrollbar region or not
  1354. //
  1355. static LRESULT NCHitTest(SCROLLWND *sw, HWND hwnd, WPARAM wParam, LPARAM lParam)
  1356. {
  1357. RECT hrect;
  1358. RECT vrect;
  1359. POINT pt;
  1360. pt.x = LOWORD(lParam);
  1361. pt.y = HIWORD(lParam);
  1362. //work out exactly where the Horizontal and Vertical scrollbars are
  1363. GetHScrollRect(sw, hwnd, &hrect);
  1364. GetVScrollRect(sw, hwnd, &vrect);
  1365. //Clicked in the horizontal scrollbar area
  1366. if(sw->sbarHorz.fScrollVisible && PtInRect(&hrect, pt))
  1367. {
  1368. return HTHSCROLL;
  1369. }
  1370. //Clicked in the vertical scrollbar area
  1371. else if(sw->sbarVert.fScrollVisible && PtInRect(&vrect, pt))
  1372. {
  1373. return HTVSCROLL;
  1374. }
  1375. //clicked somewhere else
  1376. else
  1377. {
  1378. return CallWindowProc(sw->oldproc, hwnd, WM_NCHITTEST, wParam, lParam);
  1379. }
  1380. }
  1381. //
  1382. // Return a HT* value indicating what part of the scrollbar was clicked
  1383. // Rectangle is not adjusted
  1384. //
  1385. static UINT GetHorzPortion(SCROLLBAR *sb, HWND hwnd, RECT *rect, int x, int y)
  1386. {
  1387. RECT rc = *rect;
  1388. if(y < rc.top || y >= rc.bottom) return HTSCROLL_NONE;
  1389. #ifdef INCLUDE_BUTTONS
  1390. if(sb->fButVisibleBefore) 
  1391. {
  1392. //clicked on the buttons to the left of the scrollbar
  1393. if(x >= rc.left && x < rc.left + sb->nButSizeBefore)
  1394. return HTSCROLL_INSERTED;
  1395. //adjust the rectangle to exclude the left-side buttons, now that we
  1396. //know we havn't clicked on them
  1397. rc.left  += sb->nButSizeBefore;
  1398. }
  1399. if(sb->fButVisibleAfter)
  1400. {
  1401. //clicked on the buttons to the right of the scrollbar
  1402. if(x >= rc.right - sb->nButSizeAfter && x < rc.right)
  1403. return HTSCROLL_INSERTED;
  1404. //adjust the rectangle to exclude the right-side buttons, now that we
  1405. //know we havn't clicked on them
  1406. rc.right -= sb->nButSizeAfter;
  1407. }
  1408. #endif INCLUDE_BUTTONS
  1409. //Now we have the rectangle for the scrollbar itself, so work out
  1410. //what part we clicked on.
  1411. return GetHorzScrollPortion(sb, hwnd, &rc, x, y);
  1412. }
  1413. //
  1414. // Just call the horizontal version, with adjusted coordinates
  1415. //
  1416. static UINT GetVertPortion(SCROLLBAR *sb, HWND hwnd, RECT *rect, int x, int y)
  1417. {
  1418. UINT ret;
  1419. RotateRect(rect);
  1420. ret = GetHorzPortion(sb, hwnd, rect, y, x);
  1421. RotateRect(rect);
  1422. return ret;
  1423. }
  1424. //
  1425. // Wrapper function for GetHorzPortion and GetVertPortion
  1426. //
  1427. static UINT GetPortion(SCROLLBAR *sb, HWND hwnd, RECT *rect, int x, int y)
  1428. {
  1429. if(sb->nBarType == SB_HORZ)
  1430. return GetHorzPortion(sb, hwnd, rect, x, y);
  1431. else if(sb->nBarType == SB_VERT)
  1432. return GetVertPortion(sb, hwnd, rect, x, y);
  1433. else
  1434. return HTSCROLL_NONE;
  1435. }
  1436. //
  1437. // Input: rectangle of the total scrollbar area
  1438. // Output: adjusted to take the inserted buttons into account
  1439. //
  1440. static void GetRealHorzScrollRect(SCROLLBAR *sb, RECT *rect)
  1441. {
  1442. if(sb->fButVisibleBefore) rect->left += sb->nButSizeBefore;
  1443. if(sb->fButVisibleAfter)  rect->right -= sb->nButSizeAfter;
  1444. }
  1445. //
  1446. // Input: rectangle of the total scrollbar area
  1447. // Output: adjusted to take the inserted buttons into account
  1448. //
  1449. static void GetRealVertScrollRect(SCROLLBAR *sb, RECT *rect)
  1450. {
  1451. if(sb->fButVisibleBefore) rect->top += sb->nButSizeBefore;
  1452. if(sb->fButVisibleAfter)  rect->bottom -= sb->nButSizeAfter;
  1453. }
  1454. //
  1455. // Decide which type of scrollbar we have before calling
  1456. //  the real function to do the job
  1457. //
  1458. static void GetRealScrollRect(SCROLLBAR *sb, RECT *rect)
  1459. {
  1460. if(sb->nBarType == SB_HORZ)
  1461. {
  1462. GetRealHorzScrollRect(sb, rect);
  1463. }
  1464. else if(sb->nBarType == SB_VERT)
  1465. {
  1466. GetRealVertScrollRect(sb, rect);
  1467. }
  1468. }
  1469. //
  1470. // All button code shoule be collected together
  1471. //
  1472. //
  1473. #ifdef INCLUDE_BUTTONS
  1474. //
  1475. // Return the index of the button covering the specified point
  1476. // rect - rectangle of the whole scrollbar area
  1477. // pt - screen coords of the mouse
  1478. // fReturnRect - do/don't modify the rect to return the button's area
  1479. //
  1480. static UINT GetHorzButtonFromPt(SCROLLBAR *sb, RECT *rect, POINT pt, BOOL fReturnRect)
  1481. {
  1482. int leftpos = rect->left, rightpos = rect->right;
  1483. int i;
  1484. int butwidth;
  1485. SCROLLBUT *sbut = sb->sbButtons;
  1486. if(!PtInRect(rect, pt))
  1487. return -1;
  1488. if(sb->fButVisibleAfter)
  1489. rightpos -= sb->nButSizeAfter;
  1490. for(i = 0; i < sb->nButtons; i++)
  1491. {
  1492. if(sb->fButVisibleBefore && sbut[i].uPlacement == SBBP_LEFT)
  1493. {
  1494. butwidth = GetSingleButSize(sb, &sbut[i]);
  1495. //if the current button is under the specified point
  1496. if(pt.x >= leftpos && pt.x < leftpos + butwidth)
  1497. {
  1498. //if the caller wants us to return the rectangle of the button
  1499. if(fReturnRect)
  1500. {
  1501. rect->left  = leftpos;
  1502. rect->right = leftpos + butwidth;
  1503. }
  1504. return i;
  1505. }
  1506. leftpos += butwidth;
  1507. }
  1508. else if(sb->fButVisibleAfter && sbut[i].uPlacement == SBBP_RIGHT)
  1509. {
  1510. butwidth = GetSingleButSize(sb, &sbut[i]);
  1511. //if the current button is under the specified point
  1512. if(pt.x >= rightpos && pt.x < rightpos + butwidth)
  1513. {
  1514. //if the caller wants us to return the rectangle of the button
  1515. if(fReturnRect)
  1516. {
  1517. rect->left  = rightpos;
  1518. rect->right = rightpos + butwidth;
  1519. }
  1520. return i;
  1521. }
  1522. rightpos += butwidth;
  1523. }
  1524. }
  1525. return -1;
  1526. }
  1527. static UINT GetVertButtonFromPt(SCROLLBAR *sb, RECT *rect, POINT pt, BOOL fReturnRect)
  1528. {
  1529. UINT ret;
  1530. int temp;
  1531. //swap the X/Y coords
  1532. temp = pt.x;
  1533. pt.x = pt.y;
  1534. pt.y = temp;
  1535. //swap the rectangle
  1536. RotateRect(rect);
  1537. ret = GetHorzButtonFromPt(sb, rect, pt, fReturnRect);
  1538. RotateRect(rect);
  1539. return ret;
  1540. }
  1541. //
  1542. //
  1543. //
  1544. static UINT GetButtonFromPt(SCROLLBAR *sb, RECT *rect, POINT pt, BOOL fReturnRect)
  1545. {
  1546. if(sb->nBarType == SB_HORZ)
  1547. {
  1548. return GetHorzButtonFromPt(sb, rect, pt, fReturnRect);
  1549. }
  1550. else
  1551. {
  1552. return GetVertButtonFromPt(sb, rect, pt, fReturnRect);
  1553. }
  1554. }
  1555. //
  1556. // Find the coordinates (in RECT format) of the specified button index
  1557. //
  1558. static UINT GetHorzButtonRectFromId(SCROLLBAR *sb, RECT *rect, UINT index)
  1559. {
  1560. UINT i;
  1561. SCROLLBUT *sbut = sb->sbButtons;
  1562. int leftpos = rect->left, rightpos = rect->right;
  1563. if(sb->fButVisibleAfter)
  1564. rightpos -= sb->nButSizeAfter;
  1565. //find the particular button in question
  1566. for(i = 0; i < index; i++)
  1567. {
  1568. if(sb->fButVisibleBefore && sbut[i].uPlacement == SBBP_LEFT)
  1569. {
  1570. leftpos += GetSingleButSize(sb, &sbut[i]);
  1571. }
  1572. else if(sb->fButVisibleAfter && sbut[i].uPlacement == SBBP_RIGHT)
  1573. {
  1574. rightpos += GetSingleButSize(sb, &sbut[i]);
  1575. }
  1576. }
  1577. //now return the rectangle
  1578. if(sbut[i].uPlacement == SBBP_LEFT)
  1579. {
  1580. rect->left  = leftpos;
  1581. rect->right = leftpos + GetSingleButSize(sb, &sbut[i]);
  1582. }
  1583. else
  1584. {
  1585. rect->left  = rightpos;
  1586. rect->right = rightpos + GetSingleButSize(sb, &sbut[i]);
  1587. }
  1588. return 0;
  1589. }
  1590. static UINT GetVertButtonRectFromId(SCROLLBAR *sb, RECT *rect, UINT index)
  1591. {
  1592. UINT ret;
  1593. RotateRect(rect);
  1594. ret = GetHorzButtonRectFromId(sb, rect, index);
  1595. RotateRect(rect);
  1596. return ret;
  1597. }
  1598. static UINT GetButtonRectFromId(SCROLLBAR *sb, RECT *rect, UINT index)
  1599. {
  1600. if(sb->nBarType == SB_HORZ)
  1601. {
  1602. return GetHorzButtonRectFromId(sb, rect, index);
  1603. }
  1604. else
  1605. {
  1606. return GetVertButtonRectFromId(sb, rect, index);
  1607. }
  1608. }
  1609. #endif //INCLUDE_BUTTONS
  1610. //
  1611. // Left button click in the non-client area
  1612. //
  1613. static LRESULT NCLButtonDown(SCROLLWND *sw, HWND hwnd, WPARAM wParam, LPARAM lParam)
  1614. {
  1615. RECT rect, winrect;
  1616. HDC hdc;
  1617. SCROLLBAR *sb;
  1618. SCROLLBUT *sbut = 0;
  1619. POINT pt;
  1620. pt.x = LOWORD(lParam);
  1621. pt.y = HIWORD(lParam);
  1622. hwndCurCoolSB = hwnd;
  1623. //
  1624. // HORIZONTAL SCROLLBAR PROCESSING
  1625. //
  1626. if(wParam == HTHSCROLL)
  1627. {
  1628. uScrollTimerMsg = WM_HSCROLL;
  1629. uCurrentScrollbar = SB_HORZ;
  1630. sb = &sw->sbarHorz;
  1631. //get the total area of the normal Horz scrollbar area
  1632. GetHScrollRect(sw, hwnd, &rect);
  1633. uCurrentScrollPortion = GetHorzPortion(sb, hwnd, &rect, LOWORD(lParam), HIWORD(lParam));
  1634. }
  1635. //
  1636. // VERTICAL SCROLLBAR PROCESSING
  1637. //
  1638. else if(wParam == HTVSCROLL)
  1639. {
  1640. uScrollTimerMsg = WM_VSCROLL;
  1641. uCurrentScrollbar = SB_VERT;
  1642. sb = &sw->sbarVert;
  1643. //get the total area of the normal Horz scrollbar area
  1644. GetVScrollRect(sw, hwnd, &rect);
  1645. uCurrentScrollPortion = GetVertPortion(sb, hwnd, &rect, LOWORD(lParam), HIWORD(lParam));
  1646. }
  1647. //
  1648. // NORMAL PROCESSING
  1649. //
  1650. else
  1651. {
  1652. uCurrentScrollPortion = HTSCROLL_NONE;
  1653. return CallWindowProc(sw->oldproc, hwnd, WM_NCLBUTTONDOWN, wParam, lParam);
  1654. }
  1655. //
  1656. // we can now share the same code for vertical
  1657. // and horizontal scrollbars
  1658. //
  1659. switch(uCurrentScrollPortion)
  1660. {
  1661. //inserted buttons to the left/right
  1662. #ifdef INCLUDE_BUTTONS
  1663. case HTSCROLL_INSERTED:  
  1664. #ifdef HOT_TRACKING
  1665. KillTimer(hwnd, uMouseOverId);
  1666. uMouseOverId = 0;
  1667. uMouseOverScrollbar = COOLSB_NONE;
  1668. #endif
  1669. //find the index of the button that has been clicked
  1670. //adjust the rectangle to give the button's rectangle
  1671. uCurrentButton = GetButtonFromPt(sb, &rect, pt, TRUE);
  1672. sbut = &sb->sbButtons[uCurrentButton];
  1673. //post a notification message
  1674. PostMouseNotify(hwnd, NM_CLICK, sb->nBarType, &rect, sbut->uCmdId, pt);
  1675. GetWindowRect(hwnd, &winrect);
  1676. OffsetRect(&rect, -winrect.left, -winrect.top);
  1677. hdc = GetWindowDC(hwnd);
  1678. DrawScrollButton(sbut, hdc, &rect, SBBS_PUSHED);
  1679. ReleaseDC(hwnd, hdc);
  1680. break;
  1681. #endif //INCLUDE_BUTTONS
  1682. case HTSCROLL_THUMB: 
  1683. //if the scrollbar is disabled, then do no further processing
  1684. if(!IsScrollbarActive(sb))
  1685. return 0;
  1686. GetRealScrollRect(sb, &rect);
  1687. RotateRect0(sb, &rect);
  1688. CalcThumbSize(sb, &rect, &nThumbSize, &nThumbPos);
  1689. RotateRect0(sb, &rect);
  1690. //remember the bounding rectangle of the scrollbar work area
  1691. rcThumbBounds = rect;
  1692. sw->fThumbTracking = TRUE;
  1693. sb->scrollInfo.nTrackPos = sb->scrollInfo.nPos;
  1694. if(wParam == HTVSCROLL) 
  1695. nThumbMouseOffset = pt.y - nThumbPos;
  1696. else
  1697. nThumbMouseOffset = pt.x - nThumbPos;
  1698. nLastPos = -sb->scrollInfo.nPos;
  1699. nThumbPos0 = nThumbPos;
  1700. //if(sb->fFlatScrollbar)
  1701. //{
  1702. GetWindowRect(hwnd, &winrect);
  1703. OffsetRect(&rect, -winrect.left, -winrect.top);
  1704. hdc = GetWindowDC(hwnd);
  1705. NCDrawScrollbar(sb, hwnd, hdc, &rect, HTSCROLL_THUMB);
  1706. ReleaseDC(hwnd, hdc);
  1707. //}
  1708. break;
  1709. //Any part of the scrollbar
  1710. case HTSCROLL_LEFT:  
  1711. if(sb->fScrollFlags & ESB_DISABLE_LEFT) return 0;
  1712. else goto target1;
  1713. case HTSCROLL_RIGHT: 
  1714. if(sb->fScrollFlags & ESB_DISABLE_RIGHT) return 0;
  1715. else goto target1;
  1716. goto target1;
  1717. case HTSCROLL_PAGELEFT:  case HTSCROLL_PAGERIGHT:
  1718. target1:
  1719. //if the scrollbar is disabled, then do no further processing
  1720. if(!IsScrollbarActive(sb))
  1721. break;
  1722. //ajust the horizontal rectangle to NOT include
  1723. //any inserted buttons
  1724. GetRealScrollRect(sb, &rect);
  1725. SendScrollMessage(hwnd, uScrollTimerMsg, uCurrentScrollPortion, 0);
  1726. // Check what area the mouse is now over :
  1727. // If the scroll thumb has moved under the mouse in response to 
  1728. // a call to SetScrollPos etc, then we don't hilight the scrollbar margin
  1729. if(uCurrentScrollbar == SB_HORZ)
  1730. uScrollTimerPortion = GetHorzScrollPortion(sb, hwnd, &rect, pt.x, pt.y);
  1731. else
  1732. uScrollTimerPortion = GetVertScrollPortion(sb, hwnd, &rect, pt.x, pt.y);
  1733. GetWindowRect(hwnd, &winrect);
  1734. OffsetRect(&rect, -winrect.left, -winrect.top);
  1735. hdc = GetWindowDC(hwnd);
  1736. #ifndef HOT_TRACKING
  1737. //if we aren't hot-tracking, then don't highlight 
  1738. //the scrollbar thumb unless we click on it
  1739. if(uScrollTimerPortion == HTSCROLL_THUMB)
  1740. uScrollTimerPortion = HTSCROLL_NONE;
  1741. #endif
  1742. NCDrawScrollbar(sb, hwnd, hdc, &rect, uScrollTimerPortion);
  1743. ReleaseDC(hwnd, hdc);
  1744. //Post the scroll message!!!!
  1745. uScrollTimerPortion = uCurrentScrollPortion;
  1746. //set a timer going on the first click.
  1747. //if this one expires, then we can start off a more regular timer
  1748. //to generate the auto-scroll behaviour
  1749. uScrollTimerId = SetTimer(hwnd, COOLSB_TIMERID1, COOLSB_TIMERINTERVAL1, 0);
  1750. break;
  1751. default:
  1752. return CallWindowProc(sw->oldproc, hwnd, WM_NCLBUTTONDOWN, wParam, lParam);
  1753. //return 0;
  1754. }
  1755. SetCapture(hwnd);
  1756. return 0;
  1757. }
  1758. //
  1759. // Left button released
  1760. //
  1761. static LRESULT LButtonUp(SCROLLWND *sw, HWND hwnd, WPARAM wParam, LPARAM lParam)
  1762. {
  1763. RECT rect;
  1764. //UINT thisportion;
  1765. HDC hdc;
  1766. POINT pt;
  1767. RECT winrect;
  1768. UINT buttonIdx = 0;
  1769. //current scrollportion is the button that we clicked down on
  1770. if(uCurrentScrollPortion != HTSCROLL_NONE)
  1771. {
  1772. SCROLLBAR *sb = &sw->sbarHorz;
  1773. lParam = GetMessagePos();
  1774. ReleaseCapture();
  1775. GetWindowRect(hwnd, &winrect);
  1776. pt.x = LOWORD(lParam);
  1777. pt.y = HIWORD(lParam);
  1778. //emulate the mouse input on a scrollbar here...
  1779. if(uCurrentScrollbar == SB_HORZ)
  1780. {
  1781. //get the total area of the normal Horz scrollbar area
  1782. sb = &sw->sbarHorz;
  1783. GetHScrollRect(sw, hwnd, &rect);
  1784. }
  1785. else if(uCurrentScrollbar == SB_VERT)
  1786. {
  1787. //get the total area of the normal Horz scrollbar area
  1788. sb = &sw->sbarVert;
  1789. GetVScrollRect(sw, hwnd, &rect);
  1790. }
  1791. //we need to do different things depending on if the
  1792. //user is activating the scrollbar itself, or one of
  1793. //the inserted buttons
  1794. switch(uCurrentScrollPortion)
  1795. {
  1796. #ifdef INCLUDE_BUTTONS
  1797. //inserted buttons are being clicked
  1798. case HTSCROLL_INSERTED:
  1799. //get the rectangle of the ACTIVE button 
  1800. buttonIdx = GetButtonFromPt(sb, &rect, pt, FALSE);
  1801. GetButtonRectFromId(sb, &rect, uCurrentButton);
  1802. OffsetRect(&rect, -winrect.left, -winrect.top);
  1803. //Send the notification BEFORE we redraw, so the
  1804. //bitmap can be changed smoothly by the user if they require
  1805. if(uCurrentButton == buttonIdx)
  1806. {
  1807. SCROLLBUT *sbut = &sb->sbButtons[buttonIdx];
  1808. UINT cmdid = sbut->uCmdId;
  1809. if((sbut->uButType & SBBT_MASK) == SBBT_TOGGLEBUTTON)
  1810. sbut->uState ^= 1;
  1811. //send a notify??
  1812. //only post a message if the command id is valid
  1813. if(cmdid != -1 && cmdid > 0)
  1814. SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(cmdid, CSBN_CLICKED), 0);
  1815. //user might have deleted this button, so redraw whole area
  1816. NCPaint(sw, hwnd, 1, 0);
  1817. }
  1818. else
  1819. {
  1820. //otherwise, just redraw the button in its new state
  1821. hdc = GetWindowDC(hwnd);
  1822. DrawScrollButton(&sb->sbButtons[uCurrentButton], hdc, &rect, SBBS_NORMAL);
  1823. ReleaseDC(hwnd, hdc);
  1824. }
  1825. break;
  1826. #endif // INCLUDE_BUTTONS
  1827. //The scrollbar is active
  1828. case HTSCROLL_LEFT:  case HTSCROLL_RIGHT: 
  1829. case HTSCROLL_PAGELEFT:  case HTSCROLL_PAGERIGHT: 
  1830. case HTSCROLL_NONE:
  1831. KillTimer(hwnd, uScrollTimerId);
  1832. case HTSCROLL_THUMB: 
  1833. //In case we were thumb tracking, make sure we stop NOW
  1834. if(sw->fThumbTracking == TRUE)
  1835. {
  1836. SendScrollMessage(hwnd, uScrollTimerMsg, SB_THUMBPOSITION, nLastPos);
  1837. sw->fThumbTracking = FALSE;
  1838. }
  1839. //send the SB_ENDSCROLL message now that scrolling has finished
  1840. SendScrollMessage(hwnd, uScrollTimerMsg, SB_ENDSCROLL, 0);
  1841. //adjust the total scroll area to become where the scrollbar
  1842. //really is (take into account the inserted buttons)
  1843. GetRealScrollRect(sb, &rect);
  1844. OffsetRect(&rect, -winrect.left, -winrect.top);
  1845. hdc = GetWindowDC(hwnd);
  1846. //draw whichever scrollbar sb is
  1847. NCDrawScrollbar(sb, hwnd, hdc, &rect, HTSCROLL_NORMAL);
  1848. ReleaseDC(hwnd, hdc);
  1849. break;
  1850. }
  1851. //reset our state to default
  1852. uCurrentScrollPortion = HTSCROLL_NONE;
  1853. uScrollTimerPortion   = HTSCROLL_NONE;
  1854. uScrollTimerId   = 0;
  1855. uScrollTimerMsg       = 0;
  1856. uCurrentScrollbar     = COOLSB_NONE;
  1857. return 0;
  1858. }
  1859. else
  1860. {
  1861. /*
  1862. // Can't remember why I did this!
  1863. if(GetCapture() == hwnd)
  1864. {
  1865. ReleaseCapture();
  1866. }*/
  1867. }
  1868. return CallWindowProc(sw->oldproc, hwnd, WM_LBUTTONUP, wParam, lParam);
  1869. }
  1870. //
  1871. // This function is called whenever the mouse is moved and 
  1872. //  we are dragging the scrollbar thumb about.
  1873. //
  1874. static LRESULT ThumbTrackHorz(SCROLLBAR *sbar, HWND hwnd, int x, int y)
  1875. {
  1876. POINT pt;
  1877. RECT rc, winrect, rc2;
  1878. COLORREF crCheck1 = GetSBForeColor();
  1879. COLORREF crCheck2 = GetSBBackColor();
  1880. HDC hdc;
  1881. int thumbpos = nThumbPos;
  1882. int pos;
  1883. int siMaxMin = 0;
  1884. UINT flatflag = sbar->fFlatScrollbar ? BF_FLAT : 0;
  1885. BOOL fCustomDraw = FALSE;
  1886. SCROLLINFO *si;
  1887. si = &sbar->scrollInfo;
  1888. pt.x = x;
  1889. pt.y = y;
  1890. //draw the thumb at whatever position
  1891. rc = rcThumbBounds;
  1892. SetRect(&rc2, rc.left -  THUMBTRACK_SNAPDIST*2, rc.top -    THUMBTRACK_SNAPDIST, 
  1893.   rc.right + THUMBTRACK_SNAPDIST*2, rc.bottom + THUMBTRACK_SNAPDIST);
  1894. rc.left +=  GetScrollMetric(sbar, SM_CXHORZSB);
  1895. rc.right -= GetScrollMetric(sbar, SM_CXHORZSB);
  1896. //if the mouse is not in a suitable distance of the scrollbar,
  1897. //then "snap" the thumb back to its initial position
  1898. #ifdef SNAP_THUMB_BACK
  1899. if(!PtInRect(&rc2, pt))
  1900. {
  1901. thumbpos = nThumbPos0;
  1902. }
  1903. //otherwise, move the thumb to where the mouse is
  1904. else
  1905. #endif //SNAP_THUMB_BACK
  1906. {
  1907. //keep the thumb within the scrollbar limits
  1908. thumbpos = pt.x - nThumbMouseOffset;
  1909. if(thumbpos < rc.left) thumbpos = rc.left;
  1910. if(thumbpos > rc.right - nThumbSize) thumbpos = rc.right - nThumbSize;
  1911. }
  1912. GetWindowRect(hwnd, &winrect);
  1913. if(sbar->nBarType == SB_VERT)
  1914. RotateRect(&winrect);
  1915. hdc = GetWindowDC(hwnd);
  1916. #ifdef CUSTOM_DRAW
  1917. fCustomDraw = PostCustomPrePostPaint(hwnd, hdc, sbar, CDDS_PREPAINT) == CDRF_SKIPDEFAULT;
  1918. #endif
  1919. OffsetRect(&rc, -winrect.left, -winrect.top);
  1920. thumbpos -= winrect.left;
  1921. //draw the margin before the thumb
  1922. SetRect(&rc2, rc.left, rc.top, thumbpos, rc.bottom);
  1923. RotateRect0(sbar, &rc2);
  1924. if(fCustomDraw)
  1925. PostCustomDrawNotify(hwnd, hdc, sbar->nBarType, &rc2, SB_PAGELEFT, 0, 0, 0);
  1926. else
  1927. DrawCheckedRect(hdc, &rc2, crCheck1, crCheck2);
  1928. RotateRect0(sbar, &rc2);
  1929. //draw the margin after the thumb 
  1930. SetRect(&rc2, thumbpos+nThumbSize, rc.top, rc.right, rc.bottom);
  1931. RotateRect0(sbar, &rc2);
  1932. if(fCustomDraw)
  1933. PostCustomDrawNotify(hwnd, hdc, sbar->nBarType, &rc2, SB_PAGERIGHT, 0, 0, 0);
  1934. else
  1935. DrawCheckedRect(hdc, &rc2, crCheck1, crCheck2);
  1936. RotateRect0(sbar, &rc2);
  1937. //finally draw the thumb itelf. This is how it looks on win2000, anyway
  1938. SetRect(&rc2, thumbpos, rc.top, thumbpos+nThumbSize, rc.bottom);
  1939. RotateRect0(sbar, &rc2);
  1940. if(fCustomDraw)
  1941. PostCustomDrawNotify(hwnd, hdc, sbar->nBarType, &rc2, SB_THUMBTRACK, TRUE, TRUE, FALSE);
  1942. else
  1943. {
  1944. #ifdef FLAT_SCROLLBARS
  1945. if(sbar->fFlatScrollbar)
  1946. PaintRect(hdc, &rc2, GetSysColor(COLOR_3DSHADOW));
  1947. else
  1948. #endif
  1949. {
  1950. DrawBlankButton(hdc, &rc2, flatflag);
  1951. }
  1952. }
  1953. RotateRect0(sbar, &rc2);
  1954. ReleaseDC(hwnd, hdc);
  1955. //post a SB_TRACKPOS message!!!
  1956. siMaxMin = si->nMax - si->nMin;
  1957. if(siMaxMin > 0)
  1958. pos = MulDiv(thumbpos-rc.left, siMaxMin-si->nPage + 1, rc.right-rc.left-nThumbSize);
  1959. else
  1960. pos = thumbpos - rc.left;
  1961. if(pos != nLastPos)
  1962. {
  1963. si->nTrackPos = pos;
  1964. SendScrollMessage(hwnd, uScrollTimerMsg, SB_THUMBTRACK, pos);
  1965. }
  1966. nLastPos = pos;
  1967. #ifdef CUSTOM_DRAW
  1968. PostCustomPrePostPaint(hwnd, hdc, sbar, CDDS_POSTPAINT);
  1969. #endif
  1970. return 0;
  1971. }
  1972. //
  1973. // remember to rotate the thumb bounds rectangle!!
  1974. //
  1975. static LRESULT ThumbTrackVert(SCROLLBAR *sb, HWND hwnd, int x, int y)
  1976. {
  1977. //sw->swapcoords = TRUE;
  1978. RotateRect(&rcThumbBounds);
  1979. ThumbTrackHorz(sb, hwnd, y, x);
  1980. RotateRect(&rcThumbBounds);
  1981. //sw->swapcoords = FALSE;
  1982. return 0;
  1983. }
  1984. //
  1985. // Called when we have set the capture from the NCLButtonDown(...)
  1986. //
  1987. static LRESULT MouseMove(SCROLLWND *sw, HWND hwnd, WPARAM wParam, LPARAM lParam)
  1988. {
  1989. RECT rect;
  1990. UINT thisportion;
  1991. HDC hdc;
  1992. static UINT lastportion = 0;
  1993. static UINT lastbutton = 0;
  1994. POINT pt;
  1995. RECT winrect;
  1996. UINT buttonIdx = 0;
  1997. if(sw->fThumbTracking == TRUE)
  1998. {
  1999. int x, y;
  2000. lParam = GetMessagePos();
  2001. x = LOWORD(lParam);
  2002. y = HIWORD(lParam);
  2003. if(uCurrentScrollbar == SB_HORZ)
  2004. return ThumbTrackHorz(&sw->sbarHorz, hwnd, x,y);
  2005. else if(uCurrentScrollbar == SB_VERT)
  2006. return ThumbTrackVert(&sw->sbarVert, hwnd, x,y);
  2007. }
  2008. if(uCurrentScrollPortion == HTSCROLL_NONE)
  2009. {
  2010. return CallWindowProc(sw->oldproc, hwnd, WM_MOUSEMOVE, wParam, lParam);
  2011. }
  2012. else
  2013. {
  2014. LPARAM nlParam;
  2015. SCROLLBAR *sb = &sw->sbarHorz;
  2016. SCROLLBUT *sbut = 0;
  2017. nlParam = GetMessagePos();
  2018. GetWindowRect(hwnd, &winrect);
  2019. pt.x = LOWORD(nlParam);
  2020. pt.y = HIWORD(nlParam);
  2021. //emulate the mouse input on a scrollbar here...
  2022. if(uCurrentScrollbar == SB_HORZ)
  2023. {
  2024. sb = &sw->sbarHorz;
  2025. }
  2026. else if(uCurrentScrollbar == SB_VERT)
  2027. {
  2028. sb = &sw->sbarVert;
  2029. }
  2030. //get the total area of the normal scrollbar area
  2031. GetScrollRect(sw, sb->nBarType, hwnd, &rect);
  2032. //see if we clicked in the inserted buttons / normal scrollbar
  2033. //thisportion = GetPortion(sb, hwnd, &rect, LOWORD(lParam), HIWORD(lParam));
  2034. thisportion = GetPortion(sb, hwnd, &rect, pt.x, pt.y);
  2035. //we need to do different things depending on if the
  2036. //user is activating the scrollbar itself, or one of
  2037. //the inserted buttons
  2038. switch(uCurrentScrollPortion)
  2039. {
  2040. #ifdef INCLUDE_BUTTONS
  2041. //inserted buttons are being clicked
  2042. case HTSCROLL_INSERTED:
  2043. //find the index of the button that has been clicked
  2044. //Don't adjust the rectangle though
  2045. buttonIdx = GetButtonFromPt(sb, &rect, pt, FALSE);
  2046. //Get the rectangle of the active button
  2047. GetButtonRectFromId(sb, &rect, uCurrentButton);
  2048. //if the button to the LEFT of the current 
  2049. //button is resizable, then resize it
  2050. #ifdef RESIZABLE_BUTTONS
  2051. if(uCurrentButton > 0)
  2052. {
  2053. sbut = &sb->sbButtons[uCurrentButton - 1];
  2054. //only resize if BOTH buttons are on same side of scrollbar
  2055. if(sbut->uPlacement == (sbut+1)->uPlacement && (sbut->uButType & SBBM_RESIZABLE))
  2056. {
  2057. int oldsize = sbut->nSize;
  2058. int butsize1, butsize2;
  2059. RECT rect2;
  2060. int scrollsize;
  2061. if(uCurrentScrollbar == SB_HORZ)
  2062. {
  2063. rect.left -= GetSingleButSize(sb, sbut);
  2064. sbut->nSize = pt.x - rect.left;
  2065. }
  2066. else
  2067. {
  2068. rect.top -= GetSingleButSize(sb, sbut);
  2069. sbut->nSize = pt.y - rect.top;
  2070. }
  2071. //if(sbut->nSize < 0) sbut->nSize = 0;
  2072. if(sbut->nSize < (int)sbut->nMinSize)
  2073. sbut->nSize = sbut->nMinSize;
  2074. if((UINT)sbut->nSize > (UINT)sbut->nMaxSize)
  2075. sbut->nSize = sbut->nMaxSize;
  2076. GetScrollRect(sw, uCurrentScrollbar, hwnd, &rect2);
  2077. if(uCurrentScrollbar == SB_HORZ)
  2078. scrollsize = rect2.right-rect2.left;
  2079. else
  2080. scrollsize = rect2.bottom-rect2.top;
  2081. butsize1 = GetButtonSize(sb, hwnd, SBBP_LEFT);
  2082. butsize2 = GetButtonSize(sb, hwnd, SBBP_RIGHT);
  2083. //adjust the button size if it gets too big
  2084. if(butsize1 + butsize2 > scrollsize  - MINSCROLLSIZE)
  2085. {
  2086. sbut->nSize -= (butsize1+butsize2) - (scrollsize - MINSCROLLSIZE);
  2087. }
  2088. //remember what size the USER set the button to
  2089. sbut->nSizeReserved = sbut->nSize;
  2090. NCPaint(sw, hwnd, (WPARAM)1, (LPARAM)0);
  2091. return 0;
  2092. }
  2093. }
  2094. #endif //RESIZABLE_BUTTONS
  2095. OffsetRect(&rect, -winrect.left, -winrect.top);
  2096. hdc = GetWindowDC(hwnd);
  2097. //if the button under the mouse is not the active button,
  2098. //then display the active button in its normal state
  2099. if(buttonIdx != uCurrentButton 
  2100. //include this if toggle buttons always stay depressed
  2101. //if they are being activated
  2102. && (sb->sbButtons[uCurrentButton].uButType & SBBT_MASK) != SBBT_TOGGLEBUTTON)
  2103. {
  2104. if(lastbutton != buttonIdx)
  2105. DrawScrollButton(&sb->sbButtons[uCurrentButton], hdc, &rect, SBBS_NORMAL);
  2106. }
  2107. //otherwise, depress the active button if the mouse is over
  2108. //it (just like a normal scroll button works)
  2109. else
  2110. {
  2111. if(lastbutton != buttonIdx)
  2112. DrawScrollButton(&sb->sbButtons[uCurrentButton], hdc, &rect, SBBS_PUSHED);
  2113. }
  2114. ReleaseDC(hwnd, hdc);
  2115. return CallWindowProc(sw->oldproc, hwnd, WM_MOUSEMOVE, wParam, lParam);
  2116. //break;
  2117. #endif //INCLUDE_BUTTONS
  2118. //The scrollbar is active
  2119. case HTSCROLL_LEFT:  case HTSCROLL_RIGHT:case HTSCROLL_THUMB: 
  2120. case HTSCROLL_PAGELEFT:  case HTSCROLL_PAGERIGHT: 
  2121. case HTSCROLL_NONE:
  2122. //adjust the total scroll area to become where the scrollbar
  2123. //really is (take into account the inserted buttons)
  2124. GetRealScrollRect(sb, &rect);
  2125. OffsetRect(&rect, -winrect.left, -winrect.top);
  2126. hdc = GetWindowDC(hwnd);
  2127. if(thisportion != uCurrentScrollPortion)
  2128. {
  2129. uScrollTimerPortion = HTSCROLL_NONE;
  2130. if(lastportion != thisportion)
  2131. NCDrawScrollbar(sb, hwnd, hdc, &rect, HTSCROLL_NORMAL);
  2132. }
  2133. //otherwise, draw the button in its depressed / clicked state
  2134. else
  2135. {
  2136. uScrollTimerPortion = uCurrentScrollPortion;
  2137. if(lastportion != thisportion)
  2138. NCDrawScrollbar(sb, hwnd, hdc, &rect, thisportion);
  2139. }
  2140. ReleaseDC(hwnd, hdc);
  2141. break;
  2142. }
  2143. lastportion = thisportion;
  2144. lastbutton  = buttonIdx;
  2145. //must return zero here, because we might get cursor anomilies
  2146. //CallWindowProc(sw->oldproc, hwnd, WM_MOUSEMOVE, wParam, lParam);
  2147. return 0;
  2148. }
  2149. }
  2150. #ifdef INCLUDE_BUTTONS
  2151. #ifdef RESIZABLE_BUTTONS
  2152. //
  2153. // Any resizable buttons must be shrunk to fit if the window is made too small
  2154. //
  2155. static void ResizeButtonsToFit(SCROLLWND *sw, SCROLLBAR *sbar, HWND hwnd)
  2156. {
  2157. int butsize1, butsize2;
  2158. RECT rc;
  2159. int scrollsize;
  2160. int i;
  2161. SCROLLBUT *sbut;
  2162. //make sure that the scrollbar can fit into space, by
  2163. //shrinking any resizable buttons
  2164. GetScrollRect(sw, sbar->nBarType, hwnd, &rc);
  2165. if(sbar->nBarType == SB_HORZ)
  2166. scrollsize = rc.right-rc.left;
  2167. else
  2168. scrollsize = rc.bottom-rc.top;
  2169. //restore any resizable buttons to their user-defined sizes,
  2170. //before shrinking them to fit. This means when we make the window
  2171. //bigger, the buttons will restore to their initial sizes
  2172. for(i = 0; i < sbar->nButtons; i++)
  2173. {
  2174. sbut = &sbar->sbButtons[i];
  2175. if(sbut->uButType & SBBM_RESIZABLE)
  2176. {
  2177. sbut->nSize = sbut->nSizeReserved;
  2178. }
  2179. }
  2180. butsize1 = GetButtonSize(sbar, hwnd, SBBP_LEFT);
  2181. butsize2 = GetButtonSize(sbar, hwnd, SBBP_RIGHT);
  2182. if(butsize1 + butsize2 > scrollsize - MINSCROLLSIZE)
  2183. {
  2184. i = 0;
  2185. while(i < sbar->nButtons && 
  2186. butsize1 + butsize2 > scrollsize - MINSCROLLSIZE)
  2187. {
  2188. sbut = &sbar->sbButtons[i++];
  2189. if(sbut->uButType & SBBM_RESIZABLE)
  2190. {
  2191. int oldsize = sbut->nSize;
  2192. sbut->nSize -= (butsize1+butsize2) - (scrollsize-MINSCROLLSIZE);
  2193. if(sbut->nSize < (int)sbut->nMinSize)
  2194. sbut->nSize = sbut->nMinSize;
  2195. if((UINT)sbut->nSize > (UINT)sbut->nMaxSize)
  2196. sbut->nSize = sbut->nMaxSize;
  2197. butsize1 -= (oldsize - sbut->nSize);
  2198. }
  2199. }
  2200. }
  2201. }
  2202. #endif
  2203. #endif
  2204. //
  2205. // We must allocate from in the non-client area for our scrollbars
  2206. // Call the default window procedure first, to get the borders (if any)
  2207. // allocated some space, then allocate the space for the scrollbars
  2208. // if they fit
  2209. //
  2210. static LRESULT NCCalcSize(SCROLLWND *sw, HWND hwnd, WPARAM wParam, LPARAM lParam)
  2211. {
  2212. NCCALCSIZE_PARAMS *nccsp;
  2213. RECT *rect;
  2214. RECT oldrect;
  2215. BOOL fCalcValidRects = (wParam == TRUE);
  2216. SCROLLBAR *sb;
  2217. UINT ret;
  2218. DWORD dwStyle;
  2219. //Regardless of the value of fCalcValidRects, the first rectangle 
  2220. //in the array specified by the rgrc structure member of the 
  2221. //NCCALCSIZE_PARAMS structure contains the coordinates of the window,
  2222. //so we can use the exact same code to modify this rectangle, when
  2223. //wParam is TRUE and when it is FALSE.
  2224. nccsp = (NCCALCSIZE_PARAMS *)lParam;
  2225. rect = &nccsp->rgrc[0];
  2226. oldrect = *rect;
  2227. dwStyle = GetWindowLong(hwnd, GWL_STYLE);
  2228. // TURN OFF SCROLL-STYLES.
  2229.     if ( dwStyle & (WS_VSCROLL|WS_HSCROLL) )
  2230.     {
  2231.         sw->bPreventStyleChange = TRUE;
  2232.         SetWindowLong(hwnd, GWL_STYLE, dwStyle & ~(WS_VSCROLL|WS_HSCROLL));
  2233.     }
  2234. //call the default procedure to get the borders allocated
  2235. ret = CallWindowProc(sw->oldproc, hwnd, WM_NCCALCSIZE, wParam, lParam);
  2236. // RESTORE PREVIOUS STYLES (if present at all)
  2237.     if ( dwStyle & (WS_VSCROLL|WS_HSCROLL) )
  2238.     {
  2239.         sw->bPreventStyleChange = TRUE;
  2240.         SetWindowLong(hwnd, GWL_STYLE, dwStyle);
  2241.     }
  2242. // calculate what the size of each window border is,
  2243. sw->cxLeftEdge   = rect->left     - oldrect.left;
  2244. sw->cxRightEdge  = oldrect.right  - rect->right;
  2245. sw->cyTopEdge    = rect->top      - oldrect.top;
  2246. sw->cyBottomEdge = oldrect.bottom - rect->bottom;
  2247. sb = &sw->sbarHorz;
  2248. //if there is room, allocate some space for the horizontal scrollbar
  2249. //NOTE: Change the ">" to a ">=" to make the horz bar totally fill the
  2250. //window before disappearing
  2251. if((sb->fScrollFlags & CSBS_VISIBLE) && 
  2252. #ifdef COOLSB_FILLWINDOW
  2253. rect->bottom - rect->top >= GetScrollMetric(sb, SM_CYHORZSB))
  2254. #else
  2255. rect->bottom - rect->top > GetScrollMetric(sb, SM_CYHORZSB))
  2256. #endif
  2257. {
  2258. rect->bottom -= GetScrollMetric(sb, SM_CYHORZSB);
  2259. sb->fScrollVisible = TRUE;
  2260. }
  2261. else
  2262. sb->fScrollVisible = FALSE;
  2263. sb = &sw->sbarVert;
  2264. //if there is room, allocate some space for the vertical scrollbar
  2265. if((sb->fScrollFlags & CSBS_VISIBLE) && 
  2266. rect->right - rect->left >= GetScrollMetric(sb, SM_CXVERTSB))
  2267. {
  2268. if(sw->fLeftScrollbar)
  2269. rect->left  += GetScrollMetric(sb, SM_CXVERTSB);
  2270. else
  2271. rect->right -= GetScrollMetric(sb, SM_CXVERTSB);
  2272. sb->fScrollVisible = TRUE;
  2273. }
  2274. else
  2275. sb->fScrollVisible = FALSE;
  2276. #ifdef INCLUDE_BUTTONS
  2277. #ifdef RESIZABLE_BUTTONS
  2278. ResizeButtonsToFit(sw, &sw->sbarHorz, hwnd);
  2279. ResizeButtonsToFit(sw, &sw->sbarVert, hwnd);
  2280. #endif
  2281. #endif
  2282. //don't return a value unless we actually modify the other rectangles
  2283. //in the NCCALCSIZE_PARAMS structure. In this case, we return 0
  2284. //no matter what the value of fCalcValidRects is
  2285. return ret;//FALSE;
  2286. }
  2287. //
  2288. // used for hot-tracking over the scroll buttons
  2289. //
  2290. static LRESULT NCMouseMove(SCROLLWND *sw, HWND hwnd, WPARAM wHitTest, LPARAM lParam)
  2291. {
  2292. //install a timer for the mouse-over events, if the mouse moves
  2293. //over one of the scrollbars
  2294. #ifdef HOT_TRACKING
  2295. hwndCurCoolSB = hwnd;
  2296. if(wHitTest == HTHSCROLL)
  2297. {
  2298. if(uMouseOverScrollbar == SB_HORZ)
  2299. return CallWindowProc(sw->oldproc, hwnd, WM_NCMOUSEMOVE, wHitTest, lParam);
  2300. uLastHitTestPortion = HTSCROLL_NONE;
  2301. uHitTestPortion     = HTSCROLL_NONE;
  2302. GetScrollRect(sw, SB_HORZ, hwnd, &MouseOverRect);
  2303. uMouseOverScrollbar = SB_HORZ;
  2304. uMouseOverId = SetTimer(hwnd, COOLSB_TIMERID3, COOLSB_TIMERINTERVAL3, 0);
  2305. NCPaint(sw, hwnd, 1, 0);
  2306. }
  2307. else if(wHitTest == HTVSCROLL)
  2308. {
  2309. if(uMouseOverScrollbar == SB_VERT)
  2310. return CallWindowProc(sw->oldproc, hwnd, WM_NCMOUSEMOVE, wHitTest, lParam);
  2311. uLastHitTestPortion = HTSCROLL_NONE;
  2312. uHitTestPortion     = HTSCROLL_NONE;
  2313. GetScrollRect(sw, SB_VERT, hwnd, &MouseOverRect);
  2314. uMouseOverScrollbar = SB_VERT;
  2315. uMouseOverId = SetTimer(hwnd, COOLSB_TIMERID3, COOLSB_TIMERINTERVAL3, 0);
  2316. NCPaint(sw, hwnd, 1, 0);
  2317. }
  2318. #endif //HOT_TRACKING
  2319. return CallWindowProc(sw->oldproc, hwnd, WM_NCMOUSEMOVE, wHitTest, lParam);
  2320. }
  2321. //
  2322. // Timer routine to generate scrollbar messages
  2323. //
  2324. static LRESULT CoolSB_Timer(SCROLLWND *swnd, HWND hwnd, WPARAM wTimerId, LPARAM lParam)
  2325. {
  2326. //let all timer messages go past if we don't have a timer installed ourselves
  2327. if(uScrollTimerId == 0 && uMouseOverId == 0)
  2328. {
  2329. return CallWindowProc(swnd->oldproc, hwnd, WM_TIMER, wTimerId, lParam);
  2330. }
  2331. #ifdef HOT_TRACKING
  2332. //mouse-over timer
  2333. if(wTimerId == COOLSB_TIMERID3)
  2334. {
  2335. POINT pt;
  2336. RECT rect, winrect;
  2337. HDC hdc;
  2338. SCROLLBAR *sbar;
  2339. if(swnd->fThumbTracking)
  2340. return 0;
  2341. //if the mouse moves outside the current scrollbar,
  2342. //then kill the timer..
  2343. GetCursorPos(&pt);
  2344. if(!PtInRect(&MouseOverRect, pt))
  2345. {
  2346. KillTimer(hwnd, uMouseOverId);
  2347. uMouseOverId = 0;
  2348. uMouseOverScrollbar = COOLSB_NONE;
  2349. uLastHitTestPortion = HTSCROLL_NONE;
  2350. uHitTestPortion = HTSCROLL_NONE;
  2351. NCPaint(swnd, hwnd, 1, 0);
  2352. }
  2353. else
  2354. {
  2355. if(uMouseOverScrollbar == SB_HORZ)
  2356. {
  2357. sbar = &swnd->sbarHorz;
  2358. uHitTestPortion = GetHorzPortion(sbar, hwnd, &MouseOverRect, pt.x, pt.y);
  2359. }
  2360. else
  2361. {
  2362. sbar = &swnd->sbarVert;
  2363. uHitTestPortion = GetVertPortion(sbar, hwnd, &MouseOverRect, pt.x, pt.y);
  2364. }
  2365. if(uLastHitTestPortion != uHitTestPortion)
  2366. {
  2367. rect = MouseOverRect;
  2368. GetRealScrollRect(sbar, &rect);
  2369. GetWindowRect(hwnd, &winrect);
  2370. OffsetRect(&rect, -winrect.left, -winrect.top);
  2371. hdc = GetWindowDC(hwnd);
  2372. NCDrawScrollbar(sbar, hwnd, hdc, &rect, HTSCROLL_NONE);
  2373. ReleaseDC(hwnd, hdc);
  2374. }
  2375. uLastHitTestPortion = uHitTestPortion;
  2376. }
  2377. return 0;
  2378. }
  2379. #endif // HOT_TRACKING
  2380. //if the first timer goes off, then we can start a more
  2381. //regular timer interval to auto-generate scroll messages
  2382. //this gives a slight pause between first pressing the scroll arrow, and the
  2383. //actual scroll starting
  2384. if(wTimerId == COOLSB_TIMERID1)
  2385. {
  2386. KillTimer(hwnd, uScrollTimerId);
  2387. uScrollTimerId = SetTimer(hwnd, COOLSB_TIMERID2, COOLSB_TIMERINTERVAL2, 0);
  2388. return 0;
  2389. }
  2390. //send the scrollbar message repeatedly
  2391. else if(wTimerId == COOLSB_TIMERID2)
  2392. {
  2393. //need to process a spoof WM_MOUSEMOVE, so that
  2394. //we know where the mouse is each time the scroll timer goes off.
  2395. //This is so we can stop sending scroll messages if the thumb moves
  2396. //under the mouse.
  2397. POINT pt;
  2398. GetCursorPos(&pt);
  2399. ScreenToClient(hwnd, &pt);
  2400. MouseMove(swnd, hwnd, MK_LBUTTON, MAKELPARAM(pt.x, pt.y));
  2401. if(uScrollTimerPortion != HTSCROLL_NONE)
  2402. SendScrollMessage(hwnd, uScrollTimerMsg, uScrollTimerPortion, 0);
  2403. return 0;
  2404. }
  2405. else
  2406. {
  2407. return CallWindowProc(swnd->oldproc, hwnd, WM_TIMER, wTimerId, lParam);
  2408. }
  2409. }
  2410. //
  2411. // We must intercept any calls to SetWindowLong, to check if
  2412. //  left-scrollbars are taking effect or not
  2413. //
  2414. static LRESULT CoolSB_StyleChange(SCROLLWND *swnd, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  2415. {
  2416. STYLESTRUCT *ss = (STYLESTRUCT *)lParam;
  2417. if(wParam == GWL_EXSTYLE)
  2418. {
  2419. if(ss->styleNew & WS_EX_LEFTSCROLLBAR)
  2420. swnd->fLeftScrollbar = TRUE;
  2421. else
  2422. swnd->fLeftScrollbar = FALSE;
  2423. }
  2424. return CallWindowProc(swnd->oldproc, hwnd, msg, wParam, lParam);
  2425. }
  2426. static UINT curTool = -1;
  2427. static LRESULT CoolSB_Notify(SCROLLWND *swnd, HWND hwnd, WPARAM wParam, LPARAM lParam)
  2428. {
  2429. #ifdef COOLSB_TOOLTIPS
  2430. NMTTDISPINFO *nmdi = (NMTTDISPINFO *)lParam;
  2431. if(nmdi->hdr.hwndFrom == swnd->hwndToolTip &&
  2432. nmdi->hdr.code == TTN_GETDISPINFO)
  2433. {
  2434. //convert the tooltip notify from a "ISHWND" style
  2435. //request to an id-based request. 
  2436. //We do this because our tooltip is a window-style
  2437. //tip, with no tools, and the GETDISPINFO request must
  2438. //indicate which button to retrieve the text for
  2439. //nmdi->hdr.idFrom = curTool;
  2440. nmdi->hdr.idFrom = curTool;
  2441. nmdi->hinst = GetModuleHandle(0);
  2442. nmdi->uFlags &= ~TTF_IDISHWND;
  2443. }
  2444. #endif //COOLSB_TOOLTIPS
  2445. return CallWindowProc(swnd->oldproc, hwnd, WM_NOTIFY, wParam, lParam);
  2446. }
  2447. static LRESULT SendToolTipMessage0(HWND hwndTT, UINT message, WPARAM wParam, LPARAM lParam)
  2448. {
  2449. return SendMessage(hwndTT, message, wParam, lParam);
  2450. }
  2451. #ifdef COOLSB_TOOLTIPS
  2452. #define SendToolTipMessage SendToolTipMessage0
  2453. #else
  2454. #define SendToolTipMessage 1 ? (void)0 : SendToolTipMessage0
  2455. #endif
  2456. //
  2457. // We must intercept any calls to SetWindowLong, to make sure that
  2458. // the user does not set the WS_VSCROLL or WS_HSCROLL styles
  2459. //
  2460. static LRESULT CoolSB_SetCursor(SCROLLWND *swnd, HWND hwnd, WPARAM wParam, LPARAM lParam)
  2461. {
  2462. #ifdef INCLUDE_BUTTONS
  2463. UINT lo = LOWORD(lParam);
  2464. UINT hi = HIWORD(lParam);
  2465. UINT xy;
  2466. RECT rect;
  2467. SCROLLBAR *sbar;
  2468. SCROLLBUT *sbut;
  2469. POINT pt;
  2470. UINT id;
  2471. static UINT lastid;
  2472. #ifdef HIDE_CURSOR_AFTER_MOUSEUP
  2473. static UINT lastmsg;
  2474. if(lastmsg == WM_LBUTTONDOWN)
  2475. {
  2476. lastmsg =  hi;
  2477. return CallWindowProc(swnd->oldproc, hwnd, WM_SETCURSOR, wParam, lParam);
  2478. }
  2479. else
  2480. lastmsg =  hi;
  2481. #endif
  2482. //if we are over either or our scrollbars
  2483. if(lo == HTHSCROLL || lo == HTVSCROLL)
  2484. {
  2485. xy = GetMessagePos();
  2486. pt.x = LOWORD(xy);
  2487. pt.y = HIWORD(xy);
  2488. if(lo == HTHSCROLL)
  2489. {
  2490. sbar = &swnd->sbarHorz;
  2491. GetScrollRect(swnd, SB_HORZ, hwnd, &rect);
  2492. id = GetHorzPortion(sbar, hwnd, &rect, pt.x, pt.y);
  2493. }
  2494. else
  2495. {
  2496. sbar = &swnd->sbarVert;
  2497. GetScrollRect(swnd, SB_VERT, hwnd, &rect);
  2498. id = GetVertPortion(sbar, hwnd, &rect, pt.x, pt.y);
  2499. }
  2500. if(id != HTSCROLL_INSERTED)
  2501. {
  2502. if(swnd->hwndToolTip != 0)
  2503. {
  2504. SendToolTipMessage(swnd->hwndToolTip, TTM_ACTIVATE, FALSE, 0);
  2505. SendToolTipMessage(swnd->hwndToolTip, TTM_POP, 0, 0);
  2506. }
  2507. return CallWindowProc(swnd->oldproc, hwnd, WM_SETCURSOR, wParam, lParam);
  2508. }
  2509. if(swnd->hwndToolTip != 0)
  2510. {
  2511. SendToolTipMessage(swnd->hwndToolTip, TTM_ACTIVATE, TRUE, 0);
  2512. }
  2513. //set the cursor if one has been specified
  2514. if((id = GetButtonFromPt(sbar, &rect, pt, TRUE)) != -1)
  2515. {
  2516. sbut = &sbar->sbButtons[id];
  2517. curTool = sbut->uCmdId;
  2518. if(lastid != id && swnd->hwndToolTip != 0)
  2519. {
  2520. if(IsWindowVisible(swnd->hwndToolTip))
  2521. SendToolTipMessage(swnd->hwndToolTip, TTM_UPDATE, TRUE, 0);
  2522. }
  2523. lastid = id;
  2524. if(sbut->hCurs != 0)
  2525. {
  2526. SetCursor(sbut->hCurs);
  2527. return 0;
  2528. }
  2529. }
  2530. else
  2531. {
  2532. curTool = -1;
  2533. lastid = -1;
  2534. }
  2535. }
  2536. else if(swnd->hwndToolTip != 0)
  2537. {
  2538. SendToolTipMessage(swnd->hwndToolTip, TTM_ACTIVATE, FALSE, 0);
  2539. SendToolTipMessage(swnd->hwndToolTip, TTM_POP, 0, 0);
  2540. }
  2541. #endif //INCLUDE_BUTTONS
  2542. return CallWindowProc(swnd->oldproc, hwnd, WM_SETCURSOR, wParam, lParam);
  2543. }
  2544. //
  2545. // Send the specified message to the tooltip control
  2546. //
  2547. static void __stdcall RelayMouseEvent(HWND hwnd, HWND hwndToolTip, UINT event)
  2548. {
  2549. #ifdef COOLSB_TOOLTIPS
  2550. MSG msg;
  2551. CoolSB_ZeroMemory(&msg, sizeof(MSG));
  2552. msg.hwnd = hwnd;
  2553. msg.message = event;
  2554. SendMessage(hwndToolTip, TTM_RELAYEVENT, 0, (LONG)&msg);
  2555. #else
  2556. UNREFERENCED_PARAMETER(hwnd);
  2557. UNREFERENCED_PARAMETER(hwndToolTip);
  2558. UNREFERENCED_PARAMETER(event);
  2559. #endif
  2560. }
  2561. //
  2562. //  CoolScrollbar subclass procedure.
  2563. // Handle all messages needed to mimick normal windows scrollbars
  2564. //
  2565. LRESULT CALLBACK CoolSBWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  2566. {
  2567. WNDPROC oldproc;
  2568. SCROLLWND *swnd = GetScrollWndFromHwnd(hwnd);
  2569. static int count;
  2570. switch(message)
  2571. {
  2572. case WM_NCDESTROY:
  2573. //this should NEVER be called, because the user
  2574. //should have called Uninitialize() themselves.
  2575. //However, if the user tries to call Uninitialize().. 
  2576. //after this window is destroyed, this window's entry in the lookup
  2577. //table will not be there, and the call will fail
  2578. oldproc = swnd->oldproc;
  2579. UninitializeCoolSB(hwnd);
  2580. //we must call the original window procedure, otherwise it
  2581. //will never get the WM_NCDESTROY message, and it wouldn't
  2582. //be able to clean up etc.
  2583. return CallWindowProc(oldproc, hwnd, message, wParam, lParam);
  2584. case WM_NCCALCSIZE:
  2585. return NCCalcSize(swnd, hwnd, wParam, lParam);
  2586. case WM_NCPAINT:
  2587. return NCPaint(swnd, hwnd, wParam, lParam);
  2588. case WM_NCHITTEST:
  2589. return NCHitTest(swnd, hwnd, wParam, lParam);
  2590. case WM_NCRBUTTONDOWN: case WM_NCRBUTTONUP: 
  2591. case WM_NCMBUTTONDOWN: case WM_NCMBUTTONUP: 
  2592. RelayMouseEvent(hwnd, swnd->hwndToolTip, (WM_MOUSEMOVE-WM_NCMOUSEMOVE) + (message));
  2593. if(wParam == HTHSCROLL || wParam == HTVSCROLL) 
  2594. return 0;
  2595. else 
  2596. break;
  2597. case WM_NCLBUTTONDBLCLK:
  2598. //TRACE("WM_NCLBUTTONDBLCLK %dn", count++);
  2599. if(wParam == HTHSCROLL || wParam == HTVSCROLL)
  2600. return NCLButtonDown(swnd, hwnd, wParam, lParam);
  2601. else
  2602. break;
  2603. case WM_NCLBUTTONDOWN:
  2604. //TRACE("WM_NCLBUTTONDOWN%dn", count++);
  2605. RelayMouseEvent(hwnd, swnd->hwndToolTip, WM_LBUTTONDOWN);
  2606. return NCLButtonDown(swnd, hwnd, wParam, lParam);
  2607. case WM_LBUTTONUP:
  2608. //TRACE("WM_LBUTTONUP %dn", count++);
  2609. RelayMouseEvent(hwnd, swnd->hwndToolTip, WM_LBUTTONUP);
  2610. return LButtonUp(swnd, hwnd, wParam, lParam);
  2611. case WM_NOTIFY:
  2612. return CoolSB_Notify(swnd, hwnd, wParam, lParam);
  2613. //Mouse moves are received when we set the mouse capture,
  2614. //even when the mouse moves over the non-client area
  2615. case WM_MOUSEMOVE: 
  2616. //TRACE("WM_MOUSEMOVE %dn", count++);
  2617. return MouseMove(swnd, hwnd, wParam, lParam);
  2618. case WM_TIMER:
  2619. return CoolSB_Timer(swnd, hwnd, wParam, lParam);
  2620. //case WM_STYLECHANGING:
  2621. // return CoolSB_StyleChange(swnd, hwnd, WM_STYLECHANGING, wParam, lParam);
  2622. case WM_STYLECHANGED:
  2623. if(swnd->bPreventStyleChange)
  2624. {
  2625. // the NCPAINT handler has told us to eat this message!
  2626. return 0;
  2627. }
  2628. else
  2629. {
  2630.             if (message == WM_STYLECHANGED) 
  2631. return CoolSB_StyleChange(swnd, hwnd, WM_STYLECHANGED, wParam, lParam);
  2632. else
  2633. break;
  2634. }
  2635. case WM_NCMOUSEMOVE: 
  2636. {
  2637. static LONG lastpos = -1;
  2638. //TRACE("WM_NCMOUSEMOVE %dn", count++);
  2639. //The problem with NCMOUSEMOVE is that it is sent continuously
  2640. //even when the mouse is stationary (under win2000 / win98)
  2641. //
  2642. //Tooltips don't like being sent a continous stream of mouse-moves
  2643. //if the cursor isn't moving, because they will think that the mouse
  2644. //is moving position, and the internal timer will never expire
  2645. //
  2646. if(lastpos != lParam)
  2647. {
  2648. RelayMouseEvent(hwnd, swnd->hwndToolTip, WM_MOUSEMOVE);
  2649. lastpos = lParam;
  2650. }
  2651. }
  2652. return NCMouseMove(swnd, hwnd, wParam, lParam);
  2653. case WM_SETCURSOR:
  2654. return CoolSB_SetCursor(swnd, hwnd, wParam, lParam);
  2655. case WM_CAPTURECHANGED:
  2656. break;
  2657. default:
  2658. break;
  2659. }
  2660. return CallWindowProc(swnd->oldproc, hwnd, message, wParam, lParam);
  2661. }