开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
coolsblib.c
资源名称：cool_scrollbar.zip　[点击查看]
上传用户：xhri001
上传日期：2022-07-04
资源大小：99k
文件大小：24k
源码类别：

界面编程

开发平台：

Visual C++

coolsblib.c：源码内容
  1. /*
  3. Cool Scrollbar Library Version 1.2
  5. Module: coolsblib.c
  6. Copyright (c) J Brown 2001
  8. This code is freeware, however, you may not publish
  9. this code elsewhere or charge any money for it. This code
  10. is supplied as-is. I make no guarantees about the suitability
  11. of this code - use at your own risk.
  13. It would be nice if you credited me, in the event
  14. that you use this code in a product.
  16. VERSION HISTORY:
  18.  V1.2: TreeView problem fixed by Diego Tartara
  19.    Small problem in thumbsize calculation also fixed (thanks Diego!)
  21.  V1.1: Added support for Right-left windows
  22.        Changed calling convention of APIs to WINAPI (__stdcall)
  23.    Completely standalone (no need for c-runtime)
  25.  V1.0: Apr 2001: Initial Version
  27. */
  29. #define STRICT
  31. #include <windows.h>
  32. #include <commctrl.h>
  33. #include <tchar.h>
  34. #include "coolscroll.h"
  35. #include "userdefs.h"
  36. #include "coolsb_internal.h"
  38. static TCHAR szPropStr[] = _T("CoolSBSubclassPtr");
  40. LRESULT CALLBACK CoolSBWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
  42. SCROLLWND *GetScrollWndFromHwnd(HWND hwnd)
  43. {
  44. return (SCROLLWND *)GetProp(hwnd, szPropStr);
  45. }
  47. SCROLLBAR *GetScrollBarFromHwnd(HWND hwnd, UINT nBar)
  48. {
  49. SCROLLWND *sw = GetScrollWndFromHwnd(hwnd);
  51. if(!sw) return 0;
  53. if(nBar == SB_HORZ)
  54. return &sw->sbarHorz;
  55. else if(nBar == SB_VERT)
  56. return &sw->sbarVert;
  57. else
  58. return 0;
  59. }
  61. BOOL WINAPI CoolSB_IsCoolScrollEnabled(HWND hwnd)
  62. {
  63. if(GetScrollWndFromHwnd(hwnd))
  64. return TRUE;
  65. else
  66. return FALSE;
  67. }
  69. BOOL GetScrollRect(SCROLLWND *sw, UINT nBar, HWND hwnd, RECT *rect);
  71. //
  72. // Special support for USER32.DLL patching (using Detours library)
  73. // The only place we call a real scrollbar API is in InitializeCoolSB,
  74. // where we call EnableScrollbar.
  75. //
  76. // We HAVE to call the origial EnableScrollbar function, 
  77. // so we need to be able to set a pointer to this func when using
  78. // using Detours (or any other LIB??)
  79. //
  81. static BOOL (WINAPI * pEnableScrollBar) (HWND, UINT, UINT) = 0;
  83. void WINAPI CoolSB_SetESBProc(void *proc)
  84. {
  85. pEnableScrollBar = proc;
  86. }
  87. //
  88. //
  90. static void RedrawNonClient(HWND hwnd, BOOL fFrameChanged)
  91. {
  92. if(fFrameChanged == FALSE)
  93. {
  94. /*
  95. RECT rect;
  96. HRGN hrgn1, hrgn2;
  98. SCROLLWND *sw = GetScrollWndFromHwnd(hwnd);
  100. GetScrollRect(sw, SB_HORZ, hwnd, &rect);
  101. hrgn1 = CreateRectRgnIndirect(&rect);
  103. GetScrollRect(sw, SB_VERT, hwnd, &rect);
  104. hrgn2 = CreateRectRgnIndirect(&rect);
  106. CombineRgn(hrgn1, hrgn2, hrgn1, RGN_OR);
  108. SendMessage(hwnd, WM_NCPAINT, (WPARAM)hrgn1, 0);
  110. DeleteObject(hrgn1);
  111. DeleteObject(hrgn2);*/
  113. SendMessage(hwnd, WM_NCPAINT, (WPARAM)1, 0);
  114. }
  115. else
  116. {
  117. SetWindowPos(hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE
  118. | SWP_FRAMECHANGED | SWP_DRAWFRAME);
  119. }
  120. }
  122. //
  123. // return the default minimum size of a scrollbar thumb
  124. //
  125. int WINAPI CoolSB_GetDefaultMinThumbSize(void)
  126. {
  127. DWORD dwVersion = GetVersion();
  129. // set the minimum thumb size for a scrollbar. This
  130. // differs between NT4 and 2000, so need to check to see
  131. // which platform we are running under
  132. if(dwVersion < 0x80000000)              // Windows NT/2000
  133. {
  134. if(LOBYTE(LOWORD(dwVersion)) >= 5)
  135. return MINTHUMBSIZE_2000;
  136. else
  137. return MINTHUMBSIZE_NT4;
  138. }
  139. else
  140. {
  141. return MINTHUMBSIZE_NT4;
  142. }
  143. }
  145. static SCROLLINFO *GetScrollInfoFromHwnd(HWND hwnd, int fnBar)
  146. {
  147. SCROLLBAR *sb = GetScrollBarFromHwnd(hwnd, fnBar);
  149. if(sb == 0)
  150. return FALSE;
  152. if(fnBar == SB_HORZ)
  153. {
  154. return &sb->scrollInfo;
  155. }
  156. else if(fnBar == SB_VERT)
  157. {
  158. return &sb->scrollInfo;
  159. }
  160. else
  161. return NULL;
  162. }
  163. //
  164. // Initialize the cool scrollbars for a window by subclassing it
  165. // and using the coolsb window procedure instead
  166. //
  167. BOOL WINAPI InitializeCoolSB(HWND hwnd)
  168. {
  169. SCROLLWND *sw;
  170. SCROLLINFO *si;
  171. INITCOMMONCONTROLSEX ice;
  172. TOOLINFO ti;
  173. RECT rect;
  174. DWORD dwCurStyle;
  175. //BOOL fDisabled;
  177. if(pEnableScrollBar == 0)
  178. pEnableScrollBar = EnableScrollBar;
  180. GetClientRect(hwnd, &rect);
  182. //if we have already initialized Cool Scrollbars for this window,
  183. //then stop the user from doing it again
  184. if(GetScrollWndFromHwnd(hwnd) != 0)
  185. {
  186. return FALSE;
  187. }
  189. //allocate a private scrollbar structure which we 
  190. //will use to keep track of the scrollbar data
  191. sw = (SCROLLWND *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SCROLLWND));
  193. si = &sw->sbarHorz.scrollInfo;
  194. si->cbSize = sizeof(SCROLLINFO);
  195. si->fMask  = SIF_ALL;
  196. GetScrollInfo(hwnd, SB_HORZ, si);
  198. si = &sw->sbarVert.scrollInfo;
  199. si->cbSize = sizeof(SCROLLINFO);
  200. si->fMask  = SIF_ALL;
  201. GetScrollInfo(hwnd, SB_VERT, si);
  203. //check to see if the window has left-aligned scrollbars
  204. if(GetWindowLong(hwnd, GWL_EXSTYLE) & WS_EX_LEFTSCROLLBAR)
  205. sw->fLeftScrollbar = TRUE;
  206. else
  207. sw->fLeftScrollbar = FALSE;
  209. dwCurStyle = GetWindowLong(hwnd, GWL_STYLE);
  211. SetProp(hwnd, szPropStr, (HANDLE)sw);
  213. //try to enable the scrollbar arrows - if the return value is
  214. //non-zero, then the scrollbars were previously disabled
  215. //fDisabled = pEnableScrollBar(hwnd, SB_HORZ, ESB_ENABLE_BOTH);
  217. //scrollbars will automatically get enabled, even if
  218. //they aren't to start with....sorry, but there isn't an
  219. //easy alternative.
  220. if(dwCurStyle & WS_HSCROLL)
  221. sw->sbarHorz.fScrollFlags = CSBS_VISIBLE;
  223. if(dwCurStyle & WS_VSCROLL)
  224. sw->sbarVert.fScrollFlags = CSBS_VISIBLE;
  226. //need to be able to distinguish between horizontal and vertical
  227. //scrollbars in some instances
  228. sw->sbarHorz.nBarType      = SB_HORZ;
  229. sw->sbarVert.nBarType      = SB_VERT;
  231. sw->sbarHorz.fFlatScrollbar  = CSBS_NORMAL;
  232. sw->sbarVert.fFlatScrollbar  = CSBS_NORMAL;
  234. //set the default arrow sizes for the scrollbars
  235. sw->sbarHorz.nArrowLength  = SYSTEM_METRIC;
  236. sw->sbarHorz.nArrowWidth  = SYSTEM_METRIC;
  237. sw->sbarVert.nArrowLength  = SYSTEM_METRIC;
  238. sw->sbarVert.nArrowWidth  = SYSTEM_METRIC;
  240. sw->bPreventStyleChange  = FALSE;
  242. sw->oldproc = (WNDPROC)SetWindowLong(hwnd, GWL_WNDPROC, (LONG)CoolSBWndProc);
  244. CoolSB_SetMinThumbSize(hwnd, SB_BOTH, CoolSB_GetDefaultMinThumbSize());
  246. #ifdef COOLSB_TOOLTIPS
  247. ice.dwSize = sizeof(ice);
  248. ice.dwICC  = ICC_BAR_CLASSES;
  249. InitCommonControlsEx(&ice);
  251. sw->hwndToolTip = CreateWindowEx(WS_EX_TOPMOST | WS_EX_TOOLWINDOW, TOOLTIPS_CLASS, _T(""),
  252.                             WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
  253.                             CW_USEDEFAULT, CW_USEDEFAULT,
  254.                             CW_USEDEFAULT, CW_USEDEFAULT,
  255.                             hwnd, NULL, GetModuleHandle(0),
  256.                             NULL);
  258. ti.cbSize = sizeof(TOOLINFO);
  259. ti.uFlags = TTF_IDISHWND;
  260. ti.hwnd   = hwnd;
  261. ti.uId    = (UINT)hwnd;
  262. ti.lpszText = LPSTR_TEXTCALLBACK;
  263. ti.hinst   = GetModuleHandle(0);
  265. SendMessage(sw->hwndToolTip, TTM_ADDTOOL, 0, (LPARAM)&ti);
  267. #else
  269. UNREFERENCED_PARAMETER(ice);
  270. UNREFERENCED_PARAMETER(ti);
  271. sw->hwndToolTip = 0;
  273. #endif
  275. //send the window a frame changed message to update the scrollbars
  276. RedrawNonClient(hwnd, TRUE);
  278. return TRUE;
  279. }
  281. BOOL WINAPI CoolSB_EnableScrollBar (HWND hwnd, int wSBflags, UINT wArrows)
  282. {
  283. SCROLLBAR *sbar;
  284. UINT oldstate;
  285. BOOL bFailed = FALSE;
  287. if(!CoolSB_IsCoolScrollEnabled(hwnd))
  288. return EnableScrollBar(hwnd, wSBflags, wArrows);
  290. if((wSBflags == SB_HORZ || wSBflags == SB_BOTH) && 
  291. (sbar = GetScrollBarFromHwnd(hwnd, SB_HORZ)))
  292. {
  293. oldstate = sbar->fScrollFlags;
  295. //clear any existing state, and OR in the disabled flags
  296. sbar->fScrollFlags = (sbar->fScrollFlags & ~ESB_DISABLE_BOTH) | wArrows;
  298. if(oldstate == sbar->fScrollFlags)
  299. bFailed = TRUE;
  301. }
  303. if((wSBflags == SB_VERT || wSBflags == SB_BOTH) && 
  304. (sbar = GetScrollBarFromHwnd(hwnd, SB_VERT)))
  305. {
  306. oldstate = sbar->fScrollFlags;
  308. //clear any existing state, and OR in the disabled flags
  309. sbar->fScrollFlags = (sbar->fScrollFlags & ~ESB_DISABLE_BOTH) | wArrows;
  311. if(oldstate == sbar->fScrollFlags)
  312. bFailed = TRUE;
  313. }
  315. return !bFailed;
  316. }
  318. BOOL WINAPI CoolSB_GetScrollBarInfo(HWND hwnd)
  319. {
  320. // SCROLLBARINFO sbi; not defined in winuser.h
  321. return FALSE;
  322. }
  324. BOOL WINAPI CoolSB_GetScrollInfo (HWND hwnd, int fnBar, LPSCROLLINFO lpsi)
  325. {
  326. SCROLLINFO *mysi;
  327. BOOL copied = FALSE;
  329. if(!lpsi)
  330. return FALSE;
  332. if(!(mysi = GetScrollInfoFromHwnd(hwnd, fnBar)))
  333. {
  334. return GetScrollInfo(hwnd, fnBar, lpsi);
  335. }
  337. if(lpsi->fMask & SIF_PAGE)
  338. {
  339. lpsi->nPage = mysi->nPage;
  340. copied = TRUE;
  341. }
  343. if(lpsi->fMask & SIF_POS)
  344. {
  345. lpsi->nPos = mysi->nPos;
  346. copied = TRUE;
  347. }
  349. if(lpsi->fMask & SIF_TRACKPOS)
  350. {
  351. lpsi->nTrackPos = mysi->nTrackPos;
  352. copied = TRUE;
  353. }
  355. if(lpsi->fMask & SIF_RANGE)
  356. {
  357. lpsi->nMin = mysi->nMin;
  358. lpsi->nMax = mysi->nMax;
  359. copied = TRUE;
  360. }
  362. return copied;
  363. }
  365. int WINAPI CoolSB_GetScrollPos (HWND hwnd, int nBar)
  366. {
  367. SCROLLINFO *mysi;
  369. if(!(mysi = GetScrollInfoFromHwnd(hwnd, nBar)))
  370. return GetScrollPos(hwnd, nBar);
  372. return mysi->nPos;
  373. }
  375. BOOL WINAPI CoolSB_GetScrollRange (HWND hwnd, int nBar, LPINT lpMinPos, LPINT lpMaxPos)
  376. {
  377. SCROLLINFO *mysi;
  379. if(!lpMinPos || !lpMaxPos)
  380. return FALSE;
  382. if(!(mysi = GetScrollInfoFromHwnd(hwnd, nBar)))
  383. return GetScrollRange(hwnd, nBar, lpMinPos, lpMaxPos);
  385. *lpMinPos = mysi->nMin;
  386. *lpMaxPos = mysi->nMax;
  388. return TRUE;
  389. }
  391. int WINAPI CoolSB_SetScrollInfo (HWND hwnd, int fnBar, LPSCROLLINFO lpsi, BOOL fRedraw)
  392. {
  393. SCROLLINFO *mysi;
  394. SCROLLBAR *sbar;
  395. BOOL       fRecalcFrame = FALSE;
  397. if(!lpsi)
  398. return FALSE;
  400. if(!(mysi = GetScrollInfoFromHwnd(hwnd, fnBar)))
  401. return SetScrollInfo(hwnd, fnBar, lpsi, fRedraw);
  403. //if(CoolSB_IsThumbTracking(hwnd))
  404. // return mysi->nPos;
  406. if(lpsi->fMask & SIF_RANGE)
  407. {
  408. mysi->nMin = lpsi->nMin;
  409. mysi->nMax = lpsi->nMax;
  410. }
  412. //The nPage member must specify a value from 0 to nMax - nMin +1. 
  413. if(lpsi->fMask & SIF_PAGE)
  414. {
  415. UINT t = (UINT)(mysi->nMax - mysi->nMin + 1);
  416. mysi->nPage = min(max(0, lpsi->nPage), t);
  417. }
  419. //The nPos member must specify a value between nMin and nMax - max(nPage - 1, 0).
  420. if(lpsi->fMask & SIF_POS)
  421. {
  422. mysi->nPos = max(lpsi->nPos, mysi->nMin);
  423. mysi->nPos = min((UINT)mysi->nPos, mysi->nMax - max(mysi->nPage - 1, 0));
  424. }
  426. sbar = GetScrollBarFromHwnd(hwnd, fnBar);
  428. if((lpsi->fMask & SIF_DISABLENOSCROLL) || (sbar->fScrollFlags & CSBS_THUMBALWAYS))
  429. {
  430. if(!sbar->fScrollVisible)
  431. {
  432. CoolSB_ShowScrollBar(hwnd, fnBar, TRUE);
  433. fRecalcFrame = TRUE;
  434. }
  435. }
  436. else
  437. {
  438. if(    mysi->nPage >  (UINT)mysi->nMax 
  439. || mysi->nPage == (UINT)mysi->nMax && mysi->nMax == 0
  440. || mysi->nMax  <= mysi->nMin)
  441. {
  442. if(sbar->fScrollVisible)
  443. {
  444. CoolSB_ShowScrollBar(hwnd, fnBar, FALSE);
  445. fRecalcFrame = TRUE;
  446. }
  447. }
  448. else
  449. {
  450. if(!sbar->fScrollVisible)
  451. {
  452. CoolSB_ShowScrollBar(hwnd, fnBar, TRUE);
  453. fRecalcFrame = TRUE;
  454. }
  456. }
  458. }
  460. if(fRedraw && !CoolSB_IsThumbTracking(hwnd))
  461. RedrawNonClient(hwnd, fRecalcFrame);
  463. return mysi->nPos;
  464. }
  467. int WINAPI CoolSB_SetScrollPos(HWND hwnd, int nBar, int nPos, BOOL fRedraw)
  468. {
  469. SCROLLINFO *mysi;
  470. int oldpos;
  472. if(!(mysi = GetScrollInfoFromHwnd(hwnd, nBar)))
  473. {
  474. return SetScrollPos(hwnd, nBar, nPos, fRedraw);
  475. }
  477. //this is what should happen, but real scrollbars don't work like this..
  478. //if(CoolSB_IsThumbTracking(hwnd))
  479. // return mysi->nPos;
  481. //validate and set the scollbar position
  482. oldpos = mysi->nPos;
  483. mysi->nPos = max(nPos, mysi->nMin);
  484. mysi->nPos = min((UINT)mysi->nPos, mysi->nMax - max(mysi->nPage - 1, 0));
  486. if(fRedraw && !CoolSB_IsThumbTracking(hwnd))
  487. RedrawNonClient(hwnd, FALSE);
  489. return oldpos;
  490. }
  492. int WINAPI CoolSB_SetScrollRange (HWND hwnd, int nBar, int nMinPos, int nMaxPos, BOOL fRedraw)
  493. {
  494. SCROLLINFO *mysi;
  496. if(!(mysi = GetScrollInfoFromHwnd(hwnd, nBar)))
  497. return SetScrollRange(hwnd, nBar, nMinPos, nMaxPos, fRedraw);
  499. if(CoolSB_IsThumbTracking(hwnd))
  500. return mysi->nPos;
  502. //hide the scrollbar if nMin == nMax
  503. //nMax-nMin must not be greater than MAXLONG
  504. mysi->nMin = nMinPos;
  505. mysi->nMax = nMaxPos;
  507. if(fRedraw)
  508. RedrawNonClient(hwnd, FALSE);
  510. return TRUE;
  511. }
  513. //
  514. // Show or hide the specified scrollbars
  515. //
  516. BOOL WINAPI CoolSB_ShowScrollBar (HWND hwnd, int wBar, BOOL fShow)
  517. {
  518. SCROLLBAR *sbar;
  519. BOOL bFailed = FALSE;
  520. DWORD dwStyle = GetWindowLong(hwnd, GWL_STYLE);
  522. if(!CoolSB_IsCoolScrollEnabled(hwnd))
  523. return ShowScrollBar(hwnd, wBar, fShow);
  525. if((wBar == SB_HORZ || wBar == SB_BOTH) && 
  526.    (sbar = GetScrollBarFromHwnd(hwnd, SB_HORZ)))
  527. {
  528. sbar->fScrollFlags  =  sbar->fScrollFlags & ~CSBS_VISIBLE;
  529. sbar->fScrollFlags |= (fShow == TRUE ? CSBS_VISIBLE : 0);
  530. //bFailed = TRUE;
  532. if(fShow) SetWindowLong(hwnd, GWL_STYLE, dwStyle | WS_HSCROLL);
  533. else SetWindowLong(hwnd, GWL_STYLE, dwStyle & ~WS_HSCROLL);
  534. }
  536. if((wBar == SB_VERT || wBar == SB_BOTH) && 
  537.    (sbar = GetScrollBarFromHwnd(hwnd, SB_VERT)))
  538. {
  539. sbar->fScrollFlags  =  sbar->fScrollFlags & ~CSBS_VISIBLE;
  540. sbar->fScrollFlags |= (fShow == TRUE ? CSBS_VISIBLE : 0);
  541. //bFailed = TRUE;
  543. if(fShow) SetWindowLong(hwnd, GWL_STYLE, dwStyle | WS_VSCROLL);
  544. else SetWindowLong(hwnd, GWL_STYLE, dwStyle & ~WS_VSCROLL);
  545. }
  547. if(bFailed)
  548. {
  549. return FALSE;
  550. }
  551. else
  552. {
  553. //DWORD style = GetWindowLong(hwnd, GWL_STYLE);
  554. //style |= WS_VSCROLL;
  556. //if(s
  557. //SetWindowLong(hwnd, GWL_STYLE, style);
  559. SetWindowPos(hwnd, 0, 0, 0, 0, 0, 
  560. SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | 
  561. SWP_NOACTIVATE | SWP_FRAMECHANGED);
  563. return TRUE;
  564. }
  565. }
  567. //
  568. // Remove cool scrollbars from the specified window.
  569. //
  570. HRESULT WINAPI UninitializeCoolSB(HWND hwnd)
  571. {
  572. int i = 0;
  573. SCROLLWND *sw = GetScrollWndFromHwnd(hwnd);
  574. if(!sw) return E_FAIL;
  576. //restore the window procedure with the original one
  577. SetWindowLong(hwnd, GWL_WNDPROC, (LONG)sw->oldproc);
  579. RemoveProp(hwnd, szPropStr);
  580. //SetWindowLong(hwnd, GWL_USERDATA, 0);
  582. //finally, release the memory needed for the cool scrollbars
  583. HeapFree(GetProcessHeap(), 0, sw);
  585.     //Force WM_NCCALCSIZE and WM_NCPAINT so the original scrollbars can kick in
  586.     RedrawNonClient(hwnd, TRUE);
  588. return S_OK;
  589. }
  591. #ifdef INCLUDE_BUTTONS
  593. //
  594. // Cool scrollbar specific interface (BUTTON support)
  595. //
  597. //
  598. // Insert a button into the scrollbar area
  599. //
  600. // wSBflags - SB_HORZ / SB_VERT only
  601. // uPos     - position into which to insert.
  602. // can be 0 to insert at the start, or -1 to insert
  603. // at the end of previously inserted buttons
  604. //
  606. BOOL WINAPI CoolSB_InsertButton(HWND hwnd, int wSBflags, UINT nPos, SCROLLBUT *psb)
  607. {
  608. SCROLLBAR *sbar;
  609. SCROLLBUT *sbut;
  610. UINT i;
  612. if(!psb) return FALSE;
  614. if(!(sbar = GetScrollBarFromHwnd(hwnd, wSBflags)))
  615. return FALSE;
  617. //check that we havn't reached the maximum allowed buttons yet
  618. if(sbar->nButtons == MAX_COOLSB_BUTS)
  619. return FALSE;
  621. //insert at end
  622. if(nPos == -1)
  623. {
  624. sbut = &sbar->sbButtons[sbar->nButtons];
  625. }
  626. //otherwise, need to make room
  627. else if((int)nPos < 0 || (int)nPos > (UINT)sbar->nButtons)
  628. {
  629. return FALSE;
  630. }
  631. else
  632. {
  633. //insert space for the button at the specified position
  634. for(i = sbar->nButtons; i > nPos; i--)
  635. {
  636. sbar->sbButtons[i] = sbar->sbButtons[i-1];
  637. }
  639. sbut = &sbar->sbButtons[nPos];
  640. }
  642. //only set the button's properties if they are
  643. //specified by the SCROLLBUT->fMask. 
  644. //Otherwise, use a default property value
  646. if(psb->fMask & SBBF_TYPE)
  647. sbut->uButType   = psb->uButType;
  648. else
  649. sbut->uButType  = SBBT_PUSHBUTTON;
  651. if(psb->fMask & SBBF_STATE)
  652. sbut->uState  = psb->uState;
  653. else
  654. sbut->uState  = 0;
  656. if(psb->fMask & SBBF_ID)
  657. sbut->uCmdId     = psb->uCmdId;
  658. else
  659. sbut->uCmdId  = 0;
  661. if(psb->fMask & SBBF_SIZE)
  662. sbut->nSize  = psb->nSize;
  663. else
  664. sbut->nSize  = -1;
  666. if(psb->fMask & SBBF_PLACEMENT)
  667. sbut->uPlacement = psb->uPlacement;
  668. else
  669. sbut->uPlacement = SBBP_LEFT;
  671. if(psb->fMask & SBBF_BITMAP)
  672. sbut->hBmp  = psb->hBmp;
  673. else
  674. sbut->hBmp  = 0;
  676. if(psb->fMask & SBBF_ENHMETAFILE)
  677. sbut->hEmf  = psb->hEmf;
  678. else
  679. sbut->hEmf  = 0;
  681. if(psb->fMask & SBBF_CURSOR)
  682. sbut->hCurs = psb->hCurs;
  683. else
  684. sbut->hCurs = 0;
  686. /*
  687. We don't use the callback function anymore. The uButType
  688. member must now specify SBBT_OWNERDRAW, and a WM_NOTIFY will
  689. be sent when a button must be drawn
  690. if((psb->fMask & SBBF_OWNERDRAW) && ((psb->uButType & SBBT_MASK) == SBBT_OWNERDRAW))
  691. pDrawProc  = psb->pDrawProc;
  692. else
  693. pDrawProc  = 0;*/
  695. sbar->nButtons++;
  696. sbut->nSizeReserved = sbut->nSize;
  698. //MAKE SURE that any resizable buttons are only to the left / above
  699. //a scrollbar. We don't support resize operations to the right of a scrollbar
  700. if((sbut->uButType & SBBM_RESIZABLE) && sbut->uPlacement == SBBP_RIGHT)
  701. sbut->uButType &= ~SBBM_RESIZABLE;
  703. if(psb->fMask & SBBF_BUTMINMAX)
  704. {
  705. sbut->nMinSize = psb->nMinSize;
  706. sbut->nMaxSize = psb->nMaxSize;
  707. }
  708. else
  709. {
  710. sbut->nMinSize = 0;
  711. sbut->nMaxSize = -1;
  712. }
  714. return TRUE;
  715. }
  717. static SCROLLBUT *GetButtonFromId(SCROLLBAR *sbar, UINT uCmdId)
  718. {
  719. int i;
  720. for(i = 0; i < sbar->nButtons; i++)
  721. {
  722. if(sbar->sbButtons[i].uCmdId == uCmdId)
  723. return &sbar->sbButtons[i];
  724. }
  726. return 0;
  727. }
  729. //
  730. // Modify the properties of the specified scrollbar button.
  731. // wSBflags - SB_HORZ / SB_VERT only
  732. // uItem    - the command identifier specified when the button was created,
  733. //    or a non-negative position of the button, depending on if
  734. //    fByCmd is FALSE or TRUE, respectively
  735. //
  736. BOOL WINAPI CoolSB_ModifyButton (HWND hwnd, int wSBflags, UINT uItem, BOOL fByCmd, SCROLLBUT *psb)
  737. {
  738. SCROLLBAR *sbar;
  739. SCROLLBUT *sbut;
  741. if(!psb) return FALSE;
  743. //find if this window is CoolScroll enabled
  744. if(!(sbar = GetScrollBarFromHwnd(hwnd, wSBflags)))
  745. return FALSE;
  747. //find the button to modify, depending on if we
  748. //are modifying by position or command id
  749. if(fByCmd == FALSE)
  750. {
  751. //button from position
  752. if((int)uItem < 0 || (int)uItem >= (UINT)sbar->nButtons)
  753. return FALSE;
  754. else
  755. sbut = &sbar->sbButtons[uItem];
  756. }
  757. else if(fByCmd == TRUE)
  758. {
  759. //button from command identifier
  760. if(!(sbut = GetButtonFromId(sbar, uItem)))
  761. return FALSE;
  762. }
  764. if(psb->fMask & SBBF_TYPE) sbut->uButType   = psb->uButType;
  765. if(psb->fMask & SBBF_STATE) sbut->uState  = psb->uState;
  766. if(psb->fMask & SBBF_ID) sbut->uCmdId     = psb->uCmdId;
  767. if(psb->fMask & SBBF_SIZE) sbut->nSize  = psb->nSize;
  768. if(psb->fMask & SBBF_PLACEMENT) sbut->uPlacement = psb->uPlacement;
  769. if(psb->fMask & SBBF_BITMAP) sbut->hBmp  = psb->hBmp;
  770. if(psb->fMask & SBBF_ENHMETAFILE) sbut->hEmf  = psb->hEmf;
  771. if(psb->fMask & SBBF_CURSOR) sbut->hCurs  = psb->hCurs;
  773. if(psb->fMask & SBBF_BUTMINMAX)
  774. {
  775. sbut->nMinSize = psb->nMinSize;
  776. sbut->nMaxSize = psb->nMaxSize;
  777. }
  779. return TRUE;
  780. }
  782. BOOL WINAPI CoolSB_RemoveButton(HWND hwnd, int wSBflags, UINT uItem, BOOL fByCmd)
  783. {
  784. int i;
  785. SCROLLBAR *sbar;
  787. //find if this window is CoolScroll enabled
  788. if(!(sbar = GetScrollBarFromHwnd(hwnd, wSBflags)))
  789. return FALSE;
  791. //find the button to modify, depending on if we
  792. //are modifying by position or command id
  793. if(fByCmd == FALSE && ((int)uItem < 0 || (int)uItem >= (UINT)sbar->nButtons))
  794. {
  795. return FALSE;
  796. }
  797. else if(fByCmd == TRUE)
  798. {
  799. //find the button with the specified command id
  800. for(i = 0; i < sbar->nButtons; i++)
  801. {
  802. if(sbar->sbButtons[i].uCmdId == uItem)
  803. {
  804. //change the id to an index
  805. uItem = i;
  806. break;
  807. }
  808. }
  810. //if we failed to find the button...
  811. if(i == sbar->nButtons) return FALSE;
  812. }
  814. //remove the button!
  815. for(i = uItem; i < sbar->nButtons - 1; i++)
  816. {
  817. sbar->sbButtons[i] = sbar->sbButtons[i+1];
  818. }
  820. sbar->nButtons--;
  822. RedrawNonClient(hwnd, TRUE);
  824. return TRUE;
  825. }
  827. //
  828. // fill in the supplied SCROLLBUT structure
  829. //
  830. BOOL WINAPI CoolSB_GetButton(HWND hwnd, int wSBflags, UINT uItem, BOOL fByCmd, SCROLLBUT *psb)
  831. {
  832. SCROLLBAR *sbar;
  833. SCROLLBUT *sbut;
  835. if(!psb) return FALSE;
  837. //find if this window is CoolScroll enabled
  838. if(!(sbar = GetScrollBarFromHwnd(hwnd, wSBflags)))
  839. return FALSE;
  841. //find the button to modify, depending on if we
  842. //are modifying by position or command id
  843. if(fByCmd == FALSE)
  844. {
  845. //button from position
  846. if((int)uItem < 0 || (int)uItem >= (UINT)sbar->nButtons)
  847. return FALSE;
  848. else
  849. sbut = &sbar->sbButtons[uItem];
  850. }
  851. else if(fByCmd == TRUE)
  852. {
  853. //button from command identifier
  854. if(!(sbut = GetButtonFromId(sbar, uItem)))
  855. return FALSE;
  856. }
  858. //copy them across
  859. *psb = *sbut;
  861. return FALSE; 
  862. }
  864. #else
  866. BOOL WINAPI CoolSB_InsertButton(HWND hwnd, int wSBflags, UINT nPos,  SCROLLBUT *psb) { return FALSE; }
  867. BOOL WINAPI CoolSB_ModifyButton(HWND hwnd, int wSBflags, UINT uItem, BOOL fByCmd, SCROLLBUT *psb) { return FALSE; }
  868. BOOL WINAPI CoolSB_RemoveButton(HWND hwnd, int wSBflags, UINT uItem, BOOL fByCmd) { return FALSE; }
  869. BOOL WINAPI CoolSB_GetButton   (HWND hwnd, int wSBflags, UINT uItem, BOOL fByCmd, SCROLLBUT *psb) { return FALSE; }
  871. #endif //INCLUDE_BUTTONS
  873. //
  874. // Set the size of the scrollbars
  875. //
  876. BOOL WINAPI CoolSB_SetSize (HWND hwnd, int wBar, int nLength, int nWidth)
  877. {
  878. SCROLLBAR *sbar;
  880. if(nLength == 0 || nWidth == 0)
  881. return FALSE;
  883. if(nLength < -8 || nWidth < -8)
  884. return FALSE;
  886. if(nLength > 256 || nWidth > 256)
  887. return FALSE;
  889. if(!GetScrollWndFromHwnd(hwnd))
  890. return FALSE;
  892. if((wBar == SB_HORZ || wBar == SB_BOTH) && 
  893.    (sbar = GetScrollBarFromHwnd(hwnd, SB_HORZ)))
  894. {
  895. sbar->nArrowLength = nLength;
  896. sbar->nArrowWidth  = nWidth;
  897. }
  899. if((wBar == SB_VERT || wBar == SB_BOTH) && 
  900.    (sbar = GetScrollBarFromHwnd(hwnd, SB_VERT)))
  901. {
  902. sbar->nArrowLength = nLength;
  903. sbar->nArrowWidth  = nWidth;
  904. }
  906. RedrawNonClient(hwnd, TRUE);
  908. return TRUE;
  909. }
  912. //
  913. // Alter the display mode of the scrollbars
  914. // wBar   - SB_HORZ / SB_VERT / SB_BOTH
  915. // nStyle - CSBF_NORMAL / CSBF_FLAT / CSBF_HOTTRACKED
  916. //
  917. BOOL WINAPI CoolSB_SetStyle(HWND hwnd, int wBar, UINT nStyle)
  918. {
  919. SCROLLBAR *sbar;
  921. if(!GetScrollWndFromHwnd(hwnd))
  922. return FALSE;
  924. if((wBar == SB_HORZ || wBar == SB_BOTH) && 
  925.    (sbar = GetScrollBarFromHwnd(hwnd, SB_HORZ)))
  926. {
  927. sbar->fFlatScrollbar = nStyle;
  928. }
  930. if((wBar == SB_VERT || wBar == SB_BOTH) && 
  931.    (sbar = GetScrollBarFromHwnd(hwnd, SB_VERT)))
  932. {
  933. sbar->fFlatScrollbar = nStyle;
  934. }
  936. RedrawNonClient(hwnd, FALSE);
  938. return TRUE;
  939. }
  941. //
  942. // Set if the thumb is always visible, even if there is no data to
  943. //  scroll. Setting this keeps the scrollbar enabled, but the thumb
  944. //  covers the whole area
  945. //
  946. BOOL WINAPI CoolSB_SetThumbAlways(HWND hwnd, int wBar, BOOL fThumbAlways)
  947. {
  948. SCROLLBAR *sbar;
  950. if(!GetScrollWndFromHwnd(hwnd))
  951. return FALSE;
  953. if((wBar == SB_HORZ || wBar == SB_BOTH) && 
  954.    (sbar = GetScrollBarFromHwnd(hwnd, SB_HORZ)))
  955. {
  956. if(fThumbAlways)
  957. sbar->fScrollFlags |=  CSBS_THUMBALWAYS;
  958. else
  959. sbar->fScrollFlags &= ~CSBS_THUMBALWAYS;
  960. }
  962. if((wBar == SB_VERT || wBar == SB_BOTH) && 
  963.    (sbar = GetScrollBarFromHwnd(hwnd, SB_VERT)))
  964. {
  965. if(fThumbAlways)
  966. sbar->fScrollFlags |=  CSBS_THUMBALWAYS;
  967. else
  968. sbar->fScrollFlags &= ~CSBS_THUMBALWAYS;
  969. }
  971. RedrawNonClient(hwnd, FALSE);
  973. return TRUE;
  974. }
  976. //
  977. // Set the minimum size, in pixels, that the thumb box will shrink to.
  978. //
  979. BOOL WINAPI CoolSB_SetMinThumbSize(HWND hwnd, UINT wBar, UINT size)
  980. {
  981. SCROLLBAR *sbar;
  983. if(!GetScrollWndFromHwnd(hwnd))
  984. return FALSE;
  986. if(size == -1)
  987. size = CoolSB_GetDefaultMinThumbSize();
  989. if((wBar == SB_HORZ || wBar == SB_BOTH) && 
  990.    (sbar = GetScrollBarFromHwnd(hwnd, SB_HORZ)))
  991. {
  992. sbar->nMinThumbSize = size;
  993. }
  995. if((wBar == SB_VERT || wBar == SB_BOTH) && 
  996.    (sbar = GetScrollBarFromHwnd(hwnd, SB_VERT)))
  997. {
  998. sbar->nMinThumbSize = size;
  999. }
  1001. return TRUE;
  1002. }